Store.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_STORE_HPP
#define JLM_LLVM_IR_OPERATORS_STORE_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 StoreOperation : public rvsdg::SimpleOperation
{
protected:
  StoreOperation(
      const std::vector<std::shared_ptr<const rvsdg::Type>> & operandTypes,
      const std::vector<std::shared_ptr<const rvsdg::Type>> & resultTypes,
      size_t numMemoryStates,
      size_t alignment)
      : SimpleOperation(operandTypes, resultTypes),
        NumMemoryStates_(numMemoryStates),
        Alignment_(alignment)
  {
    JLM_ASSERT(operandTypes.size() >= 2);
 
    auto & addressType = *operandTypes[0];
    JLM_ASSERT(is<PointerType>(addressType));
 
    auto & storedType = *operandTypes[1];
    JLM_ASSERT(storedType.Kind() == rvsdg::TypeKind::Value);
 
    JLM_ASSERT(operandTypes.size() == resultTypes.size() + 2);
    for (size_t n = 0; n < resultTypes.size(); n++)
    {
      auto & operandType = *operandTypes[n + 2];
      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]] const rvsdg::Type &
  GetStoredType() const noexcept
  {
    return *argument(1).get();
  }
 
  [[nodiscard]] size_t
  NumMemoryStates() const noexcept
  {
    return NumMemoryStates_;
  }
 
  [[nodiscard]] static rvsdg::Input &
  AddressInput(const rvsdg::Node & node) noexcept
  {
    JLM_ASSERT(is<StoreOperation>(&node));
    auto & input = *node.input(0);
    JLM_ASSERT(is<PointerType>(input.Type()));
    return input;
  }
 
  [[nodiscard]] static rvsdg::Input &
  StoredValueInput(const rvsdg::Node & node) noexcept
  {
    JLM_ASSERT(is<StoreOperation>(&node));
    auto & input = *node.input(1);
    JLM_ASSERT(input.Type()->Kind() == rvsdg::TypeKind::Value);
    return input;
  }
 
  [[nodiscard]] static rvsdg::Node::OutputIteratorRange
  MemoryStateOutputs(const rvsdg::Node & node) noexcept
  {
    const auto storeOperation = util::assertedCast<const StoreOperation>(&node.GetOperation());
    if (storeOperation->NumMemoryStates_ == 0)
    {
      return { rvsdg::Output::Iterator(nullptr), rvsdg::Output::Iterator(nullptr) };
    }
 
    const auto firstMemoryStateOutput =
        node.output(storeOperation->nresults() - storeOperation->NumMemoryStates_);
    JLM_ASSERT(is<MemoryStateType>(firstMemoryStateOutput->Type()));
    return { rvsdg::Output::Iterator(firstMemoryStateOutput), rvsdg::Output::Iterator(nullptr) };
  }
 
  [[nodiscard]] static rvsdg::Node::InputIteratorRange
  getMemoryStateInputs(const rvsdg::Node & node) noexcept
  {
    const auto storeOperation = util::assertedCast<const StoreOperation>(&node.GetOperation());
    if (storeOperation->NumMemoryStates_ == 0)
    {
      return { rvsdg::Input::Iterator(nullptr), rvsdg::Input::Iterator(nullptr) };
    }
 
    const auto firstMemoryStateInput =
        node.input(storeOperation->narguments() - storeOperation->NumMemoryStates_);
    JLM_ASSERT(is<MemoryStateType>(firstMemoryStateInput->Type()));
    return { rvsdg::Input::Iterator(firstMemoryStateInput), rvsdg::Input::Iterator(nullptr) };
  }
 
  [[nodiscard]] static std::vector<rvsdg::Output *>
  getMemoryStateOperands(const rvsdg::Node & node) noexcept
  {
    std::vector<rvsdg::Output *> operands;
    for (auto & input : getMemoryStateInputs(node))
      operands.push_back(input.origin());
 
    return operands;
  }
 
  [[nodiscard]] static rvsdg::Input &
  MapMemoryStateOutputToInput(const rvsdg::Output & output)
  {
    JLM_ASSERT(is<MemoryStateType>(output.Type()));
    auto [storeNode, storeOperation] = rvsdg::TryGetSimpleNodeAndOptionalOp<StoreOperation>(output);
    JLM_ASSERT(storeOperation);
    JLM_ASSERT(storeNode->ninputs() - 2 == storeNode->noutputs());
    const auto input = storeNode->input(output.index() + 2);
    JLM_ASSERT(is<MemoryStateType>(input->Type()));
    return *input;
  }
 
private:
  size_t NumMemoryStates_;
  size_t Alignment_;
};
 
