LLVM  14.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, function_ref<Metadata *(Metadata *)> Updater) {
352  assert(OrigLoopID && OrigLoopID->getNumOperands() > 0 &&
353  "Loop ID needs at least one operand");
354  assert(OrigLoopID && OrigLoopID->getOperand(0).get() == OrigLoopID &&
355  "Loop ID should refer to itself");
356 
357  // Save space for the self-referential LoopID.
358  SmallVector<Metadata *, 4> MDs = {nullptr};
359 
360  for (unsigned i = 1; i < OrigLoopID->getNumOperands(); ++i) {
361  Metadata *MD = OrigLoopID->getOperand(i);
362  if (!MD)
363  MDs.push_back(nullptr);
364  else if (Metadata *NewMD = Updater(MD))
365  MDs.push_back(NewMD);
366  }
367 
368  MDNode *NewLoopID = MDNode::getDistinct(OrigLoopID->getContext(), MDs);
369  // Insert the self-referential LoopID.
370  NewLoopID->replaceOperandWith(0, NewLoopID);
371  return NewLoopID;
372 }
373 
375  Instruction &I, function_ref<Metadata *(Metadata *)> Updater) {
376  MDNode *OrigLoopID = I.getMetadata(LLVMContext::MD_loop);
377  if (!OrigLoopID)
378  return;
379  MDNode *NewLoopID = updateLoopMetadataDebugLocationsImpl(OrigLoopID, Updater);
380  I.setMetadata(LLVMContext::MD_loop, NewLoopID);
381 }
382 
383 /// Return true if a node is a DILocation or if a DILocation is
384 /// indirectly referenced by one of the node's children.
386  SmallPtrSetImpl<Metadata *> &Reachable,
387  Metadata *MD) {
388  MDNode *N = dyn_cast_or_null<MDNode>(MD);
389  if (!N)
390  return false;
391  if (isa<DILocation>(N) || Reachable.count(N))
392  return true;
393  if (!Visited.insert(N).second)
394  return false;
395  for (auto &OpIt : N->operands()) {
396  Metadata *Op = OpIt.get();
397  if (isDILocationReachable(Visited, Reachable, Op)) {
398  Reachable.insert(N);
399  return true;
400  }
401  }
402  return false;
403 }
404 
406  assert(!N->operands().empty() && "Missing self reference?");
407  SmallPtrSet<Metadata *, 8> Visited, DILocationReachable;
408  // If we already visited N, there is nothing to do.
409  if (!Visited.insert(N).second)
410  return N;
411 
412  // If there is no debug location, we do not have to rewrite this
413  // MDNode. This loop also initializes DILocationReachable, later
414  // needed by updateLoopMetadataDebugLocationsImpl; the use of
415  // count_if avoids an early exit.
416  if (!std::count_if(N->op_begin() + 1, N->op_end(),
417  [&Visited, &DILocationReachable](const MDOperand &Op) {
418  return isDILocationReachable(
419  Visited, DILocationReachable, Op.get());
420  }))
421  return N;
422 
423  // If there is only the debug location without any actual loop metadata, we
424  // can remove the metadata.
425  if (std::all_of(
426  N->op_begin() + 1, N->op_end(),
427  [&Visited, &DILocationReachable](const MDOperand &Op) {
428  return isDILocationReachable(Visited, DILocationReachable,
429  Op.get());
430  }))
431  return nullptr;
432 
434  N, [&DILocationReachable](Metadata *MD) -> Metadata * {
435  if (isa<DILocation>(MD) || DILocationReachable.count(MD))
436  return nullptr;
437  return MD;
438  });
439 }
440 
442  bool Changed = false;
443  if (F.hasMetadata(LLVMContext::MD_dbg)) {
444  Changed = true;
445  F.setSubprogram(nullptr);
446  }
447 
448  DenseMap<MDNode *, MDNode *> LoopIDsMap;
449  for (BasicBlock &BB : F) {
450  for (auto II = BB.begin(), End = BB.end(); II != End;) {
451  Instruction &I = *II++; // We may delete the instruction, increment now.
452  if (isa<DbgInfoIntrinsic>(&I)) {
453  I.eraseFromParent();
454  Changed = true;
455  continue;
456  }
457  if (I.getDebugLoc()) {
458  Changed = true;
459  I.setDebugLoc(DebugLoc());
460  }
461  if (auto *LoopID = I.getMetadata(LLVMContext::MD_loop)) {
462  auto *NewLoopID = LoopIDsMap.lookup(LoopID);
463  if (!NewLoopID)
464  NewLoopID = LoopIDsMap[LoopID] = stripDebugLocFromLoopID(LoopID);
465  if (NewLoopID != LoopID)
466  I.setMetadata(LLVMContext::MD_loop, NewLoopID);
467  }
468  // Strip heapallocsite attachments, they point into the DIType system.
469  if (I.hasMetadataOtherThanDebugLoc())
470  I.setMetadata("heapallocsite", nullptr);
471  }
472  }
473  return Changed;
474 }
475 
477  bool Changed = false;
478 
479  for (NamedMDNode &NMD : llvm::make_early_inc_range(M.named_metadata())) {
480  // We're stripping debug info, and without them, coverage information
481  // doesn't quite make sense.
482  if (NMD.getName().startswith("llvm.dbg.") ||
483  NMD.getName() == "llvm.gcov") {
484  NMD.eraseFromParent();
485  Changed = true;
486  }
487  }
488 
489  for (Function &F : M)
490  Changed |= stripDebugInfo(F);
491 
492  for (auto &GV : M.globals()) {
493  Changed |= GV.eraseMetadata(LLVMContext::MD_dbg);
494  }
495 
496  if (GVMaterializer *Materializer = M.getMaterializer())
497  Materializer->setStripDebugInfo();
498 
499  return Changed;
500 }
501 
502 namespace {
503 
504 /// Helper class to downgrade -g metadata to -gline-tables-only metadata.
505 class DebugTypeInfoRemoval {
507 
508 public:
509  /// The (void)() type.
510  MDNode *EmptySubroutineType;
511 
512 private:
513  /// Remember what linkage name we originally had before stripping. If we end
514  /// up making two subprograms identical who originally had different linkage
515  /// names, then we need to make one of them distinct, to avoid them getting
516  /// uniqued. Maps the new node to the old linkage name.
517  DenseMap<DISubprogram *, StringRef> NewToLinkageName;
518 
519  // TODO: Remember the distinct subprogram we created for a given linkage name,
520  // so that we can continue to unique whenever possible. Map <newly created
521  // node, old linkage name> to the first (possibly distinct) mdsubprogram
522  // created for that combination. This is not strictly needed for correctness,
523  // but can cut down on the number of MDNodes and let us diff cleanly with the
524  // output of -gline-tables-only.
525 
526 public:
527  DebugTypeInfoRemoval(LLVMContext &C)
528  : EmptySubroutineType(DISubroutineType::get(C, DINode::FlagZero, 0,
529  MDNode::get(C, {}))) {}
530 
531  Metadata *map(Metadata *M) {
532  if (!M)
533  return nullptr;
534  auto Replacement = Replacements.find(M);
535  if (Replacement != Replacements.end())
536  return Replacement->second;
537 
538  return M;
539  }
540  MDNode *mapNode(Metadata *N) { return dyn_cast_or_null<MDNode>(map(N)); }
541 
542  /// Recursively remap N and all its referenced children. Does a DF post-order
543  /// traversal, so as to remap bottoms up.
544  void traverseAndRemap(MDNode *N) { traverse(N); }
545 
546 private:
547  // Create a new DISubprogram, to replace the one given.
548  DISubprogram *getReplacementSubprogram(DISubprogram *MDS) {
549  auto *FileAndScope = cast_or_null<DIFile>(map(MDS->getFile()));
550  StringRef LinkageName = MDS->getName().empty() ? MDS->getLinkageName() : "";
551  DISubprogram *Declaration = nullptr;
552  auto *Type = cast_or_null<DISubroutineType>(map(MDS->getType()));
553  DIType *ContainingType =
554  cast_or_null<DIType>(map(MDS->getContainingType()));
555  auto *Unit = cast_or_null<DICompileUnit>(map(MDS->getUnit()));
556  auto Variables = nullptr;
557  auto TemplateParams = nullptr;
558 
559  // Make a distinct DISubprogram, for situations that warrent it.
560  auto distinctMDSubprogram = [&]() {
562  MDS->getContext(), FileAndScope, MDS->getName(), LinkageName,
563  FileAndScope, MDS->getLine(), Type, MDS->getScopeLine(),
564  ContainingType, MDS->getVirtualIndex(), MDS->getThisAdjustment(),
565  MDS->getFlags(), MDS->getSPFlags(), Unit, TemplateParams, Declaration,
566  Variables);
567  };
568 
569  if (MDS->isDistinct())
570  return distinctMDSubprogram();
571 
572  auto *NewMDS = DISubprogram::get(
573  MDS->getContext(), FileAndScope, MDS->getName(), LinkageName,
574  FileAndScope, MDS->getLine(), Type, MDS->getScopeLine(), ContainingType,
575  MDS->getVirtualIndex(), MDS->getThisAdjustment(), MDS->getFlags(),
576  MDS->getSPFlags(), Unit, TemplateParams, Declaration, Variables);
577 
578  StringRef OldLinkageName = MDS->getLinkageName();
579 
580  // See if we need to make a distinct one.
581  auto OrigLinkage = NewToLinkageName.find(NewMDS);
582  if (OrigLinkage != NewToLinkageName.end()) {
583  if (OrigLinkage->second == OldLinkageName)
584  // We're good.
585  return NewMDS;
586 
587  // Otherwise, need to make a distinct one.
588  // TODO: Query the map to see if we already have one.
589  return distinctMDSubprogram();
590  }
591 
592  NewToLinkageName.insert({NewMDS, MDS->getLinkageName()});
593  return NewMDS;
594  }
595 
596  /// Create a new compile unit, to replace the one given
597  DICompileUnit *getReplacementCU(DICompileUnit *CU) {
598  // Drop skeleton CUs.
599  if (CU->getDWOId())
600  return nullptr;
601 
602  auto *File = cast_or_null<DIFile>(map(CU->getFile()));
603  MDTuple *EnumTypes = nullptr;
604  MDTuple *RetainedTypes = nullptr;
605  MDTuple *GlobalVariables = nullptr;
606  MDTuple *ImportedEntities = nullptr;
608  CU->getContext(), CU->getSourceLanguage(), File, CU->getProducer(),
609  CU->isOptimized(), CU->getFlags(), CU->getRuntimeVersion(),
610  CU->getSplitDebugFilename(), DICompileUnit::LineTablesOnly, EnumTypes,
611  RetainedTypes, GlobalVariables, ImportedEntities, CU->getMacros(),
612  CU->getDWOId(), CU->getSplitDebugInlining(),
613  CU->getDebugInfoForProfiling(), CU->getNameTableKind(),
614  CU->getRangesBaseAddress(), CU->getSysRoot(), CU->getSDK());
615  }
616 
617  DILocation *getReplacementMDLocation(DILocation *MLD) {
618  auto *Scope = map(MLD->getScope());
619  auto *InlinedAt = map(MLD->getInlinedAt());
620  if (MLD->isDistinct())
621  return DILocation::getDistinct(MLD->getContext(), MLD->getLine(),
622  MLD->getColumn(), Scope, InlinedAt);
623  return DILocation::get(MLD->getContext(), MLD->getLine(), MLD->getColumn(),
624  Scope, InlinedAt);
625  }
626 
627  /// Create a new generic MDNode, to replace the one given
628  MDNode *getReplacementMDNode(MDNode *N) {
630  Ops.reserve(N->getNumOperands());
631  for (auto &I : N->operands())
632  if (I)
633  Ops.push_back(map(I));
634  auto *Ret = MDNode::get(N->getContext(), Ops);
635  return Ret;
636  }
637 
638  /// Attempt to re-map N to a newly created node.
639  void remap(MDNode *N) {
640  if (Replacements.count(N))
641  return;
642 
643  auto doRemap = [&](MDNode *N) -> MDNode * {
644  if (!N)
645  return nullptr;
646  if (auto *MDSub = dyn_cast<DISubprogram>(N)) {
647  remap(MDSub->getUnit());
648  return getReplacementSubprogram(MDSub);
649  }
650  if (isa<DISubroutineType>(N))
651  return EmptySubroutineType;
652  if (auto *CU = dyn_cast<DICompileUnit>(N))
653  return getReplacementCU(CU);
654  if (isa<DIFile>(N))
655  return N;
656  if (auto *MDLB = dyn_cast<DILexicalBlockBase>(N))
657  // Remap to our referenced scope (recursively).
658  return mapNode(MDLB->getScope());
659  if (auto *MLD = dyn_cast<DILocation>(N))
660  return getReplacementMDLocation(MLD);
661 
662  // Otherwise, if we see these, just drop them now. Not strictly necessary,
663  // but this speeds things up a little.
664  if (isa<DINode>(N))
665  return nullptr;
666 
667  return getReplacementMDNode(N);
668  };
669  Replacements[N] = doRemap(N);
670  }
671 
672  /// Do the remapping traversal.
673  void traverse(MDNode *);
674 };
675 
676 } // end anonymous namespace
677 
678 void DebugTypeInfoRemoval::traverse(MDNode *N) {
679  if (!N || Replacements.count(N))
680  return;
681 
682  // To avoid cycles, as well as for efficiency sake, we will sometimes prune
683  // parts of the graph.
684  auto prune = [](MDNode *Parent, MDNode *Child) {
685  if (auto *MDS = dyn_cast<DISubprogram>(Parent))
686  return Child == MDS->getRetainedNodes().get();
687  return false;
688  };
689 
691  DenseSet<MDNode *> Opened;
692 
693  // Visit each node starting at N in post order, and map them.
694  ToVisit.push_back(N);
695  while (!ToVisit.empty()) {
696  auto *N = ToVisit.back();
697  if (!Opened.insert(N).second) {
698  // Close it.
699  remap(N);
700  ToVisit.pop_back();
701  continue;
702  }
703  for (auto &I : N->operands())
704  if (auto *MDN = dyn_cast_or_null<MDNode>(I))
705  if (!Opened.count(MDN) && !Replacements.count(MDN) && !prune(N, MDN) &&
706  !isa<DICompileUnit>(MDN))
707  ToVisit.push_back(MDN);
708  }
709 }
710 
712  bool Changed = false;
713 
714  // First off, delete the debug intrinsics.
715  auto RemoveUses = [&](StringRef Name) {
716  if (auto *DbgVal = M.getFunction(Name)) {
717  while (!DbgVal->use_empty())
718  cast<Instruction>(DbgVal->user_back())->eraseFromParent();
719  DbgVal->eraseFromParent();
720  Changed = true;
721  }
722  };
723  RemoveUses("llvm.dbg.addr");
724  RemoveUses("llvm.dbg.declare");
725  RemoveUses("llvm.dbg.label");
726  RemoveUses("llvm.dbg.value");
727 
728  // Delete non-CU debug info named metadata nodes.
729  for (auto NMI = M.named_metadata_begin(), NME = M.named_metadata_end();
730  NMI != NME;) {
731  NamedMDNode *NMD = &*NMI;
732  ++NMI;
733  // Specifically keep dbg.cu around.
734  if (NMD->getName() == "llvm.dbg.cu")
735  continue;
736  }
737 
738  // Drop all dbg attachments from global variables.
739  for (auto &GV : M.globals())
740  GV.eraseMetadata(LLVMContext::MD_dbg);
741 
742  DebugTypeInfoRemoval Mapper(M.getContext());
743  auto remap = [&](MDNode *Node) -> MDNode * {
744  if (!Node)
745  return nullptr;
746  Mapper.traverseAndRemap(Node);
747  auto *NewNode = Mapper.mapNode(Node);
748  Changed |= Node != NewNode;
749  Node = NewNode;
750  return NewNode;
751  };
752 
753  // Rewrite the DebugLocs to be equivalent to what
754  // -gline-tables-only would have created.
755  for (auto &F : M) {
756  if (auto *SP = F.getSubprogram()) {
757  Mapper.traverseAndRemap(SP);
758  auto *NewSP = cast<DISubprogram>(Mapper.mapNode(SP));
759  Changed |= SP != NewSP;
760  F.setSubprogram(NewSP);
761  }
762  for (auto &BB : F) {
763  for (auto &I : BB) {
764  auto remapDebugLoc = [&](const DebugLoc &DL) -> DebugLoc {
765  auto *Scope = DL.getScope();
766  MDNode *InlinedAt = DL.getInlinedAt();
767  Scope = remap(Scope);
768  InlinedAt = remap(InlinedAt);
769  return DILocation::get(M.getContext(), DL.getLine(), DL.getCol(),
770  Scope, InlinedAt);
771  };
772 
773  if (I.getDebugLoc() != DebugLoc())
774  I.setDebugLoc(remapDebugLoc(I.getDebugLoc()));
775 
776  // Remap DILocations in llvm.loop attachments.
778  if (auto *Loc = dyn_cast_or_null<DILocation>(MD))
779  return remapDebugLoc(Loc).get();
780  return MD;
781  });
782 
783  // Strip heapallocsite attachments, they point into the DIType system.
784  if (I.hasMetadataOtherThanDebugLoc())
785  I.setMetadata("heapallocsite", nullptr);
786  }
787  }
788  }
789 
790  // Create a new llvm.dbg.cu, which is equivalent to the one
791  // -gline-tables-only would have created.
792  for (auto &NMD : M.getNamedMDList()) {
794  for (MDNode *Op : NMD.operands())
795  Ops.push_back(remap(Op));
796 
797  if (!Changed)
798  continue;
799 
800  NMD.clearOperands();
801  for (auto *Op : Ops)
802  if (Op)
803  NMD.addOperand(Op);
804  }
805  return Changed;
806 }
807 
809  if (auto *Val = mdconst::dyn_extract_or_null<ConstantInt>(
810  M.getModuleFlag("Debug Info Version")))
811  return Val->getZExtValue();
812  return 0;
813 }
814 
816  const DILocation *LocB) {
817  setDebugLoc(DILocation::getMergedLocation(LocA, LocB));
818 }
819 
820 void Instruction::updateLocationAfterHoist() { dropLocation(); }
821 
823  const DebugLoc &DL = getDebugLoc();
824  if (!DL)
825  return;
826 
827  // If this isn't a call, drop the location to allow a location from a
828  // preceding instruction to propagate.
829  if (!isa<CallBase>(this)) {
830  setDebugLoc(DebugLoc());
831  return;
832  }
833 
834  // Set a line 0 location for calls to preserve scope information in case
835  // inlining occurs.
837  if (SP)
838  // If a function scope is available, set it on the line 0 location. When
839  // hoisting a call to a predecessor block, using the function scope avoids
840  // making it look like the callee was reached earlier than it should be.
841  setDebugLoc(DILocation::get(getContext(), 0, 0, SP));
842  else
843  // The parent function has no scope. Go ahead and drop the location. If
844  // the parent function is inlined, and the callee has a subprogram, the
845  // inliner will attach a location to the call.
846  //
847  // One alternative is to set a line 0 location with the existing scope and
848  // inlinedAt info. The location might be sensitive to when inlining occurs.
849  setDebugLoc(DebugLoc());
850 }
851 
852 //===----------------------------------------------------------------------===//
853 // LLVM C API implementations.
854 //===----------------------------------------------------------------------===//
855 
857  switch (lang) {
858 #define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \
859  case LLVMDWARFSourceLanguage##NAME: \
860  return ID;
861 #include "llvm/BinaryFormat/Dwarf.def"
862 #undef HANDLE_DW_LANG
863  }
864  llvm_unreachable("Unhandled Tag");
865 }
866 
867 template <typename DIT> DIT *unwrapDI(LLVMMetadataRef Ref) {
868  return (DIT *)(Ref ? unwrap<MDNode>(Ref) : nullptr);
869 }
870 
872  return static_cast<DINode::DIFlags>(Flags);
873 }
874 
876  return static_cast<LLVMDIFlags>(Flags);
877 }
878 
880 pack_into_DISPFlags(bool IsLocalToUnit, bool IsDefinition, bool IsOptimized) {
881  return DISubprogram::toSPFlags(IsLocalToUnit, IsDefinition, IsOptimized);
882 }
883 
885  return DEBUG_METADATA_VERSION;
886 }
887 
889  return wrap(new DIBuilder(*unwrap(M), false));
890 }
891 
893  return wrap(new DIBuilder(*unwrap(M)));
894 }
895 
898 }
899 
901  return StripDebugInfo(*unwrap(M));
902 }
903 
905  delete unwrap(Builder);
906 }
907 
909  unwrap(Builder)->finalize();
910 }
911 
914  LLVMMetadataRef FileRef, const char *Producer, size_t ProducerLen,
915  LLVMBool isOptimized, const char *Flags, size_t FlagsLen,
916  unsigned RuntimeVer, const char *SplitName, size_t SplitNameLen,
917  LLVMDWARFEmissionKind Kind, unsigned DWOId, LLVMBool SplitDebugInlining,
918  LLVMBool DebugInfoForProfiling, const char *SysRoot, size_t SysRootLen,
919  const char *SDK, size_t SDKLen) {
920  auto File = unwrapDI<DIFile>(FileRef);
921 
922  return wrap(unwrap(Builder)->createCompileUnit(
924  StringRef(Producer, ProducerLen), isOptimized, StringRef(Flags, FlagsLen),
925  RuntimeVer, StringRef(SplitName, SplitNameLen),
926  static_cast<DICompileUnit::DebugEmissionKind>(Kind), DWOId,
927  SplitDebugInlining, DebugInfoForProfiling,
929  StringRef(SysRoot, SysRootLen), StringRef(SDK, SDKLen)));
930 }
931 
934  size_t FilenameLen, const char *Directory,
935  size_t DirectoryLen) {
936  return wrap(unwrap(Builder)->createFile(StringRef(Filename, FilenameLen),
937  StringRef(Directory, DirectoryLen)));
938 }
939 
942  const char *Name, size_t NameLen,
943  const char *ConfigMacros, size_t ConfigMacrosLen,
944  const char *IncludePath, size_t IncludePathLen,
945  const char *APINotesFile, size_t APINotesFileLen) {
946  return wrap(unwrap(Builder)->createModule(
947  unwrapDI<DIScope>(ParentScope), StringRef(Name, NameLen),
948  StringRef(ConfigMacros, ConfigMacrosLen),
949  StringRef(IncludePath, IncludePathLen),
950  StringRef(APINotesFile, APINotesFileLen)));
951 }
952 
954  LLVMMetadataRef ParentScope,
955  const char *Name, size_t NameLen,
956  LLVMBool ExportSymbols) {
957  return wrap(unwrap(Builder)->createNameSpace(
958  unwrapDI<DIScope>(ParentScope), StringRef(Name, NameLen), ExportSymbols));
959 }
960 
963  size_t NameLen, const char *LinkageName, size_t LinkageNameLen,
964  LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty,
965  LLVMBool IsLocalToUnit, LLVMBool IsDefinition,
966  unsigned ScopeLine, LLVMDIFlags Flags, LLVMBool IsOptimized) {
967  return wrap(unwrap(Builder)->createFunction(
968  unwrapDI<DIScope>(Scope), {Name, NameLen}, {LinkageName, LinkageNameLen},
969  unwrapDI<DIFile>(File), LineNo, unwrapDI<DISubroutineType>(Ty), ScopeLine,
970  map_from_llvmDIFlags(Flags),
971  pack_into_DISPFlags(IsLocalToUnit, IsDefinition, IsOptimized), nullptr,
972  nullptr, nullptr));
973 }
974 
975 
978  LLVMMetadataRef File, unsigned Line, unsigned Col) {
979  return wrap(unwrap(Builder)->createLexicalBlock(unwrapDI<DIScope>(Scope),
980  unwrapDI<DIFile>(File),
981  Line, Col));
982 }
983 
988  unsigned Discriminator) {
989  return wrap(unwrap(Builder)->createLexicalBlockFile(unwrapDI<DIScope>(Scope),
990  unwrapDI<DIFile>(File),
991  Discriminator));
992 }
993 
997  LLVMMetadataRef NS,
999  unsigned Line) {
1000  return wrap(unwrap(Builder)->createImportedModule(unwrapDI<DIScope>(Scope),
1001  unwrapDI<DINamespace>(NS),
1002  unwrapDI<DIFile>(File),
1003  Line));
1004 }
1005 
1008  LLVMMetadataRef ImportedEntity, LLVMMetadataRef File, unsigned Line,
1009  LLVMMetadataRef *Elements, unsigned NumElements) {
1010  auto Elts =
1011  (NumElements > 0)
1012  ? unwrap(Builder)->getOrCreateArray({unwrap(Elements), NumElements})
1013  : nullptr;
1015  unwrapDI<DIScope>(Scope), unwrapDI<DIImportedEntity>(ImportedEntity),
1016  unwrapDI<DIFile>(File), Line, Elts));
1017 }
1018 
1021  LLVMMetadataRef File, unsigned Line, LLVMMetadataRef *Elements,
1022  unsigned NumElements) {
1023  auto Elts =
1024  (NumElements > 0)
1025  ? unwrap(Builder)->getOrCreateArray({unwrap(Elements), NumElements})
1026  : nullptr;
1028  unwrapDI<DIScope>(Scope), unwrapDI<DIModule>(M), unwrapDI<DIFile>(File),
1029  Line, Elts));
1030 }
1031 
1034  LLVMMetadataRef File, unsigned Line, const char *Name, size_t NameLen,
1035  LLVMMetadataRef *Elements, unsigned NumElements) {
1036  auto Elts =
1037  (NumElements > 0)
1038  ? unwrap(Builder)->getOrCreateArray({unwrap(Elements), NumElements})
1039  : nullptr;
1040  return wrap(unwrap(Builder)->createImportedDeclaration(
1041  unwrapDI<DIScope>(Scope), unwrapDI<DINode>(Decl), unwrapDI<DIFile>(File),
1042  Line, {Name, NameLen}, Elts));
1043 }
1044 
1047  unsigned Column, LLVMMetadataRef Scope,
1048  LLVMMetadataRef InlinedAt) {
1049  return wrap(DILocation::get(*unwrap(Ctx), Line, Column, unwrap(Scope),
1050  unwrap(InlinedAt)));
1051 }
1052 
1054  return unwrapDI<DILocation>(Location)->getLine();
1055 }
1056 
1058  return unwrapDI<DILocation>(Location)->getColumn();
1059 }
1060 
1062  return wrap(unwrapDI<DILocation>(Location)->getScope());
1063 }
1064 
1066  return wrap(unwrapDI<DILocation>(Location)->getInlinedAt());
1067 }
1068 
1070  return wrap(unwrapDI<DIScope>(Scope)->getFile());
1071 }
1072 
1073 const char *LLVMDIFileGetDirectory(LLVMMetadataRef File, unsigned *Len) {
1074  auto Dir = unwrapDI<DIFile>(File)->getDirectory();
1075  *Len = Dir.size();
1076  return Dir.data();
1077 }
1078 
1079 const char *LLVMDIFileGetFilename(LLVMMetadataRef File, unsigned *Len) {
1080  auto Name = unwrapDI<DIFile>(File)->getFilename();
1081  *Len = Name.size();
1082  return Name.data();
1083 }
1084 
1085 const char *LLVMDIFileGetSource(LLVMMetadataRef File, unsigned *Len) {
1086  if (auto Src = unwrapDI<DIFile>(File)->getSource()) {
1087  *Len = Src->size();
1088  return Src->data();
1089  }
1090  *Len = 0;
1091  return "";
1092 }
1093 
1095  LLVMMetadataRef ParentMacroFile,
1096  unsigned Line,
1098  const char *Name, size_t NameLen,
1099  const char *Value, size_t ValueLen) {
1100  return wrap(
1101  unwrap(Builder)->createMacro(unwrapDI<DIMacroFile>(ParentMacroFile), Line,
1102  static_cast<MacinfoRecordType>(RecordType),
1103  {Name, NameLen}, {Value, ValueLen}));
1104 }
1105 
1108  LLVMMetadataRef ParentMacroFile, unsigned Line,
1110  return wrap(unwrap(Builder)->createTempMacroFile(
1111  unwrapDI<DIMacroFile>(ParentMacroFile), Line, unwrapDI<DIFile>(File)));
1112 }
1113 
1115  const char *Name, size_t NameLen,
1116  int64_t Value,
1117  LLVMBool IsUnsigned) {
1118  return wrap(unwrap(Builder)->createEnumerator({Name, NameLen}, Value,
1119  IsUnsigned != 0));
1120 }
1121 
1124  size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
1125  uint64_t SizeInBits, uint32_t AlignInBits, LLVMMetadataRef *Elements,
1126  unsigned NumElements, LLVMMetadataRef ClassTy) {
1127 auto Elts = unwrap(Builder)->getOrCreateArray({unwrap(Elements),
1128  NumElements});
1129 return wrap(unwrap(Builder)->createEnumerationType(
1130  unwrapDI<DIScope>(Scope), {Name, NameLen}, unwrapDI<DIFile>(File),
1131  LineNumber, SizeInBits, AlignInBits, Elts, unwrapDI<DIType>(ClassTy)));
1132 }
1133 
1136  size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
1137  uint64_t SizeInBits, uint32_t AlignInBits, LLVMDIFlags Flags,
1138  LLVMMetadataRef *Elements, unsigned NumElements, unsigned RunTimeLang,
1139  const char *UniqueId, size_t UniqueIdLen) {
1140  auto Elts = unwrap(Builder)->getOrCreateArray({unwrap(Elements),
1141  NumElements});
1142  return wrap(unwrap(Builder)->createUnionType(
1143  unwrapDI<DIScope>(Scope), {Name, NameLen}, unwrapDI<DIFile>(File),
1144  LineNumber, SizeInBits, AlignInBits, map_from_llvmDIFlags(Flags),
1145  Elts, RunTimeLang, {UniqueId, UniqueIdLen}));
1146 }
1147 
1148 
1151  uint32_t AlignInBits, LLVMMetadataRef Ty,
1152  LLVMMetadataRef *Subscripts,
1153  unsigned NumSubscripts) {
1154  auto Subs = unwrap(Builder)->getOrCreateArray({unwrap(Subscripts),
1155  NumSubscripts});
1156  return wrap(unwrap(Builder)->createArrayType(Size, AlignInBits,
1157  unwrapDI<DIType>(Ty), Subs));
1158 }
1159 
1162  uint32_t AlignInBits, LLVMMetadataRef Ty,
1163  LLVMMetadataRef *Subscripts,
1164  unsigned NumSubscripts) {
1165  auto Subs = unwrap(Builder)->getOrCreateArray({unwrap(Subscripts),
1166  NumSubscripts});
1167  return wrap(unwrap(Builder)->createVectorType(Size, AlignInBits,
1168  unwrapDI<DIType>(Ty), Subs));
1169 }
1170 
1173  size_t NameLen, uint64_t SizeInBits,
1174  LLVMDWARFTypeEncoding Encoding,
1175  LLVMDIFlags Flags) {
1176  return wrap(unwrap(Builder)->createBasicType({Name, NameLen},
1177  SizeInBits, Encoding,
1178  map_from_llvmDIFlags(Flags)));
1179 }
1180 
1183  uint64_t SizeInBits, uint32_t AlignInBits, unsigned AddressSpace,
1184  const char *Name, size_t NameLen) {
1185  return wrap(unwrap(Builder)->createPointerType(unwrapDI<DIType>(PointeeTy),
1186  SizeInBits, AlignInBits,
1187  AddressSpace, {Name, NameLen}));
1188 }
1189 
1192  size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
1193  uint64_t SizeInBits, uint32_t AlignInBits, LLVMDIFlags Flags,
1194  LLVMMetadataRef DerivedFrom, LLVMMetadataRef *Elements,
1195  unsigned NumElements, unsigned RunTimeLang, LLVMMetadataRef VTableHolder,
1196  const char *UniqueId, size_t UniqueIdLen) {
1197  auto Elts = unwrap(Builder)->getOrCreateArray({unwrap(Elements),
1198  NumElements});
1199  return wrap(unwrap(Builder)->createStructType(
1200  unwrapDI<DIScope>(Scope), {Name, NameLen}, unwrapDI<DIFile>(File),
1201  LineNumber, SizeInBits, AlignInBits, map_from_llvmDIFlags(Flags),
1202  unwrapDI<DIType>(DerivedFrom), Elts, RunTimeLang,
1203  unwrapDI<DIType>(VTableHolder), {UniqueId, UniqueIdLen}));
1204 }
1205 
1208  size_t NameLen, LLVMMetadataRef File, unsigned LineNo, uint64_t SizeInBits,
1209  uint32_t AlignInBits, uint64_t OffsetInBits, LLVMDIFlags Flags,
1210  LLVMMetadataRef Ty) {
1211  return wrap(unwrap(Builder)->createMemberType(unwrapDI<DIScope>(Scope),
1212  {Name, NameLen}, unwrapDI<DIFile>(File), LineNo, SizeInBits, AlignInBits,
1213  OffsetInBits, map_from_llvmDIFlags(Flags), unwrapDI<DIType>(Ty)));
1214 }
1215 
1218  size_t NameLen) {
1219  return wrap(unwrap(Builder)->createUnspecifiedType({Name, NameLen}));
1220 }
1221 
1225  size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
1226  LLVMMetadataRef Type, LLVMDIFlags Flags, LLVMValueRef ConstantVal,
1227  uint32_t AlignInBits) {
1228  return wrap(unwrap(Builder)->createStaticMemberType(
1229  unwrapDI<DIScope>(Scope), {Name, NameLen},
1230  unwrapDI<DIFile>(File), LineNumber, unwrapDI<DIType>(Type),
1231  map_from_llvmDIFlags(Flags), unwrap<Constant>(ConstantVal),
1232  AlignInBits));
1233 }
1234 
1237  const char *Name, size_t NameLen,
1238  LLVMMetadataRef File, unsigned LineNo,
1239  uint64_t SizeInBits, uint32_t AlignInBits,
1240  uint64_t OffsetInBits, LLVMDIFlags Flags,
1241  LLVMMetadataRef Ty, LLVMMetadataRef PropertyNode) {
1242  return wrap(unwrap(Builder)->createObjCIVar(
1243  {Name, NameLen}, unwrapDI<DIFile>(File), LineNo,
1244  SizeInBits, AlignInBits, OffsetInBits,
1245  map_from_llvmDIFlags(Flags), unwrapDI<DIType>(Ty),
1246  unwrapDI<MDNode>(PropertyNode)));
1247 }
1248 
1251  const char *Name, size_t NameLen,
1252  LLVMMetadataRef File, unsigned LineNo,
1253  const char *GetterName, size_t GetterNameLen,
1254  const char *SetterName, size_t SetterNameLen,
1255  unsigned PropertyAttributes,
1256  LLVMMetadataRef Ty) {
1257  return wrap(unwrap(Builder)->createObjCProperty(
1258  {Name, NameLen}, unwrapDI<DIFile>(File), LineNo,
1259  {GetterName, GetterNameLen}, {SetterName, SetterNameLen},
1260  PropertyAttributes, unwrapDI<DIType>(Ty)));
1261 }
1262 
1266  return wrap(unwrap(Builder)->createObjectPointerType(unwrapDI<DIType>(Type)));
1267 }
1268 
1271  const char *Name, size_t NameLen,
1272  LLVMMetadataRef File, unsigned LineNo,
1273  LLVMMetadataRef Scope, uint32_t AlignInBits) {
1274  return wrap(unwrap(Builder)->createTypedef(
1275  unwrapDI<DIType>(Type), {Name, NameLen}, unwrapDI<DIFile>(File), LineNo,
1276  unwrapDI<DIScope>(Scope), AlignInBits));
1277 }
1278 
1281  LLVMMetadataRef Ty, LLVMMetadataRef BaseTy,
1282  uint64_t BaseOffset, uint32_t VBPtrOffset,
1283  LLVMDIFlags Flags) {
1284  return wrap(unwrap(Builder)->createInheritance(
1285  unwrapDI<DIType>(Ty), unwrapDI<DIType>(BaseTy),
1286  BaseOffset, VBPtrOffset, map_from_llvmDIFlags(Flags)));
1287 }
1288 
1291  LLVMDIBuilderRef Builder, unsigned Tag, const char *Name,
1292  size_t NameLen, LLVMMetadataRef Scope, LLVMMetadataRef File, unsigned Line,
1293  unsigned RuntimeLang, uint64_t SizeInBits, uint32_t AlignInBits,
1294  const char *UniqueIdentifier, size_t UniqueIdentifierLen) {
1295  return wrap(unwrap(Builder)->createForwardDecl(
1296  Tag, {Name, NameLen}, unwrapDI<DIScope>(Scope),
1297  unwrapDI<DIFile>(File), Line, RuntimeLang, SizeInBits,
1298  AlignInBits, {UniqueIdentifier, UniqueIdentifierLen}));
1299 }
1300 
1303  LLVMDIBuilderRef Builder, unsigned Tag, const char *Name,
1304  size_t NameLen, LLVMMetadataRef Scope, LLVMMetadataRef File, unsigned Line,
1305  unsigned RuntimeLang, uint64_t SizeInBits, uint32_t AlignInBits,
1306  LLVMDIFlags Flags, const char *UniqueIdentifier,
1307  size_t UniqueIdentifierLen) {
1308  return wrap(unwrap(Builder)->createReplaceableCompositeType(
1309  Tag, {Name, NameLen}, unwrapDI<DIScope>(Scope),
1310  unwrapDI<DIFile>(File), Line, RuntimeLang, SizeInBits,
1311  AlignInBits, map_from_llvmDIFlags(Flags),
1312  {UniqueIdentifier, UniqueIdentifierLen}));
1313 }
1314 
1318  return wrap(unwrap(Builder)->createQualifiedType(Tag,
1319  unwrapDI<DIType>(Type)));
1320 }
1321 
1325  return wrap(unwrap(Builder)->createReferenceType(Tag,
1326  unwrapDI<DIType>(Type)));
1327 }
1328 
1331  return wrap(unwrap(Builder)->createNullPtrType());
1332 }
1333 
1336  LLVMMetadataRef PointeeType,
1337  LLVMMetadataRef ClassType,
1338  uint64_t SizeInBits,
1339  uint32_t AlignInBits,
1340  LLVMDIFlags Flags) {
1341  return wrap(unwrap(Builder)->createMemberPointerType(
1342  unwrapDI<DIType>(PointeeType),
1343  unwrapDI<DIType>(ClassType), AlignInBits, SizeInBits,
1344  map_from_llvmDIFlags(Flags)));
1345 }
1346 
1350  const char *Name, size_t NameLen,
1351  LLVMMetadataRef File, unsigned LineNumber,
1352  uint64_t SizeInBits,
1353  uint64_t OffsetInBits,
1354  uint64_t StorageOffsetInBits,
1355  LLVMDIFlags Flags, LLVMMetadataRef Type) {
1356  return wrap(unwrap(Builder)->createBitFieldMemberType(
1357  unwrapDI<DIScope>(Scope), {Name, NameLen},
1358  unwrapDI<DIFile>(File), LineNumber,
1359  SizeInBits, OffsetInBits, StorageOffsetInBits,
1360  map_from_llvmDIFlags(Flags), unwrapDI<DIType>(Type)));
1361 }
1362 
1364  LLVMMetadataRef Scope, const char *Name, size_t NameLen,
1365  LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits,
1366  uint32_t AlignInBits, uint64_t OffsetInBits, LLVMDIFlags Flags,
1367  LLVMMetadataRef DerivedFrom,
1368  LLVMMetadataRef *Elements, unsigned NumElements,
1369  LLVMMetadataRef VTableHolder, LLVMMetadataRef TemplateParamsNode,
1370  const char *UniqueIdentifier, size_t UniqueIdentifierLen) {
1371  auto Elts = unwrap(Builder)->getOrCreateArray({unwrap(Elements),
1372  NumElements});
1373  return wrap(unwrap(Builder)->createClassType(
1374  unwrapDI<DIScope>(Scope), {Name, NameLen},
1375  unwrapDI<DIFile>(File), LineNumber,
1376  SizeInBits, AlignInBits, OffsetInBits,
1377  map_from_llvmDIFlags(Flags), unwrapDI<DIType>(DerivedFrom),
1378  Elts, unwrapDI<DIType>(VTableHolder),
1379  unwrapDI<MDNode>(TemplateParamsNode),
1380  {UniqueIdentifier, UniqueIdentifierLen}));
1381 }
1382 
1386  return wrap(unwrap(Builder)->createArtificialType(unwrapDI<DIType>(Type)));
1387 }
1388 
1389 const char *LLVMDITypeGetName(LLVMMetadataRef DType, size_t *Length) {
1390  StringRef Str = unwrap<DIType>(DType)->getName();
1391  *Length = Str.size();
1392  return Str.data();
1393 }
1394 
1396  return unwrapDI<DIType>(DType)->getSizeInBits();
1397 }
1398 
1400  return unwrapDI<DIType>(DType)->getOffsetInBits();
1401 }
1402 
1404  return unwrapDI<DIType>(DType)->getAlignInBits();
1405 }
1406 
1408  return unwrapDI<DIType>(DType)->getLine();
1409 }
1410 
1412  return map_to_llvmDIFlags(unwrapDI<DIType>(DType)->getFlags());
1413 }
1414 
1416  LLVMMetadataRef *Types,
1417  size_t Length) {
1418  return wrap(
1419  unwrap(Builder)->getOrCreateTypeArray({unwrap(Types), Length}).get());
1420 }
1421 
1425  LLVMMetadataRef *ParameterTypes,
1426  unsigned NumParameterTypes,
1427  LLVMDIFlags Flags) {
1428  auto Elts = unwrap(Builder)->getOrCreateTypeArray({unwrap(ParameterTypes),
1429  NumParameterTypes});
1430  return wrap(unwrap(Builder)->createSubroutineType(
1431  Elts, map_from_llvmDIFlags(Flags)));
1432 }
1433 
1435  int64_t *Addr, size_t Length) {
1436  return wrap(unwrap(Builder)->createExpression(ArrayRef<int64_t>(Addr,
1437  Length)));
1438 }
1439 
1442  int64_t Value) {
1443  return wrap(unwrap(Builder)->createConstantValueExpression(Value));
1444 }
1445 
1448  size_t NameLen, const char *Linkage, size_t LinkLen, LLVMMetadataRef File,
1449  unsigned LineNo, LLVMMetadataRef Ty, LLVMBool LocalToUnit,
1450  LLVMMetadataRef Expr, LLVMMetadataRef Decl, uint32_t AlignInBits) {
1451  return wrap(unwrap(Builder)->createGlobalVariableExpression(
1452  unwrapDI<DIScope>(Scope), {Name, NameLen}, {Linkage, LinkLen},
1453  unwrapDI<DIFile>(File), LineNo, unwrapDI<DIType>(Ty), LocalToUnit,
1454  true, unwrap<DIExpression>(Expr), unwrapDI<MDNode>(Decl),
1455  nullptr, AlignInBits));
1456 }
1457 
1459  return wrap(unwrapDI<DIGlobalVariableExpression>(GVE)->getVariable());
1460 }
1461 
1463  LLVMMetadataRef GVE) {
1464  return wrap(unwrapDI<DIGlobalVariableExpression>(GVE)->getExpression());
1465 }
1466 
1468  return wrap(unwrapDI<DIVariable>(Var)->getFile());
1469 }
1470 
1472  return wrap(unwrapDI<DIVariable>(Var)->getScope());
1473 }
1474 
1476  return unwrapDI<DIVariable>(Var)->getLine();
1477 }
1478 
1480  size_t Count) {
1481  return wrap(
1482  MDTuple::getTemporary(*unwrap(Ctx), {unwrap(Data), Count}).release());
1483 }
1484 
1486  MDNode::deleteTemporary(unwrapDI<MDNode>(TempNode));
1487 }
1488 
1490  LLVMMetadataRef Replacement) {
1491  auto *Node = unwrapDI<MDNode>(TargetMetadata);
1492  Node->replaceAllUsesWith(unwrap<Metadata>(Replacement));
1494 }
1495 
1498  size_t NameLen, const char *Linkage, size_t LnkLen, LLVMMetadataRef File,
1499  unsigned LineNo, LLVMMetadataRef Ty, LLVMBool LocalToUnit,
1500  LLVMMetadataRef Decl, uint32_t AlignInBits) {
1501  return wrap(unwrap(Builder)->createTempGlobalVariableFwdDecl(
1502  unwrapDI<DIScope>(Scope), {Name, NameLen}, {Linkage, LnkLen},
1503  unwrapDI<DIFile>(File), LineNo, unwrapDI<DIType>(Ty), LocalToUnit,
1504  unwrapDI<MDNode>(Decl), nullptr, AlignInBits));
1505 }
1506 
1509  LLVMMetadataRef VarInfo, LLVMMetadataRef Expr,
1510  LLVMMetadataRef DL, LLVMValueRef Instr) {
1511  return wrap(unwrap(Builder)->insertDeclare(
1512  unwrap(Storage), unwrap<DILocalVariable>(VarInfo),
1513  unwrap<DIExpression>(Expr), unwrap<DILocation>(DL),
1514  unwrap<Instruction>(Instr)));
1515 }
1516 
1520  return wrap(unwrap(Builder)->insertDeclare(
1521  unwrap(Storage), unwrap<DILocalVariable>(VarInfo),
1522  unwrap<DIExpression>(Expr), unwrap<DILocation>(DL),
1523  unwrap(Block)));
1524 }
1525 
1527  LLVMValueRef Val,
1528  LLVMMetadataRef VarInfo,
1529  LLVMMetadataRef Expr,
1531  LLVMValueRef Instr) {
1532  return wrap(unwrap(Builder)->insertDbgValueIntrinsic(
1533  unwrap(Val), unwrap<DILocalVariable>(VarInfo),
1534  unwrap<DIExpression>(Expr), unwrap<DILocation>(DebugLoc),
1535  unwrap<Instruction>(Instr)));
1536 }
1537 
1539  LLVMValueRef Val,
1540  LLVMMetadataRef VarInfo,
1541  LLVMMetadataRef Expr,
1543  LLVMBasicBlockRef Block) {
1544  return wrap(unwrap(Builder)->insertDbgValueIntrinsic(
1545  unwrap(Val), unwrap<DILocalVariable>(VarInfo),
1546  unwrap<DIExpression>(Expr), unwrap<DILocation>(DebugLoc),
1547  unwrap(Block)));
1548 }
1549 
1552  size_t NameLen, LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty,
1553  LLVMBool AlwaysPreserve, LLVMDIFlags Flags, uint32_t AlignInBits) {
1554  return wrap(unwrap(Builder)->createAutoVariable(
1555  unwrap<DIScope>(Scope), {Name, NameLen}, unwrap<DIFile>(File),
1556  LineNo, unwrap<DIType>(Ty), AlwaysPreserve,
1557  map_from_llvmDIFlags(Flags), AlignInBits));
1558 }
1559 
1562  size_t NameLen, unsigned ArgNo, LLVMMetadataRef File, unsigned LineNo,
1563  LLVMMetadataRef Ty, LLVMBool AlwaysPreserve, LLVMDIFlags Flags) {
1564  return wrap(unwrap(Builder)->createParameterVariable(
1565  unwrap<DIScope>(Scope), {Name, NameLen}, ArgNo, unwrap<DIFile>(File),
1566  LineNo, unwrap<DIType>(Ty), AlwaysPreserve,
1567  map_from_llvmDIFlags(Flags)));
1568 }
1569 
1571  int64_t Lo, int64_t Count) {
1572  return wrap(unwrap(Builder)->getOrCreateSubrange(Lo, Count));
1573 }
1574 
1576  LLVMMetadataRef *Data,
1577  size_t Length) {
1578  Metadata **DataValue = unwrap(Data);
1579  return wrap(unwrap(Builder)->getOrCreateArray({DataValue, Length}).get());
1580 }
1581 
1583  return wrap(unwrap<Function>(Func)->getSubprogram());
1584 }
1585 
1587  unwrap<Function>(Func)->setSubprogram(unwrap<DISubprogram>(SP));
1588 }
1589 
1591  return unwrapDI<DISubprogram>(Subprogram)->getLine();
1592 }
1593 
1595  return wrap(unwrap<Instruction>(Inst)->getDebugLoc().getAsMDNode());
1596 }
1597 
1599  if (Loc)
1600  unwrap<Instruction>(Inst)->setDebugLoc(DebugLoc(unwrap<MDNode>(Loc)));
1601  else
1602  unwrap<Instruction>(Inst)->setDebugLoc(DebugLoc());
1603 }
1604 
1606  switch(unwrap(Metadata)->getMetadataID()) {
1607 #define HANDLE_METADATA_LEAF(CLASS) \
1608  case Metadata::CLASS##Kind: \
1609  return (LLVMMetadataKind)LLVM##CLASS##MetadataKind;
1610 #include "llvm/IR/Metadata.def"
1611  default:
1613  }
1614 }
llvm::Check::Size
@ Size
Definition: FileCheck.h:73
llvm::DIType::getScope
DIScope * getScope() const
Definition: DebugInfoMetadata.h:707
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:1467
llvm::StripDebugInfo
bool StripDebugInfo(Module &M)
Strip debug info in the module if it exists.
Definition: DebugInfo.cpp:476
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:1181
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
llvm::DIType
Base class for types.
Definition: DebugInfoMetadata.h:662
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:1550
LLVMDITypeGetOffsetInBits
uint64_t LLVMDITypeGetOffsetInBits(LLVMMetadataRef DType)
Get the offset of this DIType in bits.
Definition: DebugInfo.cpp:1399
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:814
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:269
llvm::StringRef::empty
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:153
llvm::NamedMDNode
A tuple of MDNodes.
Definition: Metadata.h:1396
llvm::dwarf
Definition: Dwarf.h:35
LLVMDIBuilderCreateNullPtrType
LLVMMetadataRef LLVMDIBuilderCreateNullPtrType(LLVMDIBuilderRef Builder)
Create C++11 nullptr type.
Definition: DebugInfo.cpp:1330
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:100
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:961
T
llvm::Function
Definition: Function.h:61
getFunction
static Function * getFunction(Constant *C)
Definition: Evaluator.cpp:255
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
LLVMDIVariableGetLine
unsigned LLVMDIVariableGetLine(LLVMMetadataRef Var)
Get the source line where this DIVariable is declared.
Definition: DebugInfo.cpp:1475
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:1363
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:1407
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:1395
llvm::Function::getSubprogram
DISubprogram * getSubprogram() const
Get the attached subprogram.
Definition: Metadata.cpp:1541
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:941
LLVMDIBuilderCreateSubroutineType
LLVMMetadataRef LLVMDIBuilderCreateSubroutineType(LLVMDIBuilderRef Builder, LLVMMetadataRef File, LLVMMetadataRef *ParameterTypes, unsigned NumParameterTypes, LLVMDIFlags Flags)
Create subroutine type.
Definition: DebugInfo.cpp:1423
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:1462
LLVMDIBuilderGetOrCreateSubrange
LLVMMetadataRef LLVMDIBuilderGetOrCreateSubrange(LLVMDIBuilderRef Builder, int64_t Lo, int64_t Count)
Create a descriptor for a value range.
Definition: DebugInfo.cpp:1570
LLVMDIBuilderCreateUnspecifiedType
LLVMMetadataRef LLVMDIBuilderCreateUnspecifiedType(LLVMDIBuilderRef Builder, const char *Name, size_t NameLen)
Create a DWARF unspecified type.
Definition: DebugInfo.cpp:1217
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:1270
llvm::DIScope::getName
StringRef getName() const
Definition: DebugInfoMetadata.cpp:261
LLVMDisposeTemporaryMDNode
void LLVMDisposeTemporaryMDNode(LLVMMetadataRef TempNode)
Deallocate a temporary node.
Definition: DebugInfo.cpp:1485
llvm::DILocation
Debug location.
Definition: DebugInfoMetadata.h:1580
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:45
DenseMap.h
llvm::AtomicOrderingCABI::release
@ release
LLVMInstructionSetDebugLoc
void LLVMInstructionSetDebugLoc(LLVMValueRef Inst, LLVMMetadataRef Loc)
Set the debug location for the given instruction.
Definition: DebugInfo.cpp:1598
Module.h
llvm::DbgVariableIntrinsic::getVariable
DILocalVariable * getVariable() const
Definition: IntrinsicInst.h:253
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:1134
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:1264
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:1415
LLVMSetSubprogram
void LLVMSetSubprogram(LLVMValueRef Func, LLVMMetadataRef SP)
Set the subprogram attached to a function.
Definition: DebugInfo.cpp:1586
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:1085
STLExtras.h
llvm::dwarf::Tag
Tag
Definition: Dwarf.h:104
llvm::DINameKind::LinkageName
@ LinkageName
map_from_llvmDWARFsourcelanguage
static unsigned map_from_llvmDWARFsourcelanguage(LLVMDWARFSourceLanguage lang)
Definition: DebugInfo.cpp:856
LLVMDisposeDIBuilder
void LLVMDisposeDIBuilder(LLVMDIBuilderRef Builder)
Deallocates the DIBuilder and everything it owns.
Definition: DebugInfo.cpp:904
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:1508
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:1340
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::count_if
auto count_if(R &&Range, UnaryPredicate P)
Wrapper function around std::count_if to count the number of times an element satisfying a given pred...
Definition: STLExtras.h:1641
llvm::Data
@ Data
Definition: SIMachineScheduler.h:55
LLVMDIBuilderCreateImportedModuleFromNamespace
LLVMMetadataRef LLVMDIBuilderCreateImportedModuleFromNamespace(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, LLVMMetadataRef NS, LLVMMetadataRef File, unsigned Line)
Create a descriptor for an imported namespace.
Definition: DebugInfo.cpp:995
llvm::MDNode::get
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition: Metadata.h:1208
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:1118
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:953
Instruction.h
llvm::all_of
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1551
LLVMDIVariableGetScope
LLVMMetadataRef LLVMDIVariableGetScope(LLVMMetadataRef Var)
Get the metadata of the scope associated with a given variable.
Definition: DebugInfo.cpp:1471
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:1302
llvm::DbgValueInst
This represents the llvm.dbg.value instruction.
Definition: IntrinsicInst.h:347
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:1141
LLVMDILocationGetScope
LLVMMetadataRef LLVMDILocationGetScope(LLVMMetadataRef Location)
Get the local scope associated with this debug location.
Definition: DebugInfo.cpp:1061
llvm::DICompileUnit::LineTablesOnly
@ LineTablesOnly
Definition: DebugInfoMetadata.h:1343
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:1114
LLVMDIBuilderFinalize
void LLVMDIBuilderFinalize(LLVMDIBuilderRef Builder)
Construct any deferred debug info descriptors.
Definition: DebugInfo.cpp:908
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:1403
llvm::DISubprogram::DISPFlags
DISPFlags
Debug info subprogram flags.
Definition: DebugInfoMetadata.h:1835
llvm::MDTuple
Tuple of metadata.
Definition: Metadata.h:1149
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:815
map_to_llvmDIFlags
static LLVMDIFlags map_to_llvmDIFlags(DINode::DIFlags Flags)
Definition: DebugInfo.cpp:875
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:256
llvm::stripDebugInfo
bool stripDebugInfo(Function &F)
Definition: DebugInfo.cpp:441
LLVMDIBuilderCreateTempMacroFile
LLVMMetadataRef LLVMDIBuilderCreateTempMacroFile(LLVMDIBuilderRef Builder, LLVMMetadataRef ParentMacroFile, unsigned Line, LLVMMetadataRef File)
Create debugging information temporary entry for a macro file.
Definition: DebugInfo.cpp:1107
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:1172
DebugLoc.h
SmallPtrSet.h
createImportedModule
static DIImportedEntity * createImportedModule(LLVMContext &C, dwarf::Tag Tag, DIScope *Context, Metadata *NS, DIFile *File, unsigned Line, StringRef Name, DINodeArray Elements, SmallVectorImpl< TrackingMDNodeRef > &AllImportedModules)
Definition: DIBuilder.cpp:166
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:405
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:1053
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:1094
llvm::LocalAsMetadata::getIfExists
static LocalAsMetadata * getIfExists(Value *Local)
Definition: Metadata.h:449
unwrapDI
DIT * unwrapDI(LLVMMetadataRef Ref)
Definition: DebugInfo.cpp:867
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:1112
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:1122
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:1441
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:1280
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:1150
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:1594
uint64_t
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:1458
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:1575
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:1526
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:1206
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:576
DIBuilder.h
llvm::DICompileUnit
Compile unit.
Definition: DebugInfoMetadata.h:1335
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:1538
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:820
llvm::Instruction::dropLocation
void dropLocation()
Drop the instruction's debug location.
Definition: DebugInfo.cpp:822
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:1517
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:1250
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:906
LLVMDIBuilderCreateImportedDeclaration
LLVMMetadataRef LLVMDIBuilderCreateImportedDeclaration(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, LLVMMetadataRef Decl, LLVMMetadataRef File, unsigned Line, const char *Name, size_t NameLen, LLVMMetadataRef *Elements, unsigned NumElements)
Create a descriptor for an imported function, type, or variable.
Definition: DebugInfo.cpp:1032
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:1560
LLVMDebugMetadataVersion
unsigned LLVMDebugMetadataVersion()
The current debug metadata version number.
Definition: DebugInfo.cpp:884
llvm::SmallPtrSetImpl::count
size_type count(ConstPtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
Definition: SmallPtrSet.h:382
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
isDILocationReachable
static bool isDILocationReachable(SmallPtrSetImpl< Metadata * > &Visited, SmallPtrSetImpl< Metadata * > &Reachable, Metadata *MD)
Return true if a node is a DILocation or if a DILocation is indirectly referenced by one of the node'...
Definition: DebugInfo.cpp:385
llvm::DISubroutineType
Type array for a subprogram.
Definition: DebugInfoMetadata.h:1281
llvm::wrap
LLVMAttributeRef wrap(Attribute Attr)
Definition: Attributes.h:251
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:1479
llvm::DIScope::getScope
DIScope * getScope() const
Definition: DebugInfoMetadata.cpp:237
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:58
llvm::DINode
Tagged DWARF-like metadata node.
Definition: DebugInfoMetadata.h:127
updateLoopMetadataDebugLocationsImpl
static MDNode * updateLoopMetadataDebugLocationsImpl(MDNode *OrigLoopID, function_ref< Metadata *(Metadata *)> Updater)
Definition: DebugInfo.cpp:350
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:1434
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:1496
LLVMGetMetadataKind
LLVMMetadataKind LLVMGetMetadataKind(LLVMMetadataRef Metadata)
Obtain the enumerated type of a Metadata instance.
Definition: DebugInfo.cpp:1605
LLVMDIFileGetDirectory
const char * LLVMDIFileGetDirectory(LLVMMetadataRef File, unsigned *Len)
Get the directory of a given file.
Definition: DebugInfo.cpp:1073
uint32_t
llvm::Value::getContext
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:990
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:1065
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:1446
llvm::updateLoopMetadataDebugLocations
void updateLoopMetadataDebugLocations(Instruction &I, function_ref< Metadata *(Metadata *)> Updater)
Update the debug locations contained within the MD_loop metadata attached to the instruction I,...
Definition: DebugInfo.cpp:374
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:1236
llvm::MDTuple::getTemporary
static TempMDTuple getTemporary(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Return a temporary node.
Definition: Metadata.h:1195
llvm::MDNode::getDistinct
static MDTuple * getDistinct(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition: Metadata.h:1216
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:912
pack_into_DISPFlags
static DISubprogram::DISPFlags pack_into_DISPFlags(bool IsLocalToUnit, bool IsDefinition, bool IsOptimized)
Definition: DebugInfo.cpp:880
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:1323
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:976
llvm::MDNode::getContext
LLVMContext & getContext() const
Definition: Metadata.h:967
llvm::MDNode::isDistinct
bool isDistinct() const
Definition: Metadata.h:986
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:1335
LLVMDIFileGetFilename
const char * LLVMDIFileGetFilename(LLVMMetadataRef File, unsigned *Len)
Get the name of a given file.
Definition: DebugInfo.cpp:1079
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
LLVMDIBuilderCreateImportedModuleFromModule
LLVMMetadataRef LLVMDIBuilderCreateImportedModuleFromModule(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, LLVMMetadataRef M, LLVMMetadataRef File, unsigned Line, LLVMMetadataRef *Elements, unsigned NumElements)
Create a descriptor for an imported module.
Definition: DebugInfo.cpp:1019
LLVMBool
int LLVMBool
Definition: Types.h:28
llvm::DIScope
Base class for scope-like contexts.
Definition: DebugInfoMetadata.h:476
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:23
llvm::AMDGPU::SendMsg::Op
Op
Definition: SIDefines.h:321
Casting.h
Function.h
LLVMDILocationGetColumn
unsigned LLVMDILocationGetColumn(LLVMMetadataRef Location)
Get the column number of this debug location.
Definition: DebugInfo.cpp:1057
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:1855
LLVMDISubprogramGetLine
unsigned LLVMDISubprogramGetLine(LLVMMetadataRef Subprogram)
Get the line associated with a given subprogram.
Definition: DebugInfo.cpp:1590
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:933
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:1290
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:1316
llvm::DICompileUnit::DebugNameTableKind::Default
@ Default
llvm::MDNode::deleteTemporary
static void deleteTemporary(MDNode *N)
Deallocate a node created by getTemporary.
Definition: Metadata.cpp:849
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:1046
llvm::DIGlobalVariableExpression
A pair of DIGlobalVariable and DIExpression.
Definition: DebugInfoMetadata.h:3401
llvm::MDNode::replaceOperandWith
void replaceOperandWith(unsigned I, Metadata *New)
Replace a specific operand.
Definition: Metadata.cpp:877
LLVMDITypeGetName
const char * LLVMDITypeGetName(LLVMMetadataRef DType, size_t *Length)
Get the name of this DIType.
Definition: DebugInfo.cpp:1389
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:1161
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:166
llvm::Value::isUsedByMetadata
bool isUsedByMetadata() const
Return true if there is metadata referencing this value.
Definition: Value.h:558
LLVMGetSubprogram
LLVMMetadataRef LLVMGetSubprogram(LLVMValueRef Func)
Get the metadata of the subprogram attached to a function.
Definition: DebugInfo.cpp:1582
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:711
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:1190
LLVMDWARFSourceLanguage
LLVMDWARFSourceLanguage
Source languages known by DWARF.
Definition: DebugInfo.h:71
getSubprogram
static DISubprogram * getSubprogram(bool IsDistinct, Ts &&... Args)
Definition: DIBuilder.cpp:819
LLVMGenericDINodeMetadataKind
@ LLVMGenericDINodeMetadataKind
Definition: DebugInfo.h:139
LLVMDITypeGetFlags
LLVMDIFlags LLVMDITypeGetFlags(LLVMMetadataRef DType)
Get the flags associated with this DIType.
Definition: DebugInfo.cpp:1411
llvm::DISubprogram
Subprogram description.
Definition: DebugInfoMetadata.h:1820
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:900
llvm::SmallPtrSetImpl
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
Definition: SmallPtrSet.h:343
llvm::getDebugMetadataVersionFromModule
unsigned getDebugMetadataVersionFromModule(const Module &M)
Return Debug Info Metadata Version by checking module flags.
Definition: DebugInfo.cpp:808
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:1223
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
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:1069
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
LLVMDIBuilderCreateImportedModuleFromAlias
LLVMMetadataRef LLVMDIBuilderCreateImportedModuleFromAlias(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, LLVMMetadataRef ImportedEntity, LLVMMetadataRef File, unsigned Line, LLVMMetadataRef *Elements, unsigned NumElements)
Create a descriptor for an imported module that aliases another imported entity descriptor.
Definition: DebugInfo.cpp:1006
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:896
map_from_llvmDIFlags
static DINode::DIFlags map_from_llvmDIFlags(LLVMDIFlags Flags)
Definition: DebugInfo.cpp:871
CU
Definition: AArch64AsmBackend.cpp:501
llvm::Value
LLVM Value Representation.
Definition: Value.h:75
llvm::MDOperand::get
Metadata * get() const
Definition: Metadata.h:764
llvm::Value::users
iterator_range< user_iterator > users()
Definition: Value.h:422
File
Instrumentation for Order File
Definition: InstrOrderFile.cpp:205
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:1348
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:892
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:888
llvm::MDOperand
Tracking metadata reference owned by Metadata.
Definition: Metadata.h:753
LLVMMetadataReplaceAllUsesWith
void LLVMMetadataReplaceAllUsesWith(LLVMMetadataRef TargetMetadata, LLVMMetadataRef Replacement)
Replace all uses of temporary metadata.
Definition: DebugInfo.cpp:1489
llvm::DIScope::getFile
DIFile * getFile() const
Definition: DebugInfoMetadata.h:484
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:1384
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:985