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