types.hpp

Go to the documentation of this file.

/*
 * Copyright 2017 Nico Reißmann <nico.reissmann@gmail.com>
 * See COPYING for terms of redistribution.
 */
 
#ifndef JLM_LLVM_IR_TYPES_HPP
#define JLM_LLVM_IR_TYPES_HPP
 
#include <jlm/rvsdg/FunctionType.hpp>
#include <jlm/rvsdg/type.hpp>
#include <jlm/util/common.hpp>
#include <jlm/util/iterator_range.hpp>
 
#include <memory>
#include <vector>
 
namespace jlm::llvm
{
 
class PointerType final : public jlm::rvsdg::Type
{
public:
  ~PointerType() noexcept override;
 
  PointerType() = default;
 
  [[nodiscard]] std::string
  debug_string() const override;
 
  bool
  operator==(const jlm::rvsdg::Type & other) const noexcept override;
 
  [[nodiscard]] std::size_t
  ComputeHash() const noexcept override;
 
  rvsdg::TypeKind
  Kind() const noexcept override;
 
  static std::shared_ptr<const PointerType>
  Create();
};
 
class ArrayType final : public rvsdg::Type
{
public:
  ~ArrayType() noexcept override;
 
  ArrayType(std::shared_ptr<const Type> type, size_t nelements)
      : nelements_(nelements),
        type_(std::move(type))
  {}
 
  ArrayType(const ArrayType & other) = default;
 
  ArrayType(ArrayType && other) = default;
 
  ArrayType &
  operator=(const ArrayType &) = delete;
 
  ArrayType &
  operator=(ArrayType &&) = delete;
 
  [[nodiscard]] std::string
  debug_string() const override;
 
  bool
  operator==(const jlm::rvsdg::Type & other) const noexcept override;
 
  [[nodiscard]] std::size_t
  ComputeHash() const noexcept override;
 
  rvsdg::TypeKind
  Kind() const noexcept override;
 
  inline size_t
  nelements() const noexcept
  {
    return nelements_;
  }
 
  [[nodiscard]] const rvsdg::Type &
  element_type() const noexcept
  {
    return *type_;
  }
 
  [[nodiscard]] const std::shared_ptr<const rvsdg::Type> &
  GetElementType() const noexcept
  {
    return type_;
  }
 
  static std::shared_ptr<const ArrayType>
  Create(std::shared_ptr<const Type> type, size_t nelements)
  {
    return std::make_shared<ArrayType>(std::move(type), nelements);
  }
 
private:
  size_t nelements_;
  std::shared_ptr<const rvsdg::Type> type_;
};
 
/* floating point type */
 
enum class fpsize
{
  half,
  flt,
  dbl,
  x86fp80,
  fp128
};
 
class FloatingPointType final : public rvsdg::Type
{
public:
  ~FloatingPointType() noexcept override;
 
  explicit FloatingPointType(const fpsize & size)
      : size_(size)
  {}
 
  [[nodiscard]] std::string
  debug_string() const override;
 
  bool
  operator==(const jlm::rvsdg::Type & other) const noexcept override;
 
  [[nodiscard]] std::size_t
  ComputeHash() const noexcept override;
 
  rvsdg::TypeKind
  Kind() const noexcept override;
 
  inline const fpsize &
  size() const noexcept
  {
    return size_;
  }
 
  static std::shared_ptr<const FloatingPointType>
  Create(fpsize size);
 
private:
  fpsize size_;
};
 
class VariableArgumentType final : public rvsdg::Type
{
public:
  ~VariableArgumentType() noexcept override;
 
  constexpr VariableArgumentType() = default;
 
  bool
  operator==(const jlm::rvsdg::Type & other) const noexcept override;
 
  [[nodiscard]] std::size_t
  ComputeHash() const noexcept override;
 
  rvsdg::TypeKind
  Kind() const noexcept override;
 
  [[nodiscard]] std::string
  debug_string() const override;
 
  static std::shared_ptr<const VariableArgumentType>
  Create();
};
 
class StructType final : public rvsdg::Type
{
  using ElementTypeConstIterator = std::vector<std::shared_ptr<const Type>>::const_iterator;
  using ElementTypeConstRange = util::IteratorRange<ElementTypeConstIterator>;
 
public:
  ~StructType() noexcept override;
 
