TestRvsdgs.hpp

Go to the documentation of this file.

/*
 * Copyright 2020 Nico Reißmann <nico.reissmann@gmail.com>
 * See COPYING for terms of redistribution.
 */
 
#ifndef JLM_LLVM_TESTRVSDGS_HPP
#define JLM_LLVM_TESTRVSDGS_HPP
 
#include <jlm/llvm/ir/operators/delta.hpp>
#include <jlm/llvm/ir/RvsdgModule.hpp>
#include <jlm/rvsdg/lambda.hpp>
 
namespace jlm::rvsdg
{
class Graph;
class GammaNode;
class LambdaNode;
class PhiNode;
class ThetaNode;
}
 
namespace jlm::llvm
{
 
class RvsdgTest
{
public:
  virtual ~RvsdgTest() = default;
 
  jlm::llvm::LlvmRvsdgModule &
  module()
  {
    InitializeTest();
    return *module_;
  }
 
  const rvsdg::Graph &
  graph()
  {
    return module().Rvsdg();
  }
 
  void
  InitializeTest()
  {
    if (module_ == nullptr)
      module_ = SetupRvsdg();
  }
 
private:
  virtual std::unique_ptr<jlm::llvm::LlvmRvsdgModule>
  SetupRvsdg() = 0;
 
  std::unique_ptr<jlm::llvm::LlvmRvsdgModule> module_;
};
 
class StoreTest1 final : public RvsdgTest
{
private:
  std::unique_ptr<jlm::llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
public:
  jlm::rvsdg::LambdaNode * lambda;
 
  rvsdg::SimpleNode * size;
 
  rvsdg::SimpleNode * alloca_a;
  rvsdg::SimpleNode * alloca_b;
  rvsdg::SimpleNode * alloca_c;
  rvsdg::SimpleNode * alloca_d;
};
 
class StoreTest2 final : public RvsdgTest
{
private:
  std::unique_ptr<jlm::llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
public:
  jlm::rvsdg::LambdaNode * lambda;
 
  rvsdg::SimpleNode * size;
 
  rvsdg::SimpleNode * alloca_a;
  rvsdg::SimpleNode * alloca_b;
  rvsdg::SimpleNode * alloca_x;
  rvsdg::SimpleNode * alloca_y;
  rvsdg::SimpleNode * alloca_p;
};
 
class LoadTest1 final : public RvsdgTest
{
private:
  std::unique_ptr<jlm::llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
public:
  jlm::rvsdg::LambdaNode * lambda;
 
  rvsdg::Node * load_p;
  rvsdg::Node * load_x;
};
 
class LoadTest2 final : public RvsdgTest
{
private:
  std::unique_ptr<jlm::llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
public:
  jlm::rvsdg::LambdaNode * lambda;
 
  rvsdg::Node * size;
 
  rvsdg::SimpleNode * alloca_a;
  rvsdg::SimpleNode * alloca_b;
  rvsdg::SimpleNode * alloca_x;
  rvsdg::SimpleNode * alloca_y;
  rvsdg::SimpleNode * alloca_p;
 
  rvsdg::SimpleNode * load_x;
  rvsdg::SimpleNode * load_a;
};
 
class LoadFromUndefTest final : public RvsdgTest
{
private:
  std::unique_ptr<jlm::llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
public:
  [[nodiscard]] const jlm::rvsdg::LambdaNode &
  Lambda() const noexcept
  {
    return *Lambda_;
  }
 
  [[nodiscard]] const rvsdg::Node *
  UndefValueNode() const noexcept
  {
    return UndefValueNode_;
  }
 
private:
  jlm::rvsdg::LambdaNode * Lambda_{};
  rvsdg::Node * UndefValueNode_{};
};
 
class GetElementPtrTest final : public RvsdgTest
{
private:
  std::unique_ptr<jlm::llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
public:
  jlm::rvsdg::LambdaNode * lambda;
 
  rvsdg::Node * getElementPtrX;
  rvsdg::Node * getElementPtrY;
};
 
class BitCastTest final : public RvsdgTest
{
private:
  std::unique_ptr<jlm::llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
public:
  jlm::rvsdg::LambdaNode * lambda;
 
  rvsdg::Node * bitCast;
};
 
class Bits2PtrTest final : public RvsdgTest
{
public:
  [[nodiscard]] const jlm::rvsdg::LambdaNode &
  GetLambdaBits2Ptr() const noexcept
  {
    return *LambdaBits2Ptr_;
  }
 
  [[nodiscard]] const jlm::rvsdg::LambdaNode &
  GetLambdaTest() const noexcept
  {
    return *LambdaTest_;
  }
 
  [[nodiscard]] const rvsdg::SimpleNode &
  GetCallNode() const noexcept
  {
    return *CallNode_;
  }
 
  [[nodiscard]] const rvsdg::Node &
  GetBitsToPtrNode() const noexcept
  {
    return *BitsToPtrNode_;
  }
 
private:
  std::unique_ptr<jlm::llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
  jlm::rvsdg::LambdaNode * LambdaBits2Ptr_{};
  jlm::rvsdg::LambdaNode * LambdaTest_{};
 
  rvsdg::Node * BitsToPtrNode_{};
 
