LLVM API Documentation

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
MachineModuleInfo.cpp
Go to the documentation of this file.
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 
11 #include "llvm/ADT/PointerUnion.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"
21 #include "llvm/MC/MCSymbol.h"
22 #include "llvm/Support/Dwarf.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.
34 
35 namespace llvm {
37  MMIAddrLabelMap *Map;
38 public:
41 
42  void setPtr(BasicBlock *BB) {
44  }
45 
46  void setMap(MMIAddrLabelMap *map) { Map = map; }
47 
48  virtual void deleted();
49  virtual void allUsesReplacedWith(Value *V2);
50 };
51 
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.
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) {}
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 
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*>
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.
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 
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 
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 
243  Map->UpdateForDeletedBlock(cast<BasicBlock>(getValPtr()));
244 }
245 
247  Map->UpdateForRAUWBlock(cast<BasicBlock>(getValPtr()), cast<BasicBlock>(V2));
248 }
249 
250 
251 //===----------------------------------------------------------------------===//
252 
254  const MCRegisterInfo &MRI,
255  const MCObjectFileInfo *MOFI)
256  : ImmutablePass(ID), Context(&MAI, &MRI, MOFI, 0, false) {
258 }
259 
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 
268 }
269 
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 
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 ///
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;
317 }
318 
319 /// AnalyzeModule - Scan the module for global debug information.
320 ///
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.
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::
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.
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.
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.
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 ///
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.
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 ///
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 ///
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 ///
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.
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.
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.
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.
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.
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 }
virtual void allUsesReplacedWith(Value *V2)
std::vector< MCSymbol * > getAddrLabelSymbolToEmit(const BasicBlock *BB)
static PassRegistry * getPassRegistry()
MCSymbol * getAddrLabelSymbol(BasicBlock *BB)
The main container class for the LLVM Intermediate Representation.
Definition: Module.h:112
void setCallSiteLandingPad(MCSymbol *Sym, ArrayRef< unsigned > Sites)
unsigned getNumOperands() const
Definition: User.h:108
iterator end() const
Definition: ArrayRef.h:98
const Function * Personality
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:116
F(f)
const Constant * getInitializer() const
const GlobalVariable * getGlobalVariable(StringRef Name, bool AllowInternal=false) const
Definition: Module.h:355
MCSymbol * getAddrLabelSymbol(const BasicBlock *BB)
virtual bool doFinalization(Module &)
void UpdateForRAUWBlock(BasicBlock *Old, BasicBlock *New)
SmallVector< MCSymbol *, 1 > BeginLabels
MCSymbol * CreateTempSymbol()
Definition: MCContext.cpp:165
void takeDeletedSymbolsForFunction(const Function *F, std::vector< MCSymbol * > &Result)
#define llvm_unreachable(msg)
bool hasAddressTaken() const
Returns true if there are any uses of this basic block other than direct branches, switches, etc. to it.
Definition: BasicBlock.h:268
void TidyLandingPads(DenseMap< MCSymbol *, uintptr_t > *LPMap=0)
ID
LLVM Calling Convention Representation.
Definition: CallingConv.h:26
#define false
Definition: ConvertUTF.c:64
MMIAddrLabelMap(MCContext &context)
LandingPadInfo & getOrCreateLandingPadInfo(MachineBasicBlock *LandingPad)
void addPersonality(MachineBasicBlock *LandingPad, const Function *Personality)
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:109
std::vector< MCSymbol * > getAddrLabelSymbolToEmit(BasicBlock *BB)
void AnalyzeModule(const Module &M)
LLVM Basic Block Representation.
Definition: BasicBlock.h:72
SmallVector< MCSymbol *, 1 > EndLabels
void takeDeletedSymbolsForFunction(Function *F, std::vector< MCSymbol * > &Result)
std::vector< int > TypeIds
iterator begin() const
Definition: ArrayRef.h:97
Value * getOperand(unsigned i) const
Definition: User.h:88
MCSymbol * addLandingPad(MachineBasicBlock *LandingPad)
void addInvoke(MachineBasicBlock *LandingPad, MCSymbol *BeginLabel, MCSymbol *EndLabel)
unsigned getTypeIDFor(const GlobalVariable *TI)
#define INITIALIZE_PASS(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:153
void initializeMachineModuleInfoPass(PassRegistry &)
bool isDefined() const
Definition: MCSymbol.h:89
void setMap(MMIAddrLabelMap *map)
void addCatchTypeInfo(MachineBasicBlock *LandingPad, ArrayRef< const GlobalVariable * > TyInfo)
void addCleanup(MachineBasicBlock *LandingPad)
Value * stripPointerCasts()
Strips off any unneeded pointer casts, all-zero GEPs and aliases from the specified value...
Definition: Value.cpp:385
VariableDbgInfoMapTy VariableDbgInfo
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Definition: BitVector.h:591
bool hasInitializer() const
MachineBasicBlock * LandingPadBlock
int getFilterIDFor(std::vector< unsigned > &TyIds)
#define I(x, y, z)
Definition: MD5.cpp:54
#define N
unsigned getPersonalityIndex() const
Value * operator=(Value *RHS)
Definition: ValueHandle.h:83
void addFilterTypeInfo(MachineBasicBlock *LandingPad, ArrayRef< const GlobalVariable * > TyInfo)
LLVM Value Representation.
Definition: Value.h:66
virtual bool doInitialization(Module &)
void UpdateForDeletedBlock(BasicBlock *BB)
const MCRegisterInfo & MRI
const Function * getPersonality() const
getPersonality - Return the personality function for the current function.