Home | History | Annotate | Download | only in CodeGen
      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/ValueTracking.h"
     13 #include "llvm/CodeGen/MachineFunction.h"
     14 #include "llvm/CodeGen/MachineFunctionPass.h"
     15 #include "llvm/CodeGen/Passes.h"
     16 #include "llvm/IR/Constants.h"
     17 #include "llvm/IR/DerivedTypes.h"
     18 #include "llvm/IR/GlobalVariable.h"
     19 #include "llvm/IR/Module.h"
     20 #include "llvm/MC/MCObjectFileInfo.h"
     21 #include "llvm/MC/MCSymbol.h"
     22 #include "llvm/Support/Dwarf.h"
     23 #include "llvm/Support/ErrorHandling.h"
     24 using namespace llvm;
     25 using namespace llvm::dwarf;
     26 
     27 // Handle the Pass registration stuff necessary to use DataLayout's.
     28 INITIALIZE_PASS(MachineModuleInfo, "machinemoduleinfo",
     29                 "Machine Module Information", false, false)
     30 char MachineModuleInfo::ID = 0;
     31 
     32 // Out of line virtual method.
     33 MachineModuleInfoImpl::~MachineModuleInfoImpl() {}
     34 
     35 namespace llvm {
     36 class MMIAddrLabelMapCallbackPtr : CallbackVH {
     37   MMIAddrLabelMap *Map;
     38 public:
     39   MMIAddrLabelMapCallbackPtr() : Map(0) {}
     40   MMIAddrLabelMapCallbackPtr(Value *V) : CallbackVH(V), Map(0) {}
     41 
     42   void setPtr(BasicBlock *BB) {
     43     ValueHandleBase::operator=(BB);
     44   }
     45 
     46   void setMap(MMIAddrLabelMap *map) { Map = map; }
     47 
     48   virtual void deleted();
     49   virtual void allUsesReplacedWith(Value *V2);
     50 };
     51 
     52 class MMIAddrLabelMap {
     53   MCContext &Context;
     54   struct AddrLabelSymEntry {
     55     /// Symbols - The symbols for the label.  This is a pointer union that is
     56     /// either one symbol (the common case) or a list of symbols.
     57     PointerUnion<MCSymbol *, std::vector<MCSymbol*>*> Symbols;
     58 
     59     Function *Fn;   // The containing function of the BasicBlock.
     60     unsigned Index; // The index in BBCallbacks for the BasicBlock.
     61   };
     62 
     63   DenseMap<AssertingVH<BasicBlock>, AddrLabelSymEntry> AddrLabelSymbols;
     64 
     65   /// BBCallbacks - Callbacks for the BasicBlock's that we have entries for.  We
     66   /// use this so we get notified if a block is deleted or RAUWd.
     67   std::vector<MMIAddrLabelMapCallbackPtr> BBCallbacks;
     68 
     69   /// DeletedAddrLabelsNeedingEmission - This is a per-function list of symbols
     70   /// whose corresponding BasicBlock got deleted.  These symbols need to be
     71   /// emitted at some point in the file, so AsmPrinter emits them after the
     72   /// function body.
     73   DenseMap<AssertingVH<Function>, std::vector<MCSymbol*> >
     74     DeletedAddrLabelsNeedingEmission;
     75 public:
     76 
     77   MMIAddrLabelMap(MCContext &context) : Context(context) {}
     78   ~MMIAddrLabelMap() {
     79     assert(DeletedAddrLabelsNeedingEmission.empty() &&
     80            "Some labels for deleted blocks never got emitted");
     81 
     82     // Deallocate any of the 'list of symbols' case.
     83     for (DenseMap<AssertingVH<BasicBlock>, AddrLabelSymEntry>::iterator
     84          I = AddrLabelSymbols.begin(), E = AddrLabelSymbols.end(); I != E; ++I)
     85       if (I->second.Symbols.is<std::vector<MCSymbol*>*>())
     86         delete I->second.Symbols.get<std::vector<MCSymbol*>*>();
     87   }
     88 
     89   MCSymbol *getAddrLabelSymbol(BasicBlock *BB);
     90   std::vector<MCSymbol*> getAddrLabelSymbolToEmit(BasicBlock *BB);
     91 
     92   void takeDeletedSymbolsForFunction(Function *F,
     93                                      std::vector<MCSymbol*> &Result);
     94 
     95   void UpdateForDeletedBlock(BasicBlock *BB);
     96   void UpdateForRAUWBlock(BasicBlock *Old, BasicBlock *New);
     97 };
     98 }
     99 
    100 MCSymbol *MMIAddrLabelMap::getAddrLabelSymbol(BasicBlock *BB) {
    101   assert(BB->hasAddressTaken() &&
    102          "Shouldn't get label for block without address taken");
    103   AddrLabelSymEntry &Entry = AddrLabelSymbols[BB];
    104 
    105   // If we already had an entry for this block, just return it.
    106   if (!Entry.Symbols.isNull()) {
    107     assert(BB->getParent() == Entry.Fn && "Parent changed");
    108     if (Entry.Symbols.is<MCSymbol*>())
    109       return Entry.Symbols.get<MCSymbol*>();
    110     return (*Entry.Symbols.get<std::vector<MCSymbol*>*>())[0];
    111   }
    112 
    113   // Otherwise, this is a new entry, create a new symbol for it and add an
    114   // entry to BBCallbacks so we can be notified if the BB is deleted or RAUWd.
    115   BBCallbacks.push_back(BB);
    116   BBCallbacks.back().setMap(this);
    117   Entry.Index = BBCallbacks.size()-1;
    118   Entry.Fn = BB->getParent();
    119   MCSymbol *Result = Context.CreateTempSymbol();
    120   Entry.Symbols = Result;
    121   return Result;
    122 }
    123 
    124 std::vector<MCSymbol*>
    125 MMIAddrLabelMap::getAddrLabelSymbolToEmit(BasicBlock *BB) {
    126   assert(BB->hasAddressTaken() &&
    127          "Shouldn't get label for block without address taken");
    128   AddrLabelSymEntry &Entry = AddrLabelSymbols[BB];
    129 
    130   std::vector<MCSymbol*> Result;
    131 
    132   // If we already had an entry for this block, just return it.
    133   if (Entry.Symbols.isNull())
    134     Result.push_back(getAddrLabelSymbol(BB));
    135   else if (MCSymbol *Sym = Entry.Symbols.dyn_cast<MCSymbol*>())
    136     Result.push_back(Sym);
    137   else
    138     Result = *Entry.Symbols.get<std::vector<MCSymbol*>*>();
    139   return Result;
    140 }
    141 
    142 
    143 /// takeDeletedSymbolsForFunction - If we have any deleted symbols for F, return
    144 /// them.
    145 void MMIAddrLabelMap::
    146 takeDeletedSymbolsForFunction(Function *F, std::vector<MCSymbol*> &Result) {
    147   DenseMap<AssertingVH<Function>, std::vector<MCSymbol*> >::iterator I =
    148     DeletedAddrLabelsNeedingEmission.find(F);
    149 
    150   // If there are no entries for the function, just return.
    151   if (I == DeletedAddrLabelsNeedingEmission.end()) return;
    152 
    153   // Otherwise, take the list.
    154   std::swap(Result, I->second);
    155   DeletedAddrLabelsNeedingEmission.erase(I);
    156 }
    157 
    158 
    159 void MMIAddrLabelMap::UpdateForDeletedBlock(BasicBlock *BB) {
    160   // If the block got deleted, there is no need for the symbol.  If the symbol
    161   // was already emitted, we can just forget about it, otherwise we need to
    162   // queue it up for later emission when the function is output.
    163   AddrLabelSymEntry Entry = AddrLabelSymbols[BB];
    164   AddrLabelSymbols.erase(BB);
    165   assert(!Entry.Symbols.isNull() && "Didn't have a symbol, why a callback?");
    166   BBCallbacks[Entry.Index] = 0;  // Clear the callback.
    167 
    168   assert((BB->getParent() == 0 || BB->getParent() == Entry.Fn) &&
    169          "Block/parent mismatch");
    170 
    171   // Handle both the single and the multiple symbols cases.
    172   if (MCSymbol *Sym = Entry.Symbols.dyn_cast<MCSymbol*>()) {
    173     if (Sym->isDefined())
    174       return;
    175 
    176     // If the block is not yet defined, we need to emit it at the end of the
    177     // function.  Add the symbol to the DeletedAddrLabelsNeedingEmission list
    178     // for the containing Function.  Since the block is being deleted, its
    179     // parent may already be removed, we have to get the function from 'Entry'.
    180     DeletedAddrLabelsNeedingEmission[Entry.Fn].push_back(Sym);
    181   } else {
    182     std::vector<MCSymbol*> *Syms = Entry.Symbols.get<std::vector<MCSymbol*>*>();
    183 
    184     for (unsigned i = 0, e = Syms->size(); i != e; ++i) {
    185       MCSymbol *Sym = (*Syms)[i];
    186       if (Sym->isDefined()) continue;  // Ignore already emitted labels.
    187 
    188       // If the block is not yet defined, we need to emit it at the end of the
    189       // function.  Add the symbol to the DeletedAddrLabelsNeedingEmission list
    190       // for the containing Function.  Since the block is being deleted, its
    191       // parent may already be removed, we have to get the function from
    192       // 'Entry'.
    193       DeletedAddrLabelsNeedingEmission[Entry.Fn].push_back(Sym);
    194     }
    195 
    196     // The entry is deleted, free the memory associated with the symbol list.
    197     delete Syms;
    198   }
    199 }
    200 
    201 void MMIAddrLabelMap::UpdateForRAUWBlock(BasicBlock *Old, BasicBlock *New) {
    202   // Get the entry for the RAUW'd block and remove it from our map.
    203   AddrLabelSymEntry OldEntry = AddrLabelSymbols[Old];
    204   AddrLabelSymbols.erase(Old);
    205   assert(!OldEntry.Symbols.isNull() && "Didn't have a symbol, why a callback?");
    206 
    207   AddrLabelSymEntry &NewEntry = AddrLabelSymbols[New];
    208 
    209   // If New is not address taken, just move our symbol over to it.
    210   if (NewEntry.Symbols.isNull()) {
    211     BBCallbacks[OldEntry.Index].setPtr(New);    // Update the callback.
    212     NewEntry = OldEntry;     // Set New's entry.
    213     return;
    214   }
    215 
    216   BBCallbacks[OldEntry.Index] = 0;    // Update the callback.
    217 
    218   // Otherwise, we need to add the old symbol to the new block's set.  If it is
    219   // just a single entry, upgrade it to a symbol list.
    220   if (MCSymbol *PrevSym = NewEntry.Symbols.dyn_cast<MCSymbol*>()) {
    221     std::vector<MCSymbol*> *SymList = new std::vector<MCSymbol*>();
    222     SymList->push_back(PrevSym);
    223     NewEntry.Symbols = SymList;
    224   }
    225 
    226   std::vector<MCSymbol*> *SymList =
    227     NewEntry.Symbols.get<std::vector<MCSymbol*>*>();
    228 
    229   // If the old entry was a single symbol, add it.
    230   if (MCSymbol *Sym = OldEntry.Symbols.dyn_cast<MCSymbol*>()) {
    231     SymList->push_back(Sym);
    232     return;
    233   }
    234 
    235   // Otherwise, concatenate the list.
    236   std::vector<MCSymbol*> *Syms =OldEntry.Symbols.get<std::vector<MCSymbol*>*>();
    237   SymList->insert(SymList->end(), Syms->begin(), Syms->end());
    238   delete Syms;
    239 }
    240 
    241 
    242 void MMIAddrLabelMapCallbackPtr::deleted() {
    243   Map->UpdateForDeletedBlock(cast<BasicBlock>(getValPtr()));
    244 }
    245 
    246 void MMIAddrLabelMapCallbackPtr::allUsesReplacedWith(Value *V2) {
    247   Map->UpdateForRAUWBlock(cast<BasicBlock>(getValPtr()), cast<BasicBlock>(V2));
    248 }
    249 
    250 
    251 //===----------------------------------------------------------------------===//
    252 
    253 MachineModuleInfo::MachineModuleInfo(const MCAsmInfo &MAI,
    254                                      const MCRegisterInfo &MRI,
    255                                      const MCObjectFileInfo *MOFI)
    256   : ImmutablePass(ID), Context(&MAI, &MRI, MOFI, 0, false) {
    257   initializeMachineModuleInfoPass(*PassRegistry::getPassRegistry());
    258 }
    259 
    260 MachineModuleInfo::MachineModuleInfo()
    261   : ImmutablePass(ID), Context(0, 0, 0) {
    262   llvm_unreachable("This MachineModuleInfo constructor should never be called, "
    263                    "MMI should always be explicitly constructed by "
    264                    "LLVMTargetMachine");
    265 }
    266 
    267 MachineModuleInfo::~MachineModuleInfo() {
    268 }
    269 
    270 bool MachineModuleInfo::doInitialization(Module &M) {
    271 
    272   ObjFileMMI = 0;
    273   CompactUnwindEncoding = 0;
    274   CurCallSite = 0;
    275   CallsEHReturn = 0;
    276   CallsUnwindInit = 0;
    277   DbgInfoAvailable = UsesVAFloatArgument = false;
    278   // Always emit some info, by default "no personality" info.
    279   Personalities.push_back(NULL);
    280   AddrLabelSymbols = 0;
    281   TheModule = 0;
    282 
    283   return false;
    284 }
    285 
    286 bool MachineModuleInfo::doFinalization(Module &M) {
    287 
    288   Personalities.clear();
    289 
    290   delete AddrLabelSymbols;
    291   AddrLabelSymbols = 0;
    292 
    293   Context.reset();
    294 
    295   delete ObjFileMMI;
    296   ObjFileMMI = 0;
    297 
    298   return false;
    299 }
    300 
    301 /// EndFunction - Discard function meta information.
    302 ///
    303 void MachineModuleInfo::EndFunction() {
    304   // Clean up frame info.
    305   FrameInstructions.clear();
    306 
    307   // Clean up exception info.
    308   LandingPads.clear();
    309   CallSiteMap.clear();
    310   TypeInfos.clear();
    311   FilterIds.clear();
    312   FilterEnds.clear();
    313   CallsEHReturn = 0;
    314   CallsUnwindInit = 0;
    315   CompactUnwindEncoding = 0;
    316   VariableDbgInfo.clear();
    317 }
    318 
    319 /// AnalyzeModule - Scan the module for global debug information.
    320 ///
    321 void MachineModuleInfo::AnalyzeModule(const Module &M) {
    322   // Insert functions in the llvm.used array (but not llvm.compiler.used) into
    323   // UsedFunctions.
    324   const GlobalVariable *GV = M.getGlobalVariable("llvm.used");
    325   if (!GV || !GV->hasInitializer()) return;
    326 
    327   // Should be an array of 'i8*'.
    328   const ConstantArray *InitList = cast<ConstantArray>(GV->getInitializer());
    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