  StructType(
      std::string name,
      std::vector<std::shared_ptr<const Type>> types,
      const bool isPacked,
      const bool isLiteral)
      : name_(std::move(name)),
        types_(std::move(types)),
        isPacked_(isPacked),
        isLiteral_(isLiteral)
  {}
 
  StructType(const StructType &) = delete;
 
  StructType(StructType &&) = delete;
 
  StructType &
  operator=(const StructType &) = delete;
 
  StructType &
  operator=(StructType &&) = delete;
 
  bool
  operator==(const Type & other) const noexcept override;
 
  [[nodiscard]] std::size_t
  ComputeHash() const noexcept override;
 
  rvsdg::TypeKind
  Kind() const noexcept override;
 
  [[nodiscard]] ElementTypeConstRange
  elementTypes() const noexcept
  {
    return ElementTypeConstRange(
        ElementTypeConstIterator(types_.begin()),
        ElementTypeConstIterator(types_.end()));
  }
 
  [[nodiscard]] size_t
  numElements() const noexcept
  {
    return types_.size();
  }
 
  [[nodiscard]] std::shared_ptr<const Type>
  getElementType(const size_t index) const noexcept
  {
    JLM_ASSERT(index < numElements());
    return types_[index];
  }
 
  [[nodiscard]] std::string
  debug_string() const override;
 
  [[nodiscard]] bool
  HasName() const noexcept
  {
    if (isLiteral_)
      JLM_ASSERT(name_.empty());
    return !name_.empty();
  }
 
  [[nodiscard]] const std::string &
  GetName() const noexcept
  {
    JLM_ASSERT(!isLiteral_);
    return name_;
  }
 
  [[nodiscard]] bool
  IsPacked() const noexcept
  {
    return isPacked_;
  }
 
  [[nodiscard]] bool
  IsLiteral() const noexcept
  {
    return isLiteral_;
  }
 
  [[nodiscard]] size_t
  GetFieldOffset(size_t fieldIndex) const;
 
  static std::shared_ptr<const StructType>
  CreateIdentified(
      const std::string & name,
      std::vector<std::shared_ptr<const Type>> types,
      bool isPacked)
  {
    return std::make_shared<StructType>(name, std::move(types), isPacked, false);
  }
 
  static std::shared_ptr<const StructType>
  CreateIdentified(std::vector<std::shared_ptr<const Type>> types, bool isPacked)
  {
    return CreateIdentified("", std::move(types), isPacked);
  }
 
  static std::shared_ptr<const StructType>
  CreateLiteral(std::vector<std::shared_ptr<const Type>> types, bool isPacked)
  {
    // Literal structs don't have names, so always use the empty string
    return std::make_shared<StructType>("", std::move(types), isPacked, true);
  }
 
private:
  std::string name_;
  std::vector<std::shared_ptr<const Type>> types_{};
  bool isPacked_;
  bool isLiteral_;
};
 
class VectorType : public rvsdg::Type
{
public:
  VectorType(std::shared_ptr<const Type> type, size_t size)
      : size_(size),
        type_(std::move(type))
  {}
 
  VectorType(const VectorType & other) = default;
 
  VectorType(VectorType && other) = default;
 
  VectorType &
  operator=(const VectorType & other) = default;
 
  VectorType &
  operator=(VectorType && other) = default;
 
  bool
  operator==(const jlm::rvsdg::Type & other) const noexcept override;
 
  rvsdg::TypeKind
  Kind() const noexcept override;
 
  size_t
  size() const noexcept
  {
    return size_;
  }
 
  [[nodiscard]] const rvsdg::Type &
  type() const noexcept
  {
    return *type_;
  }
 
  [[nodiscard]] const std::shared_ptr<const rvsdg::Type> &
  Type() const noexcept
  {
    return type_;
  }
 
private:
  size_t size_;
  std::shared_ptr<const rvsdg::Type> type_;
};
 
class FixedVectorType final : public VectorType
{
public:
  ~FixedVectorType() noexcept override;
 
  FixedVectorType(std::shared_ptr<const rvsdg::Type> type, size_t size)
      : VectorType(std::move(type), size)
  {}
 
  bool
  operator==(const jlm::rvsdg::Type & other) const noexcept override;
 