  rvsdg::SimpleNode * CallNode_{};
};
 
class ConstantPointerNullTest final : public RvsdgTest
{
private:
  std::unique_ptr<jlm::llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
public:
  jlm::rvsdg::LambdaNode * lambda;
 
  rvsdg::Node * constantPointerNullNode;
};
 
class CallTest1 final : public RvsdgTest
{
private:
  std::unique_ptr<jlm::llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
public:
  [[nodiscard]] const rvsdg::SimpleNode &
  CallF() const noexcept
  {
    return *CallF_;
  }
 
  [[nodiscard]] const rvsdg::SimpleNode &
  CallG() const noexcept
  {
    return *CallG_;
  }
 
  jlm::rvsdg::LambdaNode * lambda_f;
  jlm::rvsdg::LambdaNode * lambda_g;
  jlm::rvsdg::LambdaNode * lambda_h;
 
  rvsdg::SimpleNode * alloca_x;
  rvsdg::SimpleNode * alloca_y;
  rvsdg::SimpleNode * alloca_z;
 
private:
  rvsdg::SimpleNode * CallF_{};
  rvsdg::SimpleNode * CallG_{};
};
 
class CallTest2 final : public RvsdgTest
{
public:
  [[nodiscard]] const rvsdg::SimpleNode &
  CallCreate1() const noexcept
  {
    return *CallCreate1_;
  }
 
  [[nodiscard]] const rvsdg::SimpleNode &
  CallCreate2() const noexcept
  {
    return *CallCreate2_;
  }
 
  [[nodiscard]] const rvsdg::SimpleNode &
  CallDestroy1() const noexcept
  {
    return *CallDestroy1_;
  }
 
  [[nodiscard]] const rvsdg::SimpleNode &
  CallDestroy2() const noexcept
  {
    return *CallDestroy2_;
  }
 
  jlm::rvsdg::LambdaNode * lambda_create;
  jlm::rvsdg::LambdaNode * lambda_destroy;
  jlm::rvsdg::LambdaNode * lambda_test;
 
  rvsdg::SimpleNode * malloc;
  rvsdg::SimpleNode * free;
 
private:
  std::unique_ptr<jlm::llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
  rvsdg::SimpleNode * CallCreate1_{};
  rvsdg::SimpleNode * CallCreate2_{};
 
  rvsdg::SimpleNode * CallDestroy1_{};
  rvsdg::SimpleNode * CallDestroy2_{};
};
 
class IndirectCallTest1 final : public RvsdgTest
{
public:
  [[nodiscard]] const rvsdg::SimpleNode &
  CallIndcall() const noexcept
  {
    return *CallIndcall_;
  }
 
  [[nodiscard]] const rvsdg::SimpleNode &
  CallThree() const noexcept
  {
    return *CallThree_;
  }
 
  [[nodiscard]] const rvsdg::SimpleNode &
  CallFour() const noexcept
  {
    return *CallFour_;
  }
 
  [[nodiscard]] const jlm::rvsdg::LambdaNode &
  GetLambdaThree() const noexcept
  {
    return *LambdaThree_;
  }
 
  [[nodiscard]] const jlm::rvsdg::LambdaNode &
  GetLambdaFour() const noexcept
  {
    return *LambdaFour_;
  }
 
  [[nodiscard]] const jlm::rvsdg::LambdaNode &
  GetLambdaIndcall() const noexcept
  {
    return *LambdaIndcall_;
  }
 
  [[nodiscard]] const jlm::rvsdg::LambdaNode &
  GetLambdaTest() const noexcept
  {
    return *LambdaTest_;
  }
 
private:
  std::unique_ptr<jlm::llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
  rvsdg::SimpleNode * CallIndcall_{};
  rvsdg::SimpleNode * CallThree_{};
  rvsdg::SimpleNode * CallFour_{};
 
  jlm::rvsdg::LambdaNode * LambdaThree_{};
  jlm::rvsdg::LambdaNode * LambdaFour_{};
  jlm::rvsdg::LambdaNode * LambdaIndcall_{};
  jlm::rvsdg::LambdaNode * LambdaTest_{};
};
 
class IndirectCallTest2 final : public RvsdgTest
{
public:
  [[nodiscard]] jlm::rvsdg::DeltaNode &
  GetDeltaG1() const noexcept
  {
    return *DeltaG1_;
  }
 
  [[nodiscard]] jlm::rvsdg::DeltaNode &
  GetDeltaG2() const noexcept
  {
    return *DeltaG2_;
  }
 
  [[nodiscard]] jlm::rvsdg::LambdaNode &
  GetLambdaThree() const noexcept
  {
    return *LambdaThree_;
  }
 
  [[nodiscard]] jlm::rvsdg::LambdaNode &
  GetLambdaFour() const noexcept
  {
    return *LambdaFour_;
  }
 
  [[nodiscard]] jlm::rvsdg::LambdaNode &
  GetLambdaI() const noexcept
  {
    return *LambdaI_;
  }
 
  [[nodiscard]] jlm::rvsdg::LambdaNode &
  GetLambdaX() const noexcept
  {
    return *LambdaX_;
  }
 
  [[nodiscard]] jlm::rvsdg::LambdaNode &
  GetLambdaY() const noexcept
  {
    return *LambdaY_;
  }
 