class StoreNonVolatileOperation final : public StoreOperation
{
public:
  ~StoreNonVolatileOperation() noexcept override;
 
  StoreNonVolatileOperation(
      std::shared_ptr<const rvsdg::Type> storedType,
      const size_t numMemoryStates,
      const size_t alignment)
      : StoreOperation(
            CreateOperandTypes(std::move(storedType), numMemoryStates),
            { numMemoryStates, MemoryStateType::Create() },
            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 *>>
  NormalizeStoreMux(
      const StoreNonVolatileOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
 
  static std::optional<std::vector<rvsdg::Output *>>
  normalizeStoreStore(
      const StoreNonVolatileOperation & store2Op,
      const std::vector<rvsdg::Output *> & operands);
 
  static std::optional<std::vector<rvsdg::Output *>>
  NormalizeStoreAlloca(
      const StoreNonVolatileOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
 
  static std::optional<std::vector<rvsdg::Output *>>
  NormalizeDuplicateStates(
      const StoreNonVolatileOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
 
  static std::optional<std::vector<rvsdg::Output *>>
  normalizeIOBarrierAddress(
      const StoreNonVolatileOperation & storeOperation,
      const std::vector<rvsdg::Output *> & operands);
 
  static std::optional<std::vector<rvsdg::Output *>>
  normalizeStoreAllocaSingleUser(
      const StoreNonVolatileOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
 
  static std::unique_ptr<llvm::ThreeAddressCode>
  Create(const Variable * address, const Variable * value, const Variable * state, size_t alignment)
  {
    auto storedType = CheckAndExtractStoredType(value->Type());
 
    auto op = std::make_unique<StoreNonVolatileOperation>(storedType, 1, alignment);
    return ThreeAddressCode::create(std::move(op), { address, value, state });
  }
 
  static std::vector<rvsdg::Output *>
  Create(
      rvsdg::Output * address,
      rvsdg::Output * value,
      const std::vector<rvsdg::Output *> & memoryStates,
      size_t alignment)
  {
    return outputs(&CreateNode(*address, *value, memoryStates, alignment));
  }
 
  static rvsdg::SimpleNode &
  CreateNode(
      rvsdg::Output & address,
      rvsdg::Output & value,
      const std::vector<rvsdg::Output *> & memoryStates,
      size_t alignment)
  {
    auto storedType = CheckAndExtractStoredType(value.Type());
 
    std::vector operands({ &address, &value });
    operands.insert(operands.end(), memoryStates.begin(), memoryStates.end());
 
    auto operation = std::make_unique<StoreNonVolatileOperation>(
        std::move(storedType),
        memoryStates.size(),
        alignment);
    return CreateNode(*address.region(), std::move(operation), operands);
  }
 
  static std::vector<rvsdg::Output *>
  Create(
      rvsdg::Region & region,
      std::unique_ptr<StoreNonVolatileOperation> storeOperation,
      const std::vector<rvsdg::Output *> & operands)
  {
    return outputs(&CreateNode(region, std::move(storeOperation), operands));
  }
 
  static rvsdg::SimpleNode &
  CreateNode(
      rvsdg::Region & region,
      std::unique_ptr<StoreNonVolatileOperation> storeOperation,
      const std::vector<rvsdg::Output *> & operands)
  {
    return rvsdg::SimpleNode::Create(region, std::move(storeOperation), operands);
  }
 
private:
  static const std::shared_ptr<const jlm::rvsdg::Type>
  CheckAndExtractStoredType(const std::shared_ptr<const rvsdg::Type> & type)
  {
    if (type->Kind() == rvsdg::TypeKind::Value)
    {
      return type;
    }
 
    throw util::Error("Expected value type");
  }
 
  static std::vector<std::shared_ptr<const rvsdg::Type>>
  CreateOperandTypes(std::shared_ptr<const rvsdg::Type> storedType, size_t numMemoryStates)
  {
    std::vector<std::shared_ptr<const rvsdg::Type>> types(
        { PointerType::Create(), std::move(storedType) });
    std::vector<std::shared_ptr<const rvsdg::Type>> states(
        numMemoryStates,
        MemoryStateType::Create());
    types.insert(types.end(), states.begin(), states.end());
    return types;
  }
};
 
class StoreVolatileOperation final : public StoreOperation
{
public:
  ~StoreVolatileOperation() noexcept override;
 
  StoreVolatileOperation(
      std::shared_ptr<const rvsdg::Type> storedType,
      const size_t numMemoryStates,
      const size_t alignment)
      : StoreOperation(
            CreateOperandTypes(std::move(storedType), numMemoryStates),
            CreateResultTypes(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<StoreOperation>(&node));
    auto & input = *node.input(2);
    JLM_ASSERT(is<IOStateType>(input.Type()));
    return input;
  }
 
  [[nodiscard]] static rvsdg::Output &
  IOStateOutput(const rvsdg::Node & node) noexcept
  {
    JLM_ASSERT(is<StoreOperation>(&node));
    auto & output = *node.output(0);
    JLM_ASSERT(is<IOStateType>(output.Type()));
    return output;
  }
 
  static std::unique_ptr<llvm::ThreeAddressCode>
  Create(
      const Variable * address,
      const Variable * value,
      const Variable * ioState,
      const Variable * memoryState,
      size_t alignment)
  {
    auto storedType = CheckAndExtractStoredType(value->Type());
 
    auto op = std::make_unique<StoreVolatileOperation>(storedType, 1, alignment);
    return ThreeAddressCode::create(std::move(op), { address, value, ioState, memoryState });
  }
 
  static rvsdg::SimpleNode &
  CreateNode(
      rvsdg::Region & region,
      std::unique_ptr<StoreVolatileOperation> storeOperation,
      const std::vector<rvsdg::Output *> & operands)
  {
    return rvsdg::SimpleNode::Create(region, std::move(storeOperation), operands);
  }
 
  static rvsdg::SimpleNode &
  CreateNode(
      rvsdg::Output & address,
      rvsdg::Output & value,
      rvsdg::Output & ioState,
      const std::vector<rvsdg::Output *> & memoryStates,
      size_t alignment)
  {
    auto storedType = CheckAndExtractStoredType(value.Type());
 
    std::vector<rvsdg::Output *> operands({ &address, &value, &ioState });
    operands.insert(operands.end(), memoryStates.begin(), memoryStates.end());
 
    auto operation =
        std::make_unique<StoreVolatileOperation>(storedType, memoryStates.size(), alignment);
    return CreateNode(*address.region(), std::move(operation), operands);
  }
 
  static std::vector<rvsdg::Output *>
  Create(
      rvsdg::Region & region,
      std::unique_ptr<StoreVolatileOperation> storeOperation,
      const std::vector<rvsdg::Output *> & operands)
  {
    return rvsdg::outputs(&CreateNode(region, std::move(storeOperation), operands));
  }
 
private:
  static std::shared_ptr<const rvsdg::Type>
  CheckAndExtractStoredType(const std::shared_ptr<const rvsdg::Type> & type)
  {
    if (type->Kind() == rvsdg::TypeKind::Value)
      return type;
 
    throw util::Error("Expected value type");
  }
 
  static std::vector<std::shared_ptr<const rvsdg::Type>>
  CreateOperandTypes(std::shared_ptr<const rvsdg::Type> storedType, size_t numMemoryStates)
  {
    std::vector<std::shared_ptr<const rvsdg::Type>> types(
        { PointerType::Create(), std::move(storedType), 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(size_t numMemoryStates)
  {
    std::vector<std::shared_ptr<const rvsdg::Type>> types({ IOStateType::Create() });
    std::vector<std::shared_ptr<const rvsdg::Type>> memoryStates(
        numMemoryStates,
        MemoryStateType::Create());
    types.insert(types.end(), memoryStates.begin(), memoryStates.end());
    return types;
  }
};
 
}
 
#endif