LLVM  13.0.0git
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 
43 /// Finds all intrinsics declaring local variables as living in the memory that
44 /// 'V' points to. This may include a mix of dbg.declare and
45 /// dbg.addr intrinsics.
47  // This function is hot. Check whether the value has any metadata to avoid a
48  // DenseMap lookup.
49  if (!V->isUsedByMetadata())
50  return {};
51  auto *L = LocalAsMetadata::getIfExists(V);
52  if (!L)
53  return {};
54  auto *MDV = MetadataAsValue::getIfExists(V->getContext(), L);
55  if (!MDV)
56  return {};
57 
59  for (User *U : MDV->users()) {
60  if (auto *DII = dyn_cast<DbgVariableIntrinsic>(U))
61  if (DII->isAddressOfVariable())
62  Declares.push_back(DII);
63  }
64 
65  return Declares;
66 }
67 
71  if (auto *DDI = dyn_cast<DbgDeclareInst>(DVI))
72  DDIs.push_back(DDI);
73  return DDIs;
74 }
75 
77  // This function is hot. Check whether the value has any metadata to avoid a
78  // DenseMap lookup.
79  if (!V->isUsedByMetadata())
80  return;
81  // TODO: If this value appears multiple times in a DIArgList, we should still
82  // only add the owning DbgValueInst once; use this set to track ArgListUsers.
83  // This behaviour can be removed when we can automatically remove duplicates.
84  SmallPtrSet<DbgValueInst *, 4> EncounteredDbgValues;
85  if (auto *L = LocalAsMetadata::getIfExists(V)) {
86  if (auto *MDV = MetadataAsValue::getIfExists(V->getContext(), L)) {
87  for (User *U : MDV->users())
88  if (DbgValueInst *DVI = dyn_cast<DbgValueInst>(U))
89  DbgValues.push_back(DVI);
90  }
91  for (Metadata *AL : L->getAllArgListUsers()) {
92  if (auto *MDV = MetadataAsValue::getIfExists(V->getContext(), AL)) {
93  for (User *U : MDV->users())
94  if (DbgValueInst *DVI = dyn_cast<DbgValueInst>(U))
95  if (EncounteredDbgValues.insert(DVI).second)
96  DbgValues.push_back(DVI);
97  }
98  }
99  }
100 }
101 
103  Value *V) {
104  // This function is hot. Check whether the value has any metadata to avoid a
105  // DenseMap lookup.
106  if (!V->isUsedByMetadata())
107  return;
108  // TODO: If this value appears multiple times in a DIArgList, we should still
109  // only add the owning DbgValueInst once; use this set to track ArgListUsers.
110  // This behaviour can be removed when we can automatically remove duplicates.
111  SmallPtrSet<DbgVariableIntrinsic *, 4> EncounteredDbgValues;
112  if (auto *L = LocalAsMetadata::getIfExists(V)) {
113  if (auto *MDV = MetadataAsValue::getIfExists(V->getContext(), L)) {
114  for (User *U : MDV->users())
115  if (DbgVariableIntrinsic *DII = dyn_cast<DbgVariableIntrinsic>(U))
116  DbgUsers.push_back(DII);
117  }
118  for (Metadata *AL : L->getAllArgListUsers()) {
119  if (auto *MDV = MetadataAsValue::getIfExists(V->getContext(), AL)) {
120  for (User *U : MDV->users())
121  if (DbgVariableIntrinsic *DII = dyn_cast<DbgVariableIntrinsic>(U))
122  if (EncounteredDbgValues.insert(DII).second)
123  DbgUsers.push_back(DII);
124  }
125  }
126  }
127 }
128 
130  if (auto *LocalScope = dyn_cast_or_null<DILocalScope>(Scope))
131  return LocalScope->getSubprogram();
132  return nullptr;
133 }
134 
135 //===----------------------------------------------------------------------===//
136 // DebugInfoFinder implementations.
137 //===----------------------------------------------------------------------===//
138 
140  CUs.clear();
141  SPs.clear();
142  GVs.clear();
143  TYs.clear();
144  Scopes.clear();
145  NodesSeen.clear();
146 }
147 
149  for (auto *CU : M.debug_compile_units())
150  processCompileUnit(CU);
151  for (auto &F : M.functions()) {
152  if (auto *SP = cast_or_null<DISubprogram>(F.getSubprogram()))
153  processSubprogram(SP);
154  // There could be subprograms from inlined functions referenced from
155  // instructions only. Walk the function to find them.
156  for (const BasicBlock &BB : F)
157  for (const Instruction &I : BB)
158  processInstruction(M, I);
159  }
160 }
161 
162 void DebugInfoFinder::processCompileUnit(DICompileUnit *CU) {
163  if (!addCompileUnit(CU))
164  return;
165  for (auto DIG : CU->getGlobalVariables()) {
166  if (!addGlobalVariable(DIG))
167  continue;
168  auto *GV = DIG->getVariable();
169  processScope(GV->getScope());
170  processType(GV->getType());
171  }
172  for (auto *ET : CU->getEnumTypes())
173  processType(ET);
174  for (auto *RT : CU->getRetainedTypes())
175  if (auto *T = dyn_cast<DIType>(RT))
176  processType(T);
177  else
178  processSubprogram(cast<DISubprogram>(RT));
179  for (auto *Import : CU->getImportedEntities()) {
180  auto *Entity = Import->getEntity();
181  if (auto *T = dyn_cast<DIType>(Entity))
182  processType(T);
183  else if (auto *SP = dyn_cast<DISubprogram>(Entity))
184  processSubprogram(SP);
185  else if (auto *NS = dyn_cast<DINamespace>(Entity))
186  processScope(NS->getScope());
187  else if (auto *M = dyn_cast<DIModule>(Entity))
188  processScope(M->getScope());
189  }
190 }
191 
193  const Instruction &I) {
194  if (auto *DVI = dyn_cast<DbgVariableIntrinsic>(&I))
195  processVariable(M, *DVI);
196 
197  if (auto DbgLoc = I.getDebugLoc())
198  processLocation(M, DbgLoc.get());
199 }
200 
202  if (!Loc)
203  return;
204  processScope(Loc->getScope());
205  processLocation(M, Loc->getInlinedAt());
206 }
207 
208 void DebugInfoFinder::processType(DIType *DT) {
209  if (!addType(DT))
210  return;
211  processScope(DT->getScope());
212  if (auto *ST = dyn_cast<DISubroutineType>(DT)) {
213  for (DIType *Ref : ST->getTypeArray())
214  processType(Ref);
215  return;
216  }
217  if (auto *DCT = dyn_cast<DICompositeType>(DT)) {
218  processType(DCT->getBaseType());
219  for (Metadata *D : DCT->getElements()) {
220  if (auto *T = dyn_cast<DIType>(D))
221  processType(T);
222  else if (auto *SP = dyn_cast<DISubprogram>(D))
223  processSubprogram(SP);
224  }
225  return;
226  }
227  if (auto *DDT = dyn_cast<DIDerivedType>(DT)) {
228  processType(DDT->getBaseType());
229  }
230 }
231 
232 void DebugInfoFinder::processScope(DIScope *Scope) {
233  if (!Scope)
234  return;
235  if (auto *Ty = dyn_cast<DIType>(Scope)) {
236  processType(Ty);
237  return;
238  }
239  if (auto *CU = dyn_cast<DICompileUnit>(Scope)) {
240  addCompileUnit(CU);
241  return;
242  }
243  if (auto *SP = dyn_cast<DISubprogram>(Scope)) {
244  processSubprogram(SP);
245  return;
246  }
247  if (!addScope(Scope))
248  return;
249  if (auto *LB = dyn_cast<DILexicalBlockBase>(Scope)) {
250  processScope(LB->getScope());
251  } else if (auto *NS = dyn_cast<DINamespace>(Scope)) {
252  processScope(NS->getScope());
253  } else if (auto *M = dyn_cast<DIModule>(Scope)) {
254  processScope(M->getScope());
255  }
256 }
257 
259  if (!addSubprogram(SP))
260  return;
261  processScope(SP->getScope());
262  // Some of the users, e.g. CloneFunctionInto / CloneModule, need to set up a
263  // ValueMap containing identity mappings for all of the DICompileUnit's, not
264  // just DISubprogram's, referenced from anywhere within the Function being
265  // cloned prior to calling MapMetadata / RemapInstruction to avoid their
266  // duplication later as DICompileUnit's are also directly referenced by
267  // llvm.dbg.cu list. Thefore we need to collect DICompileUnit's here as well.
268  // Also, DICompileUnit's may reference DISubprogram's too and therefore need
269  // to be at least looked through.
270  processCompileUnit(SP->getUnit());
271  processType(SP->getType());
272  for (auto *Element : SP->getTemplateParams()) {
273  if (auto *TType = dyn_cast<DITemplateTypeParameter>(Element)) {
274  processType(TType->getType());
275  } else if (auto *TVal = dyn_cast<DITemplateValueParameter>(Element)) {
276  processType(TVal->getType());
277  }
278  }
279 }
280 
282  const DbgVariableIntrinsic &DVI) {
283  auto *N = dyn_cast<MDNode>(DVI.getVariable());
284  if (!N)
285  return;
286 
287  auto *DV = dyn_cast<DILocalVariable>(N);
288  if (!DV)
289  return;
290 
291  if (!NodesSeen.insert(DV).second)
292  return;
293  processScope(DV->getScope());
294  processType(DV->getType());
295 }
296 
297 bool DebugInfoFinder::addType(DIType *DT) {
298  if (!DT)
299  return false;
300 
301  if (!NodesSeen.insert(DT).second)
302  return false;
303 
304  TYs.push_back(const_cast<DIType *>(DT));
305  return true;
306 }
307 
308 bool DebugInfoFinder::addCompileUnit(DICompileUnit *CU) {
309  if (!CU)
310  return false;
311  if (!NodesSeen.insert(CU).second)
312  return false;
313 
314  CUs.push_back(CU);
315  return true;
316 }
317 
318 bool DebugInfoFinder::addGlobalVariable(DIGlobalVariableExpression *DIG) {
319  if (!NodesSeen.insert(DIG).second)
320  return false;
321 
322  GVs.push_back(DIG);
323  return true;
324 }
325 
326 bool DebugInfoFinder::addSubprogram(DISubprogram *SP) {
327  if (!SP)
328  return false;
329 
330  if (!NodesSeen.insert(SP).second)
331  return false;
332 
333  SPs.push_back(SP);
334  return true;
335 }
336 
337 bool DebugInfoFinder::addScope(DIScope *Scope) {
338  if (!Scope)
339  return false;
340  // FIXME: Ocaml binding generates a scope with no content, we treat it
341  // as null for now.
342  if (Scope->getNumOperands() == 0)
343  return false;
344  if (!NodesSeen.insert(Scope).second)
345  return false;
346  Scopes.push_back(Scope);
347  return true;
348 }
349 
351  MDNode *OrigLoopID,
352  function_ref<DILocation *(const DILocation &)> Updater) {
353  assert(OrigLoopID && OrigLoopID->getNumOperands() > 0 &&
354  "Loop ID needs at least one operand");
355  assert(OrigLoopID && OrigLoopID->getOperand(0).get() == OrigLoopID &&
356  "Loop ID should refer to itself");
357 
358  // Save space for the self-referential LoopID.
359  SmallVector<Metadata *, 4> MDs = {nullptr};
360 
361  for (unsigned i = 1; i < OrigLoopID->getNumOperands(); ++i) {
362  Metadata *MD = OrigLoopID->getOperand(i);
363  if (DILocation *DL = dyn_cast<DILocation>(MD)) {
364  if (DILocation *NewDL = Updater(*DL))
365  MDs.push_back(NewDL);
366  } else
367  MDs.push_back(MD);
368  }
369 
370  MDNode *NewLoopID = MDNode::getDistinct(OrigLoopID->getContext(), MDs);
371  // Insert the self-referential LoopID.
372  NewLoopID->replaceOperandWith(0, NewLoopID);
373  return NewLoopID;
374 }
375 
377  Instruction &I, function_ref<DILocation *(const DILocation &)> Updater) {
378  MDNode *OrigLoopID = I.getMetadata(LLVMContext::MD_loop);
379  if (!OrigLoopID)
380  return;
381  MDNode *NewLoopID = updateLoopMetadataDebugLocationsImpl(OrigLoopID, Updater);
382  I.setMetadata(LLVMContext::MD_loop, NewLoopID);
383 }
384 
386  assert(!N->operands().empty() && "Missing self reference?");
387 
388  // if there is no debug location, we do not have to rewrite this MDNode.
389  if (std::none_of(N->op_begin() + 1, N->op_end(), [](const MDOperand &Op) {
390  return isa<DILocation>(Op.get());
391  }))
392  return N;
393 
394  // If there is only the debug location without any actual loop metadata, we
395  // can remove the metadata.
396  if (std::none_of(N->op_begin() + 1, N->op_end(), [](const MDOperand &Op) {
397  return !isa<DILocation>(Op.get());
398  }))
399  return nullptr;
400 
401  auto dropDebugLoc = [](const DILocation &) -> DILocation * {
402  return nullptr;
403  };
404  return updateLoopMetadataDebugLocationsImpl(N, dropDebugLoc);
405 }
406 
408  bool Changed = false;
409  if (F.hasMetadata(LLVMContext::MD_dbg)) {
410  Changed = true;
411  F.setSubprogram(nullptr);
412  }
413 
414  DenseMap<MDNode*, MDNode*> LoopIDsMap;
415  for (BasicBlock &BB : F) {
416  for (auto II = BB.begin(), End = BB.end(); II != End;) {
417  Instruction &I = *II++; // We may delete the instruction, increment now.
418  if (isa<DbgInfoIntrinsic>(&I)) {
419  I.eraseFromParent();
420  Changed = true;
421  continue;
422  }
423  if (I.getDebugLoc()) {
424  Changed = true;
425  I.setDebugLoc(DebugLoc());
426  }
427  if (auto *LoopID = I.getMetadata(LLVMContext::MD_loop)) {
428  auto *NewLoopID = LoopIDsMap.lookup(LoopID);
429  if (!NewLoopID)
430  NewLoopID = LoopIDsMap[LoopID] = stripDebugLocFromLoopID(LoopID);
431  if (NewLoopID != LoopID)
432  I.setMetadata(LLVMContext::MD_loop, NewLoopID);
433  }
434  // Strip heapallocsite attachments, they point into the DIType system.
435  if (I.hasMetadataOtherThanDebugLoc())
436  I.setMetadata("heapallocsite", nullptr);
437  }
438  }
439  return Changed;
440 }
441 
443  bool Changed = false;
444 
445  for (NamedMDNode &NMD : llvm::make_early_inc_range(M.named_metadata())) {
446  // We're stripping debug info, and without them, coverage information
447  // doesn't quite make sense.
448  if (NMD.getName().startswith("llvm.dbg.") ||
449  NMD.getName() == "llvm.gcov") {
450  NMD.eraseFromParent();
451  Changed = true;
452  }
453  }
454 
455  for (Function &F : M)
456  Changed |= stripDebugInfo(F);
457 
458  for (auto &GV : M.globals()) {
459  Changed |= GV.eraseMetadata(LLVMContext::MD_dbg);
460  }
461 
462  if (GVMaterializer *Materializer = M.getMaterializer())
463  Materializer->setStripDebugInfo();
464 
465  return Changed;
466 }
467 
468 namespace {
469 
470 /// Helper class to downgrade -g metadata to -gline-tables-only metadata.
471 class DebugTypeInfoRemoval {
473 
474 public:
475  /// The (void)() type.
476  MDNode *EmptySubroutineType;
477 
478 private:
479  /// Remember what linkage name we originally had before stripping. If we end
480  /// up making two subprograms identical who originally had different linkage
481  /// names, then we need to make one of them distinct, to avoid them getting
482  /// uniqued. Maps the new node to the old linkage name.
483  DenseMap<DISubprogram *, StringRef> NewToLinkageName;
484 
485  // TODO: Remember the distinct subprogram we created for a given linkage name,
486  // so that we can continue to unique whenever possible. Map <newly created
487  // node, old linkage name> to the first (possibly distinct) mdsubprogram
488  // created for that combination. This is not strictly needed for correctness,
489  // but can cut down on the number of MDNodes and let us diff cleanly with the
490  // output of -gline-tables-only.
491 
492 public:
493  DebugTypeInfoRemoval(LLVMContext &C)
494  : EmptySubroutineType(DISubroutineType::get(C, DINode::FlagZero, 0,
495  MDNode::get(C, {}))) {}
496 
497  Metadata *map(Metadata *M) {
498  if (!M)
499  return nullptr;
500  auto Replacement = Replacements.find(M);
501  if (Replacement != Replacements.end())
502  return Replacement->second;
503 
504  return M;
505  }
506  MDNode *mapNode(Metadata *N) { return dyn_cast_or_null<MDNode>(map(N)); }
507 
508  /// Recursively remap N and all its referenced children. Does a DF post-order
509  /// traversal, so as to remap bottoms up.
510  void traverseAndRemap(MDNode *N) { traverse(N); }
511 
512 private:
513  // Create a new DISubprogram, to replace the one given.
514  DISubprogram *getReplacementSubprogram(DISubprogram *MDS) {
515  auto *FileAndScope = cast_or_null<DIFile>(map(MDS->getFile()));
516  StringRef LinkageName = MDS->getName().empty() ? MDS->getLinkageName() : "";
517  DISubprogram *Declaration = nullptr;
518  auto *Type = cast_or_null<DISubroutineType>(map(MDS->getType()));
519  DIType *ContainingType =
520  cast_or_null<DIType>(map(MDS->getContainingType()));
521  auto *Unit = cast_or_null<DICompileUnit>(map(MDS->getUnit()));
522  auto Variables = nullptr;
523  auto TemplateParams = nullptr;
524 
525  // Make a distinct DISubprogram, for situations that warrent it.
526  auto distinctMDSubprogram = [&]() {
528  MDS->getContext(), FileAndScope, MDS->getName(), LinkageName,
529  FileAndScope, MDS->getLine(), Type, MDS->getScopeLine(),
530  ContainingType, MDS->getVirtualIndex(), MDS->getThisAdjustment(),
531  MDS->getFlags(), MDS->getSPFlags(), Unit, TemplateParams, Declaration,
532  Variables);
533  };
534 
535  if (MDS->isDistinct())
536  return distinctMDSubprogram();
537 
538  auto *NewMDS = DISubprogram::get(
539  MDS->getContext(), FileAndScope, MDS->getName(), LinkageName,
540  FileAndScope, MDS->getLine(), Type, MDS->getScopeLine(), ContainingType,
541  MDS->getVirtualIndex(), MDS->getThisAdjustment(), MDS->getFlags(),
542  MDS->getSPFlags(), Unit, TemplateParams, Declaration, Variables);
543 
544  StringRef OldLinkageName = MDS->getLinkageName();
545 
546  // See if we need to make a distinct one.
547  auto OrigLinkage = NewToLinkageName.find(NewMDS);
548  if (OrigLinkage != NewToLinkageName.end()) {
549  if (OrigLinkage->second == OldLinkageName)
550  // We're good.
551  return NewMDS;
552 
553  // Otherwise, need to make a distinct one.
554  // TODO: Query the map to see if we already have one.
555  return distinctMDSubprogram();
556  }
557 
558  NewToLinkageName.insert({NewMDS, MDS->getLinkageName()});
559  return NewMDS;
560  }
561 
562  /// Create a new compile unit, to replace the one given
563  DICompileUnit *getReplacementCU(DICompileUnit *CU) {
564  // Drop skeleton CUs.
565  if (CU->getDWOId())
566  return nullptr;
567 
568  auto *File = cast_or_null<DIFile>(map(CU->getFile()));
569  MDTuple *EnumTypes = nullptr;
570  MDTuple *RetainedTypes = nullptr;
571  MDTuple *GlobalVariables = nullptr;
572  MDTuple *ImportedEntities = nullptr;
574  CU->getContext(), CU->getSourceLanguage(), File, CU->getProducer(),
575  CU->isOptimized(), CU->getFlags(), CU->getRuntimeVersion(),
576  CU->getSplitDebugFilename(), DICompileUnit::LineTablesOnly, EnumTypes,
577  RetainedTypes, GlobalVariables, ImportedEntities, CU->getMacros(),
578  CU->getDWOId(), CU->getSplitDebugInlining(),
579  CU->getDebugInfoForProfiling(), CU->getNameTableKind(),
580  CU->getRangesBaseAddress(), CU->getSysRoot(), CU->getSDK());
581  }
582 
583  DILocation *getReplacementMDLocation(DILocation *MLD) {
584  auto *Scope = map(MLD->getScope());
585  auto *InlinedAt = map(MLD->getInlinedAt());
586  if (MLD->isDistinct())
587  return DILocation::getDistinct(MLD->getContext(), MLD->getLine(),
588  MLD->getColumn(), Scope, InlinedAt);
589  return DILocation::get(MLD->getContext(), MLD->getLine(), MLD->getColumn(),
590  Scope, InlinedAt);
591  }
592 
593  /// Create a new generic MDNode, to replace the one given
594  MDNode *getReplacementMDNode(MDNode *N) {
596  Ops.reserve(N->getNumOperands());
597  for (auto &I : N->operands())
598  if (I)
599  Ops.push_back(map(I));
600  auto *Ret = MDNode::get(N->getContext(), Ops);
601  return Ret;
602  }
603 
604  /// Attempt to re-map N to a newly created node.
605  void remap(MDNode *N) {
606  if (Replacements.count(N))
607  return;
608 
609  auto doRemap = [&](MDNode *N) -> MDNode * {
610  if (!N)
611  return nullptr;
612  if (auto *MDSub = dyn_cast<DISubprogram>(N)) {
613  remap(MDSub->getUnit());
614  return getReplacementSubprogram(MDSub);
615  }
616  if (isa<DISubroutineType>(N))
617  return EmptySubroutineType;
618  if (auto *CU = dyn_cast<DICompileUnit>(N))
619  return getReplacementCU(CU);
620  if (isa<DIFile>(N))
621  return N;
622  if (auto *MDLB = dyn_cast<DILexicalBlockBase>(N))
623  // Remap to our referenced scope (recursively).
624  return mapNode(MDLB->getScope());
625  if (auto *MLD = dyn_cast<DILocation>(N))
626  return getReplacementMDLocation(MLD);
627 
628  // Otherwise, if we see these, just drop them now. Not strictly necessary,
629  // but this speeds things up a little.
630  if (isa<DINode>(N))
631  return nullptr;
632 
633  return getReplacementMDNode(N);
634  };
635  Replacements[N] = doRemap(N);
636  }
637 
638  /// Do the remapping traversal.
639  void traverse(MDNode *);
640 };
641 
642 } // end anonymous namespace
643 
644 void DebugTypeInfoRemoval::traverse(MDNode *N) {
645  if (!N || Replacements.count(N))
646  return;
647 
648  // To avoid cycles, as well as for efficiency sake, we will sometimes prune
649  // parts of the graph.
650  auto prune = [](MDNode *Parent, MDNode *Child) {
651  if (auto *MDS = dyn_cast<DISubprogram>(Parent))
652  return Child == MDS->getRetainedNodes().get();
653  return false;
654  };
655 
657  DenseSet<MDNode *> Opened;
658 
659  // Visit each node starting at N in post order, and map them.
660  ToVisit.push_back(N);
661  while (!ToVisit.empty()) {
662  auto *N = ToVisit.back();
663  if (!Opened.insert(N).second) {
664  // Close it.
665  remap(N);
666  ToVisit.pop_back();
667  continue;
668  }
669  for (auto &I : N->operands())
670  if (auto *MDN = dyn_cast_or_null<MDNode>(I))
671  if (!Opened.count(MDN) && !Replacements.count(MDN) && !prune(N, MDN) &&
672  !isa<DICompileUnit>(MDN))
673  ToVisit.push_back(MDN);
674  }
675 }
676 
678  bool Changed = false;
679 
680  // First off, delete the debug intrinsics.
681  auto RemoveUses = [&](StringRef Name) {
682  if (auto *DbgVal = M.getFunction(Name)) {
683  while (!DbgVal->use_empty())
684  cast<Instruction>(DbgVal->user_back())->eraseFromParent();
685  DbgVal->eraseFromParent();
686  Changed = true;
687  }
688  };
689  RemoveUses("llvm.dbg.addr");
690  RemoveUses("llvm.dbg.declare");
691  RemoveUses("llvm.dbg.label");
692  RemoveUses("llvm.dbg.value");
693 
694  // Delete non-CU debug info named metadata nodes.
695  for (auto NMI = M.named_metadata_begin(), NME = M.named_metadata_end();
696  NMI != NME;) {
697  NamedMDNode *NMD = &*NMI;
698  ++NMI;
699  // Specifically keep dbg.cu around.
700  if (NMD->getName() == "llvm.dbg.cu")
701  continue;
702  }
703 
704  // Drop all dbg attachments from global variables.
705  for (auto &GV : M.globals())
706  GV.eraseMetadata(LLVMContext::MD_dbg);
707 
708  DebugTypeInfoRemoval Mapper(M.getContext());
709  auto remap = [&](MDNode *Node) -> MDNode * {
710  if (!Node)
711  return nullptr;
712  Mapper.traverseAndRemap(Node);
713  auto *NewNode = Mapper.mapNode(Node);
714  Changed |= Node != NewNode;
715  Node = NewNode;
716  return NewNode;
717  };
718 
719  // Rewrite the DebugLocs to be equivalent to what
720  // -gline-tables-only would have created.
721  for (auto &F : M) {
722  if (auto *SP = F.getSubprogram()) {
723  Mapper.traverseAndRemap(SP);
724  auto *NewSP = cast<DISubprogram>(Mapper.mapNode(SP));
725  Changed |= SP != NewSP;
726  F.setSubprogram(NewSP);
727  }
728  for (auto &BB : F) {
729  for (auto &I : BB) {
730  auto remapDebugLoc = [&](const DebugLoc &DL) -> DebugLoc {
731  auto *Scope = DL.getScope();
732  MDNode *InlinedAt = DL.getInlinedAt();
733  Scope = remap(Scope);
734  InlinedAt = remap(InlinedAt);
735  return DILocation::get(M.getContext(), DL.getLine(), DL.getCol(),
736  Scope, InlinedAt);
737  };
738 
739  if (I.getDebugLoc() != DebugLoc())
740  I.setDebugLoc(remapDebugLoc(I.getDebugLoc()));
741 
742  // Remap DILocations in llvm.loop attachments.
744  return remapDebugLoc(&Loc).get();
745  });
746 
747  // Strip heapallocsite attachments, they point into the DIType system.
748  if (I.hasMetadataOtherThanDebugLoc())
749  I.setMetadata("heapallocsite", nullptr);
750  }
751  }
752  }
753 
754  // Create a new llvm.dbg.cu, which is equivalent to the one
755  // -gline-tables-only would have created.
756  for (auto &NMD : M.getNamedMDList()) {
758  for (MDNode *Op : NMD.operands())
759  Ops.push_back(remap(Op));
760 
761  if (!Changed)
762  continue;
763 
764  NMD.clearOperands();
765  for (auto *Op : Ops)
766  if (Op)
767  NMD.addOperand(Op);
768  }
769  return Changed;
770 }
771 
773  if (auto *Val = mdconst::dyn_extract_or_null<ConstantInt>(
774  M.getModuleFlag("Debug Info Version")))
775  return Val->getZExtValue();
776  return 0;
777 }
778 
780  const DILocation *LocB) {
781  setDebugLoc(DILocation::getMergedLocation(LocA, LocB));
782 }
783 
784 void Instruction::updateLocationAfterHoist() { dropLocation(); }
785 
787  const DebugLoc &DL = getDebugLoc();
788  if (!DL)
789  return;
790 
791  // If this isn't a call, drop the location to allow a location from a
792  // preceding instruction to propagate.
793  if (!isa<CallBase>(this)) {
794  setDebugLoc(DebugLoc());
795  return;
796  }
797 
798  // Set a line 0 location for calls to preserve scope information in case
799  // inlining occurs.
801  if (SP)
802  // If a function scope is available, set it on the line 0 location. When
803  // hoisting a call to a predecessor block, using the function scope avoids
804  // making it look like the callee was reached earlier than it should be.
805  setDebugLoc(DILocation::get(getContext(), 0, 0, SP));
806  else
807  // The parent function has no scope. Go ahead and drop the location. If
808  // the parent function is inlined, and the callee has a subprogram, the
809  // inliner will attach a location to the call.
810  //
811  // One alternative is to set a line 0 location with the existing scope and
812  // inlinedAt info. The location might be sensitive to when inlining occurs.
813  setDebugLoc(DebugLoc());
814 }
815 
816 //===----------------------------------------------------------------------===//
817 // LLVM C API implementations.
818 //===----------------------------------------------------------------------===//
819 
821  switch (lang) {
822 #define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \
823  case LLVMDWARFSourceLanguage##NAME: \
824  return ID;
825 #include "llvm/BinaryFormat/Dwarf.def"
826 #undef HANDLE_DW_LANG
827  }
828  llvm_unreachable("Unhandled Tag");
829 }
830 
831 template <typename DIT> DIT *unwrapDI(LLVMMetadataRef Ref) {
832  return (DIT *)(Ref ? unwrap<MDNode>(Ref) : nullptr);
833 }
834 
836  return static_cast<DINode::DIFlags>(Flags);
837 }
838 
840  return static_cast<LLVMDIFlags>(Flags);
841 }
842 
844 pack_into_DISPFlags(bool IsLocalToUnit, bool IsDefinition, bool IsOptimized) {
845  return DISubprogram::toSPFlags(IsLocalToUnit, IsDefinition, IsOptimized);
846 }
847 
849  return DEBUG_METADATA_VERSION;
850 }
851 
853  return wrap(new DIBuilder(*unwrap(M), false));
854 }
855 
857  return wrap(new DIBuilder(*unwrap(M)));
858 }
859 
862 }
863 
865  return StripDebugInfo(*unwrap(M));
866 }
867 
869  delete unwrap(Builder);
870 }
871 
873  unwrap(Builder)->finalize();
874 }
875 
878  LLVMMetadataRef FileRef, const char *Producer, size_t ProducerLen,
879  LLVMBool isOptimized, const char *Flags, size_t FlagsLen,
880  unsigned RuntimeVer, const char *SplitName, size_t SplitNameLen,
881  LLVMDWARFEmissionKind Kind, unsigned DWOId, LLVMBool SplitDebugInlining,
882  LLVMBool DebugInfoForProfiling, const char *SysRoot, size_t SysRootLen,
883  const char *SDK, size_t SDKLen) {
884  auto File = unwrapDI<DIFile>(FileRef);
885 
886  return wrap(unwrap(Builder)->createCompileUnit(
888  StringRef(Producer, ProducerLen), isOptimized, StringRef(Flags, FlagsLen),
889  RuntimeVer, StringRef(SplitName, SplitNameLen),
890  static_cast<DICompileUnit::DebugEmissionKind>(Kind), DWOId,
891  SplitDebugInlining, DebugInfoForProfiling,
893  StringRef(SysRoot, SysRootLen), StringRef(SDK, SDKLen)));
894 }
895 
898  size_t FilenameLen, const char *Directory,
899  size_t DirectoryLen) {
900  return wrap(unwrap(Builder)->createFile(StringRef(Filename, FilenameLen),
901  StringRef(Directory, DirectoryLen)));
902 }
903 
906  const char *Name, size_t NameLen,
907  const char *ConfigMacros, size_t ConfigMacrosLen,
908  const char *IncludePath, size_t IncludePathLen,
909  const char *APINotesFile, size_t APINotesFileLen) {
910  return wrap(unwrap(Builder)->createModule(
911  unwrapDI<DIScope>(ParentScope), StringRef(Name, NameLen),
912  StringRef(ConfigMacros, ConfigMacrosLen),
913  StringRef(IncludePath, IncludePathLen),
914  StringRef(APINotesFile, APINotesFileLen)));
915 }
916 
918  LLVMMetadataRef ParentScope,
919  const char *Name, size_t NameLen,
920  LLVMBool ExportSymbols) {
921  return wrap(unwrap(Builder)->createNameSpace(
922  unwrapDI<DIScope>(ParentScope), StringRef(Name, NameLen), ExportSymbols));
923 }
924 
927  size_t NameLen, const char *LinkageName, size_t LinkageNameLen,
928  LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty,
929  LLVMBool IsLocalToUnit, LLVMBool IsDefinition,
930  unsigned ScopeLine, LLVMDIFlags Flags, LLVMBool IsOptimized) {
931  return wrap(unwrap(Builder)->createFunction(
932  unwrapDI<DIScope>(Scope), {Name, NameLen}, {LinkageName, LinkageNameLen},
933  unwrapDI<DIFile>(File), LineNo, unwrapDI<DISubroutineType>(Ty), ScopeLine,
934  map_from_llvmDIFlags(Flags),
935  pack_into_DISPFlags(IsLocalToUnit, IsDefinition, IsOptimized), nullptr,
936  nullptr, nullptr));
937 }
938 
939 
942  LLVMMetadataRef File, unsigned Line, unsigned Col) {
943  return wrap(unwrap(Builder)->createLexicalBlock(unwrapDI<DIScope>(Scope),
944  unwrapDI<DIFile>(File),
945  Line, Col));
946 }
947 
952  unsigned Discriminator) {
953  return wrap(unwrap(Builder)->createLexicalBlockFile(unwrapDI<DIScope>(Scope),
954  unwrapDI<DIFile>(File),
955  Discriminator));
956 }
957 
961  LLVMMetadataRef NS,
963  unsigned Line) {
964  return wrap(unwrap(Builder)->createImportedModule(unwrapDI<DIScope>(Scope),
965  unwrapDI<DINamespace>(NS),
966  unwrapDI<DIFile>(File),
967  Line));
968 }
969 
973  LLVMMetadataRef ImportedEntity,
975  unsigned Line) {
977  unwrapDI<DIScope>(Scope),
978  unwrapDI<DIImportedEntity>(ImportedEntity),
979  unwrapDI<DIFile>(File), Line));
980 }
981 
985  LLVMMetadataRef M,
987  unsigned Line) {
988  return wrap(unwrap(Builder)->createImportedModule(unwrapDI<DIScope>(Scope),
989  unwrapDI<DIModule>(M),
990  unwrapDI<DIFile>(File),
991  Line));
992 }
993 
997  LLVMMetadataRef Decl,
999  unsigned Line,
1000  const char *Name, size_t NameLen) {
1001  return wrap(unwrap(Builder)->createImportedDeclaration(
1002  unwrapDI<DIScope>(Scope),
1003  unwrapDI<DINode>(Decl),
1004  unwrapDI<DIFile>(File), Line, {Name, NameLen}));
1005 }
1006 
1009  unsigned Column, LLVMMetadataRef Scope,
1010  LLVMMetadataRef InlinedAt) {
1011  return wrap(DILocation::get(*unwrap(Ctx), Line, Column, unwrap(Scope),
1012  unwrap(InlinedAt)));
1013 }
1014 
1016  return unwrapDI<DILocation>(Location)->getLine();
1017 }
1018 
1020  return unwrapDI<DILocation>(Location)->getColumn();
1021 }
1022 
1024  return wrap(unwrapDI<DILocation>(Location)->getScope());
1025 }
1026 
1028  return wrap(unwrapDI<DILocation>(Location)->getInlinedAt());
1029 }
1030 
1032  return wrap(unwrapDI<DIScope>(Scope)->getFile());
1033 }
1034 
1035 const char *LLVMDIFileGetDirectory(LLVMMetadataRef File, unsigned *Len) {
1036  auto Dir = unwrapDI<DIFile>(File)->getDirectory();
1037  *Len = Dir.size();
1038  return Dir.data();
1039 }
1040 
1041 const char *LLVMDIFileGetFilename(LLVMMetadataRef File, unsigned *Len) {
1042  auto Name = unwrapDI<DIFile>(File)->getFilename();
1043  *Len = Name.size();
1044  return Name.data();
1045 }
1046 
1047 const char *LLVMDIFileGetSource(LLVMMetadataRef File, unsigned *Len) {
1048  if (auto Src = unwrapDI<DIFile>(File)->getSource()) {
1049  *Len = Src->size();
1050  return Src->data();
1051  }
1052  *Len = 0;
1053  return "";
1054 }
1055 
1057  LLVMMetadataRef ParentMacroFile,
1058  unsigned Line,
1060  const char *Name, size_t NameLen,
1061  const char *Value, size_t ValueLen) {
1062  return wrap(
1063  unwrap(Builder)->createMacro(unwrapDI<DIMacroFile>(ParentMacroFile), Line,
1064  static_cast<MacinfoRecordType>(RecordType),
1065  {Name, NameLen}, {Value, ValueLen}));
1066 }
1067 
1070  LLVMMetadataRef ParentMacroFile, unsigned Line,
1072  return wrap(unwrap(Builder)->createTempMacroFile(
1073  unwrapDI<DIMacroFile>(ParentMacroFile), Line, unwrapDI<DIFile>(File)));
1074 }
1075 
1077  const char *Name, size_t NameLen,
1078  int64_t Value,
1079  LLVMBool IsUnsigned) {
1080  return wrap(unwrap(Builder)->createEnumerator({Name, NameLen}, Value,
1081  IsUnsigned != 0));
1082 }
1083 
1086  size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
1087  uint64_t SizeInBits, uint32_t AlignInBits, LLVMMetadataRef *Elements,
1088  unsigned NumElements, LLVMMetadataRef ClassTy) {
1089 auto Elts = unwrap(Builder)->getOrCreateArray({unwrap(Elements),
1090  NumElements});
1091 return wrap(unwrap(Builder)->createEnumerationType(
1092  unwrapDI<DIScope>(Scope), {Name, NameLen}, unwrapDI<DIFile>(File),
1093  LineNumber, SizeInBits, AlignInBits, Elts, unwrapDI<DIType>(ClassTy)));
1094 }
1095 
1098  size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
1099  uint64_t SizeInBits, uint32_t AlignInBits, LLVMDIFlags Flags,
1100  LLVMMetadataRef *Elements, unsigned NumElements, unsigned RunTimeLang,
1101  const char *UniqueId, size_t UniqueIdLen) {
1102  auto Elts = unwrap(Builder)->getOrCreateArray({unwrap(Elements),
1103  NumElements});
1104  return wrap(unwrap(Builder)->createUnionType(
1105  unwrapDI<DIScope>(Scope), {Name, NameLen}, unwrapDI<DIFile>(File),
1106  LineNumber, SizeInBits, AlignInBits, map_from_llvmDIFlags(Flags),
1107  Elts, RunTimeLang, {UniqueId, UniqueIdLen}));
1108 }
1109 
1110 
1113  uint32_t AlignInBits, LLVMMetadataRef Ty,
1114  LLVMMetadataRef *Subscripts,
1115  unsigned NumSubscripts) {
1116  auto Subs = unwrap(Builder)->getOrCreateArray({unwrap(Subscripts),
1117  NumSubscripts});
1118  return wrap(unwrap(Builder)->createArrayType(Size, AlignInBits,
1119  unwrapDI<DIType>(Ty), Subs));
1120 }
1121 
1124  uint32_t AlignInBits, LLVMMetadataRef Ty,
1125  LLVMMetadataRef *Subscripts,
1126  unsigned NumSubscripts) {
1127  auto Subs = unwrap(Builder)->getOrCreateArray({unwrap(Subscripts),
1128  NumSubscripts});
1129  return wrap(unwrap(Builder)->createVectorType(Size, AlignInBits,
1130  unwrapDI<DIType>(Ty), Subs));
1131 }
1132 
1135  size_t NameLen, uint64_t SizeInBits,
1136  LLVMDWARFTypeEncoding Encoding,
1137  LLVMDIFlags Flags) {
1138  return wrap(unwrap(Builder)->createBasicType({Name, NameLen},
1139  SizeInBits, Encoding,
1140  map_from_llvmDIFlags(Flags)));
1141 }
1142 
1145  uint64_t SizeInBits, uint32_t AlignInBits, unsigned AddressSpace,
1146  const char *Name, size_t NameLen) {
1147  return wrap(unwrap(Builder)->createPointerType(unwrapDI<DIType>(PointeeTy),
1148  SizeInBits, AlignInBits,
1149  AddressSpace, {Name, NameLen}));
1150 }
1151 
1154  size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
1155  uint64_t SizeInBits, uint32_t AlignInBits, LLVMDIFlags Flags,
1156  LLVMMetadataRef DerivedFrom, LLVMMetadataRef *Elements,
1157  unsigned NumElements, unsigned RunTimeLang, LLVMMetadataRef VTableHolder,
1158  const char *UniqueId, size_t UniqueIdLen) {
1159  auto Elts = unwrap(Builder)->getOrCreateArray({unwrap(Elements),
1160  NumElements});
1161  return wrap(unwrap(Builder)->createStructType(
1162  unwrapDI<DIScope>(Scope), {Name, NameLen}, unwrapDI<DIFile>(File),
1163  LineNumber, SizeInBits, AlignInBits, map_from_llvmDIFlags(Flags),
1164  unwrapDI<DIType>(DerivedFrom), Elts, RunTimeLang,
1165  unwrapDI<DIType>(VTableHolder), {UniqueId, UniqueIdLen}));
1166 }
1167 
1170  size_t NameLen, LLVMMetadataRef File, unsigned LineNo, uint64_t SizeInBits,
1171  uint32_t AlignInBits, uint64_t OffsetInBits, LLVMDIFlags Flags,
1172  LLVMMetadataRef Ty) {
1173  return wrap(unwrap(Builder)->createMemberType(unwrapDI<DIScope>(Scope),
1174  {Name, NameLen}, unwrapDI<DIFile>(File), LineNo, SizeInBits, AlignInBits,
1175  OffsetInBits, map_from_llvmDIFlags(Flags), unwrapDI<DIType>(Ty)));
1176 }
1177 
1180  size_t NameLen) {
1181  return wrap(unwrap(Builder)->createUnspecifiedType({Name, NameLen}));
1182 }
1183 
1187  size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
1188  LLVMMetadataRef Type, LLVMDIFlags Flags, LLVMValueRef ConstantVal,
1189  uint32_t AlignInBits) {
1190  return wrap(unwrap(Builder)->createStaticMemberType(
1191  unwrapDI<DIScope>(Scope), {Name, NameLen},
1192  unwrapDI<DIFile>(File), LineNumber, unwrapDI<DIType>(Type),
1193  map_from_llvmDIFlags(Flags), unwrap<Constant>(ConstantVal),
1194  AlignInBits));
1195 }
1196 
1199  const char *Name, size_t NameLen,
1200  LLVMMetadataRef File, unsigned LineNo,
1201  uint64_t SizeInBits, uint32_t AlignInBits,
1202  uint64_t OffsetInBits, LLVMDIFlags Flags,
1203  LLVMMetadataRef Ty, LLVMMetadataRef PropertyNode) {
1204  return wrap(unwrap(Builder)->createObjCIVar(
1205  {Name, NameLen}, unwrapDI<DIFile>(File), LineNo,
1206  SizeInBits, AlignInBits, OffsetInBits,
1207  map_from_llvmDIFlags(Flags), unwrapDI<DIType>(Ty),
1208  unwrapDI<MDNode>(PropertyNode)));
1209 }
1210 
1213  const char *Name, size_t NameLen,
1214  LLVMMetadataRef File, unsigned LineNo,
1215  const char *GetterName, size_t GetterNameLen,
1216  const char *SetterName, size_t SetterNameLen,
1217  unsigned PropertyAttributes,
1218  LLVMMetadataRef Ty) {
1219  return wrap(unwrap(Builder)->createObjCProperty(
1220  {Name, NameLen}, unwrapDI<DIFile>(File), LineNo,
1221  {GetterName, GetterNameLen}, {SetterName, SetterNameLen},
1222  PropertyAttributes, unwrapDI<DIType>(Ty)));
1223 }
1224 
1228  return wrap(unwrap(Builder)->createObjectPointerType(unwrapDI<DIType>(Type)));
1229 }
1230 
1233  const char *Name, size_t NameLen,
1234  LLVMMetadataRef File, unsigned LineNo,
1235  LLVMMetadataRef Scope, uint32_t AlignInBits) {
1236  return wrap(unwrap(Builder)->createTypedef(
1237  unwrapDI<DIType>(Type), {Name, NameLen}, unwrapDI<DIFile>(File), LineNo,
1238  unwrapDI<DIScope>(Scope), AlignInBits));
1239 }
1240 
1243  LLVMMetadataRef Ty, LLVMMetadataRef BaseTy,
1244  uint64_t BaseOffset, uint32_t VBPtrOffset,
1245  LLVMDIFlags Flags) {
1246  return wrap(unwrap(Builder)->createInheritance(
1247  unwrapDI<DIType>(Ty), unwrapDI<DIType>(BaseTy),
1248  BaseOffset, VBPtrOffset, map_from_llvmDIFlags(Flags)));
1249 }
1250 
1253  LLVMDIBuilderRef Builder, unsigned Tag, const char *Name,
1254  size_t NameLen, LLVMMetadataRef Scope, LLVMMetadataRef File, unsigned Line,
1255  unsigned RuntimeLang, uint64_t SizeInBits, uint32_t AlignInBits,
1256  const char *UniqueIdentifier, size_t UniqueIdentifierLen) {
1257  return wrap(unwrap(Builder)->createForwardDecl(
1258  Tag, {Name, NameLen}, unwrapDI<DIScope>(Scope),
1259  unwrapDI<DIFile>(File), Line, RuntimeLang, SizeInBits,
1260  AlignInBits, {UniqueIdentifier, UniqueIdentifierLen}));
1261 }
1262 
1265  LLVMDIBuilderRef Builder, unsigned Tag, const char *Name,
1266  size_t NameLen, LLVMMetadataRef Scope, LLVMMetadataRef File, unsigned Line,
1267  unsigned RuntimeLang, uint64_t SizeInBits, uint32_t AlignInBits,
1268  LLVMDIFlags Flags, const char *UniqueIdentifier,
1269  size_t UniqueIdentifierLen) {
1270  return wrap(unwrap(Builder)->createReplaceableCompositeType(
1271  Tag, {Name, NameLen}, unwrapDI<DIScope>(Scope),
1272  unwrapDI<DIFile>(File), Line, RuntimeLang, SizeInBits,
1273  AlignInBits, map_from_llvmDIFlags(Flags),
1274  {UniqueIdentifier, UniqueIdentifierLen}));
1275 }
1276 
1280  return wrap(unwrap(Builder)->createQualifiedType(Tag,
1281  unwrapDI<DIType>(Type)));
1282 }
1283 
1287  return wrap(unwrap(Builder)->createReferenceType(Tag,
1288  unwrapDI<DIType>(Type)));
1289 }
1290 
1293  return wrap(unwrap(Builder)->createNullPtrType());
1294 }
1295 
1298  LLVMMetadataRef PointeeType,
1299  LLVMMetadataRef ClassType,
1300  uint64_t SizeInBits,
1301  uint32_t AlignInBits,
1302  LLVMDIFlags Flags) {
1303  return wrap(unwrap(Builder)->createMemberPointerType(
1304  unwrapDI<DIType>(PointeeType),
1305  unwrapDI<DIType>(ClassType), AlignInBits, SizeInBits,
1306  map_from_llvmDIFlags(Flags)));
1307 }
1308 
1312  const char *Name, size_t NameLen,
1313  LLVMMetadataRef File, unsigned LineNumber,
1314  uint64_t SizeInBits,
1315  uint64_t OffsetInBits,
1316  uint64_t StorageOffsetInBits,
1317  LLVMDIFlags Flags, LLVMMetadataRef Type) {
1318  return wrap(unwrap(Builder)->createBitFieldMemberType(
1319  unwrapDI<DIScope>(Scope), {Name, NameLen},
1320  unwrapDI<DIFile>(File), LineNumber,
1321  SizeInBits, OffsetInBits, StorageOffsetInBits,
1322  map_from_llvmDIFlags(Flags), unwrapDI<DIType>(Type)));
1323 }
1324 
1326  LLVMMetadataRef Scope, const char *Name, size_t NameLen,
1327  LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits,
1328  uint32_t AlignInBits, uint64_t OffsetInBits, LLVMDIFlags Flags,
1329  LLVMMetadataRef DerivedFrom,
1330  LLVMMetadataRef *Elements, unsigned NumElements,
1331  LLVMMetadataRef VTableHolder, LLVMMetadataRef TemplateParamsNode,
1332  const char *UniqueIdentifier, size_t UniqueIdentifierLen) {
1333  auto Elts = unwrap(Builder)->getOrCreateArray({unwrap(Elements),
1334  NumElements});
1335  return wrap(unwrap(Builder)->createClassType(
1336  unwrapDI<DIScope>(Scope), {Name, NameLen},
1337  unwrapDI<DIFile>(File), LineNumber,
1338  SizeInBits, AlignInBits, OffsetInBits,
1339  map_from_llvmDIFlags(Flags), unwrapDI<DIType>(DerivedFrom),
1340  Elts, unwrapDI<DIType>(VTableHolder),
1341  unwrapDI<MDNode>(TemplateParamsNode),
1342  {UniqueIdentifier, UniqueIdentifierLen}));
1343 }
1344 
1348  return wrap(unwrap(Builder)->createArtificialType(unwrapDI<DIType>(Type)));
1349 }
1350 
1351 const char *LLVMDITypeGetName(LLVMMetadataRef DType, size_t *Length) {
1352  StringRef Str = unwrap<DIType>(DType)->getName();
1353  *Length = Str.size();
1354  return Str.data();
1355 }
1356 
1358  return unwrapDI<DIType>(DType)->getSizeInBits();
1359 }
1360 
1362  return unwrapDI<DIType>(DType)->getOffsetInBits();
1363 }
1364 
1366  return unwrapDI<DIType>(DType)->getAlignInBits();
1367 }
1368 
1370  return unwrapDI<DIType>(DType)->getLine();
1371 }
1372 
1374  return map_to_llvmDIFlags(unwrapDI<DIType>(DType)->getFlags());
1375 }
1376 
1378  LLVMMetadataRef *Types,
1379  size_t Length) {
1380  return wrap(
1381  unwrap(Builder)->getOrCreateTypeArray({unwrap(Types), Length}).get());
1382 }
1383 
1387  LLVMMetadataRef *ParameterTypes,
1388  unsigned NumParameterTypes,
1389  LLVMDIFlags Flags) {
1390  auto Elts = unwrap(Builder)->getOrCreateTypeArray({unwrap(ParameterTypes),
1391  NumParameterTypes});
1392  return wrap(unwrap(Builder)->createSubroutineType(
1393  Elts, map_from_llvmDIFlags(Flags)));
1394 }
1395 
1397  int64_t *Addr, size_t Length) {
1398  return wrap(unwrap(Builder)->createExpression(ArrayRef<int64_t>(Addr,
1399  Length)));
1400 }
1401 
1404  int64_t Value) {
1405  return wrap(unwrap(Builder)->createConstantValueExpression(Value));
1406 }
1407 
1410  size_t NameLen, const char *Linkage, size_t LinkLen, LLVMMetadataRef File,
1411  unsigned LineNo, LLVMMetadataRef Ty, LLVMBool LocalToUnit,
1412  LLVMMetadataRef Expr, LLVMMetadataRef Decl, uint32_t AlignInBits) {
1413  return wrap(unwrap(Builder)->createGlobalVariableExpression(
1414  unwrapDI<DIScope>(Scope), {Name, NameLen}, {Linkage, LinkLen},
1415  unwrapDI<DIFile>(File), LineNo, unwrapDI<DIType>(Ty), LocalToUnit,
1416  true, unwrap<DIExpression>(Expr), unwrapDI<MDNode>(Decl),
1417  nullptr, AlignInBits));
1418 }
1419 
1421  return wrap(unwrapDI<DIGlobalVariableExpression>(GVE)->getVariable());
1422 }
1423 
1425  LLVMMetadataRef GVE) {
1426  return wrap(unwrapDI<DIGlobalVariableExpression>(GVE)->getExpression());
1427 }
1428 
1430  return wrap(unwrapDI<DIVariable>(Var)->getFile());
1431 }
1432 
1434  return wrap(unwrapDI<DIVariable>(Var)->getScope());
1435 }
1436 
1438  return unwrapDI<DIVariable>(Var)->getLine();
1439 }
1440 
1442  size_t Count) {
1443  return wrap(
1444  MDTuple::getTemporary(*unwrap(Ctx), {unwrap(Data), Count}).release());
1445 }
1446 
1448  MDNode::deleteTemporary(unwrapDI<MDNode>(TempNode));
1449 }
1450 
1452  LLVMMetadataRef Replacement) {
1453  auto *Node = unwrapDI<MDNode>(TargetMetadata);
1454  Node->replaceAllUsesWith(unwrap<Metadata>(Replacement));
1456 }
1457 
1460  size_t NameLen, const char *Linkage, size_t LnkLen, LLVMMetadataRef File,
1461  unsigned LineNo, LLVMMetadataRef Ty, LLVMBool LocalToUnit,
1462  LLVMMetadataRef Decl, uint32_t AlignInBits) {
1463  return wrap(unwrap(Builder)->createTempGlobalVariableFwdDecl(
1464  unwrapDI<DIScope>(Scope), {Name, NameLen}, {Linkage, LnkLen},
1465  unwrapDI<DIFile>(File), LineNo, unwrapDI<DIType>(Ty), LocalToUnit,
1466  unwrapDI<MDNode>(Decl), nullptr, AlignInBits));
1467 }
1468 
1471  LLVMMetadataRef VarInfo, LLVMMetadataRef Expr,
1472  LLVMMetadataRef DL, LLVMValueRef Instr) {
1473  return wrap(unwrap(Builder)->insertDeclare(
1474  unwrap(Storage), unwrap<DILocalVariable>(VarInfo),
1475  unwrap<DIExpression>(Expr), unwrap<DILocation>(DL),
1476  unwrap<Instruction>(Instr)));
1477 }
1478 
1482  return wrap(unwrap(Builder)->insertDeclare(
1483  unwrap(Storage), unwrap<DILocalVariable>(VarInfo),
1484  unwrap<DIExpression>(Expr), unwrap<DILocation>(DL),
1485  unwrap(Block)));
1486 }
1487 
1489  LLVMValueRef Val,
1490  LLVMMetadataRef VarInfo,
1491  LLVMMetadataRef Expr,
1493  LLVMValueRef Instr) {
1494  return wrap(unwrap(Builder)->insertDbgValueIntrinsic(
1495  unwrap(Val), unwrap<DILocalVariable>(VarInfo),
1496  unwrap<DIExpression>(Expr), unwrap<DILocation>(DebugLoc),
1497  unwrap<Instruction>(Instr)));
1498 }
1499 
1501  LLVMValueRef Val,
1502  LLVMMetadataRef VarInfo,
1503  LLVMMetadataRef Expr,
1505  LLVMBasicBlockRef Block) {
1506  return wrap(unwrap(Builder)->insertDbgValueIntrinsic(
1507  unwrap(Val), unwrap<DILocalVariable>(VarInfo),
1508  unwrap<DIExpression>(Expr), unwrap<DILocation>(DebugLoc),
1509  unwrap(Block)));
1510 }
1511 
1514  size_t NameLen, LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty,
1515  LLVMBool AlwaysPreserve, LLVMDIFlags Flags, uint32_t AlignInBits) {
1516  return wrap(unwrap(Builder)->createAutoVariable(
1517  unwrap<DIScope>(Scope), {Name, NameLen}, unwrap<DIFile>(File),
1518  LineNo, unwrap<DIType>(Ty), AlwaysPreserve,
1519  map_from_llvmDIFlags(Flags), AlignInBits));
1520 }
1521 
1524  size_t NameLen, unsigned ArgNo, LLVMMetadataRef File, unsigned LineNo,
1525  LLVMMetadataRef Ty, LLVMBool AlwaysPreserve, LLVMDIFlags Flags) {
1526  return wrap(unwrap(Builder)->createParameterVariable(
1527  unwrap<DIScope>(Scope), {Name, NameLen}, ArgNo, unwrap<DIFile>(File),
1528  LineNo, unwrap<DIType>(Ty), AlwaysPreserve,
1529  map_from_llvmDIFlags(Flags)));
1530 }
1531 
1533  int64_t Lo, int64_t Count) {
1534  return wrap(unwrap(Builder)->getOrCreateSubrange(Lo, Count));
1535 }
1536 
1538  LLVMMetadataRef *Data,
1539  size_t Length) {
1540  Metadata **DataValue = unwrap(Data);
1541  return wrap(unwrap(Builder)->getOrCreateArray({DataValue, Length}).get());
1542 }
1543 
1545  return wrap(unwrap<Function>(Func)->getSubprogram());
1546 }
1547 
1549  unwrap<Function>(Func)->setSubprogram(unwrap<DISubprogram>(SP));
1550 }
1551 
1553  return unwrapDI<DISubprogram>(Subprogram)->getLine();
1554 }
1555 
1557  return wrap(unwrap<Instruction>(Inst)->getDebugLoc().getAsMDNode());
1558 }
1559 
1561  if (Loc)
1562  unwrap<Instruction>(Inst)->setDebugLoc(DebugLoc(unwrap<MDNode>(Loc)));
1563  else
1564  unwrap<Instruction>(Inst)->setDebugLoc(DebugLoc());
1565 }
1566 
1568  switch(unwrap(Metadata)->getMetadataID()) {
1569 #define HANDLE_METADATA_LEAF(CLASS) \
1570  case Metadata::CLASS##Kind: \
1571  return (LLVMMetadataKind)LLVM##CLASS##MetadataKind;
1572 #include "llvm/IR/Metadata.def"
1573  default:
1575  }
1576 }
llvm::Check::Size
@ Size
Definition: FileCheck.h:73
llvm::DIType::getScope
DIScope * getScope() const
Definition: DebugInfoMetadata.h:703
LLVMDWARFTypeEncoding
unsigned LLVMDWARFTypeEncoding
An LLVM DWARF type encoding.
Definition: DebugInfo.h:172
i
i
Definition: README.txt:29
LLVMDIVariableGetFile
LLVMMetadataRef LLVMDIVariableGetFile(LLVMMetadataRef Var)
Get the metadata of the file associated with a given variable.
Definition: DebugInfo.cpp:1429
llvm::StripDebugInfo
bool StripDebugInfo(Module &M)
Strip debug info in the module if it exists.
Definition: DebugInfo.cpp:442
LLVMDIBuilderCreatePointerType
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:1143
llvm
Definition: AllocatorList.h:23
llvm::DIType
Base class for types.
Definition: DebugInfoMetadata.h:658
LLVMDIBuilderCreateAutoVariable
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:1512
LLVMDITypeGetOffsetInBits
uint64_t LLVMDITypeGetOffsetInBits(LLVMMetadataRef DType)
Get the offset of this DIType in bits.
Definition: DebugInfo.cpp:1361
LLVMContextRef
struct LLVMOpaqueContext * LLVMContextRef
The top-level container for all LLVM global data.
Definition: Types.h:53
llvm::DILocalScope::getSubprogram
DISubprogram * getSubprogram() const
Get the subprogram for this scope.
Definition: DebugInfoMetadata.cpp:805
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::AArch64CC::AL
@ AL
Definition: AArch64BaseInfo.h:250
llvm::StringRef::empty
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:156
llvm::none_of
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:1496
llvm::NamedMDNode
A tuple of MDNodes.
Definition: Metadata.h:1386
llvm::dwarf
Definition: Dwarf.h:35
LLVMDIBuilderCreateNullPtrType
LLVMMetadataRef LLVMDIBuilderCreateNullPtrType(LLVMDIBuilderRef Builder)
Create C++11 nullptr type.
Definition: DebugInfo.cpp:1292
Metadata.h
llvm::GVMaterializer
Definition: GVMaterializer.h:28
llvm::DebugInfoFinder::reset
void reset()
Clear all lists.
Definition: DebugInfo.cpp:139
IntrinsicInst.h
llvm::DIBuilder
Definition: DIBuilder.h:41
llvm::DILocation::getMergedLocation
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...
Definition: DebugInfoMetadata.cpp:93
DebugInfoMetadata.h
LLVMDIBuilderCreateFunction
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:925
llvm::Function
Definition: Function.h:61
getFunction
static Function * getFunction(Constant *C)
Definition: Evaluator.cpp:253
llvm::DenseMapBase< DenseMap< KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >, KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >::lookup
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:197
StringRef.h
LLVMGenericDINodeMetadataKind
@ LLVMGenericDINodeMetadataKind
Definition: DebugInfo.h:139
LLVMDIVariableGetLine
unsigned LLVMDIVariableGetLine(LLVMMetadataRef Var)
Get the source line where this DIVariable is declared.
Definition: DebugInfo.cpp:1437
LLVMDIBuilderCreateClassType
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:1325
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1168
LLVMDITypeGetLine
unsigned LLVMDITypeGetLine(LLVMMetadataRef DType)
Get the source line where this DIType is declared.
Definition: DebugInfo.cpp:1369
llvm::FunctionLoweringInfo::StatepointRelocationRecord
Helper object to track which of three possible relocation mechanisms are used for a particular value ...
Definition: FunctionLoweringInfo.h:96
LLVMDITypeGetSizeInBits
uint64_t LLVMDITypeGetSizeInBits(LLVMMetadataRef DType)
Get the size of this DIType in bits.
Definition: DebugInfo.cpp:1357
llvm::Function::getSubprogram
DISubprogram * getSubprogram() const
Get the attached subprogram.
Definition: Metadata.cpp:1526
llvm::MipsISD::Lo
@ Lo
Definition: MipsISelLowering.h:79
LLVMDIBuilderCreateModule
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 *APINotesFile, size_t APINotesFileLen)
Creates a new descriptor for a module with the specified parent scope.
Definition: DebugInfo.cpp:905
LLVMDIBuilderCreateSubroutineType
LLVMMetadataRef LLVMDIBuilderCreateSubroutineType(LLVMDIBuilderRef Builder, LLVMMetadataRef File, LLVMMetadataRef *ParameterTypes, unsigned NumParameterTypes, LLVMDIFlags Flags)
Create subroutine type.
Definition: DebugInfo.cpp:1385
llvm::findDbgUsers
void findDbgUsers(SmallVectorImpl< DbgVariableIntrinsic * > &DbgInsts, Value *V)
Finds the debug info intrinsics describing a value.
Definition: DebugInfo.cpp:102
LLVMDIGlobalVariableExpressionGetExpression
LLVMMetadataRef LLVMDIGlobalVariableExpressionGetExpression(LLVMMetadataRef GVE)
Retrieves the DIExpression associated with this global variable expression.
Definition: DebugInfo.cpp:1424
LLVMDIBuilderGetOrCreateSubrange
LLVMMetadataRef LLVMDIBuilderGetOrCreateSubrange(LLVMDIBuilderRef Builder, int64_t Lo, int64_t Count)
Create a descriptor for a value range.
Definition: DebugInfo.cpp:1532
LLVMDIBuilderCreateUnspecifiedType
LLVMMetadataRef LLVMDIBuilderCreateUnspecifiedType(LLVMDIBuilderRef Builder, const char *Name, size_t NameLen)
Create a DWARF unspecified type.
Definition: DebugInfo.cpp:1179
llvm::updateLoopMetadataDebugLocations
void updateLoopMetadataDebugLocations(Instruction &I, function_ref< DILocation *(const DILocation &)> Updater)
Update the debug locations contained within the MD_loop metadata attached to the instruction I,...
Definition: DebugInfo.cpp:376
LLVMDIBuilderCreateTypedef
LLVMMetadataRef LLVMDIBuilderCreateTypedef(LLVMDIBuilderRef Builder, LLVMMetadataRef Type, const char *Name, size_t NameLen, LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Scope, uint32_t AlignInBits)
Create debugging information entry for a typedef.
Definition: DebugInfo.cpp:1232
llvm::DIScope::getName
StringRef getName() const
Definition: DebugInfoMetadata.cpp:254
LLVMDisposeTemporaryMDNode
void LLVMDisposeTemporaryMDNode(LLVMMetadataRef TempNode)
Deallocate a temporary node.
Definition: DebugInfo.cpp:1447
llvm::DILocation
Debug location.
Definition: DebugInfoMetadata.h:1558
llvm::getDISubprogram
DISubprogram * getDISubprogram(const MDNode *Scope)
Find subprogram that is enclosing this scope.
Definition: DebugInfo.cpp:129
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:46
DenseMap.h
llvm::AtomicOrderingCABI::release
@ release
LLVMInstructionSetDebugLoc
void LLVMInstructionSetDebugLoc(LLVMValueRef Inst, LLVMMetadataRef Loc)
Set the debug location for the given instruction.
Definition: DebugInfo.cpp:1560
Module.h
llvm::DbgVariableIntrinsic::getVariable
DILocalVariable * getVariable() const
Definition: IntrinsicInst.h:248
LLVMDIBuilderCreateUnionType
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:1096
LLVMMetadataKind
unsigned LLVMMetadataKind
Definition: DebugInfo.h:167
LLVMDIBuilderCreateObjectPointerType
LLVMMetadataRef LLVMDIBuilderCreateObjectPointerType(LLVMDIBuilderRef Builder, LLVMMetadataRef Type)
Create a uniqued DIType* clone with FlagObjectPointer and FlagArtificial set.
Definition: DebugInfo.cpp:1226
llvm::SmallPtrSet
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
Definition: SmallPtrSet.h:449
llvm::FindDbgAddrUses
TinyPtrVector< DbgVariableIntrinsic * > FindDbgAddrUses(Value *V)
Finds all intrinsics declaring local variables as living in the memory that 'V' points to.
Definition: DebugInfo.cpp:46
LLVMDIBuilderGetOrCreateTypeArray
LLVMMetadataRef LLVMDIBuilderGetOrCreateTypeArray(LLVMDIBuilderRef Builder, LLVMMetadataRef *Types, size_t Length)
Create a type array.
Definition: DebugInfo.cpp:1377
LLVMSetSubprogram
void LLVMSetSubprogram(LLVMValueRef Func, LLVMMetadataRef SP)
Set the subprogram attached to a function.
Definition: DebugInfo.cpp:1548
llvm::MipsISD::Ret
@ Ret
Definition: MipsISelLowering.h:116
LLVMDIFileGetSource
const char * LLVMDIFileGetSource(LLVMMetadataRef File, unsigned *Len)
Get the source of a given file.
Definition: DebugInfo.cpp:1047
STLExtras.h
llvm::dwarf::Tag
Tag
Definition: Dwarf.h:104
updateLoopMetadataDebugLocationsImpl
static MDNode * updateLoopMetadataDebugLocationsImpl(MDNode *OrigLoopID, function_ref< DILocation *(const DILocation &)> Updater)
Definition: DebugInfo.cpp:350
llvm::DINameKind::LinkageName
@ LinkageName
map_from_llvmDWARFsourcelanguage
static unsigned map_from_llvmDWARFsourcelanguage(LLVMDWARFSourceLanguage lang)
Definition: DebugInfo.cpp:820
LLVMDisposeDIBuilder
void LLVMDisposeDIBuilder(LLVMDIBuilderRef Builder)
Deallocates the DIBuilder and everything it owns.
Definition: DebugInfo.cpp:868
LLVMDIBuilderInsertDeclareBefore
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:1470
llvm::detail::DenseSetImpl< ValueT, DenseMap< ValueT, detail::DenseSetEmpty, DenseMapInfo< ValueT >, detail::DenseSetPair< ValueT > >, DenseMapInfo< ValueT > >::insert
std::pair< iterator, bool > insert(const ValueT &V)
Definition: DenseSet.h:206
llvm::DICompileUnit::DebugEmissionKind
DebugEmissionKind
Definition: DebugInfoMetadata.h:1318
llvm::detail::DenseSetImpl< ValueT, DenseMap< ValueT, detail::DenseSetEmpty, DenseMapInfo< ValueT >, detail::DenseSetPair< ValueT > >, DenseMapInfo< ValueT > >::count
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:97
llvm::Data
@ Data
Definition: SIMachineScheduler.h:56
llvm::rust_demangle::BasicType::Unit
@ Unit
LLVMDIBuilderCreateImportedModuleFromNamespace
LLVMMetadataRef LLVMDIBuilderCreateImportedModuleFromNamespace(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, LLVMMetadataRef NS, LLVMMetadataRef File, unsigned Line)
Create a descriptor for an imported namespace.
Definition: DebugInfo.cpp:959
llvm::MDNode::get
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition: Metadata.h:1198
F
#define F(x, y, z)
Definition: MD5.cpp:56
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:58
llvm::MDNode::getNumOperands
unsigned getNumOperands() const
Return number of MDNode operands.
Definition: Metadata.h:1108
LLVMDIBuilderCreateNameSpace
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:917
LLVMDIBuilderCreateImportedModuleFromModule
LLVMMetadataRef LLVMDIBuilderCreateImportedModuleFromModule(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, LLVMMetadataRef M, LLVMMetadataRef File, unsigned Line)
Create a descriptor for an imported module.
Definition: DebugInfo.cpp:983
Instruction.h
LLVMDIVariableGetScope
LLVMMetadataRef LLVMDIVariableGetScope(LLVMMetadataRef Var)
Get the metadata of the scope associated with a given variable.
Definition: DebugInfo.cpp:1433
llvm::ModRefInfo::Ref
@ Ref
The access may reference the value stored in memory.
Constants.h
LLVMDIBuilderCreateReplaceableCompositeType
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:1264
llvm::DbgValueInst
This represents the llvm.dbg.value instruction.
Definition: IntrinsicInst.h:342
llvm::User
Definition: User.h:44
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::NamedMDNode::getName
StringRef getName() const
Definition: Metadata.cpp:1135
LLVMDILocationGetScope
LLVMMetadataRef LLVMDILocationGetScope(LLVMMetadataRef Location)
Get the local scope associated with this debug location.
Definition: DebugInfo.cpp:1023
llvm::DICompileUnit::LineTablesOnly
@ LineTablesOnly
Definition: DebugInfoMetadata.h:1321
LLVMDIBuilderCreateEnumerator
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:1076
LLVMDIBuilderFinalize
void LLVMDIBuilderFinalize(LLVMDIBuilderRef Builder)
Construct any deferred debug info descriptors.
Definition: DebugInfo.cpp:872
llvm::TinyPtrVector::push_back
void push_back(EltTy NewVal)
Definition: TinyPtrVector.h:244
LLVMDITypeGetAlignInBits
uint32_t LLVMDITypeGetAlignInBits(LLVMMetadataRef DType)
Get the alignment of this DIType in bits.
Definition: DebugInfo.cpp:1365
llvm::DISubprogram::DISPFlags
DISPFlags
Debug info subprogram flags.
Definition: DebugInfoMetadata.h:1830
llvm::MDTuple
Tuple of metadata.
Definition: Metadata.h:1139
LLVMBasicBlockRef
struct LLVMOpaqueBasicBlock * LLVMBasicBlockRef
Represents a basic block of instructions in LLVM IR.
Definition: Types.h:82
llvm::Instruction::applyMergedLocation
void applyMergedLocation(const DILocation *LocA, const DILocation *LocB)
Merge 2 debug locations and apply it to the Instruction.
Definition: DebugInfo.cpp:779
map_to_llvmDIFlags
static LLVMDIFlags map_to_llvmDIFlags(DINode::DIFlags Flags)
Definition: DebugInfo.cpp:839
GVMaterializer.h
DenseSet.h
llvm::Instruction
Definition: Instruction.h:45
llvm::FindDbgDeclareUses
TinyPtrVector< DbgDeclareInst * > FindDbgDeclareUses(Value *V)
Like FindDbgAddrUses, but only returns dbg.declare intrinsics, not dbg.addr.
Definition: DebugInfo.cpp:68
llvm::unwrap
Attribute unwrap(LLVMAttributeRef Attr)
Definition: Attributes.h:244
llvm::stripDebugInfo
bool stripDebugInfo(Function &F)
Definition: DebugInfo.cpp:407
LLVMDIBuilderCreateTempMacroFile
LLVMMetadataRef LLVMDIBuilderCreateTempMacroFile(LLVMDIBuilderRef Builder, LLVMMetadataRef ParentMacroFile, unsigned Line, LLVMMetadataRef File)
Create debugging information temporary entry for a macro file.
Definition: DebugInfo.cpp:1069
LLVMDIBuilderCreateBasicType
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:1134
DebugLoc.h
SmallPtrSet.h
llvm::Metadata
Root of the metadata hierarchy.
Definition: Metadata.h:62
llvm::DEBUG_METADATA_VERSION
@ DEBUG_METADATA_VERSION
Definition: Metadata.h:52
llvm::AddressSpace
AddressSpace
Definition: NVPTXBaseInfo.h:21
stripDebugLocFromLoopID
static MDNode * stripDebugLocFromLoopID(MDNode *N)
Definition: DebugInfo.cpp:385
llvm::lltok::Kind
Kind
Definition: LLToken.h:18
llvm::PassSummaryAction::Import
@ Import
Import information from summary.
LLVMDILocationGetLine
unsigned LLVMDILocationGetLine(LLVMMetadataRef Location)
Get the line number of this debug location.
Definition: DebugInfo.cpp:1015
LLVMDIBuilderCreateMacro
LLVMMetadataRef LLVMDIBuilderCreateMacro(LLVMDIBuilderRef Builder, LLVMMetadataRef ParentMacroFile, unsigned Line, LLVMDWARFMacinfoRecordType RecordType, const char *Name, size_t NameLen, const char *Value, size_t ValueLen)
Create debugging information entry for a macro.
Definition: DebugInfo.cpp:1056
llvm::LocalAsMetadata::getIfExists
static LocalAsMetadata * getIfExists(Value *Local)
Definition: Metadata.h:449
unwrapDI
DIT * unwrapDI(LLVMMetadataRef Ref)
Definition: DebugInfo.cpp:831
llvm::function_ref
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLExtras.h:168
llvm::DebugInfoFinder::processSubprogram
void processSubprogram(DISubprogram *SP)
Process subprogram.
Definition: DebugInfo.cpp:258
llvm::MDNode::getOperand
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:1102
LLVMDIBuilderCreateEnumerationType
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:1084
LLVMDIBuilderCreateConstantValueExpression
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:1403
llvm::DenseSet
Implements a dense probed hash-table based set.
Definition: DenseSet.h:268
BasicBlock.h
LLVMDIBuilderCreateInheritance
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:1242
llvm::DbgVariableIntrinsic
This is the common base class for debug info intrinsics for variables.
Definition: IntrinsicInst.h:148
LLVMDIBuilderCreateArrayType
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:1112
LLVMDIFlags
LLVMDIFlags
This file declares the C API endpoints for generating DWARF Debug Info.
Definition: DebugInfo.h:27
LLVMInstructionGetDebugLoc
LLVMMetadataRef LLVMInstructionGetDebugLoc(LLVMValueRef Inst)
Get the debug location for the given instruction.
Definition: DebugInfo.cpp:1556
D
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
LLVMDIGlobalVariableExpressionGetVariable
LLVMMetadataRef LLVMDIGlobalVariableExpressionGetVariable(LLVMMetadataRef GVE)
Retrieves the DIVariable associated with this global variable expression.
Definition: DebugInfo.cpp:1420
llvm::ARM_MB::ST
@ ST
Definition: ARMBaseInfo.h:73
Addr
uint64_t Addr
Definition: ELFObjHandler.cpp:80
DebugInfo.h
LLVMDIBuilderGetOrCreateArray
LLVMMetadataRef LLVMDIBuilderGetOrCreateArray(LLVMDIBuilderRef Builder, LLVMMetadataRef *Data, size_t Length)
Create an array of DI Nodes.
Definition: DebugInfo.cpp:1537
llvm::LLVMContext
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:68
llvm::DenseMap
Definition: DenseMap.h:714
LLVMDIBuilderInsertDbgValueBefore
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:1488
DebugInfo.h
LLVMDIBuilderCreateMemberType
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:1168
I
#define I(x, y, z)
Definition: MD5.cpp:59
llvm::make_early_inc_range
iterator_range< early_inc_iterator_impl< detail::IterOfRange< RangeT > > > make_early_inc_range(RangeT &&Range)
Make a range that does early increment to allow mutation of the underlying range without disrupting i...
Definition: STLExtras.h:572
DIBuilder.h
llvm::DICompileUnit
Compile unit.
Definition: DebugInfoMetadata.h:1313
llvm::findDbgValues
void findDbgValues(SmallVectorImpl< DbgValueInst * > &DbgValues, Value *V)
Finds the llvm.dbg.value intrinsics describing a value.
Definition: DebugInfo.cpp:76
LLVMDIBuilderInsertDbgValueAtEnd
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:1500
llvm::Instruction::updateLocationAfterHoist
void updateLocationAfterHoist()
Updates the debug location given that the instruction has been hoisted from a block to a predecessor ...
Definition: DebugInfo.cpp:784
llvm::Instruction::dropLocation
void dropLocation()
Drop the instruction's debug location.
Definition: DebugInfo.cpp:786
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
LLVMDIBuilderInsertDeclareAtEnd
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:1479
llvm::DebugInfoFinder::processModule
void processModule(const Module &M)
Process entire module and collect debug info anchors.
Definition: DebugInfo.cpp:148
LLVMDIBuilderCreateObjCProperty
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:1212
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:67
llvm::MDNode
Metadata node.
Definition: Metadata.h:897
LLVMDIBuilderCreateParameterVariable
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:1522
LLVMDebugMetadataVersion
unsigned LLVMDebugMetadataVersion()
The current debug metadata version number.
Definition: DebugInfo.cpp:848
Builder
assume Assume Builder
Definition: AssumeBundleBuilder.cpp:651
llvm::DebugInfoFinder::processLocation
void processLocation(const Module &M, const DILocation *Loc)
Process debug info location.
Definition: DebugInfo.cpp:201
llvm::DISubroutineType
Type array for a subprogram.
Definition: DebugInfoMetadata.h:1259
llvm::wrap
LLVMAttributeRef wrap(Attribute Attr)
Definition: Attributes.h:239
getDebugLoc
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.
Definition: MachineInstrBundle.cpp:109
LLVMTemporaryMDNode
LLVMMetadataRef LLVMTemporaryMDNode(LLVMContextRef Ctx, LLVMMetadataRef *Data, size_t Count)
Create a new temporary MDNode.
Definition: DebugInfo.cpp:1441
llvm::DIScope::getScope
DIScope * getScope() const
Definition: DebugInfoMetadata.cpp:230
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:32
None.h
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:57
llvm::DINode
Tagged DWARF-like metadata node.
Definition: DebugInfoMetadata.h:123
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:136
LLVMDIBuilderCreateExpression
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:1396
llvm::DebugInfoFinder::processVariable
void processVariable(const Module &M, const DbgVariableIntrinsic &DVI)
Process DbgVariableIntrinsic.
Definition: DebugInfo.cpp:281
LLVMDIBuilderCreateTempGlobalVariableFwdDecl
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:1458
LLVMGetMetadataKind
LLVMMetadataKind LLVMGetMetadataKind(LLVMMetadataRef Metadata)
Obtain the enumerated type of a Metadata instance.
Definition: DebugInfo.cpp:1567
LLVMDIFileGetDirectory
const char * LLVMDIFileGetDirectory(LLVMMetadataRef File, unsigned *Len)
Get the directory of a given file.
Definition: DebugInfo.cpp:1035
uint32_t
llvm::Value::getContext
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:952
DL
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Definition: AArch64SLSHardening.cpp:76
LLVMDILocationGetInlinedAt
LLVMMetadataRef LLVMDILocationGetInlinedAt(LLVMMetadataRef Location)
Get the "inline at" location associated with this debug location.
Definition: DebugInfo.cpp:1027
LLVMDIBuilderCreateGlobalVariableExpression
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:1408
LLVMDIBuilderCreateObjCIVar
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:1198
llvm::MDTuple::getTemporary
static TempMDTuple getTemporary(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Return a temporary node.
Definition: Metadata.h:1185
llvm::MDNode::getDistinct
static MDTuple * getDistinct(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition: Metadata.h:1206
LLVMDIBuilderCreateCompileUnit
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, const char *SysRoot, size_t SysRootLen, const char *SDK, size_t SDKLen)
A CompileUnit provides an anchor for all debugging information generated during this instance of comp...
Definition: DebugInfo.cpp:876
pack_into_DISPFlags
static DISubprogram::DISPFlags pack_into_DISPFlags(bool IsLocalToUnit, bool IsDefinition, bool IsOptimized)
Definition: DebugInfo.cpp:844
LLVMDIBuilderCreateReferenceType
LLVMMetadataRef LLVMDIBuilderCreateReferenceType(LLVMDIBuilderRef Builder, unsigned Tag, LLVMMetadataRef Type)
Create debugging information entry for a c++ style reference or rvalue reference type.
Definition: DebugInfo.cpp:1285
LLVMDIBuilderCreateLexicalBlock
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:940
llvm::MDNode::getContext
LLVMContext & getContext() const
Definition: Metadata.h:957
llvm::MDNode::isDistinct
bool isDistinct() const
Definition: Metadata.h:976
LLVMDIBuilderCreateMemberPointerType
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:1297
LLVMDIFileGetFilename
const char * LLVMDIFileGetFilename(LLVMMetadataRef File, unsigned *Len)
Get the name of a given file.
Definition: DebugInfo.cpp:1041
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
LLVMBool
int LLVMBool
Definition: Types.h:28
llvm::DIScope
Base class for scope-like contexts.
Definition: DebugInfoMetadata.h:472
get
Should compile to something r4 addze r3 instead we get
Definition: README.txt:24
getFlags
static uint32_t getFlags(const Symbol *Sym)
Definition: TapiFile.cpp:28
llvm::AMDGPU::SendMsg::Op
Op
Definition: SIDefines.h:314
Casting.h
Function.h
LLVMDILocationGetColumn
unsigned LLVMDILocationGetColumn(LLVMMetadataRef Location)
Get the column number of this debug location.
Definition: DebugInfo.cpp:1019
llvm::TargetStackID::Value
Value
Definition: TargetFrameLowering.h:27
llvm::DISubprogram::toSPFlags
static DISPFlags toSPFlags(bool IsLocalToUnit, bool IsDefinition, bool IsOptimized, unsigned Virtuality=SPFlagNonvirtual, bool IsMainSubprogram=false)
Definition: DebugInfoMetadata.h:1850
LLVMDISubprogramGetLine
unsigned LLVMDISubprogramGetLine(LLVMMetadataRef Subprogram)
Get the line associated with a given subprogram.
Definition: DebugInfo.cpp:1552
LLVMDIBuilderCreateFile
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:897
LLVMDIBuilderCreateForwardDecl
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:1252
LLVMDWARFMacinfoRecordType
LLVMDWARFMacinfoRecordType
Describes the kind of macro declaration used for LLVMDIBuilderCreateMacro.
Definition: DebugInfo.h:179
LLVMDIBuilderCreateQualifiedType
LLVMMetadataRef LLVMDIBuilderCreateQualifiedType(LLVMDIBuilderRef Builder, unsigned Tag, LLVMMetadataRef Type)
Create debugging information entry for a qualified type, e.g.
Definition: DebugInfo.cpp:1278
llvm::DICompileUnit::DebugNameTableKind::Default
@ Default
llvm::MDNode::deleteTemporary
static void deleteTemporary(MDNode *N)
Deallocate a node created by getTemporary.
Definition: Metadata.cpp:843
LLVMDIBuilderCreateDebugLocation
LLVMMetadataRef LLVMDIBuilderCreateDebugLocation(LLVMContextRef Ctx, unsigned Line, unsigned Column, LLVMMetadataRef Scope, LLVMMetadataRef InlinedAt)
Creates a new DebugLocation that describes a source location.
Definition: DebugInfo.cpp:1008
llvm::DIGlobalVariableExpression
A pair of DIGlobalVariable and DIExpression.
Definition: DebugInfoMetadata.h:3331
llvm::MDNode::replaceOperandWith
void replaceOperandWith(unsigned I, Metadata *New)
Replace a specific operand.
Definition: Metadata.cpp:871
LLVMDIBuilderCreateImportedDeclaration
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:995
LLVMDITypeGetName
const char * LLVMDITypeGetName(LLVMMetadataRef DType, size_t *Length)
Get the name of this DIType.
Definition: DebugInfo.cpp:1351
LLVMDIBuilderCreateVectorType
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:1123
LLVMDIBuilderRef
struct LLVMOpaqueDIBuilder * LLVMDIBuilderRef
Represents an LLVM debug info builder.
Definition: Types.h:117
llvm::MetadataAsValue::getIfExists
static MetadataAsValue * getIfExists(LLVMContext &Context, Metadata *MD)
Definition: Metadata.cpp:114
SmallVector.h
llvm::DINode::DIFlags
DIFlags
Debug info flags.
Definition: DebugInfoMetadata.h:162
llvm::Value::isUsedByMetadata
bool isUsedByMetadata() const
Return true if there is metadata referencing this value.
Definition: Value.h:566
LLVMGetSubprogram
LLVMMetadataRef LLVMGetSubprogram(LLVMValueRef Func)
Get the metadata of the subprogram attached to a function.
Definition: DebugInfo.cpp:1544
N
#define N
llvm::stripNonLineTableDebugInfo
bool stripNonLineTableDebugInfo(Module &M)
Downgrade the debug info in a module to contain only line table information.
Definition: DebugInfo.cpp:677
LLVMDIBuilderCreateStructType
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:1152
LLVMDWARFSourceLanguage
LLVMDWARFSourceLanguage
Source languages known by DWARF.
Definition: DebugInfo.h:71
getSubprogram
static DISubprogram * getSubprogram(bool IsDistinct, Ts &&... Args)
Definition: DIBuilder.cpp:804
LLVMDITypeGetFlags
LLVMDIFlags LLVMDITypeGetFlags(LLVMMetadataRef DType)
Get the flags associated with this DIType.
Definition: DebugInfo.cpp:1373
llvm::DISubprogram
Subprogram description.
Definition: DebugInfoMetadata.h:1815
llvm::SmallVectorImpl
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:43
LLVMDWARFEmissionKind
LLVMDWARFEmissionKind
The amount of debug information to emit.
Definition: DebugInfo.h:121
LLVMValueRef
struct LLVMOpaqueValue * LLVMValueRef
Represents an individual value in LLVM IR.
Definition: Types.h:75
LLVMStripModuleDebugInfo
LLVMBool LLVMStripModuleDebugInfo(LLVMModuleRef M)
Strip debug info in the module if it exists.
Definition: DebugInfo.cpp:864
llvm::getDebugMetadataVersionFromModule
unsigned getDebugMetadataVersionFromModule(const Module &M)
Return Debug Info Metadata Version by checking module flags.
Definition: DebugInfo.cpp:772
LLVMDIBuilderCreateStaticMemberType
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:1185
BB
Common register allocation spilling lr str ldr sxth r3 ldr mla r4 can lr mov lr str ldr sxth r3 mla r4 and then merge mul and lr str ldr sxth r3 mla r4 It also increase the likelihood the store may become dead bb27 Successors according to LLVM BB
Definition: README.txt:39
LLVMContext.h
createImportedModule
static DIImportedEntity * createImportedModule(LLVMContext &C, dwarf::Tag Tag, DIScope *Context, Metadata *NS, DIFile *File, unsigned Line, StringRef Name, SmallVectorImpl< TrackingMDNodeRef > &AllImportedModules)
Definition: DIBuilder.cpp:165
llvm::DebugLoc
A debug info location.
Definition: DebugLoc.h:33
LLVMDIScopeGetFile
LLVMMetadataRef LLVMDIScopeGetFile(LLVMMetadataRef Scope)
Get the metadata of the file associated with a given scope.
Definition: DebugInfo.cpp:1031
llvm::TinyPtrVector
TinyPtrVector - This class is specialized for cases where there are normally 0 or 1 element in a vect...
Definition: TinyPtrVector.h:30
llvm::DebugInfoFinder::processInstruction
void processInstruction(const Module &M, const Instruction &I)
Process a single instruction and collect debug info anchors.
Definition: DebugInfo.cpp:192
llvm::SmallVectorImpl::reserve
void reserve(size_type N)
Definition: SmallVector.h:624
LLVMMetadataRef
struct LLVMOpaqueMetadata * LLVMMetadataRef
Represents an LLVM Metadata.
Definition: Types.h:89
LLVMGetModuleDebugMetadataVersion
unsigned LLVMGetModuleDebugMetadataVersion(LLVMModuleRef M)
The version of debug metadata that's present in the provided Module.
Definition: DebugInfo.cpp:860
map_from_llvmDIFlags
static DINode::DIFlags map_from_llvmDIFlags(LLVMDIFlags Flags)
Definition: DebugInfo.cpp:835
CU
Definition: AArch64AsmBackend.cpp:506
llvm::Value
LLVM Value Representation.
Definition: Value.h:75
llvm::MDOperand::get
Metadata * get() const
Definition: Metadata.h:755
llvm::Value::users
iterator_range< user_iterator > users()
Definition: Value.h:434
File
Instrumentation for Order File
Definition: InstrOrderFile.cpp:206
LLVMDIBuilderCreateBitFieldMemberType
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:1310
LLVMCreateDIBuilder
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:856
LLVMCreateDIBuilderDisallowUnresolved
LLVMDIBuilderRef LLVMCreateDIBuilderDisallowUnresolved(LLVMModuleRef M)
Construct a builder for a module, and do not allow for unresolved nodes attached to the module.
Definition: DebugInfo.cpp:852
llvm::MDOperand
Tracking metadata reference owned by Metadata.
Definition: Metadata.h:744
LLVMMetadataReplaceAllUsesWith
void LLVMMetadataReplaceAllUsesWith(LLVMMetadataRef TargetMetadata, LLVMMetadataRef Replacement)
Replace all uses of temporary metadata.
Definition: DebugInfo.cpp:1451
llvm::DIScope::getFile
DIFile * getFile() const
Definition: DebugInfoMetadata.h:480
LLVMModuleRef
struct LLVMOpaqueModule * LLVMModuleRef
The top-level container for all other LLVM Intermediate Representation (IR) objects.
Definition: Types.h:61
LLVMDIBuilderCreateArtificialType
LLVMMetadataRef LLVMDIBuilderCreateArtificialType(LLVMDIBuilderRef Builder, LLVMMetadataRef Type)
Create a uniqued DIType* clone with FlagArtificial set.
Definition: DebugInfo.cpp:1346
LLVMDIBuilderCreateImportedModuleFromAlias
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:971
llvm::SmallPtrSetImpl::insert
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:364
llvm::dwarf::MacinfoRecordType
MacinfoRecordType
Definition: Dwarf.h:379
LLVMDIBuilderCreateLexicalBlockFile
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:949