  [[nodiscard]] jlm::rvsdg::LambdaNode &
  GetLambdaTest() const noexcept
  {
    return *LambdaTest_;
  }
 
  [[nodiscard]] jlm::rvsdg::LambdaNode &
  GetLambdaTest2() const noexcept
  {
    return *LambdaTest2_;
  }
 
  [[nodiscard]] rvsdg::SimpleNode &
  GetIndirectCall() const noexcept
  {
    return *IndirectCall_;
  }
 
  [[nodiscard]] rvsdg::SimpleNode &
  GetCallIWithThree() const noexcept
  {
    return *CallIWithThree_;
  }
 
  [[nodiscard]] rvsdg::SimpleNode &
  GetCallIWithFour() const noexcept
  {
    return *CallIWithFour_;
  }
 
  [[nodiscard]] rvsdg::SimpleNode &
  GetTestCallX() const noexcept
  {
    return *TestCallX_;
  }
 
  [[nodiscard]] rvsdg::SimpleNode &
  GetTest2CallX() const noexcept
  {
    return *Test2CallX_;
  }
 
  [[nodiscard]] rvsdg::SimpleNode &
  GetCallY() const noexcept
  {
    return *CallY_;
  }
 
  [[nodiscard]] jlm::rvsdg::SimpleNode &
  GetAllocaPx() const noexcept
  {
    return *AllocaPx_;
  }
 
  [[nodiscard]] jlm::rvsdg::SimpleNode &
  GetAllocaPy() const noexcept
  {
    return *AllocaPy_;
  }
 
  [[nodiscard]] jlm::rvsdg::SimpleNode &
  GetAllocaPz() const noexcept
  {
    return *AllocaPz_;
  }
 
private:
  std::unique_ptr<jlm::llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
  jlm::rvsdg::DeltaNode * DeltaG1_{};
  jlm::rvsdg::DeltaNode * DeltaG2_{};
 
  jlm::rvsdg::LambdaNode * LambdaThree_{};
  jlm::rvsdg::LambdaNode * LambdaFour_{};
  jlm::rvsdg::LambdaNode * LambdaI_{};
  jlm::rvsdg::LambdaNode * LambdaX_{};
  jlm::rvsdg::LambdaNode * LambdaY_{};
  jlm::rvsdg::LambdaNode * LambdaTest_{};
  jlm::rvsdg::LambdaNode * LambdaTest2_{};
 
  rvsdg::SimpleNode * IndirectCall_{};
  rvsdg::SimpleNode * CallIWithThree_{};
  rvsdg::SimpleNode * CallIWithFour_{};
  rvsdg::SimpleNode * TestCallX_{};
  rvsdg::SimpleNode * Test2CallX_{};
  rvsdg::SimpleNode * CallY_{};
 
  jlm::rvsdg::SimpleNode * AllocaPx_{};
  jlm::rvsdg::SimpleNode * AllocaPy_{};
  jlm::rvsdg::SimpleNode * AllocaPz_{};
};
 
class ExternalCallTest1 final : public RvsdgTest
{
public:
  [[nodiscard]] const jlm::rvsdg::LambdaNode &
  LambdaF() const noexcept
  {
    return *LambdaF_;
  }
 
  [[nodiscard]] const rvsdg::SimpleNode &
  CallG() const noexcept
  {
    return *CallG_;
  }
 
  [[nodiscard]] const jlm::rvsdg::GraphImport &
  ExternalGArgument() const noexcept
  {
    return *ExternalGArgument_;
  }
 
private:
  std::unique_ptr<jlm::llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
  jlm::rvsdg::LambdaNode * LambdaF_{};
 
  rvsdg::SimpleNode * CallG_{};
 
  jlm::rvsdg::GraphImport * ExternalGArgument_{};
};
 
class ExternalCallTest2 final : public RvsdgTest
{
public:
  [[nodiscard]] jlm::rvsdg::LambdaNode &
  LambdaG()
  {
    JLM_ASSERT(LambdaG_ != nullptr);
    return *LambdaG_;
  }
 
  [[nodiscard]] rvsdg::SimpleNode &
  CallF()
  {
    JLM_ASSERT(CallF_ != nullptr);
    return *CallF_;
  }
 
  [[nodiscard]] jlm::rvsdg::RegionArgument &
  ExternalF()
  {
    JLM_ASSERT(ExternalFArgument_ != nullptr);
    return *ExternalFArgument_;
  }
 
private:
  std::unique_ptr<jlm::llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
  jlm::rvsdg::LambdaNode * LambdaG_ = {};
 
  rvsdg::SimpleNode * CallF_ = {};
 
  jlm::rvsdg::RegionArgument * ExternalFArgument_ = {};
};
 
class GammaTest final : public RvsdgTest
{
private:
  std::unique_ptr<jlm::llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
public:
  jlm::rvsdg::LambdaNode * lambda;
 
  rvsdg::GammaNode * gamma;
};
 
class GammaTest2 final : public RvsdgTest
{
public:
  [[nodiscard]] rvsdg::LambdaNode &
  GetLambdaF() const noexcept
  {
    return *LambdaF_;
  }
 
  [[nodiscard]] rvsdg::LambdaNode &
  GetLambdaG() const noexcept
  {
    return *LambdaG_;
  }
 
