blob: d718ede35cde2abdc9bd1abf607a171f5e0a69e7 [file] [log] [blame]
Dan Gohmana3624b62009-11-23 17:16:22 +00001//===-- FunctionLoweringInfo.cpp ------------------------------------------===//
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 implements routines for translating functions from LLVM IR into
11// Machine IR.
12//
13//===----------------------------------------------------------------------===//
14
Dan Gohmane7846162010-07-07 16:01:37 +000015#include "llvm/CodeGen/FunctionLoweringInfo.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000016#include "llvm/ADT/PostOrderIterator.h"
17#include "llvm/CodeGen/Analysis.h"
18#include "llvm/CodeGen/MachineFrameInfo.h"
19#include "llvm/CodeGen/MachineFunction.h"
20#include "llvm/CodeGen/MachineInstrBuilder.h"
21#include "llvm/CodeGen/MachineModuleInfo.h"
22#include "llvm/CodeGen/MachineRegisterInfo.h"
David Majnemercde33032015-03-30 22:58:10 +000023#include "llvm/CodeGen/WinEHFuncInfo.h"
Chandler Carruth9fb823b2013-01-02 11:36:10 +000024#include "llvm/IR/DataLayout.h"
Chandler Carruth9a4c9e52014-03-06 00:46:21 +000025#include "llvm/IR/DebugInfo.h"
Chandler Carruth9fb823b2013-01-02 11:36:10 +000026#include "llvm/IR/DerivedTypes.h"
27#include "llvm/IR/Function.h"
28#include "llvm/IR/Instructions.h"
29#include "llvm/IR/IntrinsicInst.h"
30#include "llvm/IR/LLVMContext.h"
31#include "llvm/IR/Module.h"
Dan Gohmana3624b62009-11-23 17:16:22 +000032#include "llvm/Support/Debug.h"
33#include "llvm/Support/ErrorHandling.h"
34#include "llvm/Support/MathExtras.h"
Benjamin Kramer799003b2015-03-23 19:32:43 +000035#include "llvm/Support/raw_ostream.h"
Hans Wennborgacb842d2014-03-05 02:43:26 +000036#include "llvm/Target/TargetFrameLowering.h"
Chandler Carruth92051402014-03-05 10:30:38 +000037#include "llvm/Target/TargetInstrInfo.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000038#include "llvm/Target/TargetLowering.h"
39#include "llvm/Target/TargetOptions.h"
40#include "llvm/Target/TargetRegisterInfo.h"
Eric Christopherd9134482014-08-04 21:25:23 +000041#include "llvm/Target/TargetSubtargetInfo.h"
Dan Gohmana3624b62009-11-23 17:16:22 +000042#include <algorithm>
43using namespace llvm;
44
Chandler Carruth1b9dde02014-04-22 02:02:50 +000045#define DEBUG_TYPE "function-lowering-info"
46
Dan Gohmana3624b62009-11-23 17:16:22 +000047/// isUsedOutsideOfDefiningBlock - Return true if this instruction is used by
48/// PHI nodes or outside of the basic block that defines it, or used by a
49/// switch or atomic instruction, which may expand to multiple basic blocks.
Dan Gohman913c9982010-04-15 04:33:49 +000050static bool isUsedOutsideOfDefiningBlock(const Instruction *I) {
Dan Gohman7c845e42010-04-20 14:50:13 +000051 if (I->use_empty()) return false;
Dan Gohmana3624b62009-11-23 17:16:22 +000052 if (isa<PHINode>(I)) return true;
Dan Gohman913c9982010-04-15 04:33:49 +000053 const BasicBlock *BB = I->getParent();
Chandler Carruthcdf47882014-03-09 03:16:01 +000054 for (const User *U : I->users())
Gabor Greif52617fc2010-07-09 16:08:33 +000055 if (cast<Instruction>(U)->getParent() != BB || isa<PHINode>(U))
Dan Gohmana3624b62009-11-23 17:16:22 +000056 return true;
Chandler Carruthcdf47882014-03-09 03:16:01 +000057
Dan Gohmana3624b62009-11-23 17:16:22 +000058 return false;
59}
60
Jiangning Liuffbc6902014-09-19 05:30:35 +000061static ISD::NodeType getPreferredExtendForValue(const Value *V) {
62 // For the users of the source value being used for compare instruction, if
63 // the number of signed predicate is greater than unsigned predicate, we
64 // prefer to use SIGN_EXTEND.
65 //
66 // With this optimization, we would be able to reduce some redundant sign or
67 // zero extension instruction, and eventually more machine CSE opportunities
68 // can be exposed.
69 ISD::NodeType ExtendKind = ISD::ANY_EXTEND;
70 unsigned NumOfSigned = 0, NumOfUnsigned = 0;
71 for (const User *U : V->users()) {
72 if (const auto *CI = dyn_cast<CmpInst>(U)) {
73 NumOfSigned += CI->isSigned();
74 NumOfUnsigned += CI->isUnsigned();
75 }
76 }
77 if (NumOfSigned > NumOfUnsigned)
78 ExtendKind = ISD::SIGN_EXTEND;
79
80 return ExtendKind;
81}
82
Hans Wennborgacb842d2014-03-05 02:43:26 +000083void FunctionLoweringInfo::set(const Function &fn, MachineFunction &mf,
84 SelectionDAG *DAG) {
Dan Gohmana3624b62009-11-23 17:16:22 +000085 Fn = &fn;
86 MF = &mf;
Eric Christopher2ae2de72014-10-09 00:57:31 +000087 TLI = MF->getSubtarget().getTargetLowering();
Dan Gohmana3624b62009-11-23 17:16:22 +000088 RegInfo = &MF->getRegInfo();
David Majnemercde33032015-03-30 22:58:10 +000089 MachineModuleInfo &MMI = MF->getMMI();
Dan Gohmana3624b62009-11-23 17:16:22 +000090
Dan Gohmand7b5ce32010-07-10 09:00:22 +000091 // Check whether the function can return without sret-demotion.
92 SmallVector<ISD::OutputArg, 4> Outs;
Mehdi Amini56228da2015-07-09 01:57:34 +000093 GetReturnInfo(Fn->getReturnType(), Fn->getAttributes(), Outs, *TLI,
94 mf.getDataLayout());
Bill Wendling8db01cb2013-06-06 00:11:39 +000095 CanLowerReturn = TLI->CanLowerReturn(Fn->getCallingConv(), *MF,
Eric Christopher2ae2de72014-10-09 00:57:31 +000096 Fn->isVarArg(), Outs, Fn->getContext());
Dan Gohmand7b5ce32010-07-10 09:00:22 +000097
Dan Gohmana3624b62009-11-23 17:16:22 +000098 // Initialize the mapping of values to registers. This is only set up for
99 // instruction values that are used outside of the block that defines
100 // them.
Dan Gohman913c9982010-04-15 04:33:49 +0000101 Function::const_iterator BB = Fn->begin(), EB = Fn->end();
Dan Gohmana3624b62009-11-23 17:16:22 +0000102 for (; BB != EB; ++BB)
Eric Christopher219d51d2012-02-24 01:59:01 +0000103 for (BasicBlock::const_iterator I = BB->begin(), E = BB->end();
104 I != E; ++I) {
Hans Wennborgacb842d2014-03-05 02:43:26 +0000105 if (const AllocaInst *AI = dyn_cast<AllocaInst>(I)) {
Reid Kleckner0b2bccc2014-09-02 18:42:44 +0000106 // Static allocas can be folded into the initial stack frame adjustment.
107 if (AI->isStaticAlloca()) {
108 const ConstantInt *CUI = cast<ConstantInt>(AI->getArraySize());
109 Type *Ty = AI->getAllocatedType();
Mehdi Amini8ac7a9d2015-07-07 19:07:19 +0000110 uint64_t TySize = MF->getDataLayout().getTypeAllocSize(Ty);
Reid Kleckner0b2bccc2014-09-02 18:42:44 +0000111 unsigned Align =
Mehdi Amini8ac7a9d2015-07-07 19:07:19 +0000112 std::max((unsigned)MF->getDataLayout().getPrefTypeAlignment(Ty),
Eric Christopher2ae2de72014-10-09 00:57:31 +0000113 AI->getAlignment());
Reid Kleckner0b2bccc2014-09-02 18:42:44 +0000114
115 TySize *= CUI->getZExtValue(); // Get total allocated size.
116 if (TySize == 0) TySize = 1; // Don't create zero-sized stack objects.
117
118 StaticAllocaMap[AI] =
119 MF->getFrameInfo()->CreateStackObject(TySize, Align, false, AI);
120
121 } else {
Mehdi Amini8ac7a9d2015-07-07 19:07:19 +0000122 unsigned Align =
123 std::max((unsigned)MF->getDataLayout().getPrefTypeAlignment(
124 AI->getAllocatedType()),
125 AI->getAlignment());
Eric Christopherd9134482014-08-04 21:25:23 +0000126 unsigned StackAlign =
Eric Christopher2ae2de72014-10-09 00:57:31 +0000127 MF->getSubtarget().getFrameLowering()->getStackAlignment();
Hans Wennborgacb842d2014-03-05 02:43:26 +0000128 if (Align <= StackAlign)
129 Align = 0;
130 // Inform the Frame Information that we have variable-sized objects.
131 MF->getFrameInfo()->CreateVariableSizedObject(Align ? Align : 1, AI);
132 }
133 }
134
135 // Look for inline asm that clobbers the SP register.
136 if (isa<CallInst>(I) || isa<InvokeInst>(I)) {
137 ImmutableCallSite CS(I);
Hans Wennborg0c72fd22014-03-05 03:21:23 +0000138 if (isa<InlineAsm>(CS.getCalledValue())) {
Hans Wennborgacb842d2014-03-05 02:43:26 +0000139 unsigned SP = TLI->getStackPointerRegisterToSaveRestore();
Eric Christopher11e4df72015-02-26 22:38:43 +0000140 const TargetRegisterInfo *TRI = MF->getSubtarget().getRegisterInfo();
Hans Wennborgacb842d2014-03-05 02:43:26 +0000141 std::vector<TargetLowering::AsmOperandInfo> Ops =
Mehdi Amini8ac7a9d2015-07-07 19:07:19 +0000142 TLI->ParseConstraints(Fn->getParent()->getDataLayout(), TRI, CS);
Hans Wennborgacb842d2014-03-05 02:43:26 +0000143 for (size_t I = 0, E = Ops.size(); I != E; ++I) {
144 TargetLowering::AsmOperandInfo &Op = Ops[I];
145 if (Op.Type == InlineAsm::isClobber) {
146 // Clobbers don't have SDValue operands, hence SDValue().
147 TLI->ComputeConstraintToUse(Op, SDValue(), DAG);
Eric Christopher2ae2de72014-10-09 00:57:31 +0000148 std::pair<unsigned, const TargetRegisterClass *> PhysReg =
Eric Christopher11e4df72015-02-26 22:38:43 +0000149 TLI->getRegForInlineAsmConstraint(TRI, Op.ConstraintCode,
150 Op.ConstraintVT);
Hans Wennborgacb842d2014-03-05 02:43:26 +0000151 if (PhysReg.first == SP)
Reid Klecknere69bdb82015-07-07 23:45:58 +0000152 MF->getFrameInfo()->setHasOpaqueSPAdjustment(true);
Hans Wennborgacb842d2014-03-05 02:43:26 +0000153 }
154 }
155 }
156 }
157
Reid Kleckner2d9bb652014-08-22 21:59:26 +0000158 // Look for calls to the @llvm.va_start intrinsic. We can omit some
159 // prologue boilerplate for variadic functions that don't examine their
160 // arguments.
161 if (const auto *II = dyn_cast<IntrinsicInst>(I)) {
162 if (II->getIntrinsicID() == Intrinsic::vastart)
163 MF->getFrameInfo()->setHasVAStart(true);
164 }
165
Reid Kleckner16e55412014-08-29 21:42:08 +0000166 // If we have a musttail call in a variadic funciton, we need to ensure we
167 // forward implicit register parameters.
Reid Klecknerdccd0cb2014-08-29 21:42:21 +0000168 if (const auto *CI = dyn_cast<CallInst>(I)) {
Reid Kleckner16e55412014-08-29 21:42:08 +0000169 if (CI->isMustTailCall() && Fn->isVarArg())
170 MF->getFrameInfo()->setHasMustTailInVarArgFunc(true);
171 }
172
Dan Gohman1e9362772010-07-16 17:54:27 +0000173 // Mark values used outside their block as exported, by allocating
174 // a virtual register for them.
Cameron Zwarichf8b22b32011-02-22 03:24:52 +0000175 if (isUsedOutsideOfDefiningBlock(I))
Dan Gohmana3624b62009-11-23 17:16:22 +0000176 if (!isa<AllocaInst>(I) ||
177 !StaticAllocaMap.count(cast<AllocaInst>(I)))
178 InitializeRegForValue(I);
179
Dan Gohman1e9362772010-07-16 17:54:27 +0000180 // Collect llvm.dbg.declare information. This is done now instead of
181 // during the initial isel pass through the IR so that it is done
182 // in a predictable order.
183 if (const DbgDeclareInst *DI = dyn_cast<DbgDeclareInst>(I)) {
Duncan P. N. Exon Smithd4a19a32015-04-21 18:24:23 +0000184 assert(DI->getVariable() && "Missing variable");
185 assert(DI->getDebugLoc() && "Missing location");
186 if (MMI.hasDebugInfo()) {
Dan Gohman1e9362772010-07-16 17:54:27 +0000187 // Don't handle byval struct arguments or VLAs, for example.
188 // Non-byval arguments are handled here (they refer to the stack
189 // temporary alloca at this point).
190 const Value *Address = DI->getAddress();
191 if (Address) {
192 if (const BitCastInst *BCI = dyn_cast<BitCastInst>(Address))
193 Address = BCI->getOperand(0);
194 if (const AllocaInst *AI = dyn_cast<AllocaInst>(Address)) {
195 DenseMap<const AllocaInst *, int>::iterator SI =
196 StaticAllocaMap.find(AI);
197 if (SI != StaticAllocaMap.end()) { // Check for VLAs.
198 int FI = SI->second;
Adrian Prantl87b7eb92014-10-01 18:55:02 +0000199 MMI.setVariableDbgInfo(DI->getVariable(), DI->getExpression(),
Dan Gohman1e9362772010-07-16 17:54:27 +0000200 FI, DI->getDebugLoc());
201 }
202 }
203 }
204 }
205 }
Jiangning Liuffbc6902014-09-19 05:30:35 +0000206
207 // Decide the preferred extend type for a value.
208 PreferredExtendType[I] = getPreferredExtendForValue(I);
Dan Gohman1e9362772010-07-16 17:54:27 +0000209 }
210
Dan Gohmana3624b62009-11-23 17:16:22 +0000211 // Create an initial MachineBasicBlock for each LLVM BasicBlock in F. This
212 // also creates the initial PHI MachineInstrs, though none of the input
213 // operands are populated.
Dan Gohmanf57117d2010-04-14 16:30:40 +0000214 for (BB = Fn->begin(); BB != EB; ++BB) {
Reid Kleckner51189f0a2015-09-08 23:28:38 +0000215 // Don't create MachineBasicBlocks for imaginary EH pad blocks. These blocks
216 // are really data, and no instructions can live here.
217 if (BB->isEHPad()) {
218 const Instruction *I = BB->getFirstNonPHI();
219 if (!isa<LandingPadInst>(I))
220 MMI.setHasEHFunclets(true);
221 if (isa<CatchPadInst>(I) || isa<CatchEndPadInst>(I) ||
222 isa<CleanupEndPadInst>(I)) {
223 assert(&*BB->begin() == I &&
224 "WinEHPrepare failed to remove PHIs from imaginary BBs");
225 continue;
Reid Kleckner51189f0a2015-09-08 23:28:38 +0000226 }
227 }
228
Dan Gohmana3624b62009-11-23 17:16:22 +0000229 MachineBasicBlock *MBB = mf.CreateMachineBasicBlock(BB);
230 MBBMap[BB] = MBB;
231 MF->push_back(MBB);
232
233 // Transfer the address-taken flag. This is necessary because there could
234 // be multiple MachineBasicBlocks corresponding to one BasicBlock, and only
235 // the first one should be marked.
236 if (BB->hasAddressTaken())
237 MBB->setHasAddressTaken();
238
239 // Create Machine PHI nodes for LLVM PHI nodes, lowering them as
240 // appropriate.
Dan Gohman0f055d32010-04-20 14:46:25 +0000241 for (BasicBlock::const_iterator I = BB->begin();
242 const PHINode *PN = dyn_cast<PHINode>(I); ++I) {
243 if (PN->use_empty()) continue;
Dan Gohmana3624b62009-11-23 17:16:22 +0000244
Rafael Espindolae53b7d12011-05-13 15:18:06 +0000245 // Skip empty types
246 if (PN->getType()->isEmptyTy())
247 continue;
248
Dan Gohman7b7f0882010-04-20 14:48:02 +0000249 DebugLoc DL = PN->getDebugLoc();
Dan Gohmana3624b62009-11-23 17:16:22 +0000250 unsigned PHIReg = ValueMap[PN];
251 assert(PHIReg && "PHI node does not have an assigned virtual register!");
252
253 SmallVector<EVT, 4> ValueVTs;
Mehdi Amini56228da2015-07-09 01:57:34 +0000254 ComputeValueVTs(*TLI, MF->getDataLayout(), PN->getType(), ValueVTs);
Dan Gohmana3624b62009-11-23 17:16:22 +0000255 for (unsigned vti = 0, vte = ValueVTs.size(); vti != vte; ++vti) {
256 EVT VT = ValueVTs[vti];
Bill Wendling8db01cb2013-06-06 00:11:39 +0000257 unsigned NumRegisters = TLI->getNumRegisters(Fn->getContext(), VT);
Eric Christopherfc6de422014-08-05 02:39:49 +0000258 const TargetInstrInfo *TII = MF->getSubtarget().getInstrInfo();
Dan Gohmana3624b62009-11-23 17:16:22 +0000259 for (unsigned i = 0; i != NumRegisters; ++i)
Chris Lattnerb06015a2010-02-09 19:54:29 +0000260 BuildMI(MBB, DL, TII->get(TargetOpcode::PHI), PHIReg + i);
Dan Gohmana3624b62009-11-23 17:16:22 +0000261 PHIReg += NumRegisters;
262 }
263 }
264 }
Dan Gohman69e8e322010-04-14 16:32:56 +0000265
266 // Mark landing pad blocks.
Reid Klecknercfbfe6f2015-04-24 20:25:05 +0000267 SmallVector<const LandingPadInst *, 4> LPads;
Reid Klecknerd2a1a512015-04-21 18:23:57 +0000268 for (BB = Fn->begin(); BB != EB; ++BB) {
Reid Kleckner0e288232015-08-27 23:27:47 +0000269 const Instruction *FNP = BB->getFirstNonPHI();
Reid Kleckner78783912015-09-10 00:25:23 +0000270 if (BB->isEHPad() && MBBMap.count(BB))
Reid Kleckner51189f0a2015-09-08 23:28:38 +0000271 MBBMap[BB]->setIsEHPad();
Reid Kleckner0e288232015-08-27 23:27:47 +0000272 if (const auto *LPI = dyn_cast<LandingPadInst>(FNP))
273 LPads.push_back(LPI);
Reid Klecknerd2a1a512015-04-21 18:23:57 +0000274 }
David Majnemercde33032015-03-30 22:58:10 +0000275
Joseph Tremoulet2afea542015-10-06 20:28:16 +0000276 // If this personality uses funclets, we need to do a bit more work.
Reid Kleckner0e288232015-08-27 23:27:47 +0000277 if (!Fn->hasPersonalityFn())
278 return;
279 EHPersonality Personality = classifyEHPersonality(Fn->getPersonalityFn());
Joseph Tremoulet2afea542015-10-06 20:28:16 +0000280 if (!isFuncletEHPersonality(Personality))
Reid Klecknercfbfe6f2015-04-24 20:25:05 +0000281 return;
282
Reid Klecknerf12c0302015-06-09 21:42:19 +0000283 if (Personality == EHPersonality::MSVC_Win64SEH ||
284 Personality == EHPersonality::MSVC_X86SEH) {
Reid Klecknercfbfe6f2015-04-24 20:25:05 +0000285 addSEHHandlersForLPads(LPads);
Reid Klecknerf12c0302015-06-09 21:42:19 +0000286 }
Reid Klecknercfbfe6f2015-04-24 20:25:05 +0000287
Reid Kleckner94b704c2015-09-09 21:10:03 +0000288 // Calculate state numbers if we haven't already.
Reid Klecknerf12c0302015-06-09 21:42:19 +0000289 WinEHFuncInfo &EHInfo = MMI.getWinEHFuncInfo(&fn);
Reid Kleckner78783912015-09-10 00:25:23 +0000290 const Function *WinEHParentFn = MMI.getWinEHParent(&fn);
291 if (Personality == EHPersonality::MSVC_CXX)
Reid Klecknerf12c0302015-06-09 21:42:19 +0000292 calculateWinCXXEHStateNumbers(WinEHParentFn, EHInfo);
David Majnemerf828a0c2015-10-01 18:44:59 +0000293 else if (isAsynchronousEHPersonality(Personality))
Reid Kleckner94b704c2015-09-09 21:10:03 +0000294 calculateSEHStateNumbers(WinEHParentFn, EHInfo);
Joseph Tremoulet7f8c1162015-10-06 20:30:33 +0000295 else if (Personality == EHPersonality::CoreCLR)
296 calculateClrEHStateNumbers(WinEHParentFn, EHInfo);
Reid Kleckner78783912015-09-10 00:25:23 +0000297
David Majnemerf828a0c2015-10-01 18:44:59 +0000298 calculateCatchReturnSuccessorColors(WinEHParentFn, EHInfo);
299
Reid Kleckner78783912015-09-10 00:25:23 +0000300 // Map all BB references in the WinEH data to MBBs.
Reid Klecknerb005d282015-09-16 20:16:27 +0000301 for (WinEHTryBlockMapEntry &TBME : EHInfo.TryBlockMap) {
302 for (WinEHHandlerType &H : TBME.HandlerArray) {
303 if (H.CatchObjRecoverIdx == -2 && H.CatchObj.Alloca) {
304 assert(StaticAllocaMap.count(H.CatchObj.Alloca));
305 H.CatchObj.FrameIndex = StaticAllocaMap[H.CatchObj.Alloca];
306 } else {
307 H.CatchObj.FrameIndex = INT_MAX;
308 }
309 if (const auto *BB = dyn_cast<BasicBlock>(H.Handler.get<const Value *>()))
Reid Kleckner78783912015-09-10 00:25:23 +0000310 H.Handler = MBBMap[BB];
Reid Klecknerb005d282015-09-16 20:16:27 +0000311 }
312 }
Reid Kleckner78783912015-09-10 00:25:23 +0000313 for (WinEHUnwindMapEntry &UME : EHInfo.UnwindMap)
314 if (UME.Cleanup)
315 if (const auto *BB = dyn_cast<BasicBlock>(UME.Cleanup.get<const Value *>()))
316 UME.Cleanup = MBBMap[BB];
317 for (SEHUnwindMapEntry &UME : EHInfo.SEHUnwindMap) {
318 const BasicBlock *BB = UME.Handler.get<const BasicBlock *>();
319 UME.Handler = MBBMap[BB];
Reid Kleckner94b704c2015-09-09 21:10:03 +0000320 }
Joseph Tremoulet7f8c1162015-10-06 20:30:33 +0000321 for (ClrEHUnwindMapEntry &CME : EHInfo.ClrEHUnwindMap) {
322 const BasicBlock *BB = CME.Handler.get<const BasicBlock *>();
323 CME.Handler = MBBMap[BB];
324 }
Reid Kleckner94b704c2015-09-09 21:10:03 +0000325
Reid Kleckner94b704c2015-09-09 21:10:03 +0000326 // If there's an explicit EH registration node on the stack, record its
327 // frame index.
328 if (EHInfo.EHRegNode && EHInfo.EHRegNode->getParent()->getParent() == Fn) {
329 assert(StaticAllocaMap.count(EHInfo.EHRegNode));
330 EHInfo.EHRegNodeFrameIndex = StaticAllocaMap[EHInfo.EHRegNode];
Reid Klecknerf12c0302015-06-09 21:42:19 +0000331 }
332
333 // Copy the state numbers to LandingPadInfo for the current function, which
334 // could be a handler or the parent. This should happen for 32-bit SEH and
335 // C++ EH.
336 if (Personality == EHPersonality::MSVC_CXX ||
337 Personality == EHPersonality::MSVC_X86SEH) {
Reid Klecknercfbfe6f2015-04-24 20:25:05 +0000338 for (const LandingPadInst *LP : LPads) {
339 MachineBasicBlock *LPadMBB = MBBMap[LP->getParent()];
David Majnemer0ad363e2015-08-18 19:07:12 +0000340 MMI.addWinEHState(LPadMBB, EHInfo.EHPadStateMap[LP]);
Reid Klecknercfbfe6f2015-04-24 20:25:05 +0000341 }
David Majnemera225a192015-03-31 22:35:44 +0000342 }
David Majnemercde33032015-03-30 22:58:10 +0000343}
344
Reid Klecknercfbfe6f2015-04-24 20:25:05 +0000345void FunctionLoweringInfo::addSEHHandlersForLPads(
346 ArrayRef<const LandingPadInst *> LPads) {
Reid Klecknerd2a1a512015-04-21 18:23:57 +0000347 MachineModuleInfo &MMI = MF->getMMI();
348
349 // Iterate over all landing pads with llvm.eh.actions calls.
Reid Klecknercfbfe6f2015-04-24 20:25:05 +0000350 for (const LandingPadInst *LP : LPads) {
Reid Klecknerd2a1a512015-04-21 18:23:57 +0000351 const IntrinsicInst *ActionsCall =
352 dyn_cast<IntrinsicInst>(LP->getNextNode());
353 if (!ActionsCall ||
354 ActionsCall->getIntrinsicID() != Intrinsic::eh_actions)
355 continue;
356
357 // Parse the llvm.eh.actions call we found.
358 MachineBasicBlock *LPadMBB = MBBMap[LP->getParent()];
Benjamin Kramera48e0652015-05-16 15:40:03 +0000359 SmallVector<std::unique_ptr<ActionHandler>, 4> Actions;
Reid Klecknerd2a1a512015-04-21 18:23:57 +0000360 parseEHActions(ActionsCall, Actions);
361
362 // Iterate EH actions from most to least precedence, which means
363 // iterating in reverse.
364 for (auto I = Actions.rbegin(), E = Actions.rend(); I != E; ++I) {
Benjamin Kramera48e0652015-05-16 15:40:03 +0000365 ActionHandler *Action = I->get();
Reid Klecknerd2a1a512015-04-21 18:23:57 +0000366 if (auto *CH = dyn_cast<CatchHandler>(Action)) {
367 const auto *Filter =
368 dyn_cast<Function>(CH->getSelector()->stripPointerCasts());
369 assert((Filter || CH->getSelector()->isNullValue()) &&
370 "expected function or catch-all");
371 const auto *RecoverBA =
372 cast<BlockAddress>(CH->getHandlerBlockOrFunc());
373 MMI.addSEHCatchHandler(LPadMBB, Filter, RecoverBA);
374 } else {
375 assert(isa<CleanupHandler>(Action));
376 const auto *Fini = cast<Function>(Action->getHandlerBlockOrFunc());
377 MMI.addSEHCleanupHandler(LPadMBB, Fini);
378 }
379 }
Reid Klecknerd2a1a512015-04-21 18:23:57 +0000380 }
381}
382
Dan Gohmana3624b62009-11-23 17:16:22 +0000383/// clear - Clear out all the function-specific state. This returns this
384/// FunctionLoweringInfo to an empty state, ready to be used for a
385/// different function.
386void FunctionLoweringInfo::clear() {
Dan Gohmanad0b3ea2010-04-14 17:11:23 +0000387 assert(CatchInfoFound.size() == CatchInfoLost.size() &&
388 "Not all catch info was assigned to a landing pad!");
389
Dan Gohmana3624b62009-11-23 17:16:22 +0000390 MBBMap.clear();
391 ValueMap.clear();
392 StaticAllocaMap.clear();
393#ifndef NDEBUG
394 CatchInfoLost.clear();
395 CatchInfoFound.clear();
396#endif
397 LiveOutRegInfo.clear();
Cameron Zwarich988faf92011-02-24 10:00:13 +0000398 VisitedBBs.clear();
Evan Cheng6e822452010-04-28 23:08:54 +0000399 ArgDbgValues.clear();
Devang Patel86ec8b32010-08-31 22:22:42 +0000400 ByValArgFrameIndexMap.clear();
Dan Gohmand7b5ce32010-07-10 09:00:22 +0000401 RegFixups.clear();
Philip Reames1a1bdb22014-12-02 18:50:36 +0000402 StatepointStackSlots.clear();
Igor Laevsky423bc9ec2015-05-20 11:37:25 +0000403 StatepointRelocatedValues.clear();
Jiangning Liu3b096172014-09-24 03:22:56 +0000404 PreferredExtendType.clear();
Dan Gohmana3624b62009-11-23 17:16:22 +0000405}
406
Dan Gohman93f59202010-07-02 00:10:16 +0000407/// CreateReg - Allocate a single virtual register for the given type.
Patrik Hagglund5e6c3612012-12-13 06:34:11 +0000408unsigned FunctionLoweringInfo::CreateReg(MVT VT) {
Eric Christopherd9134482014-08-04 21:25:23 +0000409 return RegInfo->createVirtualRegister(
Eric Christopher2ae2de72014-10-09 00:57:31 +0000410 MF->getSubtarget().getTargetLowering()->getRegClassFor(VT));
Dan Gohmana3624b62009-11-23 17:16:22 +0000411}
412
Dan Gohman93f59202010-07-02 00:10:16 +0000413/// CreateRegs - Allocate the appropriate number of virtual registers of
Dan Gohmana3624b62009-11-23 17:16:22 +0000414/// the correctly promoted or expanded types. Assign these registers
415/// consecutive vreg numbers and return the first assigned number.
416///
417/// In the case that the given value has struct or array type, this function
418/// will assign registers for each member or element.
419///
Chris Lattner229907c2011-07-18 04:54:35 +0000420unsigned FunctionLoweringInfo::CreateRegs(Type *Ty) {
Eric Christopher2ae2de72014-10-09 00:57:31 +0000421 const TargetLowering *TLI = MF->getSubtarget().getTargetLowering();
Bill Wendling0ccf3102013-06-19 20:32:16 +0000422
Dan Gohmana3624b62009-11-23 17:16:22 +0000423 SmallVector<EVT, 4> ValueVTs;
Mehdi Amini56228da2015-07-09 01:57:34 +0000424 ComputeValueVTs(*TLI, MF->getDataLayout(), Ty, ValueVTs);
Dan Gohmana3624b62009-11-23 17:16:22 +0000425
426 unsigned FirstReg = 0;
427 for (unsigned Value = 0, e = ValueVTs.size(); Value != e; ++Value) {
428 EVT ValueVT = ValueVTs[Value];
Bill Wendling8db01cb2013-06-06 00:11:39 +0000429 MVT RegisterVT = TLI->getRegisterType(Ty->getContext(), ValueVT);
Dan Gohmana3624b62009-11-23 17:16:22 +0000430
Bill Wendling8db01cb2013-06-06 00:11:39 +0000431 unsigned NumRegs = TLI->getNumRegisters(Ty->getContext(), ValueVT);
Dan Gohmana3624b62009-11-23 17:16:22 +0000432 for (unsigned i = 0; i != NumRegs; ++i) {
Dan Gohman93f59202010-07-02 00:10:16 +0000433 unsigned R = CreateReg(RegisterVT);
Dan Gohmana3624b62009-11-23 17:16:22 +0000434 if (!FirstReg) FirstReg = R;
435 }
436 }
437 return FirstReg;
438}
Dan Gohmanad97b3d2009-11-23 17:42:46 +0000439
Cameron Zwaricha62fc892011-02-24 10:00:25 +0000440/// GetLiveOutRegInfo - Gets LiveOutInfo for a register, returning NULL if the
441/// register is a PHI destination and the PHI's LiveOutInfo is not valid. If
442/// the register's LiveOutInfo is for a smaller bit width, it is extended to
443/// the larger bit width by zero extension. The bit width must be no smaller
444/// than the LiveOutInfo's existing bit width.
445const FunctionLoweringInfo::LiveOutInfo *
446FunctionLoweringInfo::GetLiveOutRegInfo(unsigned Reg, unsigned BitWidth) {
447 if (!LiveOutRegInfo.inBounds(Reg))
Craig Topperc0196b12014-04-14 00:51:57 +0000448 return nullptr;
Cameron Zwaricha62fc892011-02-24 10:00:25 +0000449
450 LiveOutInfo *LOI = &LiveOutRegInfo[Reg];
451 if (!LOI->IsValid)
Craig Topperc0196b12014-04-14 00:51:57 +0000452 return nullptr;
Cameron Zwaricha62fc892011-02-24 10:00:25 +0000453
Cameron Zwarichd2f30412011-02-25 01:10:55 +0000454 if (BitWidth > LOI->KnownZero.getBitWidth()) {
Cameron Zwarich4c82cd22011-02-25 01:11:01 +0000455 LOI->NumSignBits = 1;
Cameron Zwaricha62fc892011-02-24 10:00:25 +0000456 LOI->KnownZero = LOI->KnownZero.zextOrTrunc(BitWidth);
457 LOI->KnownOne = LOI->KnownOne.zextOrTrunc(BitWidth);
458 }
459
460 return LOI;
461}
462
463/// ComputePHILiveOutRegInfo - Compute LiveOutInfo for a PHI's destination
464/// register based on the LiveOutInfo of its operands.
465void FunctionLoweringInfo::ComputePHILiveOutRegInfo(const PHINode *PN) {
Chris Lattner229907c2011-07-18 04:54:35 +0000466 Type *Ty = PN->getType();
Cameron Zwaricha62fc892011-02-24 10:00:25 +0000467 if (!Ty->isIntegerTy() || Ty->isVectorTy())
468 return;
469
470 SmallVector<EVT, 1> ValueVTs;
Mehdi Amini56228da2015-07-09 01:57:34 +0000471 ComputeValueVTs(*TLI, MF->getDataLayout(), Ty, ValueVTs);
Cameron Zwaricha62fc892011-02-24 10:00:25 +0000472 assert(ValueVTs.size() == 1 &&
473 "PHIs with non-vector integer types should have a single VT.");
474 EVT IntVT = ValueVTs[0];
475
Bill Wendling8db01cb2013-06-06 00:11:39 +0000476 if (TLI->getNumRegisters(PN->getContext(), IntVT) != 1)
Cameron Zwaricha62fc892011-02-24 10:00:25 +0000477 return;
Bill Wendling8db01cb2013-06-06 00:11:39 +0000478 IntVT = TLI->getTypeToTransformTo(PN->getContext(), IntVT);
Cameron Zwaricha62fc892011-02-24 10:00:25 +0000479 unsigned BitWidth = IntVT.getSizeInBits();
480
481 unsigned DestReg = ValueMap[PN];
482 if (!TargetRegisterInfo::isVirtualRegister(DestReg))
483 return;
484 LiveOutRegInfo.grow(DestReg);
485 LiveOutInfo &DestLOI = LiveOutRegInfo[DestReg];
486
487 Value *V = PN->getIncomingValue(0);
488 if (isa<UndefValue>(V) || isa<ConstantExpr>(V)) {
489 DestLOI.NumSignBits = 1;
490 APInt Zero(BitWidth, 0);
491 DestLOI.KnownZero = Zero;
492 DestLOI.KnownOne = Zero;
493 return;
494 }
495
496 if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
497 APInt Val = CI->getValue().zextOrTrunc(BitWidth);
498 DestLOI.NumSignBits = Val.getNumSignBits();
499 DestLOI.KnownZero = ~Val;
500 DestLOI.KnownOne = Val;
501 } else {
502 assert(ValueMap.count(V) && "V should have been placed in ValueMap when its"
503 "CopyToReg node was created.");
504 unsigned SrcReg = ValueMap[V];
505 if (!TargetRegisterInfo::isVirtualRegister(SrcReg)) {
506 DestLOI.IsValid = false;
507 return;
508 }
509 const LiveOutInfo *SrcLOI = GetLiveOutRegInfo(SrcReg, BitWidth);
510 if (!SrcLOI) {
511 DestLOI.IsValid = false;
512 return;
513 }
514 DestLOI = *SrcLOI;
515 }
516
517 assert(DestLOI.KnownZero.getBitWidth() == BitWidth &&
518 DestLOI.KnownOne.getBitWidth() == BitWidth &&
519 "Masks should have the same bit width as the type.");
520
521 for (unsigned i = 1, e = PN->getNumIncomingValues(); i != e; ++i) {
522 Value *V = PN->getIncomingValue(i);
523 if (isa<UndefValue>(V) || isa<ConstantExpr>(V)) {
524 DestLOI.NumSignBits = 1;
525 APInt Zero(BitWidth, 0);
526 DestLOI.KnownZero = Zero;
527 DestLOI.KnownOne = Zero;
Eric Christopher0713a9d2011-06-08 23:55:35 +0000528 return;
Cameron Zwaricha62fc892011-02-24 10:00:25 +0000529 }
530
531 if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
532 APInt Val = CI->getValue().zextOrTrunc(BitWidth);
533 DestLOI.NumSignBits = std::min(DestLOI.NumSignBits, Val.getNumSignBits());
534 DestLOI.KnownZero &= ~Val;
535 DestLOI.KnownOne &= Val;
536 continue;
537 }
538
539 assert(ValueMap.count(V) && "V should have been placed in ValueMap when "
540 "its CopyToReg node was created.");
541 unsigned SrcReg = ValueMap[V];
542 if (!TargetRegisterInfo::isVirtualRegister(SrcReg)) {
543 DestLOI.IsValid = false;
544 return;
545 }
546 const LiveOutInfo *SrcLOI = GetLiveOutRegInfo(SrcReg, BitWidth);
547 if (!SrcLOI) {
548 DestLOI.IsValid = false;
549 return;
550 }
551 DestLOI.NumSignBits = std::min(DestLOI.NumSignBits, SrcLOI->NumSignBits);
552 DestLOI.KnownZero &= SrcLOI->KnownZero;
553 DestLOI.KnownOne &= SrcLOI->KnownOne;
554 }
555}
556
Devang Patel9d904e12011-09-08 22:59:09 +0000557/// setArgumentFrameIndex - Record frame index for the byval
Devang Patel86ec8b32010-08-31 22:22:42 +0000558/// argument. This overrides previous frame index entry for this argument,
559/// if any.
Devang Patel9d904e12011-09-08 22:59:09 +0000560void FunctionLoweringInfo::setArgumentFrameIndex(const Argument *A,
Eric Christopher219d51d2012-02-24 01:59:01 +0000561 int FI) {
Devang Patel86ec8b32010-08-31 22:22:42 +0000562 ByValArgFrameIndexMap[A] = FI;
563}
Eric Christopher0713a9d2011-06-08 23:55:35 +0000564
Devang Patel9d904e12011-09-08 22:59:09 +0000565/// getArgumentFrameIndex - Get frame index for the byval argument.
Devang Patel86ec8b32010-08-31 22:22:42 +0000566/// If the argument does not have any assigned frame index then 0 is
567/// returned.
Devang Patel9d904e12011-09-08 22:59:09 +0000568int FunctionLoweringInfo::getArgumentFrameIndex(const Argument *A) {
Eric Christopher0713a9d2011-06-08 23:55:35 +0000569 DenseMap<const Argument *, int>::iterator I =
Devang Patel86ec8b32010-08-31 22:22:42 +0000570 ByValArgFrameIndexMap.find(A);
571 if (I != ByValArgFrameIndexMap.end())
572 return I->second;
Eric Christopher18c6be72012-02-23 03:39:43 +0000573 DEBUG(dbgs() << "Argument does not have assigned frame index!\n");
Devang Patel86ec8b32010-08-31 22:22:42 +0000574 return 0;
575}
576
Michael J. Spencer8b98bf22012-02-22 19:06:13 +0000577/// ComputeUsesVAFloatArgument - Determine if any floating-point values are
578/// being passed to this variadic function, and set the MachineModuleInfo's
579/// usesVAFloatArgument flag if so. This flag is used to emit an undefined
580/// reference to _fltused on Windows, which will link in MSVCRT's
581/// floating-point support.
582void llvm::ComputeUsesVAFloatArgument(const CallInst &I,
583 MachineModuleInfo *MMI)
584{
585 FunctionType *FT = cast<FunctionType>(
586 I.getCalledValue()->getType()->getContainedType(0));
587 if (FT->isVarArg() && !MMI->usesVAFloatArgument()) {
588 for (unsigned i = 0, e = I.getNumArgOperands(); i != e; ++i) {
589 Type* T = I.getArgOperand(i)->getType();
Daniel Berlin25db4f42015-04-15 17:41:42 +0000590 for (auto i : post_order(T)) {
Michael J. Spencer8b98bf22012-02-22 19:06:13 +0000591 if (i->isFloatingPointTy()) {
592 MMI->setUsesVAFloatArgument(true);
593 return;
594 }
595 }
596 }
597 }
598}
599
Bill Wendling247fd3b2011-08-17 21:56:44 +0000600/// AddLandingPadInfo - Extract the exception handling information from the
601/// landingpad instruction and add them to the specified machine module info.
602void llvm::AddLandingPadInfo(const LandingPadInst &I, MachineModuleInfo &MMI,
603 MachineBasicBlock *MBB) {
Reid Klecknere00faf82015-08-31 20:02:16 +0000604 if (const auto *PF = dyn_cast<Function>(
605 I.getParent()->getParent()->getPersonalityFn()->stripPointerCasts()))
606 MMI.addPersonality(PF);
Bill Wendling247fd3b2011-08-17 21:56:44 +0000607
608 if (I.isCleanup())
609 MMI.addCleanup(MBB);
610
611 // FIXME: New EH - Add the clauses in reverse order. This isn't 100% correct,
612 // but we need to do it this way because of how the DWARF EH emitter
613 // processes the clauses.
614 for (unsigned i = I.getNumClauses(); i != 0; --i) {
615 Value *Val = I.getClause(i - 1);
616 if (I.isCatch(i - 1)) {
617 MMI.addCatchTypeInfo(MBB,
Reid Kleckner283bc2e2014-11-14 00:35:50 +0000618 dyn_cast<GlobalValue>(Val->stripPointerCasts()));
Bill Wendling247fd3b2011-08-17 21:56:44 +0000619 } else {
620 // Add filters in a list.
621 Constant *CVal = cast<Constant>(Val);
Reid Kleckner283bc2e2014-11-14 00:35:50 +0000622 SmallVector<const GlobalValue*, 4> FilterList;
Bill Wendling247fd3b2011-08-17 21:56:44 +0000623 for (User::op_iterator
624 II = CVal->op_begin(), IE = CVal->op_end(); II != IE; ++II)
Reid Kleckner283bc2e2014-11-14 00:35:50 +0000625 FilterList.push_back(cast<GlobalValue>((*II)->stripPointerCasts()));
Bill Wendling247fd3b2011-08-17 21:56:44 +0000626
627 MMI.addFilterTypeInfo(MBB, FilterList);
628 }
629 }
630}