isel.h

// This file if part of the llir-opt project.
// Licensing information can be found in the LICENSE file.
// (C) 2018 Nandor Licker. All rights reserved.
 
#pragma once
 
#include <llvm/IR/CallingConv.h>
#include <llvm/CodeGen/MachineRegisterInfo.h>
#include <llvm/CodeGen/SelectionDAG.h>
#include <llvm/CodeGen/SelectionDAG/ScheduleDAGSDNodes.h>
#include <llvm/CodeGen/SelectionDAGNodes.h>
 
#include "core/analysis/live_variables.h"
#include "core/insts.h"
#include "core/type.h"
#include "emitter/isel_mapping.h"
#include "emitter/call_lowering.h"
 
class Target;
 
 
 
class ISel : public llvm::ModulePass, public ISelMapping {
protected:
  using MVT = llvm::MVT;
  using EVT = llvm::EVT;
  using SDNode = llvm::SDNode;
  using SDValue = llvm::SDValue;
  using SDVTList = llvm::SDVTList;
  using SelectionDAG = llvm::SelectionDAG;
  using GlobalValue = llvm::GlobalValue;
 
protected:
  ISel(
      char &ID,
      const Target &target,
      const Prog &prog,
      llvm::TargetLibraryInfo &libInfo,
      llvm::CodeGenOpt::Level ol
  );
 
private:
  llvm::StringRef getPassName() const override;
  void getAnalysisUsage(llvm::AnalysisUsage &AU) const override;
  bool doInitialization(llvm::Module &M) override;
  bool runOnModule(llvm::Module &M) override;
 
protected:
  void Lower(const Inst *inst);
 
protected:
  virtual void Lower(llvm::MachineFunction &mf) = 0;
 
  virtual SDValue GetRegArch(Register reg) = 0;
 
  virtual void LowerSyscall(const SyscallInst *inst) = 0;
  virtual void LowerClone(const CloneInst *inst) = 0;
  virtual void LowerReturn(const ReturnInst *inst) = 0;
  virtual void LowerRaise(const RaiseInst *inst) = 0;
  virtual void LowerSpawn(const SpawnInst *inst) = 0;
  virtual void LowerLandingPad(const LandingPadInst *inst) = 0;
  virtual void LowerSet(const SetInst *inst) = 0;
  virtual void LowerArch(const Inst *inst) = 0;
 
  virtual void LowerArguments(bool hasVAStart) = 0;
 
  virtual llvm::SelectionDAG &GetDAG() const = 0;
 
  virtual llvm::Register GetStackRegister() const = 0;
 
  virtual void PreprocessISelDAG() = 0;
  virtual void PostprocessISelDAG() = 0;
  virtual void Select(SDNode *node) = 0;
 
  virtual bool Finalize(llvm::MachineFunction &MF) { return true; }
 
protected:
  SDValue LoadReg(Register reg);
  llvm::SDValue LowerGlobal(const Global &val, Type type);
  llvm::SDValue LowerGlobal(const Global &val, int64_t offset, Type type);
  void LowerArgs(const CallLowering &lowering);
  std::pair<llvm::SDValue, llvm::SDValue>
  LowerRets(
      llvm::SDValue chain,
      const CallLowering &lowering,
      const ReturnInst *ret,
      llvm::SmallVectorImpl<SDValue> &ops
  );
  std::pair<llvm::SDValue, llvm::SDValue>
  LowerRaises(
      llvm::SDValue chain,
      const CallLowering &lowering,
      const RaiseInst *ret,
      llvm::SmallVectorImpl<llvm::Register> &regs,
      llvm::SDValue glue
  );
  void LowerPad(
      const CallLowering &lowering,
      const LandingPadInst *inst
  );
 
  using RegParts = llvm::SmallVector<std::pair<llvm::Register, llvm::MVT>, 2>;
  using ExportList = std::vector<std::pair<RegParts, SDValue>>;
 
  SDValue GetPrimitiveExportRoot();
  SDValue GetValueExportRoot();
  SDValue GetExportRoot();
  SDValue GetExportRoot(const ExportList &exports);
  bool HasPendingExports();
 
  RegParts ExportValue(SDValue value);
 
  RegParts AssignVReg(ConstRef<Inst> inst);
 
  SDValue LowerInlineAsm(
      unsigned opcode,
      SDValue chain,
      const char *code,
      unsigned flags,
      llvm::ArrayRef<llvm::Register> inputs,
      llvm::ArrayRef<llvm::Register> clobbers,
      llvm::ArrayRef<llvm::Register> outputs,
      SDValue glue = SDValue()
  );
 
  SDValue LowerImm(const APInt &val, Type type);
  SDValue LowerImm(const APFloat &val, Type type);
  SDValue LowerConstant(ConstRef<Inst> inst);
  SDValue LowerExpr(const Expr &expr, Type type);
 