  [[nodiscard]] rvsdg::LambdaNode &
  GetLambdaH() const noexcept
  {
    return *LambdaH_;
  }
 
  [[nodiscard]] rvsdg::GammaNode &
  GetGamma() const noexcept
  {
    return *Gamma_;
  }
 
  [[nodiscard]] rvsdg::SimpleNode &
  GetCallFromG() const noexcept
  {
    return *CallFromG_;
  }
 
  [[nodiscard]] rvsdg::SimpleNode &
  GetCallFromH() const noexcept
  {
    return *CallFromH_;
  }
 
  [[nodiscard]] rvsdg::Node &
  GetAllocaXFromG() const noexcept
  {
    return *AllocaXFromG_;
  }
 
  [[nodiscard]] rvsdg::Node &
  GetAllocaYFromG() const noexcept
  {
    return *AllocaYFromG_;
  }
 
  [[nodiscard]] rvsdg::Node &
  GetAllocaXFromH() const noexcept
  {
    return *AllocaXFromH_;
  }
 
  [[nodiscard]] rvsdg::Node &
  GetAllocaYFromH() const noexcept
  {
    return *AllocaYFromH_;
  }
 
  [[nodiscard]] rvsdg::Node &
  GetAllocaZ() const noexcept
  {
    return *AllocaZ_;
  }
 
private:
  std::unique_ptr<llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
  rvsdg::LambdaNode * LambdaF_{};
  rvsdg::LambdaNode * LambdaG_{};
  rvsdg::LambdaNode * LambdaH_{};
 
  rvsdg::GammaNode * Gamma_{};
 
  rvsdg::SimpleNode * CallFromG_{};
  rvsdg::SimpleNode * CallFromH_{};
 
  rvsdg::Node * AllocaXFromG_{};
  rvsdg::Node * AllocaYFromG_{};
  rvsdg::Node * AllocaXFromH_{};
  rvsdg::Node * AllocaYFromH_{};
  rvsdg::Node * AllocaZ_{};
};
 
class ThetaTest final : public RvsdgTest
{
private:
  std::unique_ptr<jlm::llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
public:
  jlm::rvsdg::LambdaNode * lambda;
  jlm::rvsdg::ThetaNode * theta;
  rvsdg::Node * gep;
};
 
class DeltaTest1 final : public RvsdgTest
{
public:
  [[nodiscard]] const rvsdg::SimpleNode &
  CallG() const noexcept
  {
    return *CallG_;
  }
 
  jlm::rvsdg::LambdaNode * lambda_g;
  jlm::rvsdg::LambdaNode * lambda_h;
 
  jlm::rvsdg::DeltaNode * delta_f;
 
  rvsdg::Node * constantFive;
 
private:
  std::unique_ptr<jlm::llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
  rvsdg::SimpleNode * CallG_{};
};
 
class DeltaTest2 final : public RvsdgTest
{
public:
  [[nodiscard]] const rvsdg::SimpleNode &
  CallF1() const noexcept
  {
    return *CallF1_;
  }
 
  jlm::rvsdg::LambdaNode * lambda_f1;
  jlm::rvsdg::LambdaNode * lambda_f2;
 
  jlm::rvsdg::DeltaNode * delta_d1;
  jlm::rvsdg::DeltaNode * delta_d2;
 
private:
  std::unique_ptr<jlm::llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
  rvsdg::SimpleNode * CallF1_{};
};
 
class DeltaTest3 final : public RvsdgTest
{
public:
  [[nodiscard]] const jlm::rvsdg::LambdaNode &
  LambdaF() const noexcept
  {
    return *LambdaF_;
  }
 
  [[nodiscard]] const jlm::rvsdg::LambdaNode &
  LambdaTest() const noexcept
  {
    return *LambdaTest_;
  }
 
  [[nodiscard]] const jlm::rvsdg::DeltaNode &
  DeltaG1() const noexcept
  {
    return *DeltaG1_;
  }
 
  [[nodiscard]] const jlm::rvsdg::DeltaNode &
  DeltaG2() const noexcept
  {
    return *DeltaG2_;
  }
 
  [[nodiscard]] const rvsdg::SimpleNode &
  CallF() const noexcept
  {
    return *CallF_;
  }
 
private:
  std::unique_ptr<jlm::llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
  jlm::rvsdg::LambdaNode * LambdaF_{};
  jlm::rvsdg::LambdaNode * LambdaTest_{};
 
  jlm::rvsdg::DeltaNode * DeltaG1_{};
  jlm::rvsdg::DeltaNode * DeltaG2_{};
 
  rvsdg::SimpleNode * CallF_{};
};
 
class ImportTest final : public RvsdgTest
{
public:
  [[nodiscard]] const rvsdg::SimpleNode &
  CallF1() const noexcept
  {
    return *CallF1_;
  }
 
  jlm::rvsdg::LambdaNode * lambda_f1;
  jlm::rvsdg::LambdaNode * lambda_f2;
 
  jlm::rvsdg::GraphImport * import_d1;
  jlm::rvsdg::GraphImport * import_d2;
 
private:
  std::unique_ptr<jlm::llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
  rvsdg::SimpleNode * CallF1_{};
};
 
class PhiTest1 final : public RvsdgTest
{
public:
  [[nodiscard]] const rvsdg::SimpleNode &
  CallFib() const noexcept
  {
    return *CallFib_;
  }
 
