call.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_CALL_HPP
#define JLM_LLVM_IR_OPERATORS_CALL_HPP
 
#include <jlm/llvm/ir/attribute.hpp>
#include <jlm/llvm/ir/CallingConvention.hpp>
#include <jlm/llvm/ir/operators/lambda.hpp>
#include <jlm/llvm/ir/operators/MemoryStateOperations.hpp>
#include <jlm/llvm/ir/tac.hpp>
#include <jlm/llvm/ir/types.hpp>
#include <jlm/rvsdg/Phi.hpp>
#include <jlm/rvsdg/simple-node.hpp>
 
namespace jlm::llvm
{
 
class CallTypeClassifier final
{
public:
  enum class CallType
  {
    NonRecursiveDirectCall,
 
    RecursiveDirectCall,
 
    ExternalCall,
 
    IndirectCall
  };
 
  CallTypeClassifier(CallType callType, jlm::rvsdg::Output & output)
      : CallType_(callType),
        Output_(&output)
  {}
 
  [[nodiscard]] CallType
  GetCallType() const noexcept
  {
    return CallType_;
  }
 
  [[nodiscard]] bool
  IsNonRecursiveDirectCall() const noexcept
  {
    return GetCallType() == CallType::NonRecursiveDirectCall;
  }
 
  [[nodiscard]] bool
  IsRecursiveDirectCall() const noexcept
  {
    return GetCallType() == CallType::RecursiveDirectCall;
  }
 
  [[nodiscard]] bool
  IsDirectCall() const noexcept
  {
    return GetCallType() == CallType::NonRecursiveDirectCall
        || GetCallType() == CallType::RecursiveDirectCall;
  }
 
  [[nodiscard]] bool
  IsExternalCall() const noexcept
  {
    return GetCallType() == CallType::ExternalCall;
  }
 
  [[nodiscard]] bool
  IsIndirectCall() const noexcept
  {
    return GetCallType() == CallType::IndirectCall;
  }
 
  [[nodiscard]] rvsdg::Output &
  GetLambdaOutput() const noexcept
  {
    if (GetCallType() == CallType::NonRecursiveDirectCall)
    {
      return *Output_;
    }
 
    JLM_ASSERT(GetCallType() == CallType::RecursiveDirectCall);
    auto argument = jlm::util::assertedCast<jlm::rvsdg::RegionArgument>(Output_);
    /*
     * FIXME: This assumes that all recursion variables where added before the dependencies. It
     * would be better if we did not use the index for retrieving the result, but instead
     * explicitly encoded it in an phi_argument.
     */
    return *argument->region()->result(argument->index())->origin();
  }
 
  [[nodiscard]] rvsdg::RegionArgument &
  GetImport() const noexcept
  {
    JLM_ASSERT(GetCallType() == CallType::ExternalCall);
    return *jlm::util::assertedCast<rvsdg::RegionArgument>(Output_);
  }
 
  [[nodiscard]] jlm::rvsdg::Output &
  GetFunctionOrigin() const noexcept
  {
    return *Output_;
  }
 
  [[nodiscard]] bool
  isSetjmpCall();
 
  [[nodiscard]] bool
  isVaStartCall();
 
  static std::unique_ptr<CallTypeClassifier>
  CreateNonRecursiveDirectCallClassifier(rvsdg::Output & output)
  {
    rvsdg::AssertGetOwnerNode<rvsdg::LambdaNode>(output);
    return std::make_unique<CallTypeClassifier>(CallType::NonRecursiveDirectCall, output);
  }
 
  static std::unique_ptr<CallTypeClassifier>
  CreateRecursiveDirectCallClassifier(rvsdg::Output & output)
  {
    return std::make_unique<CallTypeClassifier>(CallType::RecursiveDirectCall, output);
  }
 
  static std::unique_ptr<CallTypeClassifier>
  CreateExternalCallClassifier(rvsdg::RegionArgument & argument)
  {
    JLM_ASSERT(argument.region() == &argument.region()->graph()->GetRootRegion());
    return std::make_unique<CallTypeClassifier>(CallType::ExternalCall, argument);
  }
 
  static std::unique_ptr<CallTypeClassifier>
  CreateIndirectCallClassifier(jlm::rvsdg::Output & output)
  {
    return std::make_unique<CallTypeClassifier>(CallType::IndirectCall, output);
  }
 
private:
  CallType CallType_;
  jlm::rvsdg::Output * Output_;
};
 
class CallOperation final : public jlm::rvsdg::SimpleOperation
{
public:
  ~CallOperation() override;
 
  explicit CallOperation(
      std::shared_ptr<const rvsdg::FunctionType> functionType,
      CallingConvention callingConvention,
      AttributeList attributes)
      : SimpleOperation(create_srctypes(functionType), functionType->Results()),
        FunctionType_(std::move(functionType)),
        callingConvention_(callingConvention),
        attributes_(std::move(attributes))
  {}
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  [[nodiscard]] std::string
  debug_string() const override;
 
