CallingConvLower.cpp revision f423a69839c4810b890f8a8b09fb8cfbd6bf0139
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<ISD::OutputArg> &Outs, 84 CCAssignFn Fn) { 85 // Determine which register each value should be copied into. 86 for (unsigned i = 0, e = Outs.size(); i != e; ++i) { 87 EVT VT = Outs[i].VT; 88 ISD::ArgFlagsTy ArgFlags = Outs[i].Flags; 89 if (Fn(i, VT, VT, CCValAssign::Full, ArgFlags, *this)) 90 return false; 91 } 92 return true; 93} 94 95/// AnalyzeReturn - Analyze the returned values of a return, 96/// incorporating info about the result values into this state. 97void CCState::AnalyzeReturn(const SmallVectorImpl<ISD::OutputArg> &Outs, 98 CCAssignFn Fn) { 99 // Determine which register each value should be copied into. 100 for (unsigned i = 0, e = Outs.size(); i != e; ++i) { 101 EVT VT = Outs[i].VT; 102 ISD::ArgFlagsTy ArgFlags = Outs[i].Flags; 103 if (Fn(i, VT, VT, CCValAssign::Full, ArgFlags, *this)) { 104#ifndef NDEBUG 105 dbgs() << "Return operand #" << i << " has unhandled type " 106 << VT.getEVTString(); 107#endif 108 llvm_unreachable(0); 109 } 110 } 111} 112 113/// AnalyzeCallOperands - Analyze the outgoing arguments to a call, 114/// incorporating info about the passed values into this state. 115void CCState::AnalyzeCallOperands(const SmallVectorImpl<ISD::OutputArg> &Outs, 116 CCAssignFn Fn) { 117 unsigned NumOps = Outs.size(); 118 for (unsigned i = 0; i != NumOps; ++i) { 119 EVT ArgVT = Outs[i].VT; 120 ISD::ArgFlagsTy ArgFlags = Outs[i].Flags; 121 if (Fn(i, ArgVT, ArgVT, CCValAssign::Full, ArgFlags, *this)) { 122#ifndef NDEBUG 123 dbgs() << "Call operand #" << i << " has unhandled type " 124 << ArgVT.getEVTString(); 125#endif 126 llvm_unreachable(0); 127 } 128 } 129} 130 131/// AnalyzeCallOperands - Same as above except it takes vectors of types 132/// and argument flags. 133void CCState::AnalyzeCallOperands(SmallVectorImpl<EVT> &ArgVTs, 134 SmallVectorImpl<ISD::ArgFlagsTy> &Flags, 135 CCAssignFn Fn) { 136 unsigned NumOps = ArgVTs.size(); 137 for (unsigned i = 0; i != NumOps; ++i) { 138 EVT ArgVT = ArgVTs[i]; 139 ISD::ArgFlagsTy ArgFlags = Flags[i]; 140 if (Fn(i, ArgVT, ArgVT, CCValAssign::Full, ArgFlags, *this)) { 141#ifndef NDEBUG 142 dbgs() << "Call operand #" << i << " has unhandled type " 143 << ArgVT.getEVTString(); 144#endif 145 llvm_unreachable(0); 146 } 147 } 148} 149 150/// AnalyzeCallResult - Analyze the return values of a call, 151/// incorporating info about the passed values into this state. 152void CCState::AnalyzeCallResult(const SmallVectorImpl<ISD::InputArg> &Ins, 153 CCAssignFn Fn) { 154 for (unsigned i = 0, e = Ins.size(); i != e; ++i) { 155 EVT VT = Ins[i].VT; 156 ISD::ArgFlagsTy Flags = Ins[i].Flags; 157 if (Fn(i, VT, VT, CCValAssign::Full, Flags, *this)) { 158#ifndef NDEBUG 159 dbgs() << "Call result #" << i << " has unhandled type " 160 << VT.getEVTString(); 161#endif 162 llvm_unreachable(0); 163 } 164 } 165} 166 167/// AnalyzeCallResult - Same as above except it's specialized for calls which 168/// produce a single value. 169void CCState::AnalyzeCallResult(EVT VT, CCAssignFn Fn) { 170 if (Fn(0, VT, VT, CCValAssign::Full, ISD::ArgFlagsTy(), *this)) { 171#ifndef NDEBUG 172 dbgs() << "Call result has unhandled type " 173 << VT.getEVTString(); 174#endif 175 llvm_unreachable(0); 176 } 177} 178