  [[nodiscard]] const rvsdg::SimpleNode &
  CallFibm1() const noexcept
  {
    return *CallFibm1_;
  }
 
  [[nodiscard]] const rvsdg::SimpleNode &
  CallFibm2() const noexcept
  {
    return *CallFibm2_;
  }
 
  jlm::rvsdg::LambdaNode * lambda_fib;
  jlm::rvsdg::LambdaNode * lambda_test;
 
  rvsdg::GammaNode * gamma;
 
  jlm::rvsdg::PhiNode * phi;
 
  rvsdg::SimpleNode * alloca;
 
private:
  std::unique_ptr<jlm::llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
  rvsdg::SimpleNode * CallFibm1_{};
  rvsdg::SimpleNode * CallFibm2_{};
 
  rvsdg::SimpleNode * CallFib_{};
};
 
class PhiTest2 final : public RvsdgTest
{
public:
  [[nodiscard]] jlm::rvsdg::LambdaNode &
  GetLambdaEight() const noexcept
  {
    return *LambdaEight_;
  }
 
  [[nodiscard]] jlm::rvsdg::LambdaNode &
  GetLambdaI() const noexcept
  {
    return *LambdaI_;
  }
 
  [[nodiscard]] jlm::rvsdg::LambdaNode &
  GetLambdaA() const noexcept
  {
    return *LambdaA_;
  }
 
  [[nodiscard]] jlm::rvsdg::LambdaNode &
  GetLambdaB() const noexcept
  {
    return *LambdaB_;
  }
 
  [[nodiscard]] jlm::rvsdg::LambdaNode &
  GetLambdaC() const noexcept
  {
    return *LambdaC_;
  }
 
  [[nodiscard]] jlm::rvsdg::LambdaNode &
  GetLambdaD() const noexcept
  {
    return *LambdaD_;
  }
 
  [[nodiscard]] jlm::rvsdg::LambdaNode &
  GetLambdaTest() const noexcept
  {
    return *LambdaTest_;
  }
 
  [[nodiscard]] rvsdg::SimpleNode &
  GetCallAFromTest() const noexcept
  {
    return *CallAFromTest_;
  }
 
  [[nodiscard]] rvsdg::SimpleNode &
  GetCallAFromC() const noexcept
  {
    return *CallAFromC_;
  }
 
  [[nodiscard]] rvsdg::SimpleNode &
  GetCallAFromD() const noexcept
  {
    return *CallAFromD_;
  }
 
  [[nodiscard]] rvsdg::SimpleNode &
  GetCallB() const noexcept
  {
    return *CallB_;
  }
 
  [[nodiscard]] rvsdg::SimpleNode &
  GetCallC() const noexcept
  {
    return *CallC_;
  }
 
  [[nodiscard]] rvsdg::SimpleNode &
  GetCallD() const noexcept
  {
    return *CallD_;
  }
 
  [[nodiscard]] rvsdg::SimpleNode &
  GetCallI() const noexcept
  {
    return *CallI_;
  }
 
  [[nodiscard]] rvsdg::SimpleNode &
  GetIndirectCall() const noexcept
  {
    return *IndirectCall_;
  }
 
  [[nodiscard]] jlm::rvsdg::SimpleNode &
  GetPTestAlloca() const noexcept
  {
    return *PTestAlloca_;
  }
 
  [[nodiscard]] jlm::rvsdg::SimpleNode &
  GetPaAlloca() const noexcept
  {
    return *PaAlloca_;
  }
 
  [[nodiscard]] jlm::rvsdg::SimpleNode &
  GetPbAlloca() const noexcept
  {
    return *PbAlloca_;
  }
 
  [[nodiscard]] jlm::rvsdg::SimpleNode &
  GetPcAlloca() const noexcept
  {
    return *PcAlloca_;
  }
 
  [[nodiscard]] jlm::rvsdg::SimpleNode &
  GetPdAlloca() const noexcept
  {
    return *PdAlloca_;
  }
 
private:
  std::unique_ptr<jlm::llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
  jlm::rvsdg::LambdaNode * LambdaEight_{};
  jlm::rvsdg::LambdaNode * LambdaI_{};
  jlm::rvsdg::LambdaNode * LambdaA_{};
  jlm::rvsdg::LambdaNode * LambdaB_{};
  jlm::rvsdg::LambdaNode * LambdaC_{};
  jlm::rvsdg::LambdaNode * LambdaD_{};
  jlm::rvsdg::LambdaNode * LambdaTest_{};
 
  rvsdg::SimpleNode * CallAFromTest_{};
  rvsdg::SimpleNode * CallAFromC_{};
  rvsdg::SimpleNode * CallAFromD_{};
  rvsdg::SimpleNode * CallB_{};
  rvsdg::SimpleNode * CallC_{};
  rvsdg::SimpleNode * CallD_{};
  rvsdg::SimpleNode * CallI_{};
  rvsdg::SimpleNode * IndirectCall_{};
 