  [[nodiscard]] const std::shared_ptr<const rvsdg::FunctionType> &
  GetFunctionType() const noexcept
  {
    return FunctionType_;
  }
 
  [[nodiscard]] CallingConvention
  getCallingConvention() const noexcept
  {
    return callingConvention_;
  }
 
  [[nodiscard]] const AttributeList &
  getAttributes() const noexcept
  {
    return attributes_;
  }
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  [[nodiscard]] static size_t
  NumArguments(const rvsdg::Node & node) noexcept
  {
    JLM_ASSERT(is<CallOperation>(&node));
    return node.ninputs() - 1;
  }
 
  [[nodiscard]] static rvsdg::Input *
  Argument(const rvsdg::Node & node, const size_t n)
  {
    JLM_ASSERT(is<CallOperation>(&node));
    JLM_ASSERT(n < CallOperation::NumArguments(node));
    return node.input(n + 1);
  }
 
  [[nodiscard]] static rvsdg::Input &
  GetFunctionInput(const rvsdg::Node & node) noexcept
  {
    JLM_ASSERT(is<CallOperation>(&node));
    const auto functionInput = node.input(0);
    JLM_ASSERT(is<rvsdg::FunctionType>(functionInput->Type()));
    return *functionInput;
  }
 
  [[nodiscard]] static rvsdg::Input &
  GetIOStateInput(const rvsdg::Node & node) noexcept
  {
    JLM_ASSERT(is<CallOperation>(&node));
    const auto ioState = node.input(node.ninputs() - 2);
    JLM_ASSERT(is<IOStateType>(ioState->Type()));
    return *ioState;
  }
 
  [[nodiscard]] static rvsdg::Output &
  GetIOStateOutput(const rvsdg::Node & node) noexcept
  {
    JLM_ASSERT(is<CallOperation>(&node));
    const auto ioState = node.output(node.noutputs() - 2);
    JLM_ASSERT(is<IOStateType>(ioState->Type()));
    return *ioState;
  }
 
  [[nodiscard]] static rvsdg::Input &
  mapIOStateOutputToInput(rvsdg::Output & output)
  {
    JLM_ASSERT(is<IOStateType>(output.Type()));
    auto [callNode, callOperation] = rvsdg::TryGetSimpleNodeAndOptionalOp<CallOperation>(output);
    JLM_ASSERT(callOperation);
    return GetIOStateInput(*callNode);
  }
 
  [[nodiscard]] static rvsdg::Input &
  GetMemoryStateInput(const rvsdg::Node & node) noexcept
  {
    JLM_ASSERT(is<CallOperation>(&node));
    const auto memoryState = node.input(node.ninputs() - 1);
    JLM_ASSERT(is<MemoryStateType>(memoryState->Type()));
    return *memoryState;
  }
 
  [[nodiscard]] static rvsdg::Output &
  GetMemoryStateOutput(const rvsdg::Node & node) noexcept
  {
    JLM_ASSERT(is<CallOperation>(&node));
    const auto memoryState = node.output(node.noutputs() - 1);
    JLM_ASSERT(is<MemoryStateType>(memoryState->Type()));
    return *memoryState;
  }
 
  [[nodiscard]] static rvsdg::Input &
  mapMemoryStateOutputToInput(rvsdg::Output & output)
  {
    JLM_ASSERT(is<MemoryStateType>(output.Type()));
    auto [callNode, callOperation] = rvsdg::TryGetSimpleNodeAndOptionalOp<CallOperation>(output);
    JLM_ASSERT(callOperation);
    return GetMemoryStateInput(*callNode);
  }
 
  [[nodiscard]] static rvsdg::SimpleNode *
  tryGetMemoryStateEntryMerge(const rvsdg::Node & callNode) noexcept
  {
    JLM_ASSERT(is<CallOperation>(&callNode));
    const auto node =
        rvsdg::TryGetOwnerNode<rvsdg::SimpleNode>(*GetMemoryStateInput(callNode).origin());
    return is<CallEntryMemoryStateMergeOperation>(node) ? node : nullptr;
  }
 
  [[nodiscard]] static rvsdg::SimpleNode *
  tryGetMemoryStateExitSplit(const rvsdg::Node & callNode) noexcept
  {
    JLM_ASSERT(is<CallOperation>(&callNode));
 
    // If a memory state exit split node is present, then we would expect the node to be the only
    // user of the memory state output.
    if (GetMemoryStateOutput(callNode).nusers() != 1)
      return nullptr;
 
    const auto node =
        rvsdg::TryGetOwnerNode<rvsdg::SimpleNode>(GetMemoryStateOutput(callNode).SingleUser());
    return is<CallExitMemoryStateSplitOperation>(node) ? node : nullptr;
  }
 
  static rvsdg::Output &
  TraceFunctionInput(const rvsdg::SimpleNode & callNode);
 
  static std::unique_ptr<CallTypeClassifier>
  ClassifyCall(const rvsdg::SimpleNode & callNode);
 