  [[nodiscard]] std::size_t
  ComputeHash() const noexcept override;
 
  [[nodiscard]] std::string
  debug_string() const override;
 
  static std::shared_ptr<const FixedVectorType>
  Create(std::shared_ptr<const rvsdg::Type> type, size_t size)
  {
    return std::make_shared<FixedVectorType>(std::move(type), size);
  }
};
 
class ScalableVectorType final : public VectorType
{
public:
  ~ScalableVectorType() noexcept override;
 
  ScalableVectorType(std::shared_ptr<const rvsdg::Type> type, size_t size)
      : VectorType(std::move(type), size)
  {}
 
  bool
  operator==(const jlm::rvsdg::Type & other) const noexcept override;
 
  [[nodiscard]] std::size_t
  ComputeHash() const noexcept override;
 
  [[nodiscard]] std::string
  debug_string() const override;
 
  static std::shared_ptr<const ScalableVectorType>
  Create(std::shared_ptr<const rvsdg::Type> type, size_t size)
  {
    return std::make_shared<ScalableVectorType>(std::move(type), size);
  }
};
 
class IOStateType final : public rvsdg::Type
{
public:
  ~IOStateType() noexcept override;
 
  constexpr IOStateType() noexcept = default;
 
  bool
  operator==(const jlm::rvsdg::Type & other) const noexcept override;
 
  [[nodiscard]] std::size_t
  ComputeHash() const noexcept override;
 
  [[nodiscard]] std::string
  debug_string() const override;
 
  rvsdg::TypeKind
  Kind() const noexcept override;
 
  static std::shared_ptr<const IOStateType>
  Create();
};
 
class MemoryStateType final : public rvsdg::Type
{
public:
  ~MemoryStateType() noexcept override;
 
  constexpr MemoryStateType() noexcept = default;
 
  [[nodiscard]] std::string
  debug_string() const override;
 
  bool
  operator==(const jlm::rvsdg::Type & other) const noexcept override;
 
  [[nodiscard]] std::size_t
  ComputeHash() const noexcept override;
 
  rvsdg::TypeKind
  Kind() const noexcept override;
 
  static std::shared_ptr<const MemoryStateType>
  Create();
};
 
template<class ELEMENTYPE>
inline bool
IsOrContains(const jlm::rvsdg::Type & type)
{
  if (jlm::rvsdg::is<ELEMENTYPE>(type))
    return true;
 
  if (auto arrayType = dynamic_cast<const ArrayType *>(&type))
    return IsOrContains<ELEMENTYPE>(arrayType->element_type());
 
  if (const auto structType = dynamic_cast<const StructType *>(&type))
  {
    for (size_t n = 0; n < structType->numElements(); n++)
      if (IsOrContains<ELEMENTYPE>(*structType->getElementType(n)))
        return true;
 
    return false;
  }
 
  if (const auto vectorType = dynamic_cast<const VectorType *>(&type))
    return IsOrContains<ELEMENTYPE>(vectorType->type());
 
  return false;
}
 
inline bool
IsAggregateType(const jlm::rvsdg::Type & type)
{
  return jlm::rvsdg::is<ArrayType>(type) || jlm::rvsdg::is<StructType>(type);
}
 
template<class T>
bool
isVectorOf(const rvsdg::Type & type)
{
  static_assert(
      std::is_base_of_v<rvsdg::Type, T>,
      "Template parameter T must be derived from jlm::rvsdg::Type.");
 
  auto vectorType = dynamic_cast<const VectorType *>(&type);
  return vectorType && rvsdg::is<T>(vectorType->Type());
}
 
template<class T>
bool
isVectorOfSize(const rvsdg::Type & type, const size_t size)
{
  static_assert(
      std::is_base_of_v<rvsdg::Type, T>,
      "Template parameter T must be derived from jlm::rvsdg::Type.");
 
  auto vectorType = dynamic_cast<const VectorType *>(&type);
  return vectorType && rvsdg::is<T>(vectorType->Type()) && vectorType->size() == size;
}
 
[[nodiscard]] size_t
GetTypeStoreSize(const rvsdg::Type & type);
 
[[nodiscard]] size_t
GetTypeAllocSize(const rvsdg::Type & type);
 
[[nodiscard]] size_t
GetTypeAlignment(const rvsdg::Type & type);
 
}
 
#endif