  jlm::rvsdg::SimpleNode * PTestAlloca_{};
  jlm::rvsdg::SimpleNode * PaAlloca_{};
  jlm::rvsdg::SimpleNode * PbAlloca_{};
  jlm::rvsdg::SimpleNode * PcAlloca_{};
  jlm::rvsdg::SimpleNode * PdAlloca_{};
};
 
class PhiWithDeltaTest final : public RvsdgTest
{
  [[nodiscard]] const jlm::rvsdg::DeltaNode &
  GetDelta() const noexcept
  {
    JLM_ASSERT(Delta_ != nullptr);
    return *Delta_;
  }
 
private:
  std::unique_ptr<jlm::llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
  jlm::rvsdg::DeltaNode * Delta_ = {};
};
 
class ExternalMemoryTest final : public RvsdgTest
{
private:
  std::unique_ptr<jlm::llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
public:
  jlm::rvsdg::LambdaNode * LambdaF;
};
 
class EscapedMemoryTest1 final : public RvsdgTest
{
private:
  std::unique_ptr<jlm::llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
public:
  jlm::rvsdg::LambdaNode * LambdaTest;
 
  jlm::rvsdg::DeltaNode * DeltaA;
  jlm::rvsdg::DeltaNode * DeltaB;
  jlm::rvsdg::DeltaNode * DeltaX;
  jlm::rvsdg::DeltaNode * DeltaY;
 
  rvsdg::SimpleNode * LoadNode1;
};
 
class EscapedMemoryTest2 final : public RvsdgTest
{
private:
  std::unique_ptr<jlm::llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
public:
  jlm::rvsdg::LambdaNode * ReturnAddressFunction;
  jlm::rvsdg::LambdaNode * CallExternalFunction1;
  jlm::rvsdg::LambdaNode * CallExternalFunction2;
 
  rvsdg::SimpleNode * ExternalFunction1Call;
  rvsdg::SimpleNode * ExternalFunction2Call;
 
  rvsdg::SimpleNode * ReturnAddressMalloc;
  rvsdg::SimpleNode * CallExternalFunction1Malloc;
 
  jlm::rvsdg::GraphImport * ExternalFunction1Import;
  jlm::rvsdg::GraphImport * ExternalFunction2Import;
 
  rvsdg::SimpleNode * LoadNode;
};
 
class EscapedMemoryTest3 final : public RvsdgTest
{
private:
  std::unique_ptr<jlm::llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
public:
  jlm::rvsdg::LambdaNode * LambdaTest;
 
  jlm::rvsdg::DeltaNode * DeltaGlobal;
 
  jlm::rvsdg::GraphImport * ImportExternalFunction;
 
  rvsdg::SimpleNode * CallExternalFunction;
 
  rvsdg::SimpleNode * LoadNode;
};
 
class MemcpyTest final : public RvsdgTest
{
public:
  [[nodiscard]] const jlm::rvsdg::LambdaNode &
  LambdaF() const noexcept
  {
    return *LambdaF_;
  }
 
  [[nodiscard]] const jlm::rvsdg::LambdaNode &
  LambdaG() const noexcept
  {
    return *LambdaG_;
  }
 
  [[nodiscard]] const jlm::rvsdg::DeltaNode &
  LocalArray() const noexcept
  {
    return *LocalArray_;
  }
 
  [[nodiscard]] const jlm::rvsdg::DeltaNode &
  GlobalArray() const noexcept
  {
    return *GlobalArray_;
  }
 
  [[nodiscard]] const rvsdg::SimpleNode &
  CallF() const noexcept
  {
    return *CallF_;
  }
 
  [[nodiscard]] const rvsdg::SimpleNode &
  Memcpy() const noexcept
  {
    return *Memcpy_;
  }
 
private:
  std::unique_ptr<jlm::llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
  jlm::rvsdg::LambdaNode * LambdaF_{};
  jlm::rvsdg::LambdaNode * LambdaG_{};
 
  jlm::rvsdg::DeltaNode * LocalArray_{};
  jlm::rvsdg::DeltaNode * GlobalArray_{};
 
  rvsdg::SimpleNode * CallF_{};
 
  rvsdg::SimpleNode * Memcpy_{};
};
 
class MemcpyTest2 final : public RvsdgTest
{
public:
  [[nodiscard]] const jlm::rvsdg::LambdaNode &
  LambdaF() const noexcept
  {
    JLM_ASSERT(LambdaF_ != nullptr);
    return *LambdaF_;
  }
 
  [[nodiscard]] const jlm::rvsdg::LambdaNode &
  LambdaG() const noexcept
  {
    JLM_ASSERT(LambdaG_ != nullptr);
    return *LambdaG_;
  }
 
  [[nodiscard]] const rvsdg::SimpleNode &
  CallG() const noexcept
  {
    JLM_ASSERT(CallG_ != nullptr);
    return *CallG_;
  }
 
  [[nodiscard]] const rvsdg::Node &
  Memcpy() const noexcept
  {
    JLM_ASSERT(Memcpy_ != nullptr);
    return *Memcpy_;
  }
 
private:
  std::unique_ptr<jlm::llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
  jlm::rvsdg::LambdaNode * LambdaF_ = {};
  jlm::rvsdg::LambdaNode * LambdaG_ = {};
 
  rvsdg::SimpleNode * CallG_ = {};
 
  rvsdg::Node * Memcpy_ = {};
};
 
class MemcpyTest3 final : public RvsdgTest
{
public:
  [[nodiscard]] const jlm::rvsdg::LambdaNode &
  Lambda() const noexcept
  {
    JLM_ASSERT(Lambda_ != nullptr);
    return *Lambda_;
  }
 
