GetElementPtr.hpp

Go to the documentation of this file.

/*
 * Copyright 2018 Nico Reißmann <nico.reissmann@gmail.com>
 * See COPYING for terms of redistribution.
 */
 
#ifndef JLM_LLVM_IR_OPERATORS_GETELEMENTPTR_HPP
#define JLM_LLVM_IR_OPERATORS_GETELEMENTPTR_HPP
 
#include <jlm/llvm/ir/tac.hpp>
#include <jlm/llvm/ir/types.hpp>
#include <jlm/rvsdg/bitstring/type.hpp>
#include <jlm/rvsdg/simple-node.hpp>
 
namespace jlm::llvm
{
 
class GetElementPtrOperation final : public rvsdg::SimpleOperation
{
public:
  ~GetElementPtrOperation() noexcept override;
 
  GetElementPtrOperation(
      const std::vector<std::shared_ptr<const rvsdg::BitType>> & indexTypes,
      std::shared_ptr<const rvsdg::Type> pointeeType)
      : SimpleOperation(createOperandTypes(indexTypes), { PointerType::Create() }),
        pointeeType_(std::move(pointeeType))
  {}
 
  GetElementPtrOperation(const GetElementPtrOperation & other) = default;
 
  GetElementPtrOperation(GetElementPtrOperation && other) noexcept = default;
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  [[nodiscard]] std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  [[nodiscard]] const rvsdg::Type &
  getPointeeType() const noexcept
  {
    return *pointeeType_.get();
  }
 
  static std::optional<std::vector<uint64_t>>
  tryGetConstantIndices(const rvsdg::Node & node) noexcept;
 
  [[nodiscard]] static rvsdg::Node::InputConstIteratorRange
  indices(const rvsdg::Node & node) noexcept
  {
    JLM_ASSERT(GetElementPtrOperation::numIndices(node) != 0);
 
    const auto firstIndex = node.input(1);
    JLM_ASSERT(is<rvsdg::BitType>(firstIndex->Type()));
    return { rvsdg::Input::ConstIterator(firstIndex), rvsdg::Input::ConstIterator(nullptr) };
  }
 
  [[nodiscard]] static size_t
  numIndices(const rvsdg::Node & node) noexcept
  {
    JLM_ASSERT(is<GetElementPtrOperation>(node.GetOperation()));
    return node.ninputs() - 1; // Subtract base address
  }
 
  [[nodiscard]] static rvsdg::Input &
  getBaseAddressInput(rvsdg::Node & node)
  {
    JLM_ASSERT(is<GetElementPtrOperation>(node.GetOperation()));
    const auto baseAddress = node.input(0);
    JLM_ASSERT(is<PointerType>(baseAddress->Type()));
    return *baseAddress;
  }
 
  [[nodiscard]] static const rvsdg::Input &
  getBaseAddressInput(const rvsdg::Node & node)
  {
    JLM_ASSERT(is<GetElementPtrOperation>(node.GetOperation()));
    const auto baseAddress = node.input(0);
    JLM_ASSERT(is<PointerType>(baseAddress->Type()));
    return *baseAddress;
  }
 
  static std::unique_ptr<ThreeAddressCode>
  createTAC(
      const Variable * baseAddress,
      const std::vector<const Variable *> & offsets,
      std::shared_ptr<const rvsdg::Type> pointeeType)
  {
    checkPointerType(baseAddress->type());
    auto offsetTypes = checkAndExtractIndexTypes<const Variable>(offsets);
 
    auto operation = std::make_unique<GetElementPtrOperation>(offsetTypes, std::move(pointeeType));
    std::vector operands(1, baseAddress);
    operands.insert(operands.end(), offsets.begin(), offsets.end());
 
    return ThreeAddressCode::create(std::move(operation), operands);
  }
 
  static rvsdg::SimpleNode &
  createNode(
      rvsdg::Output & baseAddress,
      const std::vector<rvsdg::Output *> & indices,
      std::shared_ptr<const rvsdg::Type> pointeeType)
  {
    checkPointerType(*baseAddress.Type());
    const auto indicesTypes = checkAndExtractIndexTypes<rvsdg::Output>(indices);
 
    std::vector operands(1, &baseAddress);
    operands.insert(operands.end(), indices.begin(), indices.end());
 
    return rvsdg::CreateOpNode<GetElementPtrOperation>(
        operands,
        indicesTypes,
        std::move(pointeeType));
  }
 
  static rvsdg::Output *
  create(
      rvsdg::Output * baseAddress,
      const std::vector<rvsdg::Output *> & indices,
      std::shared_ptr<const rvsdg::Type> pointeeType)
  {
    return createNode(*baseAddress, indices, std::move(pointeeType)).output(0);
  }
 
private:
  static void
  checkPointerType(const rvsdg::Type & type)
  {
    if (!is<PointerType>(type))
    {
      throw util::Error("Expected pointer type.");
    }
  }
 
  template<class T>
  static std::vector<std::shared_ptr<const rvsdg::BitType>>
  checkAndExtractIndexTypes(const std::vector<T *> & indices)
  {
    std::vector<std::shared_ptr<const rvsdg::BitType>> offsetTypes;
    for (const auto & offset : indices)
    {
      if (auto offsetType = std::dynamic_pointer_cast<const rvsdg::BitType>(offset->Type()))
      {
        offsetTypes.emplace_back(std::move(offsetType));
        continue;
      }
 
      throw util::Error("Expected bitstring type.");
    }
 
    return offsetTypes;
  }
 
  static std::vector<std::shared_ptr<const rvsdg::Type>>
  createOperandTypes(const std::vector<std::shared_ptr<const rvsdg::BitType>> & indexTypes)
  {
    std::vector<std::shared_ptr<const rvsdg::Type>> types({ PointerType::Create() });
    types.insert(types.end(), indexTypes.begin(), indexTypes.end());
 
    return types;
  }
 
  std::shared_ptr<const rvsdg::Type> pointeeType_;
};
 
}
 
#endif