  SDValue GetValue(ConstRef<Inst> inst);
  void Export(ConstRef<Inst> inst, llvm::SDValue val);
 
  llvm::ISD::CondCode GetCond(Cond cc);
 
  using FrameExports = std::vector<std::pair<ConstRef<Inst>, llvm::SDValue>>;
  FrameExports GetFrameExport(const Inst *frame);
  llvm::SDValue LowerGCFrame(
      llvm::SDValue chain,
      llvm::SDValue glue,
      const CallSite *inst
  );
  ConstRef<Value> GetMoveArg(ConstRef<MovInst> inst);
  bool IsExported(ConstRef<Inst> inst);
  MVT GetPointerType() const;
 
protected:
  virtual void PrepareFunction(const Func &func, llvm::MachineFunction &MF) {}
  void HandleSuccessorPHI(const Block *block);
  void CodeGenAndEmitDAG();
  void DoInstructionSelection();
 
protected:
  [[noreturn]] void Error(const Inst *i, const std::string_view &message);
  [[noreturn]] void Error(const Func *f, const std::string_view &message);
 
protected:
  void LowerVAStart(const VaStartInst *inst);
  void LowerCall(const CallInst *inst);
  void LowerTailCall(const TailCallInst *inst);
  void LowerInvoke(const InvokeInst *inst);
  void LowerFrameCall(const FrameCallInst *inst);
  void LowerBinary(const Inst *inst, unsigned op);
  void LowerBinary(const Inst *inst, unsigned sop, unsigned fop);
  void LowerShift(const Inst *inst, unsigned op);
  void LowerUnary(const UnaryInst *inst, unsigned opcode);
  void LowerJUMP_COND(const JumpCondInst *inst);
  void LowerJUMP(const JumpInst *inst);
  void LowerSwitch(const SwitchInst *inst);
  void LowerLD(const LoadInst *inst);
  void LowerST(const StoreInst *inst);
  void LowerFrame(const FrameInst *inst);
  void LowerCmp(const CmpInst *inst);
  void LowerTrap(const TrapInst *inst);
  void LowerDebugTrap(const DebugTrapInst *inst);
  void LowerMov(const MovInst *inst);
  void LowerSExt(const SExtInst *inst);
  void LowerZExt(const ZExtInst *inst);
  void LowerFExt(const FExtInst *inst);
  void LowerXExt(const XExtInst *inst);
  void LowerTrunc(const TruncInst *inst);
  void LowerAlloca(const AllocaInst *inst);
  void LowerSelect(const SelectInst *inst);
  void LowerUndef(const UndefInst *inst);
  void LowerALUO(const BinaryInst *inst, unsigned op);
  void LowerGet(const GetInst *inst);
  void LowerBitCast(const BitCastInst *inst);
 
protected:
  virtual void LowerCallSite(llvm::SDValue chain, const CallSite *call) = 0;
  std::pair<bool, llvm::CallingConv::ID> GetCallingConv(
      const Func *caller,
      const CallSite *call
  );
  SDValue LowerCallArguments(
      SDValue chain,
      const CallSite *call,
      CallLowering &ci,
      llvm::SmallVectorImpl<std::pair<unsigned, SDValue>> &regs
  );
 
  std::pair<SDValue, SDValue> LowerReturns(
      SDValue chain,
      SDValue inFlag,
      const CallSite *call,
      llvm::SmallVectorImpl<CallLowering::RetLoc> &returns,
      llvm::SmallVectorImpl<SDValue> &regs,
      llvm::SmallVectorImpl<std::pair<ConstRef<Inst>, SDValue>> &values
  );
 
protected:
  const Target &target_;
  const Prog &prog_;
  llvm::TargetLibraryInfo &libInfo_;
 
  llvm::DebugLoc DL_;
  llvm::SDLoc SDL_;
 
  llvm::Module *M_;
  llvm::Type *voidTy_;
  llvm::Type *i8PtrTy_;
  llvm::FunctionType *funcTy_;
  llvm::CodeGenOpt::Level ol_;
 
  const Func *func_;
  llvm::Function *F_;
  llvm::MachineBasicBlock *MBB_;
  llvm::MachineBasicBlock::iterator insert_;
  std::unique_ptr<LiveVariables> lva_;
  std::unordered_map<ConstRef<Inst>, llvm::SDValue> values_;
  std::unordered_map<ConstRef<Inst>, RegParts> regs_;
  llvm::DenseMap<unsigned, unsigned> stackIndices_;
  int frameIndex_;
 
  std::vector<std::pair<RegParts, llvm::SDValue>> pendingPrimValues_;
  std::unordered_map<ConstRef<Inst>, RegParts> pendingPrimInsts_;
  std::unordered_map<ConstRef<Inst>, RegParts> pendingValueInsts_;
};