  [[nodiscard]] const rvsdg::Node &
  Alloca() const noexcept
  {
    JLM_ASSERT(Alloca_ != nullptr);
    return *Alloca_;
  }
 
  [[nodiscard]] const rvsdg::Node &
  Memcpy() const noexcept
  {
    JLM_ASSERT(Memcpy_ != nullptr);
    return *Memcpy_;
  }
 
private:
  std::unique_ptr<jlm::llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
  jlm::rvsdg::LambdaNode * Lambda_ = {};
 
  rvsdg::Node * Alloca_ = {};
 
  rvsdg::Node * Memcpy_ = {};
};
 
class LinkedListTest final : public RvsdgTest
{
public:
  [[nodiscard]] const rvsdg::SimpleNode &
  GetAlloca() const noexcept
  {
    return *Alloca_;
  }
 
  [[nodiscard]] const jlm::rvsdg::LambdaNode &
  GetLambdaNext() const noexcept
  {
    return *LambdaNext_;
  }
 
  [[nodiscard]] const jlm::rvsdg::DeltaNode &
  GetDeltaMyList() const noexcept
  {
    return *DeltaMyList_;
  }
 
private:
  std::unique_ptr<jlm::llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
  jlm::rvsdg::DeltaNode * DeltaMyList_{};
 
  jlm::rvsdg::LambdaNode * LambdaNext_{};
 
  rvsdg::SimpleNode * Alloca_{};
};
 
class AllMemoryNodesTest final : public RvsdgTest
{
public:
  [[nodiscard]] const jlm::rvsdg::DeltaNode &
  GetDeltaNode() const noexcept
  {
    JLM_ASSERT(Delta_);
    return *Delta_;
  }
 
  [[nodiscard]] const rvsdg::Output &
  GetDeltaOutput() const noexcept
  {
    JLM_ASSERT(Delta_);
    return Delta_->output();
  }
 
  [[nodiscard]] const llvm::LlvmGraphImport &
  GetImportOutput() const noexcept
  {
    JLM_ASSERT(Import_);
    return *Import_;
  }
 
  [[nodiscard]] const jlm::rvsdg::LambdaNode &
  GetLambdaNode() const noexcept
  {
    JLM_ASSERT(Lambda_);
    return *Lambda_;
  }
 
  [[nodiscard]] const rvsdg::Output &
  GetLambdaOutput() const noexcept
  {
    JLM_ASSERT(Lambda_);
    return *Lambda_->output();
  }
 
  [[nodiscard]] const rvsdg::SimpleNode &
  GetAllocaNode() const noexcept
  {
    JLM_ASSERT(Alloca_);
    return *Alloca_;
  }
 
  [[nodiscard]] const jlm::rvsdg::Output &
  GetAllocaOutput() const noexcept
  {
    JLM_ASSERT(Alloca_);
    return *Alloca_->output(0);
  }
 
  [[nodiscard]] const rvsdg::SimpleNode &
  GetMallocNode() const noexcept
  {
    JLM_ASSERT(Malloc_);
    return *Malloc_;
  }
 
  [[nodiscard]] const jlm::rvsdg::Output &
  GetMallocOutput() const noexcept
  {
    JLM_ASSERT(Malloc_);
    return *Malloc_->output(0);
  }
 
private:
  std::unique_ptr<jlm::llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
  jlm::rvsdg::DeltaNode * Delta_ = {};
 
  jlm::llvm::LlvmGraphImport * Import_ = {};
 
  jlm::rvsdg::LambdaNode * Lambda_ = {};
 
  rvsdg::SimpleNode * Alloca_ = {};
 
  rvsdg::SimpleNode * Malloc_ = {};
};
 
class NAllocaNodesTest final : public RvsdgTest
{
public:
  explicit NAllocaNodesTest(size_t numAllocaNodes)
      : NumAllocaNodes_(numAllocaNodes)
  {}
 
  [[nodiscard]] size_t
  GetNumAllocaNodes() const noexcept
  {
    return NumAllocaNodes_;
  }
 
  [[nodiscard]] const rvsdg::SimpleNode &
  GetAllocaNode(size_t index) const noexcept
  {
    JLM_ASSERT(index < AllocaNodes_.size());
    return *AllocaNodes_[index];
  }
 
  [[nodiscard]] const jlm::rvsdg::Output &
  GetAllocaOutput(size_t index) const noexcept
  {
    JLM_ASSERT(index < AllocaNodes_.size());
    return *AllocaNodes_[index]->output(0);
  }
 
  [[nodiscard]] const jlm::rvsdg::LambdaNode &
  GetFunction() const noexcept
  {
    JLM_ASSERT(Function_);
    return *Function_;
  }
 
private:
  std::unique_ptr<jlm::llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
  size_t NumAllocaNodes_;
 
  std::vector<const rvsdg::SimpleNode *> AllocaNodes_ = {};
 
  jlm::rvsdg::LambdaNode * Function_{};
};
 
class EscapingLocalFunctionTest final : public RvsdgTest
{
public:
  [[nodiscard]] const jlm::rvsdg::DeltaNode &
  GetGlobal() const noexcept
  {
    JLM_ASSERT(Global_);
    return *Global_;
  }
 
