lib/Target/Hexagon/HexagonCallingConvLower.h

   1 //===-- HexagonCallingConvLower.h - Calling Conventions ---------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file declares the Hexagon_CCState class, used for lowering
  11 // and implementing calling conventions. Adapted from the target independent
  12 // version but this handles calls to varargs functions
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #ifndef LLVM_Hexagon_CODEGEN_CALLINGCONVLOWER_H
  17 #define LLVM_Hexagon_CODEGEN_CALLINGCONVLOWER_H
  18
  19 #include "llvm/ADT/SmallVector.h"
  20 #include "llvm/CodeGen/ValueTypes.h"
  21 #include "llvm/CodeGen/SelectionDAGNodes.h"
  22 #include "llvm/CodeGen/CallingConvLower.h"
  23
  24 //
  25 // Need to handle varargs.
  26 //
  27 namespace llvm {
  28   class TargetRegisterInfo;
  29   class TargetMachine;
  30   class Hexagon_CCState;
  31   class SDNode;
  32
  33
  34 /// Hexagon_CCAssignFn - This function assigns a location for Val, updating
  35 /// State to reflect the change.
  36 typedef bool Hexagon_CCAssignFn(unsigned ValNo, EVT ValVT,
  37                               EVT LocVT, CCValAssign::LocInfo LocInfo,
  38                               ISD::ArgFlagsTy ArgFlags, Hexagon_CCState &State,
  39                               int NonVarArgsParams,
  40                               int CurrentParam,
  41                               bool ForceMem);
  42
  43
  44 /// CCState - This class holds information needed while lowering arguments and
  45 /// return values.  It captures which registers are already assigned and which
  46 /// stack slots are used.  It provides accessors to allocate these values.
  47 class Hexagon_CCState {
  48   CallingConv::ID CallingConv;
  49   bool IsVarArg;
  50   const TargetMachine &TM;
  51   const TargetRegisterInfo &TRI;
  52   SmallVector<CCValAssign, 16> &Locs;
  53   LLVMContext &Context;
  54
  55   unsigned StackOffset;
  56   SmallVector<uint32_t, 16> UsedRegs;
  57 public:
  58   Hexagon_CCState(CallingConv::ID CC, bool isVarArg, const TargetMachine &TM,
  59                 SmallVector<CCValAssign, 16> &locs, LLVMContext &c);
  60
  61   void addLoc(const CCValAssign &V) {
  62     Locs.push_back(V);
  63   }
  64
  65   LLVMContext &getContext() const { return Context; }
  66   const TargetMachine &getTarget() const { return TM; }
  67   unsigned getCallingConv() const { return CallingConv; }
  68   bool isVarArg() const { return IsVarArg; }
  69
  70   unsigned getNextStackOffset() const { return StackOffset; }
  71
  72   /// isAllocated - Return true if the specified register (or an alias) is
  73   /// allocated.
  74   bool isAllocated(unsigned Reg) const {
  75     return UsedRegs[Reg/32] & (1 << (Reg&31));
  76   }
  77
  78   /// AnalyzeFormalArguments - Analyze an ISD::FORMAL_ARGUMENTS node,
  79   /// incorporating info about the formals into this state.
  80   void AnalyzeFormalArguments(const SmallVectorImpl<ISD::InputArg> &Ins,
  81                               Hexagon_CCAssignFn Fn, unsigned SretValueInRegs);
  82
  83   /// AnalyzeReturn - Analyze the returned values of an ISD::RET node,
  84   /// incorporating info about the result values into this state.
  85   void AnalyzeReturn(const SmallVectorImpl<ISD::OutputArg> &Outs,
  86                      Hexagon_CCAssignFn Fn, unsigned SretValueInRegs);
  87
  88   /// AnalyzeCallOperands - Analyze an ISD::CALL node, incorporating info
  89   /// about the passed values into this state.
  90   void AnalyzeCallOperands(const SmallVectorImpl<ISD::OutputArg> &Outs,
  91                            Hexagon_CCAssignFn Fn, int NonVarArgsParams,
  92                            unsigned SretValueSize);
  93
  94   /// AnalyzeCallOperands - Same as above except it takes vectors of types
  95   /// and argument flags.
  96   void AnalyzeCallOperands(SmallVectorImpl<EVT> &ArgVTs,
  97                            SmallVectorImpl<ISD::ArgFlagsTy> &Flags,
  98                            Hexagon_CCAssignFn Fn);
  99
 100   /// AnalyzeCallResult - Analyze the return values of an ISD::CALL node,
 101   /// incorporating info about the passed values into this state.
 102   void AnalyzeCallResult(const SmallVectorImpl<ISD::InputArg> &Ins,
 103                          Hexagon_CCAssignFn Fn, unsigned SretValueInRegs);
 104
 105   /// AnalyzeCallResult - Same as above except it's specialized for calls which
 106   /// produce a single value.
 107   void AnalyzeCallResult(EVT VT, Hexagon_CCAssignFn Fn);
 108
 109   /// getFirstUnallocated - Return the first unallocated register in the set, or
 110   /// NumRegs if they are all allocated.
 111   unsigned getFirstUnallocated(const unsigned *Regs, unsigned NumRegs) const {
 112     for (unsigned i = 0; i != NumRegs; ++i)
 113       if (!isAllocated(Regs[i]))
 114         return i;
 115     return NumRegs;
 116   }
 117
 118   /// AllocateReg - Attempt to allocate one register.  If it is not available,
 119   /// return zero.  Otherwise, return the register, marking it and any aliases
 120   /// as allocated.
 121   unsigned AllocateReg(unsigned Reg) {
 122     if (isAllocated(Reg)) return 0;
 123     MarkAllocated(Reg);
 124     return Reg;
 125   }
 126
 127   /// Version of AllocateReg with extra register to be shadowed.
 128   unsigned AllocateReg(unsigned Reg, unsigned ShadowReg) {
 129     if (isAllocated(Reg)) return 0;
 130     MarkAllocated(Reg);
 131     MarkAllocated(ShadowReg);
 132     return Reg;
 133   }
 134
 135   /// AllocateReg - Attempt to allocate one of the specified registers.  If none
 136   /// are available, return zero.  Otherwise, return the first one available,
 137   /// marking it and any aliases as allocated.
 138   unsigned AllocateReg(const unsigned *Regs, unsigned NumRegs) {
 139     unsigned FirstUnalloc = getFirstUnallocated(Regs, NumRegs);
 140     if (FirstUnalloc == NumRegs)
 141       return 0;    // Didn't find the reg.
 142
 143     // Mark the register and any aliases as allocated.
 144     unsigned Reg = Regs[FirstUnalloc];
 145     MarkAllocated(Reg);
 146     return Reg;
 147   }
 148
 149   /// Version of AllocateReg with list of registers to be shadowed.
 150   unsigned AllocateReg(const unsigned *Regs, const unsigned *ShadowRegs,
 151                        unsigned NumRegs) {
 152     unsigned FirstUnalloc = getFirstUnallocated(Regs, NumRegs);
 153     if (FirstUnalloc == NumRegs)
 154       return 0;    // Didn't find the reg.
 155
 156     // Mark the register and any aliases as allocated.
 157     unsigned Reg = Regs[FirstUnalloc], ShadowReg = ShadowRegs[FirstUnalloc];
 158     MarkAllocated(Reg);
 159     MarkAllocated(ShadowReg);
 160     return Reg;
 161   }
 162
 163   /// AllocateStack - Allocate a chunk of stack space with the specified size
 164   /// and alignment.
 165   unsigned AllocateStack(unsigned Size, unsigned Align) {
 166     assert(Align && ((Align-1) & Align) == 0); // Align is power of 2.
 167     StackOffset = ((StackOffset + Align-1) & ~(Align-1));
 168     unsigned Result = StackOffset;
 169     StackOffset += Size;
 170     return Result;
 171   }
 172
 173   // HandleByVal - Allocate a stack slot large enough to pass an argument by
 174   // value. The size and alignment information of the argument is encoded in its
 175   // parameter attribute.
 176   void HandleByVal(unsigned ValNo, EVT ValVT,
 177                    EVT LocVT, CCValAssign::LocInfo LocInfo,
 178                    int MinSize, int MinAlign, ISD::ArgFlagsTy ArgFlags);
 179
 180 private:
 181   /// MarkAllocated - Mark a register and all of its aliases as allocated.
 182   void MarkAllocated(unsigned Reg);
 183 };
 184
 185
 186
 187 } // end namespace llvm
 188
 189 #endif