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