  [[nodiscard]] const jlm::rvsdg::LambdaNode &
  GetLocalFunction() const noexcept
  {
    JLM_ASSERT(LocalFunc_);
    return *LocalFunc_;
  }
 
  [[nodiscard]] const jlm::rvsdg::Output &
  GetLocalFunctionRegister() const noexcept
  {
    JLM_ASSERT(LocalFuncRegister_);
    return *LocalFuncRegister_;
  }
 
  [[nodiscard]] const jlm::rvsdg::Output &
  GetLocalFunctionParam() const noexcept
  {
    JLM_ASSERT(LocalFuncParam_);
    return *LocalFuncParam_;
  }
 
  [[nodiscard]] const rvsdg::Node &
  GetLocalFunctionParamAllocaNode() const noexcept
  {
    JLM_ASSERT(LocalFuncParamAllocaNode_);
    return *LocalFuncParamAllocaNode_;
  }
 
  [[nodiscard]] const jlm::rvsdg::LambdaNode &
  GetExportedFunction() const noexcept
  {
    JLM_ASSERT(ExportedFunc_);
    return *ExportedFunc_;
  }
 
private:
  std::unique_ptr<jlm::llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
  jlm::rvsdg::DeltaNode * Global_ = {};
  jlm::rvsdg::LambdaNode * LocalFunc_ = {};
  jlm::rvsdg::Output * LocalFuncParam_ = {};
  jlm::rvsdg::Output * LocalFuncRegister_ = {};
  rvsdg::Node * LocalFuncParamAllocaNode_ = {};
  jlm::rvsdg::LambdaNode * ExportedFunc_ = {};
};
 
class LambdaCallArgumentMismatch final : public RvsdgTest
{
public:
  [[nodiscard]] const rvsdg::LambdaNode &
  GetLambdaMain() const noexcept
  {
    return *LambdaMain_;
  }
 
  [[nodiscard]] const rvsdg::LambdaNode &
  GetLambdaG() const noexcept
  {
    return *LambdaG_;
  }
 
  [[nodiscard]] const rvsdg::SimpleNode &
  GetCall() const noexcept
  {
    return *Call_;
  }
 
private:
  std::unique_ptr<llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
  rvsdg::LambdaNode * LambdaG_ = {};
  rvsdg::LambdaNode * LambdaMain_ = {};
  rvsdg::SimpleNode * Call_ = {};
};
 
class FreeNullTest final : public RvsdgTest
{
public:
  [[nodiscard]] rvsdg::LambdaNode &
  LambdaMain() const noexcept
  {
    return *LambdaMain_;
  }
 
private:
  std::unique_ptr<llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
  rvsdg::LambdaNode * LambdaMain_{};
};
 
class VariadicFunctionTest1 final : public RvsdgTest
{
public:
  [[nodiscard]] rvsdg::LambdaNode &
  GetLambdaF() const noexcept
  {
    JLM_ASSERT(LambdaF_ != nullptr);
    return *LambdaF_;
  }
 
  [[nodiscard]] rvsdg::LambdaNode &
  GetLambdaG() const noexcept
  {
    JLM_ASSERT(LambdaG_ != nullptr);
    return *LambdaG_;
  }
 
  [[nodiscard]] rvsdg::RegionArgument &
  GetImportH() const noexcept
  {
    JLM_ASSERT(ImportH_ != nullptr);
    return *ImportH_;
  }
 
  [[nodiscard]] rvsdg::SimpleNode &
  GetCallH() const noexcept
  {
    JLM_ASSERT(CallH_ != nullptr);
    return *CallH_;
  }
 
  [[nodiscard]] rvsdg::Node &
  GetAllocaNode() const noexcept
  {
    JLM_ASSERT(AllocaNode_ != nullptr);
    return *AllocaNode_;
  }
 
private:
  std::unique_ptr<llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
  rvsdg::LambdaNode * LambdaF_ = {};
  rvsdg::LambdaNode * LambdaG_ = {};
 
  rvsdg::RegionArgument * ImportH_ = {};
 
  rvsdg::SimpleNode * CallH_ = {};
 
  rvsdg::Node * AllocaNode_ = {};
};
 
class VariadicFunctionTest2 final : public RvsdgTest
{
public:
  [[nodiscard]] const jlm::rvsdg::LambdaNode &
  GetLambdaFst() const noexcept
  {
    JLM_ASSERT(LambdaFst_ != nullptr);
    return *LambdaFst_;
  }
 
  [[nodiscard]] const jlm::rvsdg::LambdaNode &
  GetLambdaG() const noexcept
  {
    JLM_ASSERT(LambdaG_ != nullptr);
    return *LambdaG_;
  }
 
  [[nodiscard]] rvsdg::Node &
  GetAllocaNode() const noexcept
  {
    JLM_ASSERT(AllocaNode_ != nullptr);
    return *AllocaNode_;
  }
 
private:
  std::unique_ptr<jlm::llvm::LlvmRvsdgModule>
  SetupRvsdg() override;
 
  jlm::rvsdg::LambdaNode * LambdaFst_ = {};
  jlm::rvsdg::LambdaNode * LambdaG_ = {};
 
  rvsdg::Node * AllocaNode_ = {};
};
 
}
 
#endif