LLVM  4.0.0
DebugInfo.cpp
Go to the documentation of this file.
1 //===--- DebugInfo.cpp - Debug Information Helper Classes -----------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the helper classes used to build and interpret debug
11 // information in LLVM IR form.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "llvm/IR/DebugInfo.h"
16 #include "LLVMContextImpl.h"
17 #include "llvm/ADT/STLExtras.h"
18 #include "llvm/ADT/SmallPtrSet.h"
19 #include "llvm/IR/Constants.h"
20 #include "llvm/IR/DIBuilder.h"
21 #include "llvm/IR/DerivedTypes.h"
22 #include "llvm/IR/GVMaterializer.h"
23 #include "llvm/IR/Instructions.h"
24 #include "llvm/IR/IntrinsicInst.h"
25 #include "llvm/IR/Intrinsics.h"
26 #include "llvm/IR/Module.h"
27 #include "llvm/IR/ValueHandle.h"
28 #include "llvm/Support/Debug.h"
29 #include "llvm/Support/Dwarf.h"
31 using namespace llvm;
32 using namespace llvm::dwarf;
33 
35  if (auto *LocalScope = dyn_cast_or_null<DILocalScope>(Scope))
36  return LocalScope->getSubprogram();
37  return nullptr;
38 }
39 
40 //===----------------------------------------------------------------------===//
41 // DebugInfoFinder implementations.
42 //===----------------------------------------------------------------------===//
43 
45  CUs.clear();
46  SPs.clear();
47  GVs.clear();
48  TYs.clear();
49  Scopes.clear();
50  NodesSeen.clear();
51 }
52 
54  for (auto *CU : M.debug_compile_units()) {
55  addCompileUnit(CU);
56  for (auto DIG : CU->getGlobalVariables()) {
57  if (!addGlobalVariable(DIG))
58  continue;
59  auto *GV = DIG->getVariable();
60  processScope(GV->getScope());
61  processType(GV->getType().resolve());
62  }
63  for (auto *ET : CU->getEnumTypes())
64  processType(ET);
65  for (auto *RT : CU->getRetainedTypes())
66  if (auto *T = dyn_cast<DIType>(RT))
67  processType(T);
68  else
69  processSubprogram(cast<DISubprogram>(RT));
70  for (auto *Import : CU->getImportedEntities()) {
71  auto *Entity = Import->getEntity().resolve();
72  if (auto *T = dyn_cast<DIType>(Entity))
73  processType(T);
74  else if (auto *SP = dyn_cast<DISubprogram>(Entity))
75  processSubprogram(SP);
76  else if (auto *NS = dyn_cast<DINamespace>(Entity))
77  processScope(NS->getScope());
78  else if (auto *M = dyn_cast<DIModule>(Entity))
79  processScope(M->getScope());
80  }
81  }
82  for (auto &F : M.functions())
83  if (auto *SP = cast_or_null<DISubprogram>(F.getSubprogram()))
84  processSubprogram(SP);
85 }
86 
88  if (!Loc)
89  return;
90  processScope(Loc->getScope());
91  processLocation(M, Loc->getInlinedAt());
92 }
93 
94 void DebugInfoFinder::processType(DIType *DT) {
95  if (!addType(DT))
96  return;
97  processScope(DT->getScope().resolve());
98  if (auto *ST = dyn_cast<DISubroutineType>(DT)) {
99  for (DITypeRef Ref : ST->getTypeArray())
100  processType(Ref.resolve());
101  return;
102  }
103  if (auto *DCT = dyn_cast<DICompositeType>(DT)) {
104  processType(DCT->getBaseType().resolve());
105  for (Metadata *D : DCT->getElements()) {
106  if (auto *T = dyn_cast<DIType>(D))
107  processType(T);
108  else if (auto *SP = dyn_cast<DISubprogram>(D))
109  processSubprogram(SP);
110  }
111  return;
112  }
113  if (auto *DDT = dyn_cast<DIDerivedType>(DT)) {
114  processType(DDT->getBaseType().resolve());
115  }
116 }
117 
118 void DebugInfoFinder::processScope(DIScope *Scope) {
119  if (!Scope)
120  return;
121  if (auto *Ty = dyn_cast<DIType>(Scope)) {
122  processType(Ty);
123  return;
124  }
125  if (auto *CU = dyn_cast<DICompileUnit>(Scope)) {
126  addCompileUnit(CU);
127  return;
128  }
129  if (auto *SP = dyn_cast<DISubprogram>(Scope)) {
130  processSubprogram(SP);
131  return;
132  }
133  if (!addScope(Scope))
134  return;
135  if (auto *LB = dyn_cast<DILexicalBlockBase>(Scope)) {
136  processScope(LB->getScope());
137  } else if (auto *NS = dyn_cast<DINamespace>(Scope)) {
138  processScope(NS->getScope());
139  } else if (auto *M = dyn_cast<DIModule>(Scope)) {
140  processScope(M->getScope());
141  }
142 }
143 
144 void DebugInfoFinder::processSubprogram(DISubprogram *SP) {
145  if (!addSubprogram(SP))
146  return;
147  processScope(SP->getScope().resolve());
148  processType(SP->getType());
149  for (auto *Element : SP->getTemplateParams()) {
150  if (auto *TType = dyn_cast<DITemplateTypeParameter>(Element)) {
151  processType(TType->getType().resolve());
152  } else if (auto *TVal = dyn_cast<DITemplateValueParameter>(Element)) {
153  processType(TVal->getType().resolve());
154  }
155  }
156 }
157 
159  const DbgDeclareInst *DDI) {
160  auto *N = dyn_cast<MDNode>(DDI->getVariable());
161  if (!N)
162  return;
163 
164  auto *DV = dyn_cast<DILocalVariable>(N);
165  if (!DV)
166  return;
167 
168  if (!NodesSeen.insert(DV).second)
169  return;
170  processScope(DV->getScope());
171  processType(DV->getType().resolve());
172 }
173 
175  auto *N = dyn_cast<MDNode>(DVI->getVariable());
176  if (!N)
177  return;
178 
179  auto *DV = dyn_cast<DILocalVariable>(N);
180  if (!DV)
181  return;
182 
183  if (!NodesSeen.insert(DV).second)
184  return;
185  processScope(DV->getScope());
186  processType(DV->getType().resolve());
187 }
188 
189 bool DebugInfoFinder::addType(DIType *DT) {
190  if (!DT)
191  return false;
192 
193  if (!NodesSeen.insert(DT).second)
194  return false;
195 
196  TYs.push_back(const_cast<DIType *>(DT));
197  return true;
198 }
199 
200 bool DebugInfoFinder::addCompileUnit(DICompileUnit *CU) {
201  if (!CU)
202  return false;
203  if (!NodesSeen.insert(CU).second)
204  return false;
205 
206  CUs.push_back(CU);
207  return true;
208 }
209 
210 bool DebugInfoFinder::addGlobalVariable(DIGlobalVariableExpression *DIG) {
211  if (!NodesSeen.insert(DIG).second)
212  return false;
213 
214  GVs.push_back(DIG);
215  return true;
216 }
217 
218 bool DebugInfoFinder::addSubprogram(DISubprogram *SP) {
219  if (!SP)
220  return false;
221 
222  if (!NodesSeen.insert(SP).second)
223  return false;
224 
225  SPs.push_back(SP);
226  return true;
227 }
228 
229 bool DebugInfoFinder::addScope(DIScope *Scope) {
230  if (!Scope)
231  return false;
232  // FIXME: Ocaml binding generates a scope with no content, we treat it
233  // as null for now.
234  if (Scope->getNumOperands() == 0)
235  return false;
236  if (!NodesSeen.insert(Scope).second)
237  return false;
238  Scopes.push_back(Scope);
239  return true;
240 }
241 
243  bool Changed = false;
244  if (F.getSubprogram()) {
245  Changed = true;
246  F.setSubprogram(nullptr);
247  }
248 
249  for (BasicBlock &BB : F) {
250  for (auto II = BB.begin(), End = BB.end(); II != End;) {
251  Instruction &I = *II++; // We may delete the instruction, increment now.
252  if (isa<DbgInfoIntrinsic>(&I)) {
253  I.eraseFromParent();
254  Changed = true;
255  continue;
256  }
257  if (I.getDebugLoc()) {
258  Changed = true;
259  I.setDebugLoc(DebugLoc());
260  }
261  }
262  }
263  return Changed;
264 }
265 
267  bool Changed = false;
268 
270  NME = M.named_metadata_end(); NMI != NME;) {
271  NamedMDNode *NMD = &*NMI;
272  ++NMI;
273 
274  // We're stripping debug info, and without them, coverage information
275  // doesn't quite make sense.
276  if (NMD->getName().startswith("llvm.dbg.") ||
277  NMD->getName() == "llvm.gcov") {
278  NMD->eraseFromParent();
279  Changed = true;
280  }
281  }
282 
283  for (Function &F : M)
284  Changed |= stripDebugInfo(F);
285 
286  for (auto &GV : M.globals()) {
288  GV.getMetadata(LLVMContext::MD_dbg, MDs);
289  if (!MDs.empty()) {
290  GV.eraseMetadata(LLVMContext::MD_dbg);
291  Changed = true;
292  }
293  }
294 
295  if (GVMaterializer *Materializer = M.getMaterializer())
296  Materializer->setStripDebugInfo();
297 
298  return Changed;
299 }
300 
301 namespace {
302 
303 /// Helper class to downgrade -g metadata to -gline-tables-only metadata.
304 class DebugTypeInfoRemoval {
306 
307 public:
308  /// The (void)() type.
309  MDNode *EmptySubroutineType;
310 
311 private:
312  /// Remember what linkage name we originally had before stripping. If we end
313  /// up making two subprograms identical who originally had different linkage
314  /// names, then we need to make one of them distinct, to avoid them getting
315  /// uniqued. Maps the new node to the old linkage name.
316  DenseMap<DISubprogram *, StringRef> NewToLinkageName;
317 
318  // TODO: Remember the distinct subprogram we created for a given linkage name,
319  // so that we can continue to unique whenever possible. Map <newly created
320  // node, old linkage name> to the first (possibly distinct) mdsubprogram
321  // created for that combination. This is not strictly needed for correctness,
322  // but can cut down on the number of MDNodes and let us diff cleanly with the
323  // output of -gline-tables-only.
324 
325 public:
326  DebugTypeInfoRemoval(LLVMContext &C)
327  : EmptySubroutineType(DISubroutineType::get(C, DINode::FlagZero, 0,
328  MDNode::get(C, {}))) {}
329 
330  Metadata *map(Metadata *M) {
331  if (!M)
332  return nullptr;
333  auto Replacement = Replacements.find(M);
334  if (Replacement != Replacements.end())
335  return Replacement->second;
336 
337  return M;
338  }
339  MDNode *mapNode(Metadata *N) { return dyn_cast_or_null<MDNode>(map(N)); }
340 
341  /// Recursively remap N and all its referenced children. Does a DF post-order
342  /// traversal, so as to remap bottoms up.
343  void traverseAndRemap(MDNode *N) { traverse(N); }
344 
345 private:
346  // Create a new DISubprogram, to replace the one given.
347  DISubprogram *getReplacementSubprogram(DISubprogram *MDS) {
348  auto *FileAndScope = cast_or_null<DIFile>(map(MDS->getFile()));
349  StringRef LinkageName = MDS->getName().empty() ? MDS->getLinkageName() : "";
350  DISubprogram *Declaration = nullptr;
351  auto *Type = cast_or_null<DISubroutineType>(map(MDS->getType()));
352  DITypeRef ContainingType(map(MDS->getContainingType()));
353  auto *Unit = cast_or_null<DICompileUnit>(map(MDS->getUnit()));
354  auto Variables = nullptr;
355  auto TemplateParams = nullptr;
356 
357  // Make a distinct DISubprogram, for situations that warrent it.
358  auto distinctMDSubprogram = [&]() {
360  MDS->getContext(), FileAndScope, MDS->getName(), LinkageName,
361  FileAndScope, MDS->getLine(), Type, MDS->isLocalToUnit(),
362  MDS->isDefinition(), MDS->getScopeLine(), ContainingType,
363  MDS->getVirtuality(), MDS->getVirtualIndex(),
364  MDS->getThisAdjustment(), MDS->getFlags(), MDS->isOptimized(), Unit,
365  TemplateParams, Declaration, Variables);
366  };
367 
368  if (MDS->isDistinct())
369  return distinctMDSubprogram();
370 
371  auto *NewMDS = DISubprogram::get(
372  MDS->getContext(), FileAndScope, MDS->getName(), LinkageName,
373  FileAndScope, MDS->getLine(), Type, MDS->isLocalToUnit(),
374  MDS->isDefinition(), MDS->getScopeLine(), ContainingType,
375  MDS->getVirtuality(), MDS->getVirtualIndex(), MDS->getThisAdjustment(),
376  MDS->getFlags(), MDS->isOptimized(), Unit, TemplateParams, Declaration,
377  Variables);
378 
379  StringRef OldLinkageName = MDS->getLinkageName();
380 
381  // See if we need to make a distinct one.
382  auto OrigLinkage = NewToLinkageName.find(NewMDS);
383  if (OrigLinkage != NewToLinkageName.end()) {
384  if (OrigLinkage->second == OldLinkageName)
385  // We're good.
386  return NewMDS;
387 
388  // Otherwise, need to make a distinct one.
389  // TODO: Query the map to see if we already have one.
390  return distinctMDSubprogram();
391  }
392 
393  NewToLinkageName.insert({NewMDS, MDS->getLinkageName()});
394  return NewMDS;
395  }
396 
397  /// Create a new compile unit, to replace the one given
398  DICompileUnit *getReplacementCU(DICompileUnit *CU) {
399  // Drop skeleton CUs.
400  if (CU->getDWOId())
401  return nullptr;
402 
403  auto *File = cast_or_null<DIFile>(map(CU->getFile()));
404  MDTuple *EnumTypes = nullptr;
405  MDTuple *RetainedTypes = nullptr;
406  MDTuple *GlobalVariables = nullptr;
407  MDTuple *ImportedEntities = nullptr;
409  CU->getContext(), CU->getSourceLanguage(), File, CU->getProducer(),
410  CU->isOptimized(), CU->getFlags(), CU->getRuntimeVersion(),
412  RetainedTypes, GlobalVariables, ImportedEntities, CU->getMacros(),
413  CU->getDWOId(), CU->getSplitDebugInlining());
414  }
415 
416  DILocation *getReplacementMDLocation(DILocation *MLD) {
417  auto *Scope = map(MLD->getScope());
418  auto *InlinedAt = map(MLD->getInlinedAt());
419  if (MLD->isDistinct())
420  return DILocation::getDistinct(MLD->getContext(), MLD->getLine(),
421  MLD->getColumn(), Scope, InlinedAt);
422  return DILocation::get(MLD->getContext(), MLD->getLine(), MLD->getColumn(),
423  Scope, InlinedAt);
424  }
425 
426  /// Create a new generic MDNode, to replace the one given
427  MDNode *getReplacementMDNode(MDNode *N) {
429  Ops.reserve(N->getNumOperands());
430  for (auto &I : N->operands())
431  if (I)
432  Ops.push_back(map(I));
433  auto *Ret = MDNode::get(N->getContext(), Ops);
434  return Ret;
435  }
436 
437  /// Attempt to re-map N to a newly created node.
438  void remap(MDNode *N) {
439  if (Replacements.count(N))
440  return;
441 
442  auto doRemap = [&](MDNode *N) -> MDNode * {
443  if (!N)
444  return nullptr;
445  if (auto *MDSub = dyn_cast<DISubprogram>(N)) {
446  remap(MDSub->getUnit());
447  return getReplacementSubprogram(MDSub);
448  }
449  if (isa<DISubroutineType>(N))
450  return EmptySubroutineType;
451  if (auto *CU = dyn_cast<DICompileUnit>(N))
452  return getReplacementCU(CU);
453  if (isa<DIFile>(N))
454  return N;
455  if (auto *MDLB = dyn_cast<DILexicalBlockBase>(N))
456  // Remap to our referenced scope (recursively).
457  return mapNode(MDLB->getScope());
458  if (auto *MLD = dyn_cast<DILocation>(N))
459  return getReplacementMDLocation(MLD);
460 
461  // Otherwise, if we see these, just drop them now. Not strictly necessary,
462  // but this speeds things up a little.
463  if (isa<DINode>(N))
464  return nullptr;
465 
466  return getReplacementMDNode(N);
467  };
468  Replacements[N] = doRemap(N);
469  }
470 
471  /// Do the remapping traversal.
472  void traverse(MDNode *);
473 };
474 
475 } // Anonymous namespace.
476 
477 void DebugTypeInfoRemoval::traverse(MDNode *N) {
478  if (!N || Replacements.count(N))
479  return;
480 
481  // To avoid cycles, as well as for efficiency sake, we will sometimes prune
482  // parts of the graph.
483  auto prune = [](MDNode *Parent, MDNode *Child) {
484  if (auto *MDS = dyn_cast<DISubprogram>(Parent))
485  return Child == MDS->getVariables().get();
486  return false;
487  };
488 
490  DenseSet<MDNode *> Opened;
491 
492  // Visit each node starting at N in post order, and map them.
493  ToVisit.push_back(N);
494  while (!ToVisit.empty()) {
495  auto *N = ToVisit.back();
496  if (!Opened.insert(N).second) {
497  // Close it.
498  remap(N);
499  ToVisit.pop_back();
500  continue;
501  }
502  for (auto &I : N->operands())
503  if (auto *MDN = dyn_cast_or_null<MDNode>(I))
504  if (!Opened.count(MDN) && !Replacements.count(MDN) && !prune(N, MDN) &&
505  !isa<DICompileUnit>(MDN))
506  ToVisit.push_back(MDN);
507  }
508 }
509 
511  bool Changed = false;
512 
513  // First off, delete the debug intrinsics.
514  auto RemoveUses = [&](StringRef Name) {
515  if (auto *DbgVal = M.getFunction(Name)) {
516  while (!DbgVal->use_empty())
517  cast<Instruction>(DbgVal->user_back())->eraseFromParent();
518  DbgVal->eraseFromParent();
519  Changed = true;
520  }
521  };
522  RemoveUses("llvm.dbg.declare");
523  RemoveUses("llvm.dbg.value");
524 
525  // Delete non-CU debug info named metadata nodes.
526  for (auto NMI = M.named_metadata_begin(), NME = M.named_metadata_end();
527  NMI != NME;) {
528  NamedMDNode *NMD = &*NMI;
529  ++NMI;
530  // Specifically keep dbg.cu around.
531  if (NMD->getName() == "llvm.dbg.cu")
532  continue;
533  }
534 
535  // Drop all dbg attachments from global variables.
536  for (auto &GV : M.globals())
537  GV.eraseMetadata(LLVMContext::MD_dbg);
538 
539  DebugTypeInfoRemoval Mapper(M.getContext());
540  auto remap = [&](llvm::MDNode *Node) -> llvm::MDNode * {
541  if (!Node)
542  return nullptr;
543  Mapper.traverseAndRemap(Node);
544  auto *NewNode = Mapper.mapNode(Node);
545  Changed |= Node != NewNode;
546  Node = NewNode;
547  return NewNode;
548  };
549 
550  // Rewrite the DebugLocs to be equivalent to what
551  // -gline-tables-only would have created.
552  for (auto &F : M) {
553  if (auto *SP = F.getSubprogram()) {
554  Mapper.traverseAndRemap(SP);
555  auto *NewSP = cast<DISubprogram>(Mapper.mapNode(SP));
556  Changed |= SP != NewSP;
557  F.setSubprogram(NewSP);
558  }
559  for (auto &BB : F) {
560  for (auto &I : BB) {
561  if (I.getDebugLoc() == DebugLoc())
562  continue;
563 
564  // Make a replacement.
565  auto &DL = I.getDebugLoc();
566  auto *Scope = DL.getScope();
567  MDNode *InlinedAt = DL.getInlinedAt();
568  Scope = remap(Scope);
569  InlinedAt = remap(InlinedAt);
570  I.setDebugLoc(
571  DebugLoc::get(DL.getLine(), DL.getCol(), Scope, InlinedAt));
572  }
573  }
574  }
575 
576  // Create a new llvm.dbg.cu, which is equivalent to the one
577  // -gline-tables-only would have created.
578  for (auto &NMD : M.getNamedMDList()) {
580  for (MDNode *Op : NMD.operands())
581  Ops.push_back(remap(Op));
582 
583  if (!Changed)
584  continue;
585 
586  NMD.clearOperands();
587  for (auto *Op : Ops)
588  if (Op)
589  NMD.addOperand(Op);
590  }
591  return Changed;
592 }
593 
595  if (auto *Val = mdconst::dyn_extract_or_null<ConstantInt>(
596  M.getModuleFlag("Debug Info Version")))
597  return Val->getZExtValue();
598  return 0;
599 }
SymbolTableList< Instruction >::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
Definition: Instruction.cpp:76
StringRef getName() const
Definition: Metadata.cpp:1059
void processLocation(const Module &M, const DILocation *Loc)
Process debug info location.
Definition: DebugInfo.cpp:87
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:52
static MDTuple * getDistinct(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition: Metadata.h:1140
StringRef getFlags() const
Implements a dense probed hash-table based set.
Definition: DenseSet.h:202
unsigned getNumOperands() const
Return number of MDNode operands.
Definition: Metadata.h:1040
named_metadata_iterator named_metadata_end()
Definition: Module.h:627
unsigned getDebugMetadataVersionFromModule(const Module &M)
Return Debug Info Metadata Version by checking module flags.
Definition: DebugInfo.cpp:594
void reset()
Clear all lists.
Definition: DebugInfo.cpp:44
bool getSplitDebugInlining() const
A debug info location.
Definition: DebugLoc.h:34
Metadata node.
Definition: Metadata.h:830
bool stripDebugInfo(Function &F)
Definition: DebugInfo.cpp:242
void reserve(size_type N)
Definition: SmallVector.h:377
void processModule(const Module &M)
Process entire module and collect debug info anchors.
Definition: DebugInfo.cpp:53
Tuple of metadata.
Definition: Metadata.h:1072
Tagged DWARF-like metadata node.
uint64_t getDWOId() const
A tuple of MDNodes.
Definition: Metadata.h:1282
DILocation * get() const
Get the underlying DILocation.
Definition: DebugLoc.cpp:21
void eraseFromParent()
Drop all references and remove the node from parent module.
Definition: Metadata.cpp:1055
static GCRegistry::Add< StatepointGC > D("statepoint-example","an example strategy for statepoint")
bool stripNonLineTableDebugInfo(Module &M)
Downgrade the debug info in a module to contain only line table information.
Definition: DebugInfo.cpp:510
Holds a subclass of DINode.
DISubprogram * getDISubprogram(const MDNode *Scope)
Find subprogram that is enclosing this scope.
Definition: DebugInfo.cpp:34
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:60
iterator_range< debug_compile_units_iterator > debug_compile_units() const
Return an iterator for all DICompileUnits listed in this Module's llvm.dbg.cu named metadata node and...
Definition: Module.h:686
Subprogram description.
#define F(x, y, z)
Definition: MD5.cpp:51
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:264
bool StripDebugInfo(Module &M)
Strip debug info in the module if it exists.
Definition: DebugInfo.cpp:266
DIScopeRef getScope() const
Debug location.
DIScopeRef getScope() const
Function * getFunction(StringRef Name) const
Look up the specified function in the module symbol table.
Definition: Module.cpp:196
unsigned getRuntimeVersion() const
void setSubprogram(DISubprogram *SP)
Set the attached subprogram.
Definition: Metadata.cpp:1454
iterator_range< iterator > functions()
Definition: Module.h:546
void setDebugLoc(DebugLoc Loc)
Set the debug location information for this instruction.
Definition: Instruction.h:256
StringRef getName() const
LLVM Basic Block Representation.
Definition: BasicBlock.h:51
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:48
DIFile * getFile() const
This file contains the declarations for the subclasses of Constant, which represent the different fla...
unsigned getSourceLanguage() const
const DebugLoc & getDebugLoc() const
Return the debug location for this node as a DebugLoc.
Definition: Instruction.h:259
A pair of DIGlobalVariable and DIExpression.
static const unsigned End
DIMacroNodeArray getMacros() const
void processValue(const Module &M, const DbgValueInst *DVI)
Process DbgValueInst.
Definition: DebugInfo.cpp:174
Base class for scope-like contexts.
Metadata * getModuleFlag(StringRef Key) const
Return the corresponding value if Key appears in module flags, otherwise return null.
Definition: Module.cpp:325
Iterator for intrusive lists based on ilist_node.
Base class for types.
Import typeid resolutions from summary and globals.
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:843
Module.h This file contains the declarations for the Module class.
static GCRegistry::Add< ShadowStackGC > C("shadow-stack","Very portable GC for uncooperative code generators")
DISubprogram * getSubprogram() const
Get the attached subprogram.
Definition: Metadata.cpp:1458
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:130
bool isDistinct() const
Definition: Metadata.h:908
Type array for a subprogram.
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition: Metadata.h:1132
size_type count(const ValueT &V) const
Return 1 if the specified key is in the set, 0 otherwise.
Definition: DenseSet.h:81
This represents the llvm.dbg.value instruction.
void processDeclare(const Module &M, const DbgDeclareInst *DDI)
Process DbgDeclareInst.
Definition: DebugInfo.cpp:158
#define I(x, y, z)
Definition: MD5.cpp:54
#define N
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:287
op_range operands() const
Definition: Metadata.h:1032
LLVMContext & getContext() const
Definition: Metadata.h:889
std::vector< uint8_t > Unit
Definition: FuzzerDefs.h:71
DILocalVariable * getVariable() const
Definition: IntrinsicInst.h:93
DILocalVariable * getVariable() const
iterator_range< global_iterator > globals()
Definition: Module.h:524
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:47
DISubprogram * getSubprogram() const
Get the subprogram for this scope.
This represents the llvm.dbg.declare instruction.
Definition: IntrinsicInst.h:89
StringRef getProducer() const
Root of the metadata hierarchy.
Definition: Metadata.h:55
named_metadata_iterator named_metadata_begin()
Definition: Module.h:622
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:222
StringRef getSplitDebugFilename() const