call_lowering.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/CodeGen/Register.h>
#include <llvm/CodeGen/TargetRegisterInfo.h>
 
#include "core/type.h"
#include "core/calling_conv.h"
#include "core/insts.h"
 
class Func;
 
 
 
class CallLowering {
public:
  struct ArgPart {
    enum Kind {
      REG,
      STK,
      BYVAL,
    };
 
    Kind K;
    llvm::MVT VT;
 
    llvm::Register Reg = 0u;
 
    unsigned Offset = 0;
    unsigned Size = 0;
    llvm::Align Align;
 
    ArgPart(llvm::MVT vt, llvm::Register reg)
        : K(Kind::REG), VT(vt), Reg(reg) {}
 
    ArgPart(llvm::MVT vt, unsigned offset, unsigned size)
        : K(Kind::STK), VT(vt), Offset(offset), Size(size) {}
 
    ArgPart(llvm::MVT vt, unsigned offset, unsigned size, llvm::Align align)
        : K(Kind::BYVAL), VT(vt), Offset(offset), Size(size), Align(align) {}
  };
 
  struct ArgLoc {
    unsigned Index;
    Type ArgType;
    llvm::SmallVector<ArgPart, 2> Parts;
 
    ArgLoc(unsigned index, FlaggedType argType)
      : Index(index), ArgType(argType.GetType())
    {
    }
  };
 
  // Iterator over the arguments.
  using arg_iterator = std::vector<ArgLoc>::iterator;
  using const_arg_iterator = std::vector<ArgLoc>::const_iterator;
 
  struct RetPart {
    llvm::MVT VT;
    llvm::Register Reg;
 
    RetPart(llvm::MVT partVT, llvm::Register reg)
      : VT(partVT), Reg(reg)
    {
    }
  };
 
  struct RetLoc {
    unsigned Index;
    llvm::SmallVector<RetPart, 2> Parts;
 
    RetLoc(unsigned index) : Index(index) {}
  };
 
  // Iterator over the returns.
  using ret_iterator = std::vector<RetLoc>::iterator;
  using const_ret_iterator = std::vector<RetLoc>::const_iterator;
 
public:
  CallLowering(const Func *func);
  CallLowering(const CallSite *call);
  CallLowering(const RaiseInst *inst);
  CallLowering(const LandingPadInst *inst);
  CallLowering(const ReturnInst *inst);
 
  virtual ~CallLowering();
 
  unsigned GetNumArgs() const { return args_.size(); }
  virtual unsigned GetFrameSize() const = 0;
 
  // Iterator over argument info.
  arg_iterator arg_begin() { return args_.begin(); }
  arg_iterator arg_end() { return args_.end(); }
  const_arg_iterator arg_begin() const { return args_.begin(); }
  const_arg_iterator arg_end() const { return args_.end(); }
 
  llvm::iterator_range<arg_iterator> args()
  {
    return llvm::make_range(arg_begin(), arg_end());
  }
 
  llvm::iterator_range<const_arg_iterator> args() const
  {
    return llvm::make_range(arg_begin(), arg_end());
  }
 
  const ArgLoc &Argument(size_t idx) const { return args_[idx]; }
 
  // Iterator over argument info.
  ret_iterator ret_begin() { return rets_.begin(); }
  ret_iterator ret_end() { return rets_.end(); }
  const_ret_iterator ret_begin() const { return rets_.begin(); }
  const_ret_iterator ret_end() const { return rets_.end(); }
 
  llvm::iterator_range<ret_iterator> rets()
  {
    return llvm::make_range(ret_begin(), ret_end());
  }
 
  llvm::iterator_range<const_ret_iterator> rets() const
  {
    return llvm::make_range(ret_begin(), ret_end());
  }
 
  const RetLoc &Return(unsigned idx) const { return rets_[idx]; }
 
protected:
  virtual void AssignArgC(unsigned i, FlaggedType type) = 0;
  virtual void AssignArgOCaml(unsigned i, FlaggedType type) = 0;
  virtual void AssignArgOCamlAlloc(unsigned i, FlaggedType type) = 0;
  virtual void AssignArgOCamlGc(unsigned i, FlaggedType type) = 0;
  virtual void AssignArgXen(unsigned i, FlaggedType type) = 0;
  virtual void AssignArgMultiboot(unsigned i, FlaggedType type)
  {
    llvm_unreachable("no args to multiboot");
  }
  virtual void AssignArgWin64(unsigned i, FlaggedType type) = 0;
 
  virtual void AssignRetC(unsigned i, FlaggedType type) = 0;
  virtual void AssignRetOCaml(unsigned i, FlaggedType type) = 0;
  virtual void AssignRetOCamlAlloc(unsigned i, FlaggedType type) = 0;
  virtual void AssignRetOCamlGc(unsigned i, FlaggedType type) = 0;
  virtual void AssignRetXen(unsigned i, FlaggedType type) = 0;
  virtual void AssignRetWin64(unsigned i, FlaggedType type) = 0;
 
protected:
  void AnalyseFunc(const Func *func);
  void AnalyseCall(const CallSite *call);
  void AnalyseReturn(const ReturnInst *inst);
  void AnalyseRaise(const RaiseInst *inst);
  void AnalysePad(const LandingPadInst *inst);
 
  void AssignArg(unsigned i, FlaggedType type);
  void AssignRet(unsigned i, FlaggedType type);
 
protected:
  CallingConv conv_;
  std::vector<ArgLoc> args_;
  std::vector<RetLoc> rets_;
};