1 //===-- llvm/CodeGen/MachineModuleInfo.cpp ----------------------*- 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 #include "llvm/CodeGen/MachineModuleInfo.h" 11 #include "llvm/ADT/PointerUnion.h" 12 #include "llvm/Analysis/LibCallSemantics.h" 13 #include "llvm/Analysis/ValueTracking.h" 14 #include "llvm/CodeGen/MachineFunction.h" 15 #include "llvm/CodeGen/MachineFunctionPass.h" 16 #include "llvm/CodeGen/Passes.h" 17 #include "llvm/CodeGen/WinEHFuncInfo.h" 18 #include "llvm/IR/Constants.h" 19 #include "llvm/IR/DerivedTypes.h" 20 #include "llvm/IR/GlobalVariable.h" 21 #include "llvm/IR/Module.h" 22 #include "llvm/MC/MCObjectFileInfo.h" 23 #include "llvm/MC/MCSymbol.h" 24 #include "llvm/Support/Dwarf.h" 25 #include "llvm/Support/ErrorHandling.h" 26 using namespace llvm; 27 using namespace llvm::dwarf; 28 29 // Handle the Pass registration stuff necessary to use DataLayout's. 30 INITIALIZE_PASS(MachineModuleInfo, "machinemoduleinfo", 31 "Machine Module Information", false, false) 32 char MachineModuleInfo::ID = 0; 33 34 // Out of line virtual method. 35 MachineModuleInfoImpl::~MachineModuleInfoImpl() {} 36 37 namespace llvm { 38 class MMIAddrLabelMapCallbackPtr : CallbackVH { 39 MMIAddrLabelMap *Map; 40 public: 41 MMIAddrLabelMapCallbackPtr() : Map(nullptr) {} 42 MMIAddrLabelMapCallbackPtr(Value *V) : CallbackVH(V), Map(nullptr) {} 43 44 void setPtr(BasicBlock *BB) { 45 ValueHandleBase::operator=(BB); 46 } 47 48 void setMap(MMIAddrLabelMap *map) { Map = map; } 49 50 void deleted() override; 51 void allUsesReplacedWith(Value *V2) override; 52 }; 53 54 class MMIAddrLabelMap { 55 MCContext &Context; 56 struct AddrLabelSymEntry { 57 /// Symbols - The symbols for the label. This is a pointer union that is 58 /// either one symbol (the common case) or a list of symbols. 59 PointerUnion<MCSymbol *, std::vector<MCSymbol*>*> Symbols; 60 61 Function *Fn; // The containing function of the BasicBlock. 62 unsigned Index; // The index in BBCallbacks for the BasicBlock. 63 }; 64 65 DenseMap<AssertingVH<BasicBlock>, AddrLabelSymEntry> AddrLabelSymbols; 66 67 /// BBCallbacks - Callbacks for the BasicBlock's that we have entries for. We 68 /// use this so we get notified if a block is deleted or RAUWd. 69 std::vector<MMIAddrLabelMapCallbackPtr> BBCallbacks; 70 71 /// DeletedAddrLabelsNeedingEmission - This is a per-function list of symbols 72 /// whose corresponding BasicBlock got deleted. These symbols need to be 73 /// emitted at some point in the file, so AsmPrinter emits them after the 74 /// function body. 75 DenseMap<AssertingVH<Function>, std::vector<MCSymbol*> > 76 DeletedAddrLabelsNeedingEmission; 77 public: 78 79 MMIAddrLabelMap(MCContext &context) : Context(context) {} 80 ~MMIAddrLabelMap() { 81 assert(DeletedAddrLabelsNeedingEmission.empty() && 82 "Some labels for deleted blocks never got emitted"); 83 84 // Deallocate any of the 'list of symbols' case. 85 for (DenseMap<AssertingVH<BasicBlock>, AddrLabelSymEntry>::iterator 86 I = AddrLabelSymbols.begin(), E = AddrLabelSymbols.end(); I != E; ++I) 87 if (I->second.Symbols.is<std::vector<MCSymbol*>*>()) 88 delete I->second.Symbols.get<std::vector<MCSymbol*>*>(); 89 } 90 91 MCSymbol *getAddrLabelSymbol(BasicBlock *BB); 92 std::vector<MCSymbol*> getAddrLabelSymbolToEmit(BasicBlock *BB); 93 94 void takeDeletedSymbolsForFunction(Function *F, 95 std::vector<MCSymbol*> &Result); 96 97 void UpdateForDeletedBlock(BasicBlock *BB); 98 void UpdateForRAUWBlock(BasicBlock *Old, BasicBlock *New); 99 }; 100 } 101 102 MCSymbol *MMIAddrLabelMap::getAddrLabelSymbol(BasicBlock *BB) { 103 assert(BB->hasAddressTaken() && 104 "Shouldn't get label for block without address taken"); 105 AddrLabelSymEntry &Entry = AddrLabelSymbols[BB]; 106 107 // If we already had an entry for this block, just return it. 108 if (!Entry.Symbols.isNull()) { 109 assert(BB->getParent() == Entry.Fn && "Parent changed"); 110 if (Entry.Symbols.is<MCSymbol*>()) 111 return Entry.Symbols.get<MCSymbol*>(); 112 return (*Entry.Symbols.get<std::vector<MCSymbol*>*>())[0]; 113 } 114 115 // Otherwise, this is a new entry, create a new symbol for it and add an 116 // entry to BBCallbacks so we can be notified if the BB is deleted or RAUWd. 117 BBCallbacks.push_back(BB); 118 BBCallbacks.back().setMap(this); 119 Entry.Index = BBCallbacks.size()-1; 120 Entry.Fn = BB->getParent(); 121 MCSymbol *Result = Context.CreateTempSymbol(); 122 Entry.Symbols = Result; 123 return Result; 124 } 125 126 std::vector<MCSymbol*> 127 MMIAddrLabelMap::getAddrLabelSymbolToEmit(BasicBlock *BB) { 128 assert(BB->hasAddressTaken() && 129 "Shouldn't get label for block without address taken"); 130 AddrLabelSymEntry &Entry = AddrLabelSymbols[BB]; 131 132 std::vector<MCSymbol*> Result; 133 134 // If we already had an entry for this block, just return it. 135 if (Entry.Symbols.isNull()) 136 Result.push_back(getAddrLabelSymbol(BB)); 137 else if (MCSymbol *Sym = Entry.Symbols.dyn_cast<MCSymbol*>()) 138 Result.push_back(Sym); 139 else 140 Result = *Entry.Symbols.get<std::vector<MCSymbol*>*>(); 141 return Result; 142 } 143 144 145 /// takeDeletedSymbolsForFunction - If we have any deleted symbols for F, return 146 /// them. 147 void MMIAddrLabelMap:: 148 takeDeletedSymbolsForFunction(Function *F, std::vector<MCSymbol*> &Result) { 149 DenseMap<AssertingVH<Function>, std::vector<MCSymbol*> >::iterator I = 150 DeletedAddrLabelsNeedingEmission.find(F); 151 152 // If there are no entries for the function, just return. 153 if (I == DeletedAddrLabelsNeedingEmission.end()) return; 154 155 // Otherwise, take the list. 156 std::swap(Result, I->second); 157 DeletedAddrLabelsNeedingEmission.erase(I); 158 } 159 160 161 void MMIAddrLabelMap::UpdateForDeletedBlock(BasicBlock *BB) { 162 // If the block got deleted, there is no need for the symbol. If the symbol 163 // was already emitted, we can just forget about it, otherwise we need to 164 // queue it up for later emission when the function is output. 165 AddrLabelSymEntry Entry = AddrLabelSymbols[BB]; 166 AddrLabelSymbols.erase(BB); 167 assert(!Entry.Symbols.isNull() && "Didn't have a symbol, why a callback?"); 168 BBCallbacks[Entry.Index] = nullptr; // Clear the callback. 169 170 assert((BB->getParent() == nullptr || BB->getParent() == Entry.Fn) && 171 "Block/parent mismatch"); 172 173 // Handle both the single and the multiple symbols cases. 174 if (MCSymbol *Sym = Entry.Symbols.dyn_cast<MCSymbol*>()) { 175 if (Sym->isDefined()) 176 return; 177 178 // If the block is not yet defined, we need to emit it at the end of the 179 // function. Add the symbol to the DeletedAddrLabelsNeedingEmission list 180 // for the containing Function. Since the block is being deleted, its 181 // parent may already be removed, we have to get the function from 'Entry'. 182 DeletedAddrLabelsNeedingEmission[Entry.Fn].push_back(Sym); 183 } else { 184 std::vector<MCSymbol*> *Syms = Entry.Symbols.get<std::vector<MCSymbol*>*>(); 185 186 for (unsigned i = 0, e = Syms->size(); i != e; ++i) { 187 MCSymbol *Sym = (*Syms)[i]; 188 if (Sym->isDefined()) continue; // Ignore already emitted labels. 189 190 // If the block is not yet defined, we need to emit it at the end of the 191 // function. Add the symbol to the DeletedAddrLabelsNeedingEmission list 192 // for the containing Function. Since the block is being deleted, its 193 // parent may already be removed, we have to get the function from 194 // 'Entry'. 195 DeletedAddrLabelsNeedingEmission[Entry.Fn].push_back(Sym); 196 } 197 198 // The entry is deleted, free the memory associated with the symbol list. 199 delete Syms; 200 } 201 } 202 203 void MMIAddrLabelMap::UpdateForRAUWBlock(BasicBlock *Old, BasicBlock *New) { 204 // Get the entry for the RAUW'd block and remove it from our map. 205 AddrLabelSymEntry OldEntry = AddrLabelSymbols[Old]; 206 AddrLabelSymbols.erase(Old); 207 assert(!OldEntry.Symbols.isNull() && "Didn't have a symbol, why a callback?"); 208 209 AddrLabelSymEntry &NewEntry = AddrLabelSymbols[New]; 210 211 // If New is not address taken, just move our symbol over to it. 212 if (NewEntry.Symbols.isNull()) { 213 BBCallbacks[OldEntry.Index].setPtr(New); // Update the callback. 214 NewEntry = OldEntry; // Set New's entry. 215 return; 216 } 217 218 BBCallbacks[OldEntry.Index] = nullptr; // Update the callback. 219 220 // Otherwise, we need to add the old symbol to the new block's set. If it is 221 // just a single entry, upgrade it to a symbol list. 222 if (MCSymbol *PrevSym = NewEntry.Symbols.dyn_cast<MCSymbol*>()) { 223 std::vector<MCSymbol*> *SymList = new std::vector<MCSymbol*>(); 224 SymList->push_back(PrevSym); 225 NewEntry.Symbols = SymList; 226 } 227 228 std::vector<MCSymbol*> *SymList = 229 NewEntry.Symbols.get<std::vector<MCSymbol*>*>(); 230 231 // If the old entry was a single symbol, add it. 232 if (MCSymbol *Sym = OldEntry.Symbols.dyn_cast<MCSymbol*>()) { 233 SymList->push_back(Sym); 234 return; 235 } 236 237 // Otherwise, concatenate the list. 238 std::vector<MCSymbol*> *Syms =OldEntry.Symbols.get<std::vector<MCSymbol*>*>(); 239 SymList->insert(SymList->end(), Syms->begin(), Syms->end()); 240 delete Syms; 241 } 242 243 244 void MMIAddrLabelMapCallbackPtr::deleted() { 245 Map->UpdateForDeletedBlock(cast<BasicBlock>(getValPtr())); 246 } 247 248 void MMIAddrLabelMapCallbackPtr::allUsesReplacedWith(Value *V2) { 249 Map->UpdateForRAUWBlock(cast<BasicBlock>(getValPtr()), cast<BasicBlock>(V2)); 250 } 251 252 253 //===----------------------------------------------------------------------===// 254 255 MachineModuleInfo::MachineModuleInfo(const MCAsmInfo &MAI, 256 const MCRegisterInfo &MRI, 257 const MCObjectFileInfo *MOFI) 258 : ImmutablePass(ID), Context(&MAI, &MRI, MOFI, nullptr, false) { 259 initializeMachineModuleInfoPass(*PassRegistry::getPassRegistry()); 260 } 261 262 MachineModuleInfo::MachineModuleInfo() 263 : ImmutablePass(ID), Context(nullptr, nullptr, nullptr) { 264 llvm_unreachable("This MachineModuleInfo constructor should never be called, " 265 "MMI should always be explicitly constructed by " 266 "LLVMTargetMachine"); 267 } 268 269 MachineModuleInfo::~MachineModuleInfo() { 270 } 271 272 bool MachineModuleInfo::doInitialization(Module &M) { 273 274 ObjFileMMI = nullptr; 275 CurCallSite = 0; 276 CallsEHReturn = 0; 277 CallsUnwindInit = 0; 278 DbgInfoAvailable = UsesVAFloatArgument = UsesMorestackAddr = false; 279 // Always emit some info, by default "no personality" info. 280 Personalities.push_back(nullptr); 281 PersonalityTypeCache = EHPersonality::Unknown; 282 AddrLabelSymbols = nullptr; 283 TheModule = nullptr; 284 285 return false; 286 } 287 288 bool MachineModuleInfo::doFinalization(Module &M) { 289 290 Personalities.clear(); 291 292 delete AddrLabelSymbols; 293 AddrLabelSymbols = nullptr; 294 295 Context.reset(); 296 297 delete ObjFileMMI; 298 ObjFileMMI = nullptr; 299 300 return false; 301 } 302 303 /// EndFunction - Discard function meta information. 304 /// 305 void MachineModuleInfo::EndFunction() { 306 // Clean up frame info. 307 FrameInstructions.clear(); 308 309 // Clean up exception info. 310 LandingPads.clear(); 311 CallSiteMap.clear(); 312 TypeInfos.clear(); 313 FilterIds.clear(); 314 FilterEnds.clear(); 315 CallsEHReturn = 0; 316 CallsUnwindInit = 0; 317 VariableDbgInfos.clear(); 318 } 319 320 /// AnalyzeModule - Scan the module for global debug information. 321 /// 322 void MachineModuleInfo::AnalyzeModule(const Module &M) { 323 // Insert functions in the llvm.used array (but not llvm.compiler.used) into 324 // UsedFunctions. 325 const GlobalVariable *GV = M.getGlobalVariable("llvm.used"); 326 if (!GV || !GV->hasInitializer()) return; 327 328 // Should be an array of 'i8*'. 329 const ConstantArray *InitList = cast<ConstantArray>(GV->getInitializer()); 330 331 for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) 332 if (const Function *F = 333 dyn_cast<Function>(InitList->getOperand(i)->stripPointerCasts())) 334 UsedFunctions.insert(F); 335 } 336 337 //===- Address of Block Management ----------------------------------------===// 338 339 340 /// getAddrLabelSymbol - Return the symbol to be used for the specified basic 341 /// block when its address is taken. This cannot be its normal LBB label 342 /// because the block may be accessed outside its containing function. 343 MCSymbol *MachineModuleInfo::getAddrLabelSymbol(const BasicBlock *BB) { 344 // Lazily create AddrLabelSymbols. 345 if (!AddrLabelSymbols) 346 AddrLabelSymbols = new MMIAddrLabelMap(Context); 347 return AddrLabelSymbols->getAddrLabelSymbol(const_cast<BasicBlock*>(BB)); 348 } 349 350 /// getAddrLabelSymbolToEmit - Return the symbol to be used for the specified 351 /// basic block when its address is taken. If other blocks were RAUW'd to 352 /// this one, we may have to emit them as well, return the whole set. 353 std::vector<MCSymbol*> MachineModuleInfo:: 354 getAddrLabelSymbolToEmit(const BasicBlock *BB) { 355 // Lazily create AddrLabelSymbols. 356 if (!AddrLabelSymbols) 357 AddrLabelSymbols = new MMIAddrLabelMap(Context); 358 return AddrLabelSymbols->getAddrLabelSymbolToEmit(const_cast<BasicBlock*>(BB)); 359 } 360 361 362 /// takeDeletedSymbolsForFunction - If the specified function has had any 363 /// references to address-taken blocks generated, but the block got deleted, 364 /// return the symbol now so we can emit it. This prevents emitting a 365 /// reference to a symbol that has no definition. 366 void MachineModuleInfo:: 367 takeDeletedSymbolsForFunction(const Function *F, 368 std::vector<MCSymbol*> &Result) { 369 // If no blocks have had their addresses taken, we're done. 370 if (!AddrLabelSymbols) return; 371 return AddrLabelSymbols-> 372 takeDeletedSymbolsForFunction(const_cast<Function*>(F), Result); 373 } 374 375 //===- EH -----------------------------------------------------------------===// 376 377 /// getOrCreateLandingPadInfo - Find or create an LandingPadInfo for the 378 /// specified MachineBasicBlock. 379 LandingPadInfo &MachineModuleInfo::getOrCreateLandingPadInfo 380 (MachineBasicBlock *LandingPad) { 381 unsigned N = LandingPads.size(); 382 for (unsigned i = 0; i < N; ++i) { 383 LandingPadInfo &LP = LandingPads[i]; 384 if (LP.LandingPadBlock == LandingPad) 385 return LP; 386 } 387 388 LandingPads.push_back(LandingPadInfo(LandingPad)); 389 return LandingPads[N]; 390 } 391 392 /// addInvoke - Provide the begin and end labels of an invoke style call and 393 /// associate it with a try landing pad block. 394 void MachineModuleInfo::addInvoke(MachineBasicBlock *LandingPad, 395 MCSymbol *BeginLabel, MCSymbol *EndLabel) { 396 LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad); 397 LP.BeginLabels.push_back(BeginLabel); 398 LP.EndLabels.push_back(EndLabel); 399 } 400 401 /// addLandingPad - Provide the label of a try LandingPad block. 402 /// 403 MCSymbol *MachineModuleInfo::addLandingPad(MachineBasicBlock *LandingPad) { 404 MCSymbol *LandingPadLabel = Context.CreateTempSymbol(); 405 LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad); 406 LP.LandingPadLabel = LandingPadLabel; 407 return LandingPadLabel; 408 } 409 410 /// addPersonality - Provide the personality function for the exception 411 /// information. 412 void MachineModuleInfo::addPersonality(MachineBasicBlock *LandingPad, 413 const Function *Personality) { 414 LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad); 415 LP.Personality = Personality; 416 417 for (unsigned i = 0; i < Personalities.size(); ++i) 418 if (Personalities[i] == Personality) 419 return; 420 421 // If this is the first personality we're adding go 422 // ahead and add it at the beginning. 423 if (!Personalities[0]) 424 Personalities[0] = Personality; 425 else 426 Personalities.push_back(Personality); 427 } 428 429 void MachineModuleInfo::addWinEHState(MachineBasicBlock *LandingPad, 430 int State) { 431 LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad); 432 LP.WinEHState = State; 433 } 434 435 /// addCatchTypeInfo - Provide the catch typeinfo for a landing pad. 436 /// 437 void MachineModuleInfo:: 438 addCatchTypeInfo(MachineBasicBlock *LandingPad, 439 ArrayRef<const GlobalValue *> TyInfo) { 440 LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad); 441 for (unsigned N = TyInfo.size(); N; --N) 442 LP.TypeIds.push_back(getTypeIDFor(TyInfo[N - 1])); 443 } 444 445 /// addFilterTypeInfo - Provide the filter typeinfo for a landing pad. 446 /// 447 void MachineModuleInfo:: 448 addFilterTypeInfo(MachineBasicBlock *LandingPad, 449 ArrayRef<const GlobalValue *> TyInfo) { 450 LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad); 451 std::vector<unsigned> IdsInFilter(TyInfo.size()); 452 for (unsigned I = 0, E = TyInfo.size(); I != E; ++I) 453 IdsInFilter[I] = getTypeIDFor(TyInfo[I]); 454 LP.TypeIds.push_back(getFilterIDFor(IdsInFilter)); 455 } 456 457 /// addCleanup - Add a cleanup action for a landing pad. 458 /// 459 void MachineModuleInfo::addCleanup(MachineBasicBlock *LandingPad) { 460 LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad); 461 LP.TypeIds.push_back(0); 462 } 463 464 MCSymbol * 465 MachineModuleInfo::addClauseForLandingPad(MachineBasicBlock *LandingPad) { 466 MCSymbol *ClauseLabel = Context.CreateTempSymbol(); 467 LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad); 468 LP.ClauseLabels.push_back(ClauseLabel); 469 return ClauseLabel; 470 } 471 472 /// TidyLandingPads - Remap landing pad labels and remove any deleted landing 473 /// pads. 474 void MachineModuleInfo::TidyLandingPads(DenseMap<MCSymbol*, uintptr_t> *LPMap) { 475 for (unsigned i = 0; i != LandingPads.size(); ) { 476 LandingPadInfo &LandingPad = LandingPads[i]; 477 if (LandingPad.LandingPadLabel && 478 !LandingPad.LandingPadLabel->isDefined() && 479 (!LPMap || (*LPMap)[LandingPad.LandingPadLabel] == 0)) 480 LandingPad.LandingPadLabel = nullptr; 481 482 // Special case: we *should* emit LPs with null LP MBB. This indicates 483 // "nounwind" case. 484 if (!LandingPad.LandingPadLabel && LandingPad.LandingPadBlock) { 485 LandingPads.erase(LandingPads.begin() + i); 486 continue; 487 } 488 489 for (unsigned j = 0, e = LandingPads[i].BeginLabels.size(); j != e; ++j) { 490 MCSymbol *BeginLabel = LandingPad.BeginLabels[j]; 491 MCSymbol *EndLabel = LandingPad.EndLabels[j]; 492 if ((BeginLabel->isDefined() || 493 (LPMap && (*LPMap)[BeginLabel] != 0)) && 494 (EndLabel->isDefined() || 495 (LPMap && (*LPMap)[EndLabel] != 0))) continue; 496 497 LandingPad.BeginLabels.erase(LandingPad.BeginLabels.begin() + j); 498 LandingPad.EndLabels.erase(LandingPad.EndLabels.begin() + j); 499 --j, --e; 500 } 501 502 // Remove landing pads with no try-ranges. 503 if (LandingPads[i].BeginLabels.empty()) { 504 LandingPads.erase(LandingPads.begin() + i); 505 continue; 506 } 507 508 // If there is no landing pad, ensure that the list of typeids is empty. 509 // If the only typeid is a cleanup, this is the same as having no typeids. 510 if (!LandingPad.LandingPadBlock || 511 (LandingPad.TypeIds.size() == 1 && !LandingPad.TypeIds[0])) 512 LandingPad.TypeIds.clear(); 513 ++i; 514 } 515 } 516 517 /// setCallSiteLandingPad - Map the landing pad's EH symbol to the call site 518 /// indexes. 519 void MachineModuleInfo::setCallSiteLandingPad(MCSymbol *Sym, 520 ArrayRef<unsigned> Sites) { 521 LPadToCallSiteMap[Sym].append(Sites.begin(), Sites.end()); 522 } 523 524 /// getTypeIDFor - Return the type id for the specified typeinfo. This is 525 /// function wide. 526 unsigned MachineModuleInfo::getTypeIDFor(const GlobalValue *TI) { 527 for (unsigned i = 0, N = TypeInfos.size(); i != N; ++i) 528 if (TypeInfos[i] == TI) return i + 1; 529 530 TypeInfos.push_back(TI); 531 return TypeInfos.size(); 532 } 533 534 /// getFilterIDFor - Return the filter id for the specified typeinfos. This is 535 /// function wide. 536 int MachineModuleInfo::getFilterIDFor(std::vector<unsigned> &TyIds) { 537 // If the new filter coincides with the tail of an existing filter, then 538 // re-use the existing filter. Folding filters more than this requires 539 // re-ordering filters and/or their elements - probably not worth it. 540 for (std::vector<unsigned>::iterator I = FilterEnds.begin(), 541 E = FilterEnds.end(); I != E; ++I) { 542 unsigned i = *I, j = TyIds.size(); 543 544 while (i && j) 545 if (FilterIds[--i] != TyIds[--j]) 546 goto try_next; 547 548 if (!j) 549 // The new filter coincides with range [i, end) of the existing filter. 550 return -(1 + i); 551 552 try_next:; 553 } 554 555 // Add the new filter. 556 int FilterID = -(1 + FilterIds.size()); 557 FilterIds.reserve(FilterIds.size() + TyIds.size() + 1); 558 FilterIds.insert(FilterIds.end(), TyIds.begin(), TyIds.end()); 559 FilterEnds.push_back(FilterIds.size()); 560 FilterIds.push_back(0); // terminator 561 return FilterID; 562 } 563 564 /// getPersonality - Return the personality function for the current function. 565 const Function *MachineModuleInfo::getPersonality() const { 566 for (const LandingPadInfo &LPI : LandingPads) 567 if (LPI.Personality) 568 return LPI.Personality; 569 return nullptr; 570 } 571 572 EHPersonality MachineModuleInfo::getPersonalityType() { 573 if (PersonalityTypeCache == EHPersonality::Unknown) { 574 if (const Function *F = getPersonality()) 575 PersonalityTypeCache = classifyEHPersonality(F); 576 } 577 return PersonalityTypeCache; 578 } 579 580 /// getPersonalityIndex - Return unique index for current personality 581 /// function. NULL/first personality function should always get zero index. 582 unsigned MachineModuleInfo::getPersonalityIndex() const { 583 const Function* Personality = nullptr; 584 585 // Scan landing pads. If there is at least one non-NULL personality - use it. 586 for (unsigned i = 0, e = LandingPads.size(); i != e; ++i) 587 if (LandingPads[i].Personality) { 588 Personality = LandingPads[i].Personality; 589 break; 590 } 591 592 for (unsigned i = 0, e = Personalities.size(); i < e; ++i) { 593 if (Personalities[i] == Personality) 594 return i; 595 } 596 597 // This will happen if the current personality function is 598 // in the zero index. 599 return 0; 600 } 601 602 const Function *MachineModuleInfo::getWinEHParent(const Function *F) const { 603 StringRef WinEHParentName = 604 F->getFnAttribute("wineh-parent").getValueAsString(); 605 if (WinEHParentName.empty() || WinEHParentName == F->getName()) 606 return F; 607 return F->getParent()->getFunction(WinEHParentName); 608 } 609 610 WinEHFuncInfo &MachineModuleInfo::getWinEHFuncInfo(const Function *F) { 611 auto &Ptr = FuncInfoMap[getWinEHParent(F)]; 612 if (!Ptr) 613 Ptr.reset(new WinEHFuncInfo); 614 return *Ptr; 615 } 616