1 //===-- 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 15 #include "llvm/CodeGen/FunctionLoweringInfo.h" 16 #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" 23 #include "llvm/CodeGen/WinEHFuncInfo.h" 24 #include "llvm/IR/DataLayout.h" 25 #include "llvm/IR/DebugInfo.h" 26 #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" 32 #include "llvm/Support/Debug.h" 33 #include "llvm/Support/ErrorHandling.h" 34 #include "llvm/Support/MathExtras.h" 35 #include "llvm/Support/raw_ostream.h" 36 #include "llvm/Target/TargetFrameLowering.h" 37 #include "llvm/Target/TargetInstrInfo.h" 38 #include "llvm/Target/TargetLowering.h" 39 #include "llvm/Target/TargetOptions.h" 40 #include "llvm/Target/TargetRegisterInfo.h" 41 #include "llvm/Target/TargetSubtargetInfo.h" 42 #include <algorithm> 43 using namespace llvm; 44 45 #define DEBUG_TYPE "function-lowering-info" 46 47 /// 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. 50 static bool isUsedOutsideOfDefiningBlock(const Instruction *I) { 51 if (I->use_empty()) return false; 52 if (isa<PHINode>(I)) return true; 53 const BasicBlock *BB = I->getParent(); 54 for (const User *U : I->users()) 55 if (cast<Instruction>(U)->getParent() != BB || isa<PHINode>(U)) 56 return true; 57 58 return false; 59 } 60 61 static 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 83 namespace { 84 struct WinEHNumbering { 85 WinEHNumbering(WinEHFuncInfo &FuncInfo) : FuncInfo(FuncInfo), NextState(0) {} 86 87 WinEHFuncInfo &FuncInfo; 88 int NextState; 89 90 SmallVector<ActionHandler *, 4> HandlerStack; 91 SmallPtrSet<const Function *, 4> VisitedHandlers; 92 93 int currentEHNumber() const { 94 return HandlerStack.empty() ? -1 : HandlerStack.back()->getEHState(); 95 } 96 97 void createUnwindMapEntry(int ToState, ActionHandler *AH); 98 void createTryBlockMapEntry(int TryLow, int TryHigh, 99 ArrayRef<CatchHandler *> Handlers); 100 void processCallSite(ArrayRef<ActionHandler *> Actions, ImmutableCallSite CS); 101 void calculateStateNumbers(const Function &F); 102 }; 103 } 104 105 void FunctionLoweringInfo::set(const Function &fn, MachineFunction &mf, 106 SelectionDAG *DAG) { 107 Fn = &fn; 108 MF = &mf; 109 TLI = MF->getSubtarget().getTargetLowering(); 110 RegInfo = &MF->getRegInfo(); 111 MachineModuleInfo &MMI = MF->getMMI(); 112 113 // Check whether the function can return without sret-demotion. 114 SmallVector<ISD::OutputArg, 4> Outs; 115 GetReturnInfo(Fn->getReturnType(), Fn->getAttributes(), Outs, *TLI); 116 CanLowerReturn = TLI->CanLowerReturn(Fn->getCallingConv(), *MF, 117 Fn->isVarArg(), Outs, Fn->getContext()); 118 119 // Initialize the mapping of values to registers. This is only set up for 120 // instruction values that are used outside of the block that defines 121 // them. 122 Function::const_iterator BB = Fn->begin(), EB = Fn->end(); 123 for (; BB != EB; ++BB) 124 for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); 125 I != E; ++I) { 126 if (const AllocaInst *AI = dyn_cast<AllocaInst>(I)) { 127 // Static allocas can be folded into the initial stack frame adjustment. 128 if (AI->isStaticAlloca()) { 129 const ConstantInt *CUI = cast<ConstantInt>(AI->getArraySize()); 130 Type *Ty = AI->getAllocatedType(); 131 uint64_t TySize = TLI->getDataLayout()->getTypeAllocSize(Ty); 132 unsigned Align = 133 std::max((unsigned)TLI->getDataLayout()->getPrefTypeAlignment(Ty), 134 AI->getAlignment()); 135 136 TySize *= CUI->getZExtValue(); // Get total allocated size. 137 if (TySize == 0) TySize = 1; // Don't create zero-sized stack objects. 138 139 StaticAllocaMap[AI] = 140 MF->getFrameInfo()->CreateStackObject(TySize, Align, false, AI); 141 142 } else { 143 unsigned Align = std::max( 144 (unsigned)TLI->getDataLayout()->getPrefTypeAlignment( 145 AI->getAllocatedType()), 146 AI->getAlignment()); 147 unsigned StackAlign = 148 MF->getSubtarget().getFrameLowering()->getStackAlignment(); 149 if (Align <= StackAlign) 150 Align = 0; 151 // Inform the Frame Information that we have variable-sized objects. 152 MF->getFrameInfo()->CreateVariableSizedObject(Align ? Align : 1, AI); 153 } 154 } 155 156 // Look for inline asm that clobbers the SP register. 157 if (isa<CallInst>(I) || isa<InvokeInst>(I)) { 158 ImmutableCallSite CS(I); 159 if (isa<InlineAsm>(CS.getCalledValue())) { 160 unsigned SP = TLI->getStackPointerRegisterToSaveRestore(); 161 const TargetRegisterInfo *TRI = MF->getSubtarget().getRegisterInfo(); 162 std::vector<TargetLowering::AsmOperandInfo> Ops = 163 TLI->ParseConstraints(TRI, CS); 164 for (size_t I = 0, E = Ops.size(); I != E; ++I) { 165 TargetLowering::AsmOperandInfo &Op = Ops[I]; 166 if (Op.Type == InlineAsm::isClobber) { 167 // Clobbers don't have SDValue operands, hence SDValue(). 168 TLI->ComputeConstraintToUse(Op, SDValue(), DAG); 169 std::pair<unsigned, const TargetRegisterClass *> PhysReg = 170 TLI->getRegForInlineAsmConstraint(TRI, Op.ConstraintCode, 171 Op.ConstraintVT); 172 if (PhysReg.first == SP) 173 MF->getFrameInfo()->setHasInlineAsmWithSPAdjust(true); 174 } 175 } 176 } 177 } 178 179 // Look for calls to the @llvm.va_start intrinsic. We can omit some 180 // prologue boilerplate for variadic functions that don't examine their 181 // arguments. 182 if (const auto *II = dyn_cast<IntrinsicInst>(I)) { 183 if (II->getIntrinsicID() == Intrinsic::vastart) 184 MF->getFrameInfo()->setHasVAStart(true); 185 } 186 187 // If we have a musttail call in a variadic funciton, we need to ensure we 188 // forward implicit register parameters. 189 if (const auto *CI = dyn_cast<CallInst>(I)) { 190 if (CI->isMustTailCall() && Fn->isVarArg()) 191 MF->getFrameInfo()->setHasMustTailInVarArgFunc(true); 192 } 193 194 // Mark values used outside their block as exported, by allocating 195 // a virtual register for them. 196 if (isUsedOutsideOfDefiningBlock(I)) 197 if (!isa<AllocaInst>(I) || 198 !StaticAllocaMap.count(cast<AllocaInst>(I))) 199 InitializeRegForValue(I); 200 201 // Collect llvm.dbg.declare information. This is done now instead of 202 // during the initial isel pass through the IR so that it is done 203 // in a predictable order. 204 if (const DbgDeclareInst *DI = dyn_cast<DbgDeclareInst>(I)) { 205 DIVariable DIVar = DI->getVariable(); 206 if (MMI.hasDebugInfo() && DIVar && DI->getDebugLoc()) { 207 // Don't handle byval struct arguments or VLAs, for example. 208 // Non-byval arguments are handled here (they refer to the stack 209 // temporary alloca at this point). 210 const Value *Address = DI->getAddress(); 211 if (Address) { 212 if (const BitCastInst *BCI = dyn_cast<BitCastInst>(Address)) 213 Address = BCI->getOperand(0); 214 if (const AllocaInst *AI = dyn_cast<AllocaInst>(Address)) { 215 DenseMap<const AllocaInst *, int>::iterator SI = 216 StaticAllocaMap.find(AI); 217 if (SI != StaticAllocaMap.end()) { // Check for VLAs. 218 int FI = SI->second; 219 MMI.setVariableDbgInfo(DI->getVariable(), DI->getExpression(), 220 FI, DI->getDebugLoc()); 221 } 222 } 223 } 224 } 225 } 226 227 // Decide the preferred extend type for a value. 228 PreferredExtendType[I] = getPreferredExtendForValue(I); 229 } 230 231 // Create an initial MachineBasicBlock for each LLVM BasicBlock in F. This 232 // also creates the initial PHI MachineInstrs, though none of the input 233 // operands are populated. 234 for (BB = Fn->begin(); BB != EB; ++BB) { 235 MachineBasicBlock *MBB = mf.CreateMachineBasicBlock(BB); 236 MBBMap[BB] = MBB; 237 MF->push_back(MBB); 238 239 // Transfer the address-taken flag. This is necessary because there could 240 // be multiple MachineBasicBlocks corresponding to one BasicBlock, and only 241 // the first one should be marked. 242 if (BB->hasAddressTaken()) 243 MBB->setHasAddressTaken(); 244 245 // Create Machine PHI nodes for LLVM PHI nodes, lowering them as 246 // appropriate. 247 for (BasicBlock::const_iterator I = BB->begin(); 248 const PHINode *PN = dyn_cast<PHINode>(I); ++I) { 249 if (PN->use_empty()) continue; 250 251 // Skip empty types 252 if (PN->getType()->isEmptyTy()) 253 continue; 254 255 DebugLoc DL = PN->getDebugLoc(); 256 unsigned PHIReg = ValueMap[PN]; 257 assert(PHIReg && "PHI node does not have an assigned virtual register!"); 258 259 SmallVector<EVT, 4> ValueVTs; 260 ComputeValueVTs(*TLI, PN->getType(), ValueVTs); 261 for (unsigned vti = 0, vte = ValueVTs.size(); vti != vte; ++vti) { 262 EVT VT = ValueVTs[vti]; 263 unsigned NumRegisters = TLI->getNumRegisters(Fn->getContext(), VT); 264 const TargetInstrInfo *TII = MF->getSubtarget().getInstrInfo(); 265 for (unsigned i = 0; i != NumRegisters; ++i) 266 BuildMI(MBB, DL, TII->get(TargetOpcode::PHI), PHIReg + i); 267 PHIReg += NumRegisters; 268 } 269 } 270 } 271 272 // Mark landing pad blocks. 273 for (BB = Fn->begin(); BB != EB; ++BB) 274 if (const auto *Invoke = dyn_cast<InvokeInst>(BB->getTerminator())) 275 MBBMap[Invoke->getSuccessor(1)]->setIsLandingPad(); 276 277 // Calculate EH numbers for WinEH. 278 if (fn.hasFnAttribute("wineh-parent")) { 279 const Function *WinEHParentFn = MMI.getWinEHParent(&fn); 280 WinEHFuncInfo &FI = MMI.getWinEHFuncInfo(WinEHParentFn); 281 if (FI.LandingPadStateMap.empty()) { 282 WinEHNumbering Num(FI); 283 Num.calculateStateNumbers(*WinEHParentFn); 284 // Pop everything on the handler stack. 285 Num.processCallSite(None, ImmutableCallSite()); 286 } 287 } 288 } 289 290 void WinEHNumbering::createUnwindMapEntry(int ToState, ActionHandler *AH) { 291 WinEHUnwindMapEntry UME; 292 UME.ToState = ToState; 293 if (auto *CH = dyn_cast_or_null<CleanupHandler>(AH)) 294 UME.Cleanup = cast<Function>(CH->getHandlerBlockOrFunc()); 295 else 296 UME.Cleanup = nullptr; 297 FuncInfo.UnwindMap.push_back(UME); 298 } 299 300 void WinEHNumbering::createTryBlockMapEntry(int TryLow, int TryHigh, 301 ArrayRef<CatchHandler *> Handlers) { 302 WinEHTryBlockMapEntry TBME; 303 TBME.TryLow = TryLow; 304 TBME.TryHigh = TryHigh; 305 assert(TBME.TryLow <= TBME.TryHigh); 306 for (CatchHandler *CH : Handlers) { 307 WinEHHandlerType HT; 308 if (CH->getSelector()->isNullValue()) { 309 HT.Adjectives = 0x40; 310 HT.TypeDescriptor = nullptr; 311 } else { 312 auto *GV = cast<GlobalVariable>(CH->getSelector()->stripPointerCasts()); 313 // Selectors are always pointers to GlobalVariables with 'struct' type. 314 // The struct has two fields, adjectives and a type descriptor. 315 auto *CS = cast<ConstantStruct>(GV->getInitializer()); 316 HT.Adjectives = 317 cast<ConstantInt>(CS->getAggregateElement(0U))->getZExtValue(); 318 HT.TypeDescriptor = 319 cast<GlobalVariable>(CS->getAggregateElement(1)->stripPointerCasts()); 320 } 321 HT.Handler = cast<Function>(CH->getHandlerBlockOrFunc()); 322 HT.CatchObjRecoverIdx = CH->getExceptionVarIndex(); 323 TBME.HandlerArray.push_back(HT); 324 } 325 FuncInfo.TryBlockMap.push_back(TBME); 326 } 327 328 static void print_name(const Value *V) { 329 #ifndef NDEBUG 330 if (!V) { 331 DEBUG(dbgs() << "null"); 332 return; 333 } 334 335 if (const auto *F = dyn_cast<Function>(V)) 336 DEBUG(dbgs() << F->getName()); 337 else 338 DEBUG(V->dump()); 339 #endif 340 } 341 342 void WinEHNumbering::processCallSite(ArrayRef<ActionHandler *> Actions, 343 ImmutableCallSite CS) { 344 int FirstMismatch = 0; 345 for (int E = std::min(HandlerStack.size(), Actions.size()); FirstMismatch < E; 346 ++FirstMismatch) { 347 if (HandlerStack[FirstMismatch]->getHandlerBlockOrFunc() != 348 Actions[FirstMismatch]->getHandlerBlockOrFunc()) 349 break; 350 delete Actions[FirstMismatch]; 351 } 352 353 bool EnteringScope = (int)Actions.size() > FirstMismatch; 354 355 // Don't recurse while we are looping over the handler stack. Instead, defer 356 // the numbering of the catch handlers until we are done popping. 357 SmallVector<CatchHandler *, 4> PoppedCatches; 358 for (int I = HandlerStack.size() - 1; I >= FirstMismatch; --I) { 359 if (auto *CH = dyn_cast<CatchHandler>(HandlerStack.back())) { 360 PoppedCatches.push_back(CH); 361 } else { 362 // Delete cleanup handlers 363 delete HandlerStack.back(); 364 } 365 HandlerStack.pop_back(); 366 } 367 368 // We need to create a new state number if we are exiting a try scope and we 369 // will not push any more actions. 370 int TryHigh = NextState - 1; 371 if (!EnteringScope && !PoppedCatches.empty()) { 372 createUnwindMapEntry(currentEHNumber(), nullptr); 373 ++NextState; 374 } 375 376 int LastTryLowIdx = 0; 377 for (int I = 0, E = PoppedCatches.size(); I != E; ++I) { 378 CatchHandler *CH = PoppedCatches[I]; 379 if (I + 1 == E || CH->getEHState() != PoppedCatches[I + 1]->getEHState()) { 380 int TryLow = CH->getEHState(); 381 auto Handlers = 382 makeArrayRef(&PoppedCatches[LastTryLowIdx], I - LastTryLowIdx + 1); 383 createTryBlockMapEntry(TryLow, TryHigh, Handlers); 384 LastTryLowIdx = I + 1; 385 } 386 } 387 388 for (CatchHandler *CH : PoppedCatches) { 389 if (auto *F = dyn_cast<Function>(CH->getHandlerBlockOrFunc())) 390 calculateStateNumbers(*F); 391 delete CH; 392 } 393 394 bool LastActionWasCatch = false; 395 for (size_t I = FirstMismatch; I != Actions.size(); ++I) { 396 // We can reuse eh states when pushing two catches for the same invoke. 397 bool CurrActionIsCatch = isa<CatchHandler>(Actions[I]); 398 // FIXME: Reenable this optimization! 399 if (CurrActionIsCatch && LastActionWasCatch && false) { 400 Actions[I]->setEHState(currentEHNumber()); 401 } else { 402 createUnwindMapEntry(currentEHNumber(), Actions[I]); 403 Actions[I]->setEHState(NextState); 404 NextState++; 405 DEBUG(dbgs() << "Creating unwind map entry for: ("); 406 print_name(Actions[I]->getHandlerBlockOrFunc()); 407 DEBUG(dbgs() << ", " << currentEHNumber() << ")\n"); 408 } 409 HandlerStack.push_back(Actions[I]); 410 LastActionWasCatch = CurrActionIsCatch; 411 } 412 413 DEBUG(dbgs() << "In EHState " << currentEHNumber() << " for CallSite: "); 414 print_name(CS ? CS.getCalledValue() : nullptr); 415 DEBUG(dbgs() << '\n'); 416 } 417 418 void WinEHNumbering::calculateStateNumbers(const Function &F) { 419 auto I = VisitedHandlers.insert(&F); 420 if (!I.second) 421 return; // We've already visited this handler, don't renumber it. 422 423 DEBUG(dbgs() << "Calculating state numbers for: " << F.getName() << '\n'); 424 SmallVector<ActionHandler *, 4> ActionList; 425 for (const BasicBlock &BB : F) { 426 for (const Instruction &I : BB) { 427 const auto *CI = dyn_cast<CallInst>(&I); 428 if (!CI || CI->doesNotThrow()) 429 continue; 430 processCallSite(None, CI); 431 } 432 const auto *II = dyn_cast<InvokeInst>(BB.getTerminator()); 433 if (!II) 434 continue; 435 const LandingPadInst *LPI = II->getLandingPadInst(); 436 auto *ActionsCall = dyn_cast<IntrinsicInst>(LPI->getNextNode()); 437 if (!ActionsCall) 438 continue; 439 assert(ActionsCall->getIntrinsicID() == Intrinsic::eh_actions); 440 parseEHActions(ActionsCall, ActionList); 441 processCallSite(ActionList, II); 442 ActionList.clear(); 443 FuncInfo.LandingPadStateMap[LPI] = currentEHNumber(); 444 } 445 446 FuncInfo.CatchHandlerMaxState[&F] = NextState - 1; 447 } 448 449 /// clear - Clear out all the function-specific state. This returns this 450 /// FunctionLoweringInfo to an empty state, ready to be used for a 451 /// different function. 452 void FunctionLoweringInfo::clear() { 453 assert(CatchInfoFound.size() == CatchInfoLost.size() && 454 "Not all catch info was assigned to a landing pad!"); 455 456 MBBMap.clear(); 457 ValueMap.clear(); 458 StaticAllocaMap.clear(); 459 #ifndef NDEBUG 460 CatchInfoLost.clear(); 461 CatchInfoFound.clear(); 462 #endif 463 LiveOutRegInfo.clear(); 464 VisitedBBs.clear(); 465 ArgDbgValues.clear(); 466 ByValArgFrameIndexMap.clear(); 467 RegFixups.clear(); 468 StatepointStackSlots.clear(); 469 PreferredExtendType.clear(); 470 } 471 472 /// CreateReg - Allocate a single virtual register for the given type. 473 unsigned FunctionLoweringInfo::CreateReg(MVT VT) { 474 return RegInfo->createVirtualRegister( 475 MF->getSubtarget().getTargetLowering()->getRegClassFor(VT)); 476 } 477 478 /// CreateRegs - Allocate the appropriate number of virtual registers of 479 /// the correctly promoted or expanded types. Assign these registers 480 /// consecutive vreg numbers and return the first assigned number. 481 /// 482 /// In the case that the given value has struct or array type, this function 483 /// will assign registers for each member or element. 484 /// 485 unsigned FunctionLoweringInfo::CreateRegs(Type *Ty) { 486 const TargetLowering *TLI = MF->getSubtarget().getTargetLowering(); 487 488 SmallVector<EVT, 4> ValueVTs; 489 ComputeValueVTs(*TLI, Ty, ValueVTs); 490 491 unsigned FirstReg = 0; 492 for (unsigned Value = 0, e = ValueVTs.size(); Value != e; ++Value) { 493 EVT ValueVT = ValueVTs[Value]; 494 MVT RegisterVT = TLI->getRegisterType(Ty->getContext(), ValueVT); 495 496 unsigned NumRegs = TLI->getNumRegisters(Ty->getContext(), ValueVT); 497 for (unsigned i = 0; i != NumRegs; ++i) { 498 unsigned R = CreateReg(RegisterVT); 499 if (!FirstReg) FirstReg = R; 500 } 501 } 502 return FirstReg; 503 } 504 505 /// GetLiveOutRegInfo - Gets LiveOutInfo for a register, returning NULL if the 506 /// register is a PHI destination and the PHI's LiveOutInfo is not valid. If 507 /// the register's LiveOutInfo is for a smaller bit width, it is extended to 508 /// the larger bit width by zero extension. The bit width must be no smaller 509 /// than the LiveOutInfo's existing bit width. 510 const FunctionLoweringInfo::LiveOutInfo * 511 FunctionLoweringInfo::GetLiveOutRegInfo(unsigned Reg, unsigned BitWidth) { 512 if (!LiveOutRegInfo.inBounds(Reg)) 513 return nullptr; 514 515 LiveOutInfo *LOI = &LiveOutRegInfo[Reg]; 516 if (!LOI->IsValid) 517 return nullptr; 518 519 if (BitWidth > LOI->KnownZero.getBitWidth()) { 520 LOI->NumSignBits = 1; 521 LOI->KnownZero = LOI->KnownZero.zextOrTrunc(BitWidth); 522 LOI->KnownOne = LOI->KnownOne.zextOrTrunc(BitWidth); 523 } 524 525 return LOI; 526 } 527 528 /// ComputePHILiveOutRegInfo - Compute LiveOutInfo for a PHI's destination 529 /// register based on the LiveOutInfo of its operands. 530 void FunctionLoweringInfo::ComputePHILiveOutRegInfo(const PHINode *PN) { 531 Type *Ty = PN->getType(); 532 if (!Ty->isIntegerTy() || Ty->isVectorTy()) 533 return; 534 535 SmallVector<EVT, 1> ValueVTs; 536 ComputeValueVTs(*TLI, Ty, ValueVTs); 537 assert(ValueVTs.size() == 1 && 538 "PHIs with non-vector integer types should have a single VT."); 539 EVT IntVT = ValueVTs[0]; 540 541 if (TLI->getNumRegisters(PN->getContext(), IntVT) != 1) 542 return; 543 IntVT = TLI->getTypeToTransformTo(PN->getContext(), IntVT); 544 unsigned BitWidth = IntVT.getSizeInBits(); 545 546 unsigned DestReg = ValueMap[PN]; 547 if (!TargetRegisterInfo::isVirtualRegister(DestReg)) 548 return; 549 LiveOutRegInfo.grow(DestReg); 550 LiveOutInfo &DestLOI = LiveOutRegInfo[DestReg]; 551 552 Value *V = PN->getIncomingValue(0); 553 if (isa<UndefValue>(V) || isa<ConstantExpr>(V)) { 554 DestLOI.NumSignBits = 1; 555 APInt Zero(BitWidth, 0); 556 DestLOI.KnownZero = Zero; 557 DestLOI.KnownOne = Zero; 558 return; 559 } 560 561 if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) { 562 APInt Val = CI->getValue().zextOrTrunc(BitWidth); 563 DestLOI.NumSignBits = Val.getNumSignBits(); 564 DestLOI.KnownZero = ~Val; 565 DestLOI.KnownOne = Val; 566 } else { 567 assert(ValueMap.count(V) && "V should have been placed in ValueMap when its" 568 "CopyToReg node was created."); 569 unsigned SrcReg = ValueMap[V]; 570 if (!TargetRegisterInfo::isVirtualRegister(SrcReg)) { 571 DestLOI.IsValid = false; 572 return; 573 } 574 const LiveOutInfo *SrcLOI = GetLiveOutRegInfo(SrcReg, BitWidth); 575 if (!SrcLOI) { 576 DestLOI.IsValid = false; 577 return; 578 } 579 DestLOI = *SrcLOI; 580 } 581 582 assert(DestLOI.KnownZero.getBitWidth() == BitWidth && 583 DestLOI.KnownOne.getBitWidth() == BitWidth && 584 "Masks should have the same bit width as the type."); 585 586 for (unsigned i = 1, e = PN->getNumIncomingValues(); i != e; ++i) { 587 Value *V = PN->getIncomingValue(i); 588 if (isa<UndefValue>(V) || isa<ConstantExpr>(V)) { 589 DestLOI.NumSignBits = 1; 590 APInt Zero(BitWidth, 0); 591 DestLOI.KnownZero = Zero; 592 DestLOI.KnownOne = Zero; 593 return; 594 } 595 596 if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) { 597 APInt Val = CI->getValue().zextOrTrunc(BitWidth); 598 DestLOI.NumSignBits = std::min(DestLOI.NumSignBits, Val.getNumSignBits()); 599 DestLOI.KnownZero &= ~Val; 600 DestLOI.KnownOne &= Val; 601 continue; 602 } 603 604 assert(ValueMap.count(V) && "V should have been placed in ValueMap when " 605 "its CopyToReg node was created."); 606 unsigned SrcReg = ValueMap[V]; 607 if (!TargetRegisterInfo::isVirtualRegister(SrcReg)) { 608 DestLOI.IsValid = false; 609 return; 610 } 611 const LiveOutInfo *SrcLOI = GetLiveOutRegInfo(SrcReg, BitWidth); 612 if (!SrcLOI) { 613 DestLOI.IsValid = false; 614 return; 615 } 616 DestLOI.NumSignBits = std::min(DestLOI.NumSignBits, SrcLOI->NumSignBits); 617 DestLOI.KnownZero &= SrcLOI->KnownZero; 618 DestLOI.KnownOne &= SrcLOI->KnownOne; 619 } 620 } 621 622 /// setArgumentFrameIndex - Record frame index for the byval 623 /// argument. This overrides previous frame index entry for this argument, 624 /// if any. 625 void FunctionLoweringInfo::setArgumentFrameIndex(const Argument *A, 626 int FI) { 627 ByValArgFrameIndexMap[A] = FI; 628 } 629 630 /// getArgumentFrameIndex - Get frame index for the byval argument. 631 /// If the argument does not have any assigned frame index then 0 is 632 /// returned. 633 int FunctionLoweringInfo::getArgumentFrameIndex(const Argument *A) { 634 DenseMap<const Argument *, int>::iterator I = 635 ByValArgFrameIndexMap.find(A); 636 if (I != ByValArgFrameIndexMap.end()) 637 return I->second; 638 DEBUG(dbgs() << "Argument does not have assigned frame index!\n"); 639 return 0; 640 } 641 642 /// ComputeUsesVAFloatArgument - Determine if any floating-point values are 643 /// being passed to this variadic function, and set the MachineModuleInfo's 644 /// usesVAFloatArgument flag if so. This flag is used to emit an undefined 645 /// reference to _fltused on Windows, which will link in MSVCRT's 646 /// floating-point support. 647 void llvm::ComputeUsesVAFloatArgument(const CallInst &I, 648 MachineModuleInfo *MMI) 649 { 650 FunctionType *FT = cast<FunctionType>( 651 I.getCalledValue()->getType()->getContainedType(0)); 652 if (FT->isVarArg() && !MMI->usesVAFloatArgument()) { 653 for (unsigned i = 0, e = I.getNumArgOperands(); i != e; ++i) { 654 Type* T = I.getArgOperand(i)->getType(); 655 for (auto i : post_order(T)) { 656 if (i->isFloatingPointTy()) { 657 MMI->setUsesVAFloatArgument(true); 658 return; 659 } 660 } 661 } 662 } 663 } 664 665 /// AddLandingPadInfo - Extract the exception handling information from the 666 /// landingpad instruction and add them to the specified machine module info. 667 void llvm::AddLandingPadInfo(const LandingPadInst &I, MachineModuleInfo &MMI, 668 MachineBasicBlock *MBB) { 669 MMI.addPersonality(MBB, 670 cast<Function>(I.getPersonalityFn()->stripPointerCasts())); 671 672 if (I.isCleanup()) 673 MMI.addCleanup(MBB); 674 675 // FIXME: New EH - Add the clauses in reverse order. This isn't 100% correct, 676 // but we need to do it this way because of how the DWARF EH emitter 677 // processes the clauses. 678 for (unsigned i = I.getNumClauses(); i != 0; --i) { 679 Value *Val = I.getClause(i - 1); 680 if (I.isCatch(i - 1)) { 681 MMI.addCatchTypeInfo(MBB, 682 dyn_cast<GlobalValue>(Val->stripPointerCasts())); 683 } else { 684 // Add filters in a list. 685 Constant *CVal = cast<Constant>(Val); 686 SmallVector<const GlobalValue*, 4> FilterList; 687 for (User::op_iterator 688 II = CVal->op_begin(), IE = CVal->op_end(); II != IE; ++II) 689 FilterList.push_back(cast<GlobalValue>((*II)->stripPointerCasts())); 690 691 MMI.addFilterTypeInfo(MBB, FilterList); 692 } 693 } 694 } 695