  static std::unique_ptr<ThreeAddressCode>
  create(
      const Variable * function,
      std::shared_ptr<const rvsdg::FunctionType> functionType,
      CallingConvention callingConvention,
      AttributeList attributes,
      const std::vector<const Variable *> & arguments)
  {
    CheckFunctionInputType(function->type());
 
    auto op = std::make_unique<CallOperation>(
        std::move(functionType),
        callingConvention,
        std::move(attributes));
    std::vector<const Variable *> operands({ function });
    operands.insert(operands.end(), arguments.begin(), arguments.end());
    return ThreeAddressCode::create(std::move(op), operands);
  }
 
  static std::vector<rvsdg::Output *>
  Create(
      rvsdg::Output * function,
      std::shared_ptr<const rvsdg::FunctionType> functionType,
      const std::vector<rvsdg::Output *> & arguments)
  {
    return outputs(&CreateNode(function, std::move(functionType), arguments));
  }
 
  static std::vector<rvsdg::Output *>
  Create(
      rvsdg::Output * function,
      std::shared_ptr<const rvsdg::FunctionType> functionType,
      CallingConvention callingConvention,
      AttributeList attributes,
      const std::vector<rvsdg::Output *> & arguments)
  {
    return outputs(&CreateNode(
        function,
        std::move(functionType),
        callingConvention,
        std::move(attributes),
        arguments));
  }
 
  static rvsdg::SimpleNode &
  CreateNode(
      rvsdg::Region & region,
      std::unique_ptr<CallOperation> callOperation,
      const std::vector<rvsdg::Output *> & operands)
  {
    CheckFunctionType(*callOperation->GetFunctionType());
 
    return rvsdg::SimpleNode::Create(region, std::move(callOperation), operands);
  }
 
  static rvsdg::SimpleNode &
  CreateNode(
      rvsdg::Output * function,
      std::shared_ptr<const rvsdg::FunctionType> functionType,
      const std::vector<rvsdg::Output *> & arguments)
  {
    return CreateNode(
        function,
        std::move(functionType),
        CallingConvention::Default,
        AttributeList::createEmptyList(),
        arguments);
  }
 
  static rvsdg::SimpleNode &
  CreateNode(
      rvsdg::Output * function,
      std::shared_ptr<const rvsdg::FunctionType> functionType,
      CallingConvention callingConvention,
      AttributeList attributes,
      const std::vector<rvsdg::Output *> & arguments)
  {
    CheckFunctionInputType(*function->Type());
 
    auto callOperation = std::make_unique<CallOperation>(
        std::move(functionType),
        callingConvention,
        std::move(attributes));
    std::vector operands({ function });
    operands.insert(operands.end(), arguments.begin(), arguments.end());
 
    return CreateNode(*function->region(), std::move(callOperation), operands);
  }
 
private:
  static inline std::vector<std::shared_ptr<const rvsdg::Type>>
  create_srctypes(const std::shared_ptr<const rvsdg::FunctionType> & functionType)
  {
    std::vector<std::shared_ptr<const rvsdg::Type>> types({ functionType });
    for (auto & argumentType : functionType->Arguments())
      types.emplace_back(argumentType);
 
    return types;
  }
 
  static void
  CheckFunctionInputType(const jlm::rvsdg::Type & type)
  {
    if (!is<rvsdg::FunctionType>(type))
      throw util::Error("Expected function type.");
  }
 
  static void
  CheckFunctionType(const rvsdg::FunctionType & functionType)
  {
    auto CheckArgumentTypes = [](const rvsdg::FunctionType & functionType)
    {
      if (functionType.NumArguments() < 2)
        throw util::Error("Expected at least three argument types.");
 
      auto memoryStateArgumentIndex = functionType.NumArguments() - 1;
      auto iOStateArgumentIndex = functionType.NumArguments() - 2;
 
      if (!is<MemoryStateType>(functionType.ArgumentType(memoryStateArgumentIndex)))
        throw util::Error("Expected memory state type.");
 
      if (!is<IOStateType>(functionType.ArgumentType(iOStateArgumentIndex)))
        throw util::Error("Expected IO state type.");
    };
 
    auto CheckResultTypes = [](const rvsdg::FunctionType & functionType)
    {
      if (functionType.NumResults() < 2)
        throw util::Error("Expected at least three result types.");
 
      auto memoryStateResultIndex = functionType.NumResults() - 1;
      auto iOStateResultIndex = functionType.NumResults() - 2;
 
      if (!is<MemoryStateType>(functionType.ResultType(memoryStateResultIndex)))
        throw util::Error("Expected memory state type.");
 
      if (!is<IOStateType>(functionType.ResultType(iOStateResultIndex)))
        throw util::Error("Expected IO state type.");
    };
 
    CheckArgumentTypes(functionType);
    CheckResultTypes(functionType);
  }
 
  std::shared_ptr<const rvsdg::FunctionType> FunctionType_;
  CallingConvention callingConvention_;
  AttributeList attributes_;
};
 
}
 
#endif