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 (!TermInst)
315  // This is invalid IR, but we may not have run the verifier yet
316  continue;
317  if (auto *LoopID = TermInst->getMetadata(LLVMContext::MD_loop)) {
318  auto *NewLoopID = LoopIDsMap.lookup(LoopID);
319  if (!NewLoopID)
320  NewLoopID = LoopIDsMap[LoopID] = stripDebugLocFromLoopID(LoopID);
321  if (NewLoopID != LoopID)
322  TermInst->setMetadata(LLVMContext::MD_loop, NewLoopID);
323  }
324  }
325  return Changed;
326 }
327 
329  bool Changed = false;
330 
332  NME = M.named_metadata_end(); NMI != NME;) {
333  NamedMDNode *NMD = &*NMI;
334  ++NMI;
335 
336  // We're stripping debug info, and without them, coverage information
337  // doesn't quite make sense.
338  if (NMD->getName().startswith("llvm.dbg.") ||
339  NMD->getName() == "llvm.gcov") {
340  NMD->eraseFromParent();
341  Changed = true;
342  }
343  }
344 
345  for (Function &F : M)
346  Changed |= stripDebugInfo(F);
347 
348  for (auto &GV : M.globals()) {
350  GV.getMetadata(LLVMContext::MD_dbg, MDs);
351  if (!MDs.empty()) {
352  GV.eraseMetadata(LLVMContext::MD_dbg);
353  Changed = true;
354  }
355  }
356 
357  if (GVMaterializer *Materializer = M.getMaterializer())
358  Materializer->setStripDebugInfo();
359 
360  return Changed;
361 }
362 
363 namespace {
364 
365 /// Helper class to downgrade -g metadata to -gline-tables-only metadata.
366 class DebugTypeInfoRemoval {
368 
369 public:
370  /// The (void)() type.
371  MDNode *EmptySubroutineType;
372 
373 private:
374  /// Remember what linkage name we originally had before stripping. If we end
375  /// up making two subprograms identical who originally had different linkage
376  /// names, then we need to make one of them distinct, to avoid them getting
377  /// uniqued. Maps the new node to the old linkage name.
378  DenseMap<DISubprogram *, StringRef> NewToLinkageName;
379 
380  // TODO: Remember the distinct subprogram we created for a given linkage name,
381  // so that we can continue to unique whenever possible. Map <newly created
382  // node, old linkage name> to the first (possibly distinct) mdsubprogram
383  // created for that combination. This is not strictly needed for correctness,
384  // but can cut down on the number of MDNodes and let us diff cleanly with the
385  // output of -gline-tables-only.
386 
387 public:
388  DebugTypeInfoRemoval(LLVMContext &C)
389  : EmptySubroutineType(DISubroutineType::get(C, DINode::FlagZero, 0,
390  MDNode::get(C, {}))) {}
391 
392  Metadata *map(Metadata *M) {
393  if (!M)
394  return nullptr;
395  auto Replacement = Replacements.find(M);
396  if (Replacement != Replacements.end())
397  return Replacement->second;
398 
399  return M;
400  }
401  MDNode *mapNode(Metadata *N) { return dyn_cast_or_null<MDNode>(map(N)); }
402 
403  /// Recursively remap N and all its referenced children. Does a DF post-order
404  /// traversal, so as to remap bottoms up.
405  void traverseAndRemap(MDNode *N) { traverse(N); }
406 
407 private:
408  // Create a new DISubprogram, to replace the one given.
409  DISubprogram *getReplacementSubprogram(DISubprogram *MDS) {
410  auto *FileAndScope = cast_or_null<DIFile>(map(MDS->getFile()));
411  StringRef LinkageName = MDS->getName().empty() ? MDS->getLinkageName() : "";
412  DISubprogram *Declaration = nullptr;
413  auto *Type = cast_or_null<DISubroutineType>(map(MDS->getType()));
414  DITypeRef ContainingType(map(MDS->getContainingType()));
415  auto *Unit = cast_or_null<DICompileUnit>(map(MDS->getUnit()));
416  auto Variables = nullptr;
417  auto TemplateParams = nullptr;
418 
419  // Make a distinct DISubprogram, for situations that warrent it.
420  auto distinctMDSubprogram = [&]() {
422  MDS->getContext(), FileAndScope, MDS->getName(), LinkageName,
423  FileAndScope, MDS->getLine(), Type, MDS->isLocalToUnit(),
424  MDS->isDefinition(), MDS->getScopeLine(), ContainingType,
425  MDS->getVirtuality(), MDS->getVirtualIndex(),
426  MDS->getThisAdjustment(), MDS->getFlags(), MDS->isOptimized(), Unit,
427  TemplateParams, Declaration, Variables);
428  };
429 
430  if (MDS->isDistinct())
431  return distinctMDSubprogram();
432 
433  auto *NewMDS = DISubprogram::get(
434  MDS->getContext(), FileAndScope, MDS->getName(), LinkageName,
435  FileAndScope, MDS->getLine(), Type, MDS->isLocalToUnit(),
436  MDS->isDefinition(), MDS->getScopeLine(), ContainingType,
437  MDS->getVirtuality(), MDS->getVirtualIndex(), MDS->getThisAdjustment(),
438  MDS->getFlags(), MDS->isOptimized(), Unit, TemplateParams, Declaration,
439  Variables);
440 
441  StringRef OldLinkageName = MDS->getLinkageName();
442 
443  // See if we need to make a distinct one.
444  auto OrigLinkage = NewToLinkageName.find(NewMDS);
445  if (OrigLinkage != NewToLinkageName.end()) {
446  if (OrigLinkage->second == OldLinkageName)
447  // We're good.
448  return NewMDS;
449 
450  // Otherwise, need to make a distinct one.
451  // TODO: Query the map to see if we already have one.
452  return distinctMDSubprogram();
453  }
454 
455  NewToLinkageName.insert({NewMDS, MDS->getLinkageName()});
456  return NewMDS;
457  }
458 
459  /// Create a new compile unit, to replace the one given
460  DICompileUnit *getReplacementCU(DICompileUnit *CU) {
461  // Drop skeleton CUs.
462  if (CU->getDWOId())
463  return nullptr;
464 
465  auto *File = cast_or_null<DIFile>(map(CU->getFile()));
466  MDTuple *EnumTypes = nullptr;
467  MDTuple *RetainedTypes = nullptr;
468  MDTuple *GlobalVariables = nullptr;
469  MDTuple *ImportedEntities = nullptr;
471  CU->getContext(), CU->getSourceLanguage(), File, CU->getProducer(),
472  CU->isOptimized(), CU->getFlags(), CU->getRuntimeVersion(),
474  RetainedTypes, GlobalVariables, ImportedEntities, CU->getMacros(),
475  CU->getDWOId(), CU->getSplitDebugInlining(),
477  }
478 
479  DILocation *getReplacementMDLocation(DILocation *MLD) {
480  auto *Scope = map(MLD->getScope());
481  auto *InlinedAt = map(MLD->getInlinedAt());
482  if (MLD->isDistinct())
483  return DILocation::getDistinct(MLD->getContext(), MLD->getLine(),
484  MLD->getColumn(), Scope, InlinedAt);
485  return DILocation::get(MLD->getContext(), MLD->getLine(), MLD->getColumn(),
486  Scope, InlinedAt);
487  }
488 
489  /// Create a new generic MDNode, to replace the one given
490  MDNode *getReplacementMDNode(MDNode *N) {
492  Ops.reserve(N->getNumOperands());
493  for (auto &I : N->operands())
494  if (I)
495  Ops.push_back(map(I));
496  auto *Ret = MDNode::get(N->getContext(), Ops);
497  return Ret;
498  }
499 
500  /// Attempt to re-map N to a newly created node.
501  void remap(MDNode *N) {
502  if (Replacements.count(N))
503  return;
504 
505  auto doRemap = [&](MDNode *N) -> MDNode * {
506  if (!N)
507  return nullptr;
508  if (auto *MDSub = dyn_cast<DISubprogram>(N)) {
509  remap(MDSub->getUnit());
510  return getReplacementSubprogram(MDSub);
511  }
512  if (isa<DISubroutineType>(N))
513  return EmptySubroutineType;
514  if (auto *CU = dyn_cast<DICompileUnit>(N))
515  return getReplacementCU(CU);
516  if (isa<DIFile>(N))
517  return N;
518  if (auto *MDLB = dyn_cast<DILexicalBlockBase>(N))
519  // Remap to our referenced scope (recursively).
520  return mapNode(MDLB->getScope());
521  if (auto *MLD = dyn_cast<DILocation>(N))
522  return getReplacementMDLocation(MLD);
523 
524  // Otherwise, if we see these, just drop them now. Not strictly necessary,
525  // but this speeds things up a little.
526  if (isa<DINode>(N))
527  return nullptr;
528 
529  return getReplacementMDNode(N);
530  };
531  Replacements[N] = doRemap(N);
532  }
533 
534  /// Do the remapping traversal.
535  void traverse(MDNode *);
536 };
537 
538 } // end anonymous namespace
539 
540 void DebugTypeInfoRemoval::traverse(MDNode *N) {
541  if (!N || Replacements.count(N))
542  return;
543 
544  // To avoid cycles, as well as for efficiency sake, we will sometimes prune
545  // parts of the graph.
546  auto prune = [](MDNode *Parent, MDNode *Child) {
547  if (auto *MDS = dyn_cast<DISubprogram>(Parent))
548  return Child == MDS->getVariables().get();
549  return false;
550  };
551 
553  DenseSet<MDNode *> Opened;
554 
555  // Visit each node starting at N in post order, and map them.
556  ToVisit.push_back(N);
557  while (!ToVisit.empty()) {
558  auto *N = ToVisit.back();
559  if (!Opened.insert(N).second) {
560  // Close it.
561  remap(N);
562  ToVisit.pop_back();
563  continue;
564  }
565  for (auto &I : N->operands())
566  if (auto *MDN = dyn_cast_or_null<MDNode>(I))
567  if (!Opened.count(MDN) && !Replacements.count(MDN) && !prune(N, MDN) &&
568  !isa<DICompileUnit>(MDN))
569  ToVisit.push_back(MDN);
570  }
571 }
572 
574  bool Changed = false;
575 
576  // First off, delete the debug intrinsics.
577  auto RemoveUses = [&](StringRef Name) {
578  if (auto *DbgVal = M.getFunction(Name)) {
579  while (!DbgVal->use_empty())
580  cast<Instruction>(DbgVal->user_back())->eraseFromParent();
581  DbgVal->eraseFromParent();
582  Changed = true;
583  }
584  };
585  RemoveUses("llvm.dbg.declare");
586  RemoveUses("llvm.dbg.value");
587 
588  // Delete non-CU debug info named metadata nodes.
589  for (auto NMI = M.named_metadata_begin(), NME = M.named_metadata_end();
590  NMI != NME;) {
591  NamedMDNode *NMD = &*NMI;
592  ++NMI;
593  // Specifically keep dbg.cu around.
594  if (NMD->getName() == "llvm.dbg.cu")
595  continue;
596  }
597 
598  // Drop all dbg attachments from global variables.
599  for (auto &GV : M.globals())
600  GV.eraseMetadata(LLVMContext::MD_dbg);
601 
602  DebugTypeInfoRemoval Mapper(M.getContext());
603  auto remap = [&](MDNode *Node) -> MDNode * {
604  if (!Node)
605  return nullptr;
606  Mapper.traverseAndRemap(Node);
607  auto *NewNode = Mapper.mapNode(Node);
608  Changed |= Node != NewNode;
609  Node = NewNode;
610  return NewNode;
611  };
612 
613  // Rewrite the DebugLocs to be equivalent to what
614  // -gline-tables-only would have created.
615  for (auto &F : M) {
616  if (auto *SP = F.getSubprogram()) {
617  Mapper.traverseAndRemap(SP);
618  auto *NewSP = cast<DISubprogram>(Mapper.mapNode(SP));
619  Changed |= SP != NewSP;
620  F.setSubprogram(NewSP);
621  }
622  for (auto &BB : F) {
623  for (auto &I : BB) {
624  auto remapDebugLoc = [&](DebugLoc DL) -> DebugLoc {
625  auto *Scope = DL.getScope();
626  MDNode *InlinedAt = DL.getInlinedAt();
627  Scope = remap(Scope);
628  InlinedAt = remap(InlinedAt);
629  return DebugLoc::get(DL.getLine(), DL.getCol(), Scope, InlinedAt);
630  };
631 
632  if (I.getDebugLoc() != DebugLoc())
633  I.setDebugLoc(remapDebugLoc(I.getDebugLoc()));
634 
635  // Remap DILocations in untyped MDNodes (e.g., llvm.loop).
637  I.getAllMetadata(MDs);
638  for (auto Attachment : MDs)
639  if (auto *T = dyn_cast_or_null<MDTuple>(Attachment.second))
640  for (unsigned N = 0; N < T->getNumOperands(); ++N)
641  if (auto *Loc = dyn_cast_or_null<DILocation>(T->getOperand(N)))
642  if (Loc != DebugLoc())
643  T->replaceOperandWith(N, remapDebugLoc(Loc));
644  }
645  }
646  }
647 
648  // Create a new llvm.dbg.cu, which is equivalent to the one
649  // -gline-tables-only would have created.
650  for (auto &NMD : M.getNamedMDList()) {
652  for (MDNode *Op : NMD.operands())
653  Ops.push_back(remap(Op));
654 
655  if (!Changed)
656  continue;
657 
658  NMD.clearOperands();
659  for (auto *Op : Ops)
660  if (Op)
661  NMD.addOperand(Op);
662  }
663  return Changed;
664 }
665 
667  if (auto *Val = mdconst::dyn_extract_or_null<ConstantInt>(
668  M.getModuleFlag("Debug Info Version")))
669  return Val->getZExtValue();
670  return 0;
671 }
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:666
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
F(f)
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:191
StringRef getSplitDebugFilename() const
A tuple of MDNodes.
Definition: Metadata.h:1323
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:830
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:573
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
op_range operands() const
Definition: Metadata.h:1065
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:328
Debug location.
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:281
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:69
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.
DILocalVariable * getVariable() const
Definition: IntrinsicInst.h:80
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.
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
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:284
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
#define N
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:141
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:181
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
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.
Root of the metadata hierarchy.
Definition: Metadata.h:58
named_metadata_iterator named_metadata_begin()
Definition: Module.h:684
DIScopeRef getScope() const