CallingConvLower.cpp revision af52ee40fb60099ddec2b896aa4c759ef05b70c8
1//===-- CallingConvLower.cpp - Calling Conventions ------------------------===// 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 implements the CCState class, used for lowering and implementing 11// calling conventions. 12// 13//===----------------------------------------------------------------------===// 14 15#include "llvm/CodeGen/CallingConvLower.h" 16#include "llvm/Support/Debug.h" 17#include "llvm/Support/ErrorHandling.h" 18#include "llvm/Support/raw_ostream.h" 19#include "llvm/Target/TargetRegisterInfo.h" 20#include "llvm/Target/TargetData.h" 21#include "llvm/Target/TargetMachine.h" 22using namespace llvm; 23 24CCState::CCState(CallingConv::ID CC, bool isVarArg, const TargetMachine &tm, 25 SmallVector<CCValAssign, 16> &locs, LLVMContext &C) 26 : CallingConv(CC), IsVarArg(isVarArg), TM(tm), 27 TRI(*TM.getRegisterInfo()), Locs(locs), Context(C) { 28 // No stack is used. 29 StackOffset = 0; 30 31 UsedRegs.resize((TRI.getNumRegs()+31)/32); 32} 33 34// HandleByVal - Allocate a stack slot large enough to pass an argument by 35// value. The size and alignment information of the argument is encoded in its 36// parameter attribute. 37void CCState::HandleByVal(unsigned ValNo, EVT ValVT, 38 EVT LocVT, CCValAssign::LocInfo LocInfo, 39 int MinSize, int MinAlign, 40 ISD::ArgFlagsTy ArgFlags) { 41 unsigned Align = ArgFlags.getByValAlign(); 42 unsigned Size = ArgFlags.getByValSize(); 43 if (MinSize > (int)Size) 44 Size = MinSize; 45 if (MinAlign > (int)Align) 46 Align = MinAlign; 47 unsigned Offset = AllocateStack(Size, Align); 48 49 addLoc(CCValAssign::getMem(ValNo, ValVT, Offset, LocVT, LocInfo)); 50} 51 52/// MarkAllocated - Mark a register and all of its aliases as allocated. 53void CCState::MarkAllocated(unsigned Reg) { 54 UsedRegs[Reg/32] |= 1 << (Reg&31); 55 56 if (const unsigned *RegAliases = TRI.getAliasSet(Reg)) 57 for (; (Reg = *RegAliases); ++RegAliases) 58 UsedRegs[Reg/32] |= 1 << (Reg&31); 59} 60 61/// AnalyzeFormalArguments - Analyze an array of argument values, 62/// incorporating info about the formals into this state. 63void 64CCState::AnalyzeFormalArguments(const SmallVectorImpl<ISD::InputArg> &Ins, 65 CCAssignFn Fn) { 66 unsigned NumArgs = Ins.size(); 67 68 for (unsigned i = 0; i != NumArgs; ++i) { 69 EVT ArgVT = Ins[i].VT; 70 ISD::ArgFlagsTy ArgFlags = Ins[i].Flags; 71 if (Fn(i, ArgVT, ArgVT, CCValAssign::Full, ArgFlags, *this)) { 72#ifndef NDEBUG 73 dbgs() << "Formal argument #" << i << " has unhandled type " 74 << ArgVT.getEVTString(); 75#endif 76 llvm_unreachable(0); 77 } 78 } 79} 80 81/// CheckReturn - Analyze the return values of a function, returning true if 82/// the return can be performed without sret-demotion, and false otherwise. 83bool CCState::CheckReturn(const SmallVectorImpl<EVT> &OutTys, 84 const SmallVectorImpl<ISD::ArgFlagsTy> &ArgsFlags, 85 CCAssignFn Fn) { 86 // Determine which register each value should be copied into. 87 for (unsigned i = 0, e = OutTys.size(); i != e; ++i) { 88 EVT VT = OutTys[i]; 89 ISD::ArgFlagsTy ArgFlags = ArgsFlags[i]; 90 if (Fn(i, VT, VT, CCValAssign::Full, ArgFlags, *this)) 91 return false; 92 } 93 return true; 94} 95 96/// AnalyzeReturn - Analyze the returned values of a return, 97/// incorporating info about the result values into this state. 98void CCState::AnalyzeReturn(const SmallVectorImpl<ISD::OutputArg> &Outs, 99 CCAssignFn Fn) { 100 // Determine which register each value should be copied into. 101 for (unsigned i = 0, e = Outs.size(); i != e; ++i) { 102 EVT VT = Outs[i].VT; 103 ISD::ArgFlagsTy ArgFlags = Outs[i].Flags; 104 if (Fn(i, VT, VT, CCValAssign::Full, ArgFlags, *this)) { 105#ifndef NDEBUG 106 dbgs() << "Return operand #" << i << " has unhandled type " 107 << VT.getEVTString(); 108#endif 109 llvm_unreachable(0); 110 } 111 } 112} 113 114/// AnalyzeCallOperands - Analyze the outgoing arguments to a call, 115/// incorporating info about the passed values into this state. 116void CCState::AnalyzeCallOperands(const SmallVectorImpl<ISD::OutputArg> &Outs, 117 CCAssignFn Fn) { 118 unsigned NumOps = Outs.size(); 119 for (unsigned i = 0; i != NumOps; ++i) { 120 EVT ArgVT = Outs[i].VT; 121 ISD::ArgFlagsTy ArgFlags = Outs[i].Flags; 122 if (Fn(i, ArgVT, ArgVT, CCValAssign::Full, ArgFlags, *this)) { 123#ifndef NDEBUG 124 dbgs() << "Call operand #" << i << " has unhandled type " 125 << ArgVT.getEVTString(); 126#endif 127 llvm_unreachable(0); 128 } 129 } 130} 131 132/// AnalyzeCallOperands - Same as above except it takes vectors of types 133/// and argument flags. 134void CCState::AnalyzeCallOperands(SmallVectorImpl<EVT> &ArgVTs, 135 SmallVectorImpl<ISD::ArgFlagsTy> &Flags, 136 CCAssignFn Fn) { 137 unsigned NumOps = ArgVTs.size(); 138 for (unsigned i = 0; i != NumOps; ++i) { 139 EVT ArgVT = ArgVTs[i]; 140 ISD::ArgFlagsTy ArgFlags = Flags[i]; 141 if (Fn(i, ArgVT, ArgVT, CCValAssign::Full, ArgFlags, *this)) { 142#ifndef NDEBUG 143 dbgs() << "Call operand #" << i << " has unhandled type " 144 << ArgVT.getEVTString(); 145#endif 146 llvm_unreachable(0); 147 } 148 } 149} 150 151/// AnalyzeCallResult - Analyze the return values of a call, 152/// incorporating info about the passed values into this state. 153void CCState::AnalyzeCallResult(const SmallVectorImpl<ISD::InputArg> &Ins, 154 CCAssignFn Fn) { 155 for (unsigned i = 0, e = Ins.size(); i != e; ++i) { 156 EVT VT = Ins[i].VT; 157 ISD::ArgFlagsTy Flags = Ins[i].Flags; 158 if (Fn(i, VT, VT, CCValAssign::Full, Flags, *this)) { 159#ifndef NDEBUG 160 dbgs() << "Call result #" << i << " has unhandled type " 161 << VT.getEVTString(); 162#endif 163 llvm_unreachable(0); 164 } 165 } 166} 167 168/// AnalyzeCallResult - Same as above except it's specialized for calls which 169/// produce a single value. 170void CCState::AnalyzeCallResult(EVT VT, CCAssignFn Fn) { 171 if (Fn(0, VT, VT, CCValAssign::Full, ISD::ArgFlagsTy(), *this)) { 172#ifndef NDEBUG 173 dbgs() << "Call result has unhandled type " 174 << VT.getEVTString(); 175#endif 176 llvm_unreachable(0); 177 } 178} 179