LLVM  8.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-c/DebugInfo.h"
16 #include "llvm/ADT/DenseMap.h"
17 #include "llvm/ADT/DenseSet.h"
18 #include "llvm/ADT/None.h"
19 #include "llvm/ADT/STLExtras.h"
20 #include "llvm/ADT/SmallPtrSet.h"
21 #include "llvm/ADT/SmallVector.h"
22 #include "llvm/ADT/StringRef.h"
23 #include "llvm/IR/BasicBlock.h"
24 #include "llvm/IR/Constants.h"
26 #include "llvm/IR/DebugLoc.h"
27 #include "llvm/IR/DebugInfo.h"
28 #include "llvm/IR/DIBuilder.h"
29 #include "llvm/IR/Function.h"
30 #include "llvm/IR/GVMaterializer.h"
31 #include "llvm/IR/Instruction.h"
32 #include "llvm/IR/IntrinsicInst.h"
33 #include "llvm/IR/LLVMContext.h"
34 #include "llvm/IR/Metadata.h"
35 #include "llvm/IR/Module.h"
36 #include "llvm/Support/Casting.h"
37 #include <algorithm>
38 #include <cassert>
39 #include <utility>
40 
41 using namespace llvm;
42 using namespace llvm::dwarf;
43 
45  if (auto *LocalScope = dyn_cast_or_null<DILocalScope>(Scope))
46  return LocalScope->getSubprogram();
47  return nullptr;
48 }
49 
50 //===----------------------------------------------------------------------===//
51 // DebugInfoFinder implementations.
52 //===----------------------------------------------------------------------===//
53 
55  CUs.clear();
56  SPs.clear();
57  GVs.clear();
58  TYs.clear();
59  Scopes.clear();
60  NodesSeen.clear();
61 }
62 
64  for (auto *CU : M.debug_compile_units())
65  processCompileUnit(CU);
66  for (auto &F : M.functions()) {
67  if (auto *SP = cast_or_null<DISubprogram>(F.getSubprogram()))
68  processSubprogram(SP);
69  // There could be subprograms from inlined functions referenced from
70  // instructions only. Walk the function to find them.
71  for (const BasicBlock &BB : F)
72  for (const Instruction &I : BB)
73  processInstruction(M, I);
74  }
75 }
76 
77 void DebugInfoFinder::processCompileUnit(DICompileUnit *CU) {
78  if (!addCompileUnit(CU))
79  return;
80  for (auto DIG : CU->getGlobalVariables()) {
81  if (!addGlobalVariable(DIG))
82  continue;
83  auto *GV = DIG->getVariable();
84  processScope(GV->getScope());
85  processType(GV->getType().resolve());
86  }
87  for (auto *ET : CU->getEnumTypes())
88  processType(ET);
89  for (auto *RT : CU->getRetainedTypes())
90  if (auto *T = dyn_cast<DIType>(RT))
91  processType(T);
92  else
93  processSubprogram(cast<DISubprogram>(RT));
94  for (auto *Import : CU->getImportedEntities()) {
95  auto *Entity = Import->getEntity().resolve();
96  if (auto *T = dyn_cast<DIType>(Entity))
97  processType(T);
98  else if (auto *SP = dyn_cast<DISubprogram>(Entity))
99  processSubprogram(SP);
100  else if (auto *NS = dyn_cast<DINamespace>(Entity))
101  processScope(NS->getScope());
102  else if (auto *M = dyn_cast<DIModule>(Entity))
103  processScope(M->getScope());
104  }
105 }
106 
108  const Instruction &I) {
109  if (auto *DDI = dyn_cast<DbgDeclareInst>(&I))
110  processDeclare(M, DDI);
111  else if (auto *DVI = dyn_cast<DbgValueInst>(&I))
112  processValue(M, DVI);
113 
114  if (auto DbgLoc = I.getDebugLoc())
115  processLocation(M, DbgLoc.get());
116 }
117 
119  if (!Loc)
120  return;
121  processScope(Loc->getScope());
122  processLocation(M, Loc->getInlinedAt());
123 }
124 
125 void DebugInfoFinder::processType(DIType *DT) {
126  if (!addType(DT))
127  return;
128  processScope(DT->getScope().resolve());
129  if (auto *ST = dyn_cast<DISubroutineType>(DT)) {
130  for (DITypeRef Ref : ST->getTypeArray())
131  processType(Ref.resolve());
132  return;
133  }
134  if (auto *DCT = dyn_cast<DICompositeType>(DT)) {
135  processType(DCT->getBaseType().resolve());
136  for (Metadata *D : DCT->getElements()) {
137  if (auto *T = dyn_cast<DIType>(D))
138  processType(T);
139  else if (auto *SP = dyn_cast<DISubprogram>(D))
140  processSubprogram(SP);
141  }
142  return;
143  }
144  if (auto *DDT = dyn_cast<DIDerivedType>(DT)) {
145  processType(DDT->getBaseType().resolve());
146  }
147 }
148 
149 void DebugInfoFinder::processScope(DIScope *Scope) {
150  if (!Scope)
151  return;
152  if (auto *Ty = dyn_cast<DIType>(Scope)) {
153  processType(Ty);
154  return;
155  }
156  if (auto *CU = dyn_cast<DICompileUnit>(Scope)) {
157  addCompileUnit(CU);
158  return;
159  }
160  if (auto *SP = dyn_cast<DISubprogram>(Scope)) {
161  processSubprogram(SP);
162  return;
163  }
164  if (!addScope(Scope))
165  return;
166  if (auto *LB = dyn_cast<DILexicalBlockBase>(Scope)) {
167  processScope(LB->getScope());
168  } else if (auto *NS = dyn_cast<DINamespace>(Scope)) {
169  processScope(NS->getScope());
170  } else if (auto *M = dyn_cast<DIModule>(Scope)) {
171  processScope(M->getScope());
172  }
173 }
174 
175 void DebugInfoFinder::processSubprogram(DISubprogram *SP) {
176  if (!addSubprogram(SP))
177  return;
178  processScope(SP->getScope().resolve());
179  // Some of the users, e.g. CloneFunctionInto / CloneModule, need to set up a
180  // ValueMap containing identity mappings for all of the DICompileUnit's, not
181  // just DISubprogram's, referenced from anywhere within the Function being
182  // cloned prior to calling MapMetadata / RemapInstruction to avoid their
183  // duplication later as DICompileUnit's are also directly referenced by
184  // llvm.dbg.cu list. Thefore we need to collect DICompileUnit's here as well.
185  // Also, DICompileUnit's may reference DISubprogram's too and therefore need
186  // to be at least looked through.
187  processCompileUnit(SP->getUnit());
188  processType(SP->getType());
189  for (auto *Element : SP->getTemplateParams()) {
190  if (auto *TType = dyn_cast<DITemplateTypeParameter>(Element)) {
191  processType(TType->getType().resolve());
192  } else if (auto *TVal = dyn_cast<DITemplateValueParameter>(Element)) {
193  processType(TVal->getType().resolve());
194  }
195  }
196 }
197 
199  const DbgDeclareInst *DDI) {
200  auto *N = dyn_cast<MDNode>(DDI->getVariable());
201  if (!N)
202  return;
203 
204  auto *DV = dyn_cast<DILocalVariable>(N);
205  if (!DV)
206  return;
207 
208  if (!NodesSeen.insert(DV).second)
209  return;
210  processScope(DV->getScope());
211  processType(DV->getType().resolve());
212 }
213 
215  auto *N = dyn_cast<MDNode>(DVI->getVariable());
216  if (!N)
217  return;
218 
219  auto *DV = dyn_cast<DILocalVariable>(N);
220  if (!DV)
221  return;
222 
223  if (!NodesSeen.insert(DV).second)
224  return;
225  processScope(DV->getScope());
226  processType(DV->getType().resolve());
227 }
228 
229 bool DebugInfoFinder::addType(DIType *DT) {
230  if (!DT)
231  return false;
232 
233  if (!NodesSeen.insert(DT).second)
234  return false;
235 
236  TYs.push_back(const_cast<DIType *>(DT));
237  return true;
238 }
239 
240 bool DebugInfoFinder::addCompileUnit(DICompileUnit *CU) {
241  if (!CU)
242  return false;
243  if (!NodesSeen.insert(CU).second)
244  return false;
245 
246  CUs.push_back(CU);
247  return true;
248 }
249 
250 bool DebugInfoFinder::addGlobalVariable(DIGlobalVariableExpression *DIG) {
251  if (!NodesSeen.insert(DIG).second)
252  return false;
253 
254  GVs.push_back(DIG);
255  return true;
256 }
257 
258 bool DebugInfoFinder::addSubprogram(DISubprogram *SP) {
259  if (!SP)
260  return false;
261 
262  if (!NodesSeen.insert(SP).second)
263  return false;
264 
265  SPs.push_back(SP);
266  return true;
267 }
268 
269 bool DebugInfoFinder::addScope(DIScope *Scope) {
270  if (!Scope)
271  return false;
272  // FIXME: Ocaml binding generates a scope with no content, we treat it
273  // as null for now.
274  if (Scope->getNumOperands() == 0)
275  return false;
276  if (!NodesSeen.insert(Scope).second)
277  return false;
278  Scopes.push_back(Scope);
279  return true;
280 }
281 
283  assert(N->op_begin() != N->op_end() && "Missing self reference?");
284 
285  // if there is no debug location, we do not have to rewrite this MDNode.
286  if (std::none_of(N->op_begin() + 1, N->op_end(), [](const MDOperand &Op) {
287  return isa<DILocation>(Op.get());
288  }))
289  return N;
290 
291  // If there is only the debug location without any actual loop metadata, we
292  // can remove the metadata.
293  if (std::none_of(N->op_begin() + 1, N->op_end(), [](const MDOperand &Op) {
294  return !isa<DILocation>(Op.get());
295  }))
296  return nullptr;
297 
299  // Reserve operand 0 for loop id self reference.
300  auto TempNode = MDNode::getTemporary(N->getContext(), None);
301  Args.push_back(TempNode.get());
302  // Add all non-debug location operands back.
303  for (auto Op = N->op_begin() + 1; Op != N->op_end(); Op++) {
304  if (!isa<DILocation>(*Op))
305  Args.push_back(*Op);
306  }
307 
308  // Set the first operand to itself.
309  MDNode *LoopID = MDNode::get(N->getContext(), Args);
310  LoopID->replaceOperandWith(0, LoopID);
311  return LoopID;
312 }
313 
315  bool Changed = false;
317  Changed = true;
318  F.setSubprogram(nullptr);
319  }
320 
321  DenseMap<MDNode*, MDNode*> LoopIDsMap;
322  for (BasicBlock &BB : F) {
323  for (auto II = BB.begin(), End = BB.end(); II != End;) {
324  Instruction &I = *II++; // We may delete the instruction, increment now.
325  if (isa<DbgInfoIntrinsic>(&I)) {
326  I.eraseFromParent();
327  Changed = true;
328  continue;
329  }
330  if (I.getDebugLoc()) {
331  Changed = true;
332  I.setDebugLoc(DebugLoc());
333  }
334  }
335 
336  auto *TermInst = BB.getTerminator();
337  if (!TermInst)
338  // This is invalid IR, but we may not have run the verifier yet
339  continue;
340  if (auto *LoopID = TermInst->getMetadata(LLVMContext::MD_loop)) {
341  auto *NewLoopID = LoopIDsMap.lookup(LoopID);
342  if (!NewLoopID)
343  NewLoopID = LoopIDsMap[LoopID] = stripDebugLocFromLoopID(LoopID);
344  if (NewLoopID != LoopID)
345  TermInst->setMetadata(LLVMContext::MD_loop, NewLoopID);
346  }
347  }
348  return Changed;
349 }
350 
352  bool Changed = false;
353 
355  NME = M.named_metadata_end(); NMI != NME;) {
356  NamedMDNode *NMD = &*NMI;
357  ++NMI;
358 
359  // We're stripping debug info, and without them, coverage information
360  // doesn't quite make sense.
361  if (NMD->getName().startswith("llvm.dbg.") ||
362  NMD->getName() == "llvm.gcov") {
363  NMD->eraseFromParent();
364  Changed = true;
365  }
366  }
367 
368  for (Function &F : M)
369  Changed |= stripDebugInfo(F);
370 
371  for (auto &GV : M.globals()) {
372  Changed |= GV.eraseMetadata(LLVMContext::MD_dbg);
373  }
374 
375  if (GVMaterializer *Materializer = M.getMaterializer())
376  Materializer->setStripDebugInfo();
377 
378  return Changed;
379 }
380 
381 namespace {
382 
383 /// Helper class to downgrade -g metadata to -gline-tables-only metadata.
384 class DebugTypeInfoRemoval {
386 
387 public:
388  /// The (void)() type.
389  MDNode *EmptySubroutineType;
390 
391 private:
392  /// Remember what linkage name we originally had before stripping. If we end
393  /// up making two subprograms identical who originally had different linkage
394  /// names, then we need to make one of them distinct, to avoid them getting
395  /// uniqued. Maps the new node to the old linkage name.
396  DenseMap<DISubprogram *, StringRef> NewToLinkageName;
397 
398  // TODO: Remember the distinct subprogram we created for a given linkage name,
399  // so that we can continue to unique whenever possible. Map <newly created
400  // node, old linkage name> to the first (possibly distinct) mdsubprogram
401  // created for that combination. This is not strictly needed for correctness,
402  // but can cut down on the number of MDNodes and let us diff cleanly with the
403  // output of -gline-tables-only.
404 
405 public:
406  DebugTypeInfoRemoval(LLVMContext &C)
407  : EmptySubroutineType(DISubroutineType::get(C, DINode::FlagZero, 0,
408  MDNode::get(C, {}))) {}
409 
410  Metadata *map(Metadata *M) {
411  if (!M)
412  return nullptr;
413  auto Replacement = Replacements.find(M);
414  if (Replacement != Replacements.end())
415  return Replacement->second;
416 
417  return M;
418  }
419  MDNode *mapNode(Metadata *N) { return dyn_cast_or_null<MDNode>(map(N)); }
420 
421  /// Recursively remap N and all its referenced children. Does a DF post-order
422  /// traversal, so as to remap bottoms up.
423  void traverseAndRemap(MDNode *N) { traverse(N); }
424 
425 private:
426  // Create a new DISubprogram, to replace the one given.
427  DISubprogram *getReplacementSubprogram(DISubprogram *MDS) {
428  auto *FileAndScope = cast_or_null<DIFile>(map(MDS->getFile()));
429  StringRef LinkageName = MDS->getName().empty() ? MDS->getLinkageName() : "";
430  DISubprogram *Declaration = nullptr;
431  auto *Type = cast_or_null<DISubroutineType>(map(MDS->getType()));
432  DITypeRef ContainingType(map(MDS->getContainingType()));
433  auto *Unit = cast_or_null<DICompileUnit>(map(MDS->getUnit()));
434  auto Variables = nullptr;
435  auto TemplateParams = nullptr;
436 
437  // Make a distinct DISubprogram, for situations that warrent it.
438  auto distinctMDSubprogram = [&]() {
440  MDS->getContext(), FileAndScope, MDS->getName(), LinkageName,
441  FileAndScope, MDS->getLine(), Type, MDS->isLocalToUnit(),
442  MDS->isDefinition(), MDS->getScopeLine(), ContainingType,
443  MDS->getVirtuality(), MDS->getVirtualIndex(),
444  MDS->getThisAdjustment(), MDS->getFlags(), MDS->isOptimized(), Unit,
445  TemplateParams, Declaration, Variables);
446  };
447 
448  if (MDS->isDistinct())
449  return distinctMDSubprogram();
450 
451  auto *NewMDS = DISubprogram::get(
452  MDS->getContext(), FileAndScope, MDS->getName(), LinkageName,
453  FileAndScope, MDS->getLine(), Type, MDS->isLocalToUnit(),
454  MDS->isDefinition(), MDS->getScopeLine(), ContainingType,
455  MDS->getVirtuality(), MDS->getVirtualIndex(), MDS->getThisAdjustment(),
456  MDS->getFlags(), MDS->isOptimized(), Unit, TemplateParams, Declaration,
457  Variables);
458 
459  StringRef OldLinkageName = MDS->getLinkageName();
460 
461  // See if we need to make a distinct one.
462  auto OrigLinkage = NewToLinkageName.find(NewMDS);
463  if (OrigLinkage != NewToLinkageName.end()) {
464  if (OrigLinkage->second == OldLinkageName)
465  // We're good.
466  return NewMDS;
467 
468  // Otherwise, need to make a distinct one.
469  // TODO: Query the map to see if we already have one.
470  return distinctMDSubprogram();
471  }
472 
473  NewToLinkageName.insert({NewMDS, MDS->getLinkageName()});
474  return NewMDS;
475  }
476 
477  /// Create a new compile unit, to replace the one given
478  DICompileUnit *getReplacementCU(DICompileUnit *CU) {
479  // Drop skeleton CUs.
480  if (CU->getDWOId())
481  return nullptr;
482 
483  auto *File = cast_or_null<DIFile>(map(CU->getFile()));
484  MDTuple *EnumTypes = nullptr;
485  MDTuple *RetainedTypes = nullptr;
486  MDTuple *GlobalVariables = nullptr;
487  MDTuple *ImportedEntities = nullptr;
489  CU->getContext(), CU->getSourceLanguage(), File, CU->getProducer(),
490  CU->isOptimized(), CU->getFlags(), CU->getRuntimeVersion(),
492  RetainedTypes, GlobalVariables, ImportedEntities, CU->getMacros(),
493  CU->getDWOId(), CU->getSplitDebugInlining(),
495  }
496 
497  DILocation *getReplacementMDLocation(DILocation *MLD) {
498  auto *Scope = map(MLD->getScope());
499  auto *InlinedAt = map(MLD->getInlinedAt());
500  if (MLD->isDistinct())
501  return DILocation::getDistinct(MLD->getContext(), MLD->getLine(),
502  MLD->getColumn(), Scope, InlinedAt);
503  return DILocation::get(MLD->getContext(), MLD->getLine(), MLD->getColumn(),
504  Scope, InlinedAt);
505  }
506 
507  /// Create a new generic MDNode, to replace the one given
508  MDNode *getReplacementMDNode(MDNode *N) {
510  Ops.reserve(N->getNumOperands());
511  for (auto &I : N->operands())
512  if (I)
513  Ops.push_back(map(I));
514  auto *Ret = MDNode::get(N->getContext(), Ops);
515  return Ret;
516  }
517 
518  /// Attempt to re-map N to a newly created node.
519  void remap(MDNode *N) {
520  if (Replacements.count(N))
521  return;
522 
523  auto doRemap = [&](MDNode *N) -> MDNode * {
524  if (!N)
525  return nullptr;
526  if (auto *MDSub = dyn_cast<DISubprogram>(N)) {
527  remap(MDSub->getUnit());
528  return getReplacementSubprogram(MDSub);
529  }
530  if (isa<DISubroutineType>(N))
531  return EmptySubroutineType;
532  if (auto *CU = dyn_cast<DICompileUnit>(N))
533  return getReplacementCU(CU);
534  if (isa<DIFile>(N))
535  return N;
536  if (auto *MDLB = dyn_cast<DILexicalBlockBase>(N))
537  // Remap to our referenced scope (recursively).
538  return mapNode(MDLB->getScope());
539  if (auto *MLD = dyn_cast<DILocation>(N))
540  return getReplacementMDLocation(MLD);
541 
542  // Otherwise, if we see these, just drop them now. Not strictly necessary,
543  // but this speeds things up a little.
544  if (isa<DINode>(N))
545  return nullptr;
546 
547  return getReplacementMDNode(N);
548  };
549  Replacements[N] = doRemap(N);
550  }
551 
552  /// Do the remapping traversal.
553  void traverse(MDNode *);
554 };
555 
556 } // end anonymous namespace
557 
558 void DebugTypeInfoRemoval::traverse(MDNode *N) {
559  if (!N || Replacements.count(N))
560  return;
561 
562  // To avoid cycles, as well as for efficiency sake, we will sometimes prune
563  // parts of the graph.
564  auto prune = [](MDNode *Parent, MDNode *Child) {
565  if (auto *MDS = dyn_cast<DISubprogram>(Parent))
566  return Child == MDS->getRetainedNodes().get();
567  return false;
568  };
569 
571  DenseSet<MDNode *> Opened;
572 
573  // Visit each node starting at N in post order, and map them.
574  ToVisit.push_back(N);
575  while (!ToVisit.empty()) {
576  auto *N = ToVisit.back();
577  if (!Opened.insert(N).second) {
578  // Close it.
579  remap(N);
580  ToVisit.pop_back();
581  continue;
582  }
583  for (auto &I : N->operands())
584  if (auto *MDN = dyn_cast_or_null<MDNode>(I))
585  if (!Opened.count(MDN) && !Replacements.count(MDN) && !prune(N, MDN) &&
586  !isa<DICompileUnit>(MDN))
587  ToVisit.push_back(MDN);
588  }
589 }
590 
592  bool Changed = false;
593 
594  // First off, delete the debug intrinsics.
595  auto RemoveUses = [&](StringRef Name) {
596  if (auto *DbgVal = M.getFunction(Name)) {
597  while (!DbgVal->use_empty())
598  cast<Instruction>(DbgVal->user_back())->eraseFromParent();
599  DbgVal->eraseFromParent();
600  Changed = true;
601  }
602  };
603  RemoveUses("llvm.dbg.declare");
604  RemoveUses("llvm.dbg.value");
605 
606  // Delete non-CU debug info named metadata nodes.
607  for (auto NMI = M.named_metadata_begin(), NME = M.named_metadata_end();
608  NMI != NME;) {
609  NamedMDNode *NMD = &*NMI;
610  ++NMI;
611  // Specifically keep dbg.cu around.
612  if (NMD->getName() == "llvm.dbg.cu")
613  continue;
614  }
615 
616  // Drop all dbg attachments from global variables.
617  for (auto &GV : M.globals())
618  GV.eraseMetadata(LLVMContext::MD_dbg);
619 
620  DebugTypeInfoRemoval Mapper(M.getContext());
621  auto remap = [&](MDNode *Node) -> MDNode * {
622  if (!Node)
623  return nullptr;
624  Mapper.traverseAndRemap(Node);
625  auto *NewNode = Mapper.mapNode(Node);
626  Changed |= Node != NewNode;
627  Node = NewNode;
628  return NewNode;
629  };
630 
631  // Rewrite the DebugLocs to be equivalent to what
632  // -gline-tables-only would have created.
633  for (auto &F : M) {
634  if (auto *SP = F.getSubprogram()) {
635  Mapper.traverseAndRemap(SP);
636  auto *NewSP = cast<DISubprogram>(Mapper.mapNode(SP));
637  Changed |= SP != NewSP;
638  F.setSubprogram(NewSP);
639  }
640  for (auto &BB : F) {
641  for (auto &I : BB) {
642  auto remapDebugLoc = [&](DebugLoc DL) -> DebugLoc {
643  auto *Scope = DL.getScope();
644  MDNode *InlinedAt = DL.getInlinedAt();
645  Scope = remap(Scope);
646  InlinedAt = remap(InlinedAt);
647  return DebugLoc::get(DL.getLine(), DL.getCol(), Scope, InlinedAt);
648  };
649 
650  if (I.getDebugLoc() != DebugLoc())
651  I.setDebugLoc(remapDebugLoc(I.getDebugLoc()));
652 
653  // Remap DILocations in untyped MDNodes (e.g., llvm.loop).
655  I.getAllMetadata(MDs);
656  for (auto Attachment : MDs)
657  if (auto *T = dyn_cast_or_null<MDTuple>(Attachment.second))
658  for (unsigned N = 0; N < T->getNumOperands(); ++N)
659  if (auto *Loc = dyn_cast_or_null<DILocation>(T->getOperand(N)))
660  if (Loc != DebugLoc())
661  T->replaceOperandWith(N, remapDebugLoc(Loc));
662  }
663  }
664  }
665 
666  // Create a new llvm.dbg.cu, which is equivalent to the one
667  // -gline-tables-only would have created.
668  for (auto &NMD : M.getNamedMDList()) {
670  for (MDNode *Op : NMD.operands())
671  Ops.push_back(remap(Op));
672 
673  if (!Changed)
674  continue;
675 
676  NMD.clearOperands();
677  for (auto *Op : Ops)
678  if (Op)
679  NMD.addOperand(Op);
680  }
681  return Changed;
682 }
683 
685  if (auto *Val = mdconst::dyn_extract_or_null<ConstantInt>(
686  M.getModuleFlag("Debug Info Version")))
687  return Val->getZExtValue();
688  return 0;
689 }
690 
692  const DILocation *LocB) {
693  setDebugLoc(DILocation::getMergedLocation(LocA, LocB));
694 }
695 
696 //===----------------------------------------------------------------------===//
697 // LLVM C API implementations.
698 //===----------------------------------------------------------------------===//
699 
701  switch (lang) {
702 #define HANDLE_DW_LANG(ID, NAME, VERSION, VENDOR) \
703 case LLVMDWARFSourceLanguage##NAME: return ID;
704 #include "llvm/BinaryFormat/Dwarf.def"
705 #undef HANDLE_DW_LANG
706  }
707  llvm_unreachable("Unhandled Tag");
708 }
709 
710 template <typename DIT> DIT *unwrapDI(LLVMMetadataRef Ref) {
711  return (DIT *)(Ref ? unwrap<MDNode>(Ref) : nullptr);
712 }
713 
715  return static_cast<DINode::DIFlags>(Flags);
716 }
717 
719  return static_cast<LLVMDIFlags>(Flags);
720 }
721 
723  return DEBUG_METADATA_VERSION;
724 }
725 
727  return wrap(new DIBuilder(*unwrap(M), false));
728 }
729 
731  return wrap(new DIBuilder(*unwrap(M)));
732 }
733 
736 }
737 
739  return StripDebugInfo(*unwrap(M));
740 }
741 
743  delete unwrap(Builder);
744 }
745 
747  unwrap(Builder)->finalize();
748 }
749 
752  LLVMMetadataRef FileRef, const char *Producer, size_t ProducerLen,
753  LLVMBool isOptimized, const char *Flags, size_t FlagsLen,
754  unsigned RuntimeVer, const char *SplitName, size_t SplitNameLen,
755  LLVMDWARFEmissionKind Kind, unsigned DWOId, LLVMBool SplitDebugInlining,
756  LLVMBool DebugInfoForProfiling) {
757  auto File = unwrapDI<DIFile>(FileRef);
758 
759  return wrap(unwrap(Builder)->createCompileUnit(
761  StringRef(Producer, ProducerLen), isOptimized,
762  StringRef(Flags, FlagsLen), RuntimeVer,
763  StringRef(SplitName, SplitNameLen),
764  static_cast<DICompileUnit::DebugEmissionKind>(Kind), DWOId,
765  SplitDebugInlining, DebugInfoForProfiling));
766 }
767 
769 LLVMDIBuilderCreateFile(LLVMDIBuilderRef Builder, const char *Filename,
770  size_t FilenameLen, const char *Directory,
771  size_t DirectoryLen) {
772  return wrap(unwrap(Builder)->createFile(StringRef(Filename, FilenameLen),
773  StringRef(Directory, DirectoryLen)));
774 }
775 
778  const char *Name, size_t NameLen,
779  const char *ConfigMacros, size_t ConfigMacrosLen,
780  const char *IncludePath, size_t IncludePathLen,
781  const char *ISysRoot, size_t ISysRootLen) {
782  return wrap(unwrap(Builder)->createModule(
783  unwrapDI<DIScope>(ParentScope), StringRef(Name, NameLen),
784  StringRef(ConfigMacros, ConfigMacrosLen),
785  StringRef(IncludePath, IncludePathLen),
786  StringRef(ISysRoot, ISysRootLen)));
787 }
788 
790  LLVMMetadataRef ParentScope,
791  const char *Name, size_t NameLen,
792  LLVMBool ExportSymbols) {
793  return wrap(unwrap(Builder)->createNameSpace(
794  unwrapDI<DIScope>(ParentScope), StringRef(Name, NameLen), ExportSymbols));
795 }
796 
798  LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
799  size_t NameLen, const char *LinkageName, size_t LinkageNameLen,
800  LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty,
801  LLVMBool IsLocalToUnit, LLVMBool IsDefinition,
802  unsigned ScopeLine, LLVMDIFlags Flags, LLVMBool IsOptimized) {
803  return wrap(unwrap(Builder)->createFunction(
804  unwrapDI<DIScope>(Scope), {Name, NameLen}, {LinkageName, LinkageNameLen},
805  unwrapDI<DIFile>(File), LineNo, unwrapDI<DISubroutineType>(Ty),
806  IsLocalToUnit, IsDefinition, ScopeLine, map_from_llvmDIFlags(Flags),
807  IsOptimized, nullptr, nullptr, nullptr));
808 }
809 
810 
812  LLVMDIBuilderRef Builder, LLVMMetadataRef Scope,
813  LLVMMetadataRef File, unsigned Line, unsigned Col) {
814  return wrap(unwrap(Builder)->createLexicalBlock(unwrapDI<DIScope>(Scope),
815  unwrapDI<DIFile>(File),
816  Line, Col));
817 }
818 
821  LLVMMetadataRef Scope,
823  unsigned Discriminator) {
824  return wrap(unwrap(Builder)->createLexicalBlockFile(unwrapDI<DIScope>(Scope),
825  unwrapDI<DIFile>(File),
826  Discriminator));
827 }
828 
831  LLVMMetadataRef Scope,
832  LLVMMetadataRef NS,
834  unsigned Line) {
835  return wrap(unwrap(Builder)->createImportedModule(unwrapDI<DIScope>(Scope),
836  unwrapDI<DINamespace>(NS),
837  unwrapDI<DIFile>(File),
838  Line));
839 }
840 
843  LLVMMetadataRef Scope,
844  LLVMMetadataRef ImportedEntity,
846  unsigned Line) {
847  return wrap(unwrap(Builder)->createImportedModule(
848  unwrapDI<DIScope>(Scope),
849  unwrapDI<DIImportedEntity>(ImportedEntity),
850  unwrapDI<DIFile>(File), Line));
851 }
852 
855  LLVMMetadataRef Scope,
856  LLVMMetadataRef M,
858  unsigned Line) {
859  return wrap(unwrap(Builder)->createImportedModule(unwrapDI<DIScope>(Scope),
860  unwrapDI<DIModule>(M),
861  unwrapDI<DIFile>(File),
862  Line));
863 }
864 
867  LLVMMetadataRef Scope,
868  LLVMMetadataRef Decl,
870  unsigned Line,
871  const char *Name, size_t NameLen) {
872  return wrap(unwrap(Builder)->createImportedDeclaration(
873  unwrapDI<DIScope>(Scope),
874  unwrapDI<DINode>(Decl),
875  unwrapDI<DIFile>(File), Line, {Name, NameLen}));
876 }
877 
880  unsigned Column, LLVMMetadataRef Scope,
881  LLVMMetadataRef InlinedAt) {
882  return wrap(DILocation::get(*unwrap(Ctx), Line, Column, unwrap(Scope),
883  unwrap(InlinedAt)));
884 }
885 
887  return unwrapDI<DILocation>(Location)->getLine();
888 }
889 
891  return unwrapDI<DILocation>(Location)->getColumn();
892 }
893 
895  return wrap(unwrapDI<DILocation>(Location)->getScope());
896 }
897 
899  LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
900  size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
901  uint64_t SizeInBits, uint32_t AlignInBits, LLVMMetadataRef *Elements,
902  unsigned NumElements, LLVMMetadataRef ClassTy) {
903 auto Elts = unwrap(Builder)->getOrCreateArray({unwrap(Elements),
904  NumElements});
905 return wrap(unwrap(Builder)->createEnumerationType(
906  unwrapDI<DIScope>(Scope), {Name, NameLen}, unwrapDI<DIFile>(File),
907  LineNumber, SizeInBits, AlignInBits, Elts, unwrapDI<DIType>(ClassTy)));
908 }
909 
911  LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
912  size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
913  uint64_t SizeInBits, uint32_t AlignInBits, LLVMDIFlags Flags,
914  LLVMMetadataRef *Elements, unsigned NumElements, unsigned RunTimeLang,
915  const char *UniqueId, size_t UniqueIdLen) {
916  auto Elts = unwrap(Builder)->getOrCreateArray({unwrap(Elements),
917  NumElements});
918  return wrap(unwrap(Builder)->createUnionType(
919  unwrapDI<DIScope>(Scope), {Name, NameLen}, unwrapDI<DIFile>(File),
920  LineNumber, SizeInBits, AlignInBits, map_from_llvmDIFlags(Flags),
921  Elts, RunTimeLang, {UniqueId, UniqueIdLen}));
922 }
923 
924 
927  uint32_t AlignInBits, LLVMMetadataRef Ty,
928  LLVMMetadataRef *Subscripts,
929  unsigned NumSubscripts) {
930  auto Subs = unwrap(Builder)->getOrCreateArray({unwrap(Subscripts),
931  NumSubscripts});
932  return wrap(unwrap(Builder)->createArrayType(Size, AlignInBits,
933  unwrapDI<DIType>(Ty), Subs));
934 }
935 
938  uint32_t AlignInBits, LLVMMetadataRef Ty,
939  LLVMMetadataRef *Subscripts,
940  unsigned NumSubscripts) {
941  auto Subs = unwrap(Builder)->getOrCreateArray({unwrap(Subscripts),
942  NumSubscripts});
943  return wrap(unwrap(Builder)->createVectorType(Size, AlignInBits,
944  unwrapDI<DIType>(Ty), Subs));
945 }
946 
949  size_t NameLen, uint64_t SizeInBits,
950  LLVMDWARFTypeEncoding Encoding,
951  LLVMDIFlags Flags) {
952  return wrap(unwrap(Builder)->createBasicType({Name, NameLen},
953  SizeInBits, Encoding,
954  map_from_llvmDIFlags(Flags)));
955 }
956 
958  LLVMDIBuilderRef Builder, LLVMMetadataRef PointeeTy,
959  uint64_t SizeInBits, uint32_t AlignInBits, unsigned AddressSpace,
960  const char *Name, size_t NameLen) {
961  return wrap(unwrap(Builder)->createPointerType(unwrapDI<DIType>(PointeeTy),
962  SizeInBits, AlignInBits,
963  AddressSpace, {Name, NameLen}));
964 }
965 
967  LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
968  size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
969  uint64_t SizeInBits, uint32_t AlignInBits, LLVMDIFlags Flags,
970  LLVMMetadataRef DerivedFrom, LLVMMetadataRef *Elements,
971  unsigned NumElements, unsigned RunTimeLang, LLVMMetadataRef VTableHolder,
972  const char *UniqueId, size_t UniqueIdLen) {
973  auto Elts = unwrap(Builder)->getOrCreateArray({unwrap(Elements),
974  NumElements});
975  return wrap(unwrap(Builder)->createStructType(
976  unwrapDI<DIScope>(Scope), {Name, NameLen}, unwrapDI<DIFile>(File),
977  LineNumber, SizeInBits, AlignInBits, map_from_llvmDIFlags(Flags),
978  unwrapDI<DIType>(DerivedFrom), Elts, RunTimeLang,
979  unwrapDI<DIType>(VTableHolder), {UniqueId, UniqueIdLen}));
980 }
981 
983  LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
984  size_t NameLen, LLVMMetadataRef File, unsigned LineNo, uint64_t SizeInBits,
985  uint32_t AlignInBits, uint64_t OffsetInBits, LLVMDIFlags Flags,
986  LLVMMetadataRef Ty) {
987  return wrap(unwrap(Builder)->createMemberType(unwrapDI<DIScope>(Scope),
988  {Name, NameLen}, unwrapDI<DIFile>(File), LineNo, SizeInBits, AlignInBits,
989  OffsetInBits, map_from_llvmDIFlags(Flags), unwrapDI<DIType>(Ty)));
990 }
991 
994  size_t NameLen) {
995  return wrap(unwrap(Builder)->createUnspecifiedType({Name, NameLen}));
996 }
997 
1000  LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
1001  size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
1002  LLVMMetadataRef Type, LLVMDIFlags Flags, LLVMValueRef ConstantVal,
1003  uint32_t AlignInBits) {
1004  return wrap(unwrap(Builder)->createStaticMemberType(
1005  unwrapDI<DIScope>(Scope), {Name, NameLen},
1006  unwrapDI<DIFile>(File), LineNumber, unwrapDI<DIType>(Type),
1007  map_from_llvmDIFlags(Flags), unwrap<Constant>(ConstantVal),
1008  AlignInBits));
1009 }
1010 
1013  const char *Name, size_t NameLen,
1014  LLVMMetadataRef File, unsigned LineNo,
1015  uint64_t SizeInBits, uint32_t AlignInBits,
1016  uint64_t OffsetInBits, LLVMDIFlags Flags,
1017  LLVMMetadataRef Ty, LLVMMetadataRef PropertyNode) {
1018  return wrap(unwrap(Builder)->createObjCIVar(
1019  {Name, NameLen}, unwrapDI<DIFile>(File), LineNo,
1020  SizeInBits, AlignInBits, OffsetInBits,
1021  map_from_llvmDIFlags(Flags), unwrapDI<DIType>(Ty),
1022  unwrapDI<MDNode>(PropertyNode)));
1023 }
1024 
1027  const char *Name, size_t NameLen,
1028  LLVMMetadataRef File, unsigned LineNo,
1029  const char *GetterName, size_t GetterNameLen,
1030  const char *SetterName, size_t SetterNameLen,
1031  unsigned PropertyAttributes,
1032  LLVMMetadataRef Ty) {
1033  return wrap(unwrap(Builder)->createObjCProperty(
1034  {Name, NameLen}, unwrapDI<DIFile>(File), LineNo,
1035  {GetterName, GetterNameLen}, {SetterName, SetterNameLen},
1036  PropertyAttributes, unwrapDI<DIType>(Ty)));
1037 }
1038 
1042  return wrap(unwrap(Builder)->createObjectPointerType(unwrapDI<DIType>(Type)));
1043 }
1044 
1047  const char *Name, size_t NameLen,
1048  LLVMMetadataRef File, unsigned LineNo,
1049  LLVMMetadataRef Scope) {
1050  return wrap(unwrap(Builder)->createTypedef(
1051  unwrapDI<DIType>(Type), {Name, NameLen},
1052  unwrapDI<DIFile>(File), LineNo,
1053  unwrapDI<DIScope>(Scope)));
1054 }
1055 
1058  LLVMMetadataRef Ty, LLVMMetadataRef BaseTy,
1059  uint64_t BaseOffset, uint32_t VBPtrOffset,
1060  LLVMDIFlags Flags) {
1061  return wrap(unwrap(Builder)->createInheritance(
1062  unwrapDI<DIType>(Ty), unwrapDI<DIType>(BaseTy),
1063  BaseOffset, VBPtrOffset, map_from_llvmDIFlags(Flags)));
1064 }
1065 
1068  LLVMDIBuilderRef Builder, unsigned Tag, const char *Name,
1069  size_t NameLen, LLVMMetadataRef Scope, LLVMMetadataRef File, unsigned Line,
1070  unsigned RuntimeLang, uint64_t SizeInBits, uint32_t AlignInBits,
1071  const char *UniqueIdentifier, size_t UniqueIdentifierLen) {
1072  return wrap(unwrap(Builder)->createForwardDecl(
1073  Tag, {Name, NameLen}, unwrapDI<DIScope>(Scope),
1074  unwrapDI<DIFile>(File), Line, RuntimeLang, SizeInBits,
1075  AlignInBits, {UniqueIdentifier, UniqueIdentifierLen}));
1076 }
1077 
1080  LLVMDIBuilderRef Builder, unsigned Tag, const char *Name,
1081  size_t NameLen, LLVMMetadataRef Scope, LLVMMetadataRef File, unsigned Line,
1082  unsigned RuntimeLang, uint64_t SizeInBits, uint32_t AlignInBits,
1083  LLVMDIFlags Flags, const char *UniqueIdentifier,
1084  size_t UniqueIdentifierLen) {
1085  return wrap(unwrap(Builder)->createReplaceableCompositeType(
1086  Tag, {Name, NameLen}, unwrapDI<DIScope>(Scope),
1087  unwrapDI<DIFile>(File), Line, RuntimeLang, SizeInBits,
1088  AlignInBits, map_from_llvmDIFlags(Flags),
1089  {UniqueIdentifier, UniqueIdentifierLen}));
1090 }
1091 
1095  return wrap(unwrap(Builder)->createQualifiedType(Tag,
1096  unwrapDI<DIType>(Type)));
1097 }
1098 
1102  return wrap(unwrap(Builder)->createReferenceType(Tag,
1103  unwrapDI<DIType>(Type)));
1104 }
1105 
1108  return wrap(unwrap(Builder)->createNullPtrType());
1109 }
1110 
1113  LLVMMetadataRef PointeeType,
1114  LLVMMetadataRef ClassType,
1115  uint64_t SizeInBits,
1116  uint32_t AlignInBits,
1117  LLVMDIFlags Flags) {
1118  return wrap(unwrap(Builder)->createMemberPointerType(
1119  unwrapDI<DIType>(PointeeType),
1120  unwrapDI<DIType>(ClassType), AlignInBits, SizeInBits,
1121  map_from_llvmDIFlags(Flags)));
1122 }
1123 
1126  LLVMMetadataRef Scope,
1127  const char *Name, size_t NameLen,
1128  LLVMMetadataRef File, unsigned LineNumber,
1129  uint64_t SizeInBits,
1130  uint64_t OffsetInBits,
1131  uint64_t StorageOffsetInBits,
1132  LLVMDIFlags Flags, LLVMMetadataRef Type) {
1133  return wrap(unwrap(Builder)->createBitFieldMemberType(
1134  unwrapDI<DIScope>(Scope), {Name, NameLen},
1135  unwrapDI<DIFile>(File), LineNumber,
1136  SizeInBits, OffsetInBits, StorageOffsetInBits,
1137  map_from_llvmDIFlags(Flags), unwrapDI<DIType>(Type)));
1138 }
1139 
1141  LLVMMetadataRef Scope, const char *Name, size_t NameLen,
1142  LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits,
1143  uint32_t AlignInBits, uint64_t OffsetInBits, LLVMDIFlags Flags,
1144  LLVMMetadataRef DerivedFrom,
1145  LLVMMetadataRef *Elements, unsigned NumElements,
1146  LLVMMetadataRef VTableHolder, LLVMMetadataRef TemplateParamsNode,
1147  const char *UniqueIdentifier, size_t UniqueIdentifierLen) {
1148  auto Elts = unwrap(Builder)->getOrCreateArray({unwrap(Elements),
1149  NumElements});
1150  return wrap(unwrap(Builder)->createClassType(
1151  unwrapDI<DIScope>(Scope), {Name, NameLen},
1152  unwrapDI<DIFile>(File), LineNumber,
1153  SizeInBits, AlignInBits, OffsetInBits,
1154  map_from_llvmDIFlags(Flags), unwrapDI<DIType>(DerivedFrom),
1155  Elts, unwrapDI<DIType>(VTableHolder),
1156  unwrapDI<MDNode>(TemplateParamsNode),
1157  {UniqueIdentifier, UniqueIdentifierLen}));
1158 }
1159 
1163  return wrap(unwrap(Builder)->createArtificialType(unwrapDI<DIType>(Type)));
1164 }
1165 
1166 const char *LLVMDITypeGetName(LLVMMetadataRef DType, size_t *Length) {
1167  StringRef Str = unwrap<DIType>(DType)->getName();
1168  *Length = Str.size();
1169  return Str.data();
1170 }
1171 
1173  return unwrapDI<DIType>(DType)->getSizeInBits();
1174 }
1175 
1177  return unwrapDI<DIType>(DType)->getOffsetInBits();
1178 }
1179 
1181  return unwrapDI<DIType>(DType)->getAlignInBits();
1182 }
1183 
1185  return unwrapDI<DIType>(DType)->getLine();
1186 }
1187 
1189  return map_to_llvmDIFlags(unwrapDI<DIType>(DType)->getFlags());
1190 }
1191 
1193  LLVMMetadataRef *Types,
1194  size_t Length) {
1195  return wrap(
1196  unwrap(Builder)->getOrCreateTypeArray({unwrap(Types), Length}).get());
1197 }
1198 
1202  LLVMMetadataRef *ParameterTypes,
1203  unsigned NumParameterTypes,
1204  LLVMDIFlags Flags) {
1205  auto Elts = unwrap(Builder)->getOrCreateTypeArray({unwrap(ParameterTypes),
1206  NumParameterTypes});
1207  return wrap(unwrap(Builder)->createSubroutineType(
1208  Elts, map_from_llvmDIFlags(Flags)));
1209 }
1210 
1212  int64_t *Addr, size_t Length) {
1213  return wrap(unwrap(Builder)->createExpression(ArrayRef<int64_t>(Addr,
1214  Length)));
1215 }
1216 
1219  int64_t Value) {
1220  return wrap(unwrap(Builder)->createConstantValueExpression(Value));
1221 }
1222 
1225  LLVMMetadataRef Scope,
1226  const char *Name, size_t NameLen,
1227  const char *Linkage, size_t LinkLen,
1229  unsigned LineNo,
1230  LLVMMetadataRef Ty,
1231  LLVMBool LocalToUnit,
1232  LLVMMetadataRef Expr,
1233  LLVMMetadataRef Decl,
1234  uint32_t AlignInBits) {
1235  return wrap(unwrap(Builder)->createGlobalVariableExpression(
1236  unwrapDI<DIScope>(Scope), {Name, NameLen}, {Linkage, LinkLen},
1237  unwrapDI<DIFile>(File), LineNo, unwrapDI<DIType>(Ty),
1238  LocalToUnit, unwrap<DIExpression>(Expr),
1239  unwrapDI<MDNode>(Decl), AlignInBits));
1240 }
1241 
1243  size_t Count) {
1244  return wrap(
1245  MDTuple::getTemporary(*unwrap(Ctx), {unwrap(Data), Count}).release());
1246 }
1247 
1249  MDNode::deleteTemporary(unwrapDI<MDNode>(TempNode));
1250 }
1251 
1253  LLVMMetadataRef Replacement) {
1254  auto *Node = unwrapDI<MDNode>(TargetMetadata);
1255  Node->replaceAllUsesWith(unwrap<Metadata>(Replacement));
1257 }
1258 
1261  LLVMMetadataRef Scope,
1262  const char *Name, size_t NameLen,
1263  const char *Linkage, size_t LnkLen,
1265  unsigned LineNo,
1266  LLVMMetadataRef Ty,
1267  LLVMBool LocalToUnit,
1268  LLVMMetadataRef Decl,
1269  uint32_t AlignInBits) {
1270  return wrap(unwrap(Builder)->createTempGlobalVariableFwdDecl(
1271  unwrapDI<DIScope>(Scope), {Name, NameLen}, {Linkage, LnkLen},
1272  unwrapDI<DIFile>(File), LineNo, unwrapDI<DIType>(Ty),
1273  LocalToUnit, unwrapDI<MDNode>(Decl), AlignInBits));
1274 }
1275 
1277  LLVMDIBuilderRef Builder, LLVMValueRef Storage, LLVMMetadataRef VarInfo,
1278  LLVMMetadataRef Expr, LLVMMetadataRef DL, LLVMValueRef Instr) {
1279  return wrap(unwrap(Builder)->insertDeclare(
1280  unwrap(Storage), unwrap<DILocalVariable>(VarInfo),
1281  unwrap<DIExpression>(Expr), unwrap<DILocation>(DL),
1282  unwrap<Instruction>(Instr)));
1283 }
1284 
1286  LLVMDIBuilderRef Builder, LLVMValueRef Storage, LLVMMetadataRef VarInfo,
1288  return wrap(unwrap(Builder)->insertDeclare(
1289  unwrap(Storage), unwrap<DILocalVariable>(VarInfo),
1290  unwrap<DIExpression>(Expr), unwrap<DILocation>(DL),
1291  unwrap(Block)));
1292 }
1293 
1295  LLVMValueRef Val,
1296  LLVMMetadataRef VarInfo,
1297  LLVMMetadataRef Expr,
1299  LLVMValueRef Instr) {
1300  return wrap(unwrap(Builder)->insertDbgValueIntrinsic(
1301  unwrap(Val), unwrap<DILocalVariable>(VarInfo),
1302  unwrap<DIExpression>(Expr), unwrap<DILocation>(DebugLoc),
1303  unwrap<Instruction>(Instr)));
1304 }
1305 
1307  LLVMValueRef Val,
1308  LLVMMetadataRef VarInfo,
1309  LLVMMetadataRef Expr,
1311  LLVMBasicBlockRef Block) {
1312  return wrap(unwrap(Builder)->insertDbgValueIntrinsic(
1313  unwrap(Val), unwrap<DILocalVariable>(VarInfo),
1314  unwrap<DIExpression>(Expr), unwrap<DILocation>(DebugLoc),
1315  unwrap(Block)));
1316 }
1317 
1319  LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
1320  size_t NameLen, LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty,
1321  LLVMBool AlwaysPreserve, LLVMDIFlags Flags, uint32_t AlignInBits) {
1322  return wrap(unwrap(Builder)->createAutoVariable(
1323  unwrap<DIScope>(Scope), {Name, NameLen}, unwrap<DIFile>(File),
1324  LineNo, unwrap<DIType>(Ty), AlwaysPreserve,
1325  map_from_llvmDIFlags(Flags), AlignInBits));
1326 }
1327 
1329  LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
1330  size_t NameLen, unsigned ArgNo, LLVMMetadataRef File, unsigned LineNo,
1331  LLVMMetadataRef Ty, LLVMBool AlwaysPreserve, LLVMDIFlags Flags) {
1332  return wrap(unwrap(Builder)->createParameterVariable(
1333  unwrap<DIScope>(Scope), {Name, NameLen}, ArgNo, unwrap<DIFile>(File),
1334  LineNo, unwrap<DIType>(Ty), AlwaysPreserve,
1335  map_from_llvmDIFlags(Flags)));
1336 }
1337 
1339  int64_t Lo, int64_t Count) {
1340  return wrap(unwrap(Builder)->getOrCreateSubrange(Lo, Count));
1341 }
1342 
1344  LLVMMetadataRef *Data,
1345  size_t Length) {
1346  Metadata **DataValue = unwrap(Data);
1347  return wrap(unwrap(Builder)->getOrCreateArray({DataValue, Length}).get());
1348 }
1349 
1351  return wrap(unwrap<Function>(Func)->getSubprogram());
1352 }
1353 
1355  unwrap<Function>(Func)->setSubprogram(unwrap<DISubprogram>(SP));
1356 }
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:68
void processLocation(const Module &M, const DILocation *Loc)
Process debug info location.
Definition: DebugInfo.cpp:118
LLVMMetadataRef LLVMDIBuilderCreateUnspecifiedType(LLVMDIBuilderRef Builder, const char *Name, size_t NameLen)
Create a DWARF unspecified type.
Definition: DebugInfo.cpp:993
static void deleteTemporary(MDNode *N)
Deallocate a node created by getTemporary.
Definition: Metadata.cpp:831
Tracking metadata reference owned by Metadata.
Definition: Metadata.h:711
LLVMMetadataRef LLVMDIBuilderCreateUnionType(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name, size_t NameLen, LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits, uint32_t AlignInBits, LLVMDIFlags Flags, LLVMMetadataRef *Elements, unsigned NumElements, unsigned RunTimeLang, const char *UniqueId, size_t UniqueIdLen)
Create debugging information entry for a union.
Definition: DebugInfo.cpp:910
LLVMMetadataRef LLVMDIBuilderCreateObjectPointerType(LLVMDIBuilderRef Builder, LLVMMetadataRef Type)
Create a uniqued DIType* clone with FlagObjectPointer and FlagArtificial set.
Definition: DebugInfo.cpp:1040
bool isDistinct() const
Definition: Metadata.h:943
DILocation * get() const
Get the underlying DILocation.
Definition: DebugLoc.cpp:22
LLVMMetadataRef LLVMDIBuilderCreateTempGlobalVariableFwdDecl(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name, size_t NameLen, const char *Linkage, size_t LnkLen, LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty, LLVMBool LocalToUnit, LLVMMetadataRef Decl, uint32_t AlignInBits)
Create a new descriptor for the specified global variable that is temporary and meant to be RAUWed...
Definition: DebugInfo.cpp:1260
LLVMMetadataRef LLVMDIBuilderCreateArrayType(LLVMDIBuilderRef Builder, uint64_t Size, uint32_t AlignInBits, LLVMMetadataRef Ty, LLVMMetadataRef *Subscripts, unsigned NumSubscripts)
Create debugging information entry for an array.
Definition: DebugInfo.cpp:926
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
struct LLVMOpaqueModule * LLVMModuleRef
The top-level container for all other LLVM Intermediate Representation (IR) objects.
Definition: Types.h:62
unsigned getRuntimeVersion() const
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:64
LLVMMetadataRef LLVMDIBuilderGetOrCreateTypeArray(LLVMDIBuilderRef Builder, LLVMMetadataRef *Types, size_t Length)
Create a type array.
Definition: DebugInfo.cpp:1192
unsigned LLVMGetModuleDebugMetadataVersion(LLVMModuleRef M)
The version of debug metadata that&#39;s present in the provided Module.
Definition: DebugInfo.cpp:734
static const DILocation * getMergedLocation(const DILocation *LocA, const DILocation *LocB)
When two instructions are combined into a single instruction we also need to combine the original loc...
void replaceOperandWith(unsigned I, Metadata *New)
Replace a specific operand.
Definition: Metadata.cpp:859
void LLVMDisposeTemporaryMDNode(LLVMMetadataRef TempNode)
Deallocate a temporary node.
Definition: DebugInfo.cpp:1248
Implements a dense probed hash-table based set.
Definition: DenseSet.h:221
DIFile * getFile() const
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
Definition: StringRef.h:138
named_metadata_iterator named_metadata_end()
Definition: Module.h:702
static DINode::DIFlags map_from_llvmDIFlags(LLVMDIFlags Flags)
Definition: DebugInfo.cpp:714
This file contains the declarations for metadata subclasses.
LLVMMetadataRef LLVMDIBuilderCreateFunction(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name, size_t NameLen, const char *LinkageName, size_t LinkageNameLen, LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty, LLVMBool IsLocalToUnit, LLVMBool IsDefinition, unsigned ScopeLine, LLVMDIFlags Flags, LLVMBool IsOptimized)
Create a new descriptor for the specified subprogram.
Definition: DebugInfo.cpp:797
unsigned getDebugMetadataVersionFromModule(const Module &M)
Return Debug Info Metadata Version by checking module flags.
Definition: DebugInfo.cpp:684
DICompositeTypeArray getEnumTypes() const
void reset()
Clear all lists.
Definition: DebugInfo.cpp:54
LLVMMetadataRef LLVMDIBuilderCreateImportedModuleFromAlias(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, LLVMMetadataRef ImportedEntity, LLVMMetadataRef File, unsigned Line)
Create a descriptor for an imported module that aliases another imported entity descriptor.
Definition: DebugInfo.cpp:842
uint64_t getDWOId() const
struct LLVMOpaqueDIBuilder * LLVMDIBuilderRef
Represents an LLVM debug info builder.
Definition: Types.h:111
A debug info location.
Definition: DebugLoc.h:34
Metadata node.
Definition: Metadata.h:864
LLVMValueRef LLVMDIBuilderInsertDbgValueAtEnd(LLVMDIBuilderRef Builder, LLVMValueRef Val, LLVMMetadataRef VarInfo, LLVMMetadataRef Expr, LLVMMetadataRef DebugLoc, LLVMBasicBlockRef Block)
Insert a new llvm.dbg.value intrinsic call at the end of the given basic block.
Definition: DebugInfo.cpp:1306
F(f)
bool stripDebugInfo(Function &F)
Definition: DebugInfo.cpp:314
uint64_t LLVMDITypeGetOffsetInBits(LLVMMetadataRef DType)
Get the offset of this DIType in bits.
Definition: DebugInfo.cpp:1176
StringRef getProducer() const
void reserve(size_type N)
Definition: SmallVector.h:376
bool getDebugInfoForProfiling() const
LLVMMetadataRef LLVMDIBuilderCreateMemberType(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name, size_t NameLen, LLVMMetadataRef File, unsigned LineNo, uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits, LLVMDIFlags Flags, LLVMMetadataRef Ty)
Create debugging information entry for a member.
Definition: DebugInfo.cpp:982
op_iterator op_end() const
Definition: Metadata.h:1063
LLVMMetadataRef LLVMDIBuilderCreateBasicType(LLVMDIBuilderRef Builder, const char *Name, size_t NameLen, uint64_t SizeInBits, LLVMDWARFTypeEncoding Encoding, LLVMDIFlags Flags)
Create debugging information entry for a basic type.
Definition: DebugInfo.cpp:948
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:128
void processModule(const Module &M)
Process entire module and collect debug info anchors.
Definition: DebugInfo.cpp:63
Tuple of metadata.
Definition: Metadata.h:1106
static DIImportedEntity * createImportedModule(LLVMContext &C, dwarf::Tag Tag, DIScope *Context, Metadata *NS, DIFile *File, unsigned Line, StringRef Name, SmallVectorImpl< TrackingMDNodeRef > &AllImportedModules)
Definition: DIBuilder.cpp:163
LLVMMetadataRef LLVMDIBuilderCreateCompileUnit(LLVMDIBuilderRef Builder, LLVMDWARFSourceLanguage Lang, LLVMMetadataRef FileRef, const char *Producer, size_t ProducerLen, LLVMBool isOptimized, const char *Flags, size_t FlagsLen, unsigned RuntimeVer, const char *SplitName, size_t SplitNameLen, LLVMDWARFEmissionKind Kind, unsigned DWOId, LLVMBool SplitDebugInlining, LLVMBool DebugInfoForProfiling)
A CompileUnit provides an anchor for all debugging information generated during this instance of comp...
Definition: DebugInfo.cpp:750
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Definition: DenseMap.h:191
unsigned LLVMDILocationGetColumn(LLVMMetadataRef Location)
Get the column number of this debug location.
Definition: DebugInfo.cpp:890
LLVMMetadataRef LLVMDIBuilderCreateObjCProperty(LLVMDIBuilderRef Builder, const char *Name, size_t NameLen, LLVMMetadataRef File, unsigned LineNo, const char *GetterName, size_t GetterNameLen, const char *SetterName, size_t SetterNameLen, unsigned PropertyAttributes, LLVMMetadataRef Ty)
Create debugging information entry for Objective-C property.
Definition: DebugInfo.cpp:1026
LLVMDWARFEmissionKind
The amount of debug information to emit.
Definition: DebugInfo.h:123
LLVMMetadataRef LLVMDIBuilderCreateClassType(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name, size_t NameLen, LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits, LLVMDIFlags Flags, LLVMMetadataRef DerivedFrom, LLVMMetadataRef *Elements, unsigned NumElements, LLVMMetadataRef VTableHolder, LLVMMetadataRef TemplateParamsNode, const char *UniqueIdentifier, size_t UniqueIdentifierLen)
Create debugging information entry for a class.
Definition: DebugInfo.cpp:1140
StringRef getSplitDebugFilename() const
A tuple of MDNodes.
Definition: Metadata.h:1326
StringRef getFlags() const
Attribute unwrap(LLVMAttributeRef Attr)
Definition: Attributes.h:195
LLVMMetadataRef LLVMDIBuilderCreateEnumerationType(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name, size_t NameLen, LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits, uint32_t AlignInBits, LLVMMetadataRef *Elements, unsigned NumElements, LLVMMetadataRef ClassTy)
Create debugging information entry for an enumeration.
Definition: DebugInfo.cpp:898
LLVMMetadataRef LLVMDIBuilderCreateParameterVariable(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name, size_t NameLen, unsigned ArgNo, LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty, LLVMBool AlwaysPreserve, LLVMDIFlags Flags)
Create a new descriptor for a function parameter variable.
Definition: DebugInfo.cpp:1328
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:243
void eraseFromParent()
Drop all references and remove the node from parent module.
Definition: Metadata.cpp:1094
LLVMMetadataRef LLVMDIBuilderCreateConstantValueExpression(LLVMDIBuilderRef Builder, int64_t Value)
Create a new descriptor for the specified variable that does not have an address, but does have a con...
Definition: DebugInfo.cpp:1218
The access may reference the value stored in memory.
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:1056
static StringRef getName(Value *V)
unsigned LLVMDILocationGetLine(LLVMMetadataRef Location)
Get the line number of this debug location.
Definition: DebugInfo.cpp:886
static TempMDTuple getTemporary(LLVMContext &Context, ArrayRef< Metadata *> MDs)
Definition: Metadata.h:1178
bool stripNonLineTableDebugInfo(Module &M)
Downgrade the debug info in a module to contain only line table information.
Definition: DebugInfo.cpp:591
Holds a subclass of DINode.
DISubprogram * getDISubprogram(const MDNode *Scope)
Find subprogram that is enclosing this scope.
Definition: DebugInfo.cpp:44
op_iterator op_begin() const
Definition: Metadata.h:1059
static Optional< DebugNameTableKind > getNameTableKind(StringRef Str)
LLVMMetadataRef LLVMDIBuilderCreateBitFieldMemberType(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name, size_t NameLen, LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits, uint64_t OffsetInBits, uint64_t StorageOffsetInBits, LLVMDIFlags Flags, LLVMMetadataRef Type)
Create debugging information entry for a bit field member.
Definition: DebugInfo.cpp:1125
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
LLVMMetadataRef LLVMDIBuilderCreateNameSpace(LLVMDIBuilderRef Builder, LLVMMetadataRef ParentScope, const char *Name, size_t NameLen, LLVMBool ExportSymbols)
Creates a new descriptor for a namespace with the specified parent scope.
Definition: DebugInfo.cpp:789
LLVMDIBuilderRef LLVMCreateDIBuilder(LLVMModuleRef M)
Construct a builder for a module and collect unresolved nodes attached to the module in order to reso...
Definition: DebugInfo.cpp:730
LLVMMetadataRef LLVMDIBuilderCreateReferenceType(LLVMDIBuilderRef Builder, unsigned Tag, LLVMMetadataRef Type)
Create debugging information entry for a c++ style reference or rvalue reference type.
Definition: DebugInfo.cpp:1100
op_range operands() const
Definition: Metadata.h:1067
LLVMContext & getContext() const
Definition: Metadata.h:924
struct LLVMOpaqueContext * LLVMContextRef
The top-level container for all LLVM global data.
Definition: Types.h:54
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:351
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
LLVMMetadataRef LLVMDIBuilderCreateArtificialType(LLVMDIBuilderRef Builder, LLVMMetadataRef Type)
Create a uniqued DIType* clone with FlagArtificial set.
Definition: DebugInfo.cpp:1161
Debug location.
LLVMMetadataRef LLVMDIBuilderCreatePointerType(LLVMDIBuilderRef Builder, LLVMMetadataRef PointeeTy, uint64_t SizeInBits, uint32_t AlignInBits, unsigned AddressSpace, const char *Name, size_t NameLen)
Create debugging information entry for a pointer.
Definition: DebugInfo.cpp:957
LLVMDIBuilderRef LLVMCreateDIBuilderDisallowUnresolved(LLVMModuleRef M)
Construct a builder for a module, and do not allow for unresolved nodes attached to the module...
Definition: DebugInfo.cpp:726
DIMacroNodeArray getMacros() const
static TempMDTuple getTemporary(LLVMContext &Context, ArrayRef< Metadata *> MDs)
Return a temporary node.
Definition: Metadata.h:1153
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata *> MDs)
Definition: Metadata.h:1166
void setSubprogram(DISubprogram *SP)
Set the attached subprogram.
Definition: Metadata.cpp:1504
LLVMDIFlags LLVMDITypeGetFlags(LLVMMetadataRef DType)
Get the flags associated with this DIType.
Definition: DebugInfo.cpp:1188
iterator_range< iterator > functions()
Definition: Module.h:596
void setDebugLoc(DebugLoc Loc)
Set the debug location information for this instruction.
Definition: Instruction.h:304
LLVMMetadataRef LLVMDIBuilderCreateDebugLocation(LLVMContextRef Ctx, unsigned Line, unsigned Column, LLVMMetadataRef Scope, LLVMMetadataRef InlinedAt)
Creates a new DebugLocation that describes a source location.
Definition: DebugInfo.cpp:879
LLVMValueRef LLVMDIBuilderInsertDeclareAtEnd(LLVMDIBuilderRef Builder, LLVMValueRef Storage, LLVMMetadataRef VarInfo, LLVMMetadataRef Expr, LLVMMetadataRef DL, LLVMBasicBlockRef Block)
Insert a new llvm.dbg.declare intrinsic call at the end of the given basic block. ...
Definition: DebugInfo.cpp:1285
LLVMMetadataRef LLVMDIBuilderCreateImportedModuleFromNamespace(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, LLVMMetadataRef NS, LLVMMetadataRef File, unsigned Line)
Create a descriptor for an imported namespace.
Definition: DebugInfo.cpp:830
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
Metadata * getModuleFlag(StringRef Key) const
Return the corresponding value if Key appears in module flags, otherwise return null.
Definition: Module.cpp:305
LLVMMetadataRef LLVMDIBuilderCreateReplaceableCompositeType(LLVMDIBuilderRef Builder, unsigned Tag, const char *Name, size_t NameLen, LLVMMetadataRef Scope, LLVMMetadataRef File, unsigned Line, unsigned RuntimeLang, uint64_t SizeInBits, uint32_t AlignInBits, LLVMDIFlags Flags, const char *UniqueIdentifier, size_t UniqueIdentifierLen)
Create a temporary forward-declared type.
Definition: DebugInfo.cpp:1079
static MDTuple * getDistinct(LLVMContext &Context, ArrayRef< Metadata *> MDs)
Definition: Metadata.h:1174
This file contains the declarations for the subclasses of Constant, which represent the different fla...
unsigned LLVMDebugMetadataVersion()
The current debug metadata version number.
Definition: DebugInfo.cpp:722
LLVMMetadataRef LLVMGetSubprogram(LLVMValueRef Func)
Get the metadata of the subprogram attached to a function.
Definition: DebugInfo.cpp:1350
LLVMMetadataRef LLVMDIBuilderCreateLexicalBlock(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, LLVMMetadataRef File, unsigned Line, unsigned Col)
Create a descriptor for a lexical block with the specified parent context.
Definition: DebugInfo.cpp:811
unsigned LLVMDITypeGetLine(LLVMMetadataRef DType)
Get the source line where this DIType is declared.
Definition: DebugInfo.cpp:1184
A pair of DIGlobalVariable and DIExpression.
DIImportedEntityArray getImportedEntities() const
LLVMDWARFSourceLanguage
Source languages known by DWARF.
Definition: DebugInfo.h:73
void processValue(const Module &M, const DbgValueInst *DVI)
Process DbgValueInst.
Definition: DebugInfo.cpp:214
LLVMMetadataRef LLVMDIBuilderGetOrCreateSubrange(LLVMDIBuilderRef Builder, int64_t Lo, int64_t Count)
Create a descriptor for a value range.
Definition: DebugInfo.cpp:1338
int LLVMBool
Definition: Types.h:29
static DISubprogram * getSubprogram(bool IsDistinct, Ts &&... Args)
Definition: DIBuilder.cpp:745
LLVMMetadataRef LLVMTemporaryMDNode(LLVMContextRef Ctx, LLVMMetadataRef *Data, size_t Count)
Create a new temporary MDNode.
Definition: DebugInfo.cpp:1242
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
LLVMValueRef LLVMDIBuilderInsertDeclareBefore(LLVMDIBuilderRef Builder, LLVMValueRef Storage, LLVMMetadataRef VarInfo, LLVMMetadataRef Expr, LLVMMetadataRef DL, LLVMValueRef Instr)
Insert a new llvm.dbg.declare intrinsic call before the given instruction.
Definition: DebugInfo.cpp:1276
void processInstruction(const Module &M, const Instruction &I)
Process a single instruction and collect debug info anchors.
Definition: DebugInfo.cpp:107
Base class for scope-like contexts.
void LLVMMetadataReplaceAllUsesWith(LLVMMetadataRef TargetMetadata, LLVMMetadataRef Replacement)
Replace all uses of temporary metadata.
Definition: DebugInfo.cpp:1252
LLVMMetadataRef LLVMDIBuilderCreateModule(LLVMDIBuilderRef Builder, LLVMMetadataRef ParentScope, const char *Name, size_t NameLen, const char *ConfigMacros, size_t ConfigMacrosLen, const char *IncludePath, size_t IncludePathLen, const char *ISysRoot, size_t ISysRootLen)
Creates a new descriptor for a module with the specified parent scope.
Definition: DebugInfo.cpp:777
LLVMMetadataRef LLVMDIBuilderCreateMemberPointerType(LLVMDIBuilderRef Builder, LLVMMetadataRef PointeeType, LLVMMetadataRef ClassType, uint64_t SizeInBits, uint32_t AlignInBits, LLVMDIFlags Flags)
Create debugging information entry for a pointer to member.
Definition: DebugInfo.cpp:1112
LLVMMetadataRef LLVMDIBuilderCreateNullPtrType(LLVMDIBuilderRef Builder)
Create C++11 nullptr type.
Definition: DebugInfo.cpp:1107
DIT * unwrapDI(LLVMMetadataRef Ref)
Definition: DebugInfo.cpp:710
Iterator for intrusive lists based on ilist_node.
LLVMMetadataRef LLVMDIBuilderCreateFile(LLVMDIBuilderRef Builder, const char *Filename, size_t FilenameLen, const char *Directory, size_t DirectoryLen)
Create a file descriptor to hold debugging information for a file.
Definition: DebugInfo.cpp:769
LLVMMetadataRef LLVMDIBuilderCreateImportedModuleFromModule(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, LLVMMetadataRef M, LLVMMetadataRef File, unsigned Line)
Create a descriptor for an imported module.
Definition: DebugInfo.cpp:854
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:847
Module.h This file contains the declarations for the Module class.
AddressSpace
Definition: NVPTXBaseInfo.h:22
LLVMValueRef LLVMDIBuilderInsertDbgValueBefore(LLVMDIBuilderRef Builder, LLVMValueRef Val, LLVMMetadataRef VarInfo, LLVMMetadataRef Expr, LLVMMetadataRef DebugLoc, LLVMValueRef Instr)
Insert a new llvm.dbg.value intrinsic call before the given instruction.
Definition: DebugInfo.cpp:1294
struct LLVMOpaqueBasicBlock * LLVMBasicBlockRef
Represents a basic block of instructions in LLVM IR.
Definition: Types.h:83
LLVMMetadataRef LLVMDIBuilderCreateAutoVariable(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name, size_t NameLen, LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty, LLVMBool AlwaysPreserve, LLVMDIFlags Flags, uint32_t AlignInBits)
Create a new descriptor for a local auto variable.
Definition: DebugInfo.cpp:1318
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
void applyMergedLocation(const DILocation *LocA, const DILocation *LocB)
Merge 2 debug locations and apply it to the Instruction.
Definition: DebugInfo.cpp:691
LLVMMetadataRef LLVMDILocationGetScope(LLVMMetadataRef Location)
Get the local scope associated with this debug location.
Definition: DebugInfo.cpp:894
LLVMMetadataRef LLVMDIBuilderGetOrCreateArray(LLVMDIBuilderRef Builder, LLVMMetadataRef *Data, size_t Length)
Create an array of DI Nodes.
Definition: DebugInfo.cpp:1343
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:175
unsigned getSourceLanguage() const
void LLVMDIBuilderFinalize(LLVMDIBuilderRef Builder)
Construct any deferred debug info descriptors.
Definition: DebugInfo.cpp:746
uint32_t LLVMDITypeGetAlignInBits(LLVMMetadataRef DType)
Get the alignment of this DIType in bits.
Definition: DebugInfo.cpp:1180
StringRef getName() const
Definition: Metadata.cpp:1098
DIGlobalVariableExpressionArray getGlobalVariables() const
LLVMMetadataRef LLVMDIBuilderCreateStructType(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name, size_t NameLen, LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits, uint32_t AlignInBits, LLVMDIFlags Flags, LLVMMetadataRef DerivedFrom, LLVMMetadataRef *Elements, unsigned NumElements, unsigned RunTimeLang, LLVMMetadataRef VTableHolder, const char *UniqueId, size_t UniqueIdLen)
Create debugging information entry for a struct.
Definition: DebugInfo.cpp:966
uint64_t LLVMDITypeGetSizeInBits(LLVMMetadataRef DType)
Get the size of this DIType in bits.
Definition: DebugInfo.cpp:1172
bool getSplitDebugInlining() const
DIFlags
Debug info flags.
static LLVMDIFlags map_to_llvmDIFlags(DINode::DIFlags Flags)
Definition: DebugInfo.cpp:718
const DebugLoc & getDebugLoc() const
Return the debug location for this node as a DebugLoc.
Definition: Instruction.h:307
LLVMAttributeRef wrap(Attribute Attr)
Definition: Attributes.h:190
LLVMMetadataRef LLVMDIBuilderCreateSubroutineType(LLVMDIBuilderRef Builder, LLVMMetadataRef File, LLVMMetadataRef *ParameterTypes, unsigned NumParameterTypes, LLVMDIFlags Flags)
Create subroutine type.
Definition: DebugInfo.cpp:1200
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:56
void LLVMDisposeDIBuilder(LLVMDIBuilderRef Builder)
Deallocates the DIBuilder and everything it owns.
Definition: DebugInfo.cpp:742
This represents the llvm.dbg.value instruction.
void processDeclare(const Module &M, const DbgDeclareInst *DDI)
Process DbgDeclareInst.
Definition: DebugInfo.cpp:198
void LLVMSetSubprogram(LLVMValueRef Func, LLVMMetadataRef SP)
Set the subprogram attached to a function.
Definition: DebugInfo.cpp:1354
#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:768
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
uint32_t Size
Definition: Profile.cpp:47
static unsigned map_from_llvmDWARFsourcelanguage(LLVMDWARFSourceLanguage lang)
Definition: DebugInfo.cpp:700
DILocalVariable * getVariable() const
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
LLVMBool LLVMStripModuleDebugInfo(LLVMModuleRef M)
Strip debug info in the module if it exists.
Definition: DebugInfo.cpp:738
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
LLVMMetadataRef LLVMDIBuilderCreateStaticMemberType(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name, size_t NameLen, LLVMMetadataRef File, unsigned LineNumber, LLVMMetadataRef Type, LLVMDIFlags Flags, LLVMValueRef ConstantVal, uint32_t AlignInBits)
Create debugging information entry for a C++ static data member.
Definition: DebugInfo.cpp:999
LLVMMetadataRef LLVMDIBuilderCreateGlobalVariableExpression(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name, size_t NameLen, const char *Linkage, size_t LinkLen, LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty, LLVMBool LocalToUnit, LLVMMetadataRef Expr, LLVMMetadataRef Decl, uint32_t AlignInBits)
Create a new descriptor for the specified variable.
Definition: DebugInfo.cpp:1224
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
LLVMDIFlags
This file declares the C API endpoints for generating DWARF Debug Info.
Definition: DebugInfo.h:29
LLVMMetadataRef LLVMDIBuilderCreateInheritance(LLVMDIBuilderRef Builder, LLVMMetadataRef Ty, LLVMMetadataRef BaseTy, uint64_t BaseOffset, uint32_t VBPtrOffset, LLVMDIFlags Flags)
Create debugging information entry to establish inheritance relationship between two types...
Definition: DebugInfo.cpp:1057
DIScopeArray getRetainedTypes() const
const unsigned Kind
LLVMMetadataRef LLVMDIBuilderCreateLexicalBlockFile(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, LLVMMetadataRef File, unsigned Discriminator)
Create a descriptor for a lexical block with a new file attached.
Definition: DebugInfo.cpp:820
struct LLVMOpaqueMetadata * LLVMMetadataRef
Represents an LLVM Metadata.
Definition: Types.h:90
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static MDNode * stripDebugLocFromLoopID(MDNode *N)
Definition: DebugInfo.cpp:282
LLVMMetadataRef LLVMDIBuilderCreateExpression(LLVMDIBuilderRef Builder, int64_t *Addr, size_t Length)
Create a new descriptor for the specified variable which has a complex address expression for its add...
Definition: DebugInfo.cpp:1211
LLVM Value Representation.
Definition: Value.h:73
DIScopeRef getScope() const
unsigned getSizeInBits(unsigned Reg, const MachineRegisterInfo &MRI, const TargetRegisterInfo &TRI) const
Get the size in bits of Reg.
bool hasMetadata() const
Check if this has any metadata.
Definition: GlobalObject.h:106
LLVMMetadataRef LLVMDIBuilderCreateObjCIVar(LLVMDIBuilderRef Builder, const char *Name, size_t NameLen, LLVMMetadataRef File, unsigned LineNo, uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits, LLVMDIFlags Flags, LLVMMetadataRef Ty, LLVMMetadataRef PropertyNode)
Create debugging information entry for Objective-C instance variable.
Definition: DebugInfo.cpp:1012
iterator_range< global_iterator > globals()
Definition: Module.h:574
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
LLVMMetadataRef LLVMDIBuilderCreateForwardDecl(LLVMDIBuilderRef Builder, unsigned Tag, const char *Name, size_t NameLen, LLVMMetadataRef Scope, LLVMMetadataRef File, unsigned Line, unsigned RuntimeLang, uint64_t SizeInBits, uint32_t AlignInBits, const char *UniqueIdentifier, size_t UniqueIdentifierLen)
Create a permanent forward-declared type.
Definition: DebugInfo.cpp:1067
LLVMMetadataRef LLVMDIBuilderCreateTypedef(LLVMDIBuilderRef Builder, LLVMMetadataRef Type, const char *Name, size_t NameLen, LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Scope)
Create debugging information entry for a typedef.
Definition: DebugInfo.cpp:1046
unsigned getNumOperands() const
Return number of MDNode operands.
Definition: Metadata.h:1075
const char * LLVMDITypeGetName(LLVMMetadataRef DType, size_t *Length)
Get the name of this DIType.
Definition: DebugInfo.cpp:1166
LLVMMetadataRef LLVMDIBuilderCreateVectorType(LLVMDIBuilderRef Builder, uint64_t Size, uint32_t AlignInBits, LLVMMetadataRef Ty, LLVMMetadataRef *Subscripts, unsigned NumSubscripts)
Create debugging information entry for a vector type.
Definition: DebugInfo.cpp:937
This represents the llvm.dbg.declare instruction.
Root of the metadata hierarchy.
Definition: Metadata.h:58
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
LLVMMetadataRef LLVMDIBuilderCreateQualifiedType(LLVMDIBuilderRef Builder, unsigned Tag, LLVMMetadataRef Type)
Create debugging information entry for a qualified type, e.g.
Definition: DebugInfo.cpp:1093
struct LLVMOpaqueValue * LLVMValueRef
Represents an individual value in LLVM IR.
Definition: Types.h:76
named_metadata_iterator named_metadata_begin()
Definition: Module.h:697
LLVMMetadataRef LLVMDIBuilderCreateImportedDeclaration(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, LLVMMetadataRef Decl, LLVMMetadataRef File, unsigned Line, const char *Name, size_t NameLen)
Create a descriptor for an imported function, type, or variable.
Definition: DebugInfo.cpp:866
DIScopeRef getScope() const