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