Load.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_OPERATORS_LOAD_HPP
#define JLM_LLVM_IR_OPERATORS_LOAD_HPP
 
#include <jlm/llvm/ir/tac.hpp>
#include <jlm/llvm/ir/types.hpp>
#include <jlm/rvsdg/graph.hpp>
#include <jlm/rvsdg/simple-node.hpp>
 
#include <optional>
 
namespace jlm::llvm
{
 
class LoadOperation : public rvsdg::SimpleOperation
{
protected:
  LoadOperation(
      const std::vector<std::shared_ptr<const rvsdg::Type>> & operandTypes,
      const std::vector<std::shared_ptr<const rvsdg::Type>> & resultTypes,
      const size_t numMemoryStates,
      const size_t alignment)
      : SimpleOperation(operandTypes, resultTypes),
        NumMemoryStates_(numMemoryStates),
        Alignment_(alignment)
  {
    JLM_ASSERT(!operandTypes.empty() && !resultTypes.empty());
 
    auto & addressType = *operandTypes[0];
    JLM_ASSERT(is<PointerType>(addressType));
 
    auto & loadedType = *resultTypes[0];
    JLM_ASSERT(loadedType.Kind() == rvsdg::TypeKind::Value);
 
    JLM_ASSERT(operandTypes.size() == resultTypes.size());
    for (size_t n = 1; n < operandTypes.size(); n++)
    {
      auto & operandType = *operandTypes[n];
      auto & resultType = *resultTypes[n];
      JLM_ASSERT(operandType == resultType);
      JLM_ASSERT(operandType.Kind() == rvsdg::TypeKind::State);
    }
  }
 
public:
  [[nodiscard]] size_t
  GetAlignment() const noexcept
  {
    return Alignment_;
  }
 
  [[nodiscard]] std::shared_ptr<const rvsdg::Type>
  GetLoadedType() const noexcept
  {
    return result(0);
  }
 
  [[nodiscard]] size_t
  NumMemoryStates() const noexcept
  {
    return NumMemoryStates_;
  }
 
  [[nodiscard]] static rvsdg::Input &
  AddressInput(const rvsdg::Node & node) noexcept
  {
    JLM_ASSERT(is<LoadOperation>(&node));
    const auto input = node.input(0);
    JLM_ASSERT(is<PointerType>(input->Type()));
    return *input;
  }
 
  [[nodiscard]] static rvsdg::Output &
  LoadedValueOutput(const rvsdg::Node & node)
  {
    JLM_ASSERT(is<LoadOperation>(&node));
    const auto output = node.output(0);
    JLM_ASSERT(output->Type()->Kind() == rvsdg::TypeKind::Value);
    return *output;
  }
 
  [[nodiscard]] static rvsdg::Node::OutputIteratorRange
  MemoryStateOutputs(const rvsdg::Node & node) noexcept
  {
    const auto loadOperation = util::assertedCast<const LoadOperation>(&node.GetOperation());
    if (loadOperation->NumMemoryStates_ == 0)
    {
      return { rvsdg::Output::Iterator(nullptr), rvsdg::Output::Iterator(nullptr) };
    }
 
    const auto firstMemoryStateOutput =
        node.output(loadOperation->nresults() - loadOperation->NumMemoryStates_);
    JLM_ASSERT(is<MemoryStateType>(firstMemoryStateOutput->Type()));
    return { rvsdg::Output::Iterator(firstMemoryStateOutput), rvsdg::Output::Iterator(nullptr) };
  }
 
  [[nodiscard]] static rvsdg::Node::InputIteratorRange
  MemoryStateInputs(const rvsdg::Node & node) noexcept
  {
    const auto loadOperation = util::assertedCast<const LoadOperation>(&node.GetOperation());
    if (loadOperation->NumMemoryStates_ == 0)
    {
      return { rvsdg::Input::Iterator(nullptr), rvsdg::Input::Iterator(nullptr) };
    }
 
    const auto firstMemoryStateOutput =
        node.input(loadOperation->narguments() - loadOperation->NumMemoryStates_);
    JLM_ASSERT(is<MemoryStateType>(firstMemoryStateOutput->Type()));
    return { rvsdg::Input::Iterator(firstMemoryStateOutput), rvsdg::Input::Iterator(nullptr) };
  }
 
  [[nodiscard]] static rvsdg::Input &
  MapMemoryStateOutputToInput(const rvsdg::Output & output)
  {
    JLM_ASSERT(is<MemoryStateType>(output.Type()));
    auto [loadNode, loadOperation] = rvsdg::TryGetSimpleNodeAndOptionalOp<LoadOperation>(output);
    JLM_ASSERT(loadOperation);
    JLM_ASSERT(loadNode->ninputs() == loadNode->noutputs());
    const auto input = loadNode->input(output.index());
    JLM_ASSERT(is<MemoryStateType>(input->Type()));
    return *input;
  }
 
  [[nodiscard]] static rvsdg::Output &
  mapMemoryStateInputToOutput(const rvsdg::Input & input)
  {
    JLM_ASSERT(is<MemoryStateType>(input.Type()));
    auto [loadNode, loadOperation] = rvsdg::TryGetSimpleNodeAndOptionalOp<LoadOperation>(input);
    JLM_ASSERT(loadOperation);
    JLM_ASSERT(loadNode->ninputs() == loadNode->noutputs());
    const auto output = loadNode->output(input.index());
    JLM_ASSERT(is<MemoryStateType>(output->Type()));
    return *output;
  }
 
private:
  size_t NumMemoryStates_;
  size_t Alignment_;
};
 
class LoadVolatileOperation final : public LoadOperation
{
public:
  ~LoadVolatileOperation() noexcept override;
 
  LoadVolatileOperation(
      std::shared_ptr<const rvsdg::Type> loadedType,
      size_t numMemoryStates,
      size_t alignment)
      : LoadOperation(
            CreateOperandTypes(numMemoryStates),
            CreateResultTypes(std::move(loadedType), numMemoryStates),
            numMemoryStates,
            alignment)
  {}
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  [[nodiscard]] std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  [[nodiscard]] static rvsdg::Input &
  IOStateInput(const rvsdg::Node & node) noexcept
  {
    JLM_ASSERT(is<LoadVolatileOperation>(&node));
    const auto input = node.input(1);
    JLM_ASSERT(is<IOStateType>(input->Type()));
    return *input;
  }
 
  [[nodiscard]] static rvsdg::Output &
  IOStateOutput(const rvsdg::Node & node)
  {
    JLM_ASSERT(is<LoadVolatileOperation>(&node));
    const auto output = node.output(1);
    JLM_ASSERT(is<IOStateType>(output->Type()));
    return *output;
  }
 
  static std::unique_ptr<llvm::ThreeAddressCode>
  Create(
      const Variable * address,
      const Variable * iOState,
      const Variable * memoryState,
      std::shared_ptr<const rvsdg::Type> loadedType,
      size_t alignment)
  {
    auto operation = std::make_unique<LoadVolatileOperation>(std::move(loadedType), 1, alignment);
    return ThreeAddressCode::create(std::move(operation), { address, iOState, memoryState });
  }
 
  static rvsdg::SimpleNode &
  CreateNode(
      rvsdg::Region & region,
      std::unique_ptr<LoadVolatileOperation> loadOperation,
      const std::vector<rvsdg::Output *> & operands);
 
  static rvsdg::SimpleNode &
  CreateNode(
      rvsdg::Output & address,
      rvsdg::Output & iOState,
      const std::vector<rvsdg::Output *> & memoryStates,
      std::shared_ptr<const rvsdg::Type> loadedType,
      size_t alignment)
  {
    std::vector operands({ &address, &iOState });
    operands.insert(operands.end(), memoryStates.begin(), memoryStates.end());
 
    auto operation = std::make_unique<LoadVolatileOperation>(
        std::move(loadedType),
        memoryStates.size(),
        alignment);
    return CreateNode(*address.region(), std::move(operation), operands);
  }
 
private:
  static std::vector<std::shared_ptr<const rvsdg::Type>>
  CreateOperandTypes(size_t numMemoryStates)
  {
    std::vector<std::shared_ptr<const rvsdg::Type>> types(
        { PointerType::Create(), IOStateType::Create() });
    std::vector<std::shared_ptr<const rvsdg::Type>> states(
        numMemoryStates,
        MemoryStateType::Create());
    types.insert(types.end(), states.begin(), states.end());
    return types;
  }
 
  static std::vector<std::shared_ptr<const rvsdg::Type>>
  CreateResultTypes(std::shared_ptr<const rvsdg::Type> loadedType, size_t numMemoryStates)
  {
    std::vector<std::shared_ptr<const rvsdg::Type>> types(
        { std::move(loadedType), IOStateType::Create() });
    std::vector<std::shared_ptr<const rvsdg::Type>> states(
        numMemoryStates,
        MemoryStateType::Create());
    types.insert(types.end(), states.begin(), states.end());
    return types;
  }
};
 
class LoadNonVolatileOperation final : public LoadOperation
{
public:
  ~LoadNonVolatileOperation() noexcept override;
 
  LoadNonVolatileOperation(
      std::shared_ptr<const rvsdg::Type> loadedType,
      size_t numMemoryStates,
      size_t alignment)
      : LoadOperation(
            CreateOperandTypes(numMemoryStates),
            CreateResultTypes(std::move(loadedType), numMemoryStates),
            numMemoryStates,
            alignment)
  {}
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  [[nodiscard]] std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  static std::optional<std::vector<rvsdg::Output *>>
  NormalizeLoadAlloca(
      const LoadNonVolatileOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
 
  static std::optional<std::vector<rvsdg::Output *>>
  NormalizeLoadStore(
      const LoadNonVolatileOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
 
  static std::optional<std::vector<rvsdg::Output *>>
  NormalizeLoadStoreState(
      const LoadNonVolatileOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
 
  static std::optional<std::vector<rvsdg::Output *>>
  NormalizeDuplicateStates(
      const LoadNonVolatileOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
 
  static std::optional<std::vector<rvsdg::Output *>>
  NormalizeIOBarrierAllocaAddress(
      const LoadNonVolatileOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
 
  static std::unique_ptr<llvm::ThreeAddressCode>
  Create(
      const Variable * address,
      const Variable * state,
      std::shared_ptr<const rvsdg::Type> loadedType,
      size_t alignment)
  {
    auto operation =
        std::make_unique<LoadNonVolatileOperation>(std::move(loadedType), 1, alignment);
    return ThreeAddressCode::create(std::move(operation), { address, state });
  }
 
  static std::vector<rvsdg::Output *>
  Create(
      rvsdg::Output * address,
      const std::vector<rvsdg::Output *> & memoryStates,
      std::shared_ptr<const rvsdg::Type> loadedType,
      const size_t alignment)
  {
    return rvsdg::outputs(&CreateNode(*address, memoryStates, std::move(loadedType), alignment));
  }
 
  static rvsdg::SimpleNode &
  CreateNode(
      rvsdg::Region & region,
      std::unique_ptr<LoadNonVolatileOperation> loadOperation,
      const std::vector<rvsdg::Output *> & operands)
  {
    return rvsdg::SimpleNode::Create(region, std::move(loadOperation), operands);
  }
 
  static std::vector<rvsdg::Output *>
  Create(
      rvsdg::Region & region,
      std::unique_ptr<LoadNonVolatileOperation> loadOperation,
      const std::vector<rvsdg::Output *> & operands)
  {
    return outputs(&CreateNode(region, std::move(loadOperation), operands));
  }
 
  static rvsdg::SimpleNode &
  CreateNode(
      rvsdg::Output & address,
      const std::vector<rvsdg::Output *> & memoryStates,
      std::shared_ptr<const rvsdg::Type> loadedType,
      size_t alignment)
  {
    std::vector operands({ &address });
    operands.insert(operands.end(), memoryStates.begin(), memoryStates.end());
 
    auto operation = std::make_unique<LoadNonVolatileOperation>(
        std::move(loadedType),
        memoryStates.size(),
        alignment);
    return CreateNode(*address.region(), std::move(operation), operands);
  }
 
private:
  static std::vector<std::shared_ptr<const rvsdg::Type>>
  CreateOperandTypes(size_t numMemoryStates)
  {
    std::vector<std::shared_ptr<const rvsdg::Type>> types(1, PointerType::Create());
    std::vector<std::shared_ptr<const rvsdg::Type>> states(
        numMemoryStates,
        MemoryStateType::Create());
    types.insert(types.end(), states.begin(), states.end());
    return types;
  }
 
  static std::vector<std::shared_ptr<const rvsdg::Type>>
  CreateResultTypes(std::shared_ptr<const rvsdg::Type> loadedType, size_t numMemoryStates)
  {
    std::vector<std::shared_ptr<const rvsdg::Type>> types(1, std::move(loadedType));
    std::vector<std::shared_ptr<const rvsdg::Type>> states(
        numMemoryStates,
        MemoryStateType::Create());
    types.insert(types.end(), states.begin(), states.end());
    return types;
  }
};
 
}
 
#endif