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) {
451  if (isa<DbgInfoIntrinsic>(&I)) {
452  I.eraseFromParent();
453  Changed = true;
454  continue;
455  }
456  if (I.getDebugLoc()) {
457  Changed = true;
458  I.setDebugLoc(DebugLoc());
459  }
460  if (auto *LoopID = I.getMetadata(LLVMContext::MD_loop)) {
461  auto *NewLoopID = LoopIDsMap.lookup(LoopID);
462  if (!NewLoopID)
463  NewLoopID = LoopIDsMap[LoopID] = stripDebugLocFromLoopID(LoopID);
464  if (NewLoopID != LoopID)
465  I.setMetadata(LLVMContext::MD_loop, NewLoopID);
466  }
467  // Strip heapallocsite attachments, they point into the DIType system.
468  if (I.hasMetadataOtherThanDebugLoc())
469  I.setMetadata("heapallocsite", nullptr);
470  }
471  }
472  return Changed;
473 }
474 
476  bool Changed = false;
477 
478  for (NamedMDNode &NMD : llvm::make_early_inc_range(M.named_metadata())) {
479  // We're stripping debug info, and without them, coverage information
480  // doesn't quite make sense.
481  if (NMD.getName().startswith("llvm.dbg.") ||
482  NMD.getName() == "llvm.gcov") {
483  NMD.eraseFromParent();
484  Changed = true;
485  }
486  }
487 
488  for (Function &F : M)
489  Changed |= stripDebugInfo(F);
490 
491  for (auto &GV : M.globals()) {
492  Changed |= GV.eraseMetadata(LLVMContext::MD_dbg);
493  }
494 
495  if (GVMaterializer *Materializer = M.getMaterializer())
496  Materializer->setStripDebugInfo();
497 
498  return Changed;
499 }
500 
501 namespace {
502 
503 /// Helper class to downgrade -g metadata to -gline-tables-only metadata.
504 class DebugTypeInfoRemoval {
506 
507 public:
508  /// The (void)() type.
509  MDNode *EmptySubroutineType;
510 
511 private:
512  /// Remember what linkage name we originally had before stripping. If we end
513  /// up making two subprograms identical who originally had different linkage
514  /// names, then we need to make one of them distinct, to avoid them getting
515  /// uniqued. Maps the new node to the old linkage name.
516  DenseMap<DISubprogram *, StringRef> NewToLinkageName;
517 
518  // TODO: Remember the distinct subprogram we created for a given linkage name,
519  // so that we can continue to unique whenever possible. Map <newly created
520  // node, old linkage name> to the first (possibly distinct) mdsubprogram
521  // created for that combination. This is not strictly needed for correctness,
522  // but can cut down on the number of MDNodes and let us diff cleanly with the
523  // output of -gline-tables-only.
524 
525 public:
526  DebugTypeInfoRemoval(LLVMContext &C)
527  : EmptySubroutineType(DISubroutineType::get(C, DINode::FlagZero, 0,
528  MDNode::get(C, {}))) {}
529 
530  Metadata *map(Metadata *M) {
531  if (!M)
532  return nullptr;
533  auto Replacement = Replacements.find(M);
534  if (Replacement != Replacements.end())
535  return Replacement->second;
536 
537  return M;
538  }
539  MDNode *mapNode(Metadata *N) { return dyn_cast_or_null<MDNode>(map(N)); }
540 
541  /// Recursively remap N and all its referenced children. Does a DF post-order
542  /// traversal, so as to remap bottoms up.
543  void traverseAndRemap(MDNode *N) { traverse(N); }
544 
545 private:
546  // Create a new DISubprogram, to replace the one given.
547  DISubprogram *getReplacementSubprogram(DISubprogram *MDS) {
548  auto *FileAndScope = cast_or_null<DIFile>(map(MDS->getFile()));
549  StringRef LinkageName = MDS->getName().empty() ? MDS->getLinkageName() : "";
550  DISubprogram *Declaration = nullptr;
551  auto *Type = cast_or_null<DISubroutineType>(map(MDS->getType()));
552  DIType *ContainingType =
553  cast_or_null<DIType>(map(MDS->getContainingType()));
554  auto *Unit = cast_or_null<DICompileUnit>(map(MDS->getUnit()));
555  auto Variables = nullptr;
556  auto TemplateParams = nullptr;
557 
558  // Make a distinct DISubprogram, for situations that warrent it.
559  auto distinctMDSubprogram = [&]() {
561  MDS->getContext(), FileAndScope, MDS->getName(), LinkageName,
562  FileAndScope, MDS->getLine(), Type, MDS->getScopeLine(),
563  ContainingType, MDS->getVirtualIndex(), MDS->getThisAdjustment(),
564  MDS->getFlags(), MDS->getSPFlags(), Unit, TemplateParams, Declaration,
565  Variables);
566  };
567 
568  if (MDS->isDistinct())
569  return distinctMDSubprogram();
570 
571  auto *NewMDS = DISubprogram::get(
572  MDS->getContext(), FileAndScope, MDS->getName(), LinkageName,
573  FileAndScope, MDS->getLine(), Type, MDS->getScopeLine(), ContainingType,
574  MDS->getVirtualIndex(), MDS->getThisAdjustment(), MDS->getFlags(),
575  MDS->getSPFlags(), Unit, TemplateParams, Declaration, Variables);
576 
577  StringRef OldLinkageName = MDS->getLinkageName();
578 
579  // See if we need to make a distinct one.
580  auto OrigLinkage = NewToLinkageName.find(NewMDS);
581  if (OrigLinkage != NewToLinkageName.end()) {
582  if (OrigLinkage->second == OldLinkageName)
583  // We're good.
584  return NewMDS;
585 
586  // Otherwise, need to make a distinct one.
587  // TODO: Query the map to see if we already have one.
588  return distinctMDSubprogram();
589  }
590 
591  NewToLinkageName.insert({NewMDS, MDS->getLinkageName()});
592  return NewMDS;
593  }
594 
595  /// Create a new compile unit, to replace the one given
596  DICompileUnit *getReplacementCU(DICompileUnit *CU) {
597  // Drop skeleton CUs.
598  if (CU->getDWOId())
599  return nullptr;
600 
601  auto *File = cast_or_null<DIFile>(map(CU->getFile()));
602  MDTuple *EnumTypes = nullptr;
603  MDTuple *RetainedTypes = nullptr;
604  MDTuple *GlobalVariables = nullptr;
605  MDTuple *ImportedEntities = nullptr;
607  CU->getContext(), CU->getSourceLanguage(), File, CU->getProducer(),
608  CU->isOptimized(), CU->getFlags(), CU->getRuntimeVersion(),
609  CU->getSplitDebugFilename(), DICompileUnit::LineTablesOnly, EnumTypes,
610  RetainedTypes, GlobalVariables, ImportedEntities, CU->getMacros(),
611  CU->getDWOId(), CU->getSplitDebugInlining(),
612  CU->getDebugInfoForProfiling(), CU->getNameTableKind(),
613  CU->getRangesBaseAddress(), CU->getSysRoot(), CU->getSDK());
614  }
615 
616  DILocation *getReplacementMDLocation(DILocation *MLD) {
617  auto *Scope = map(MLD->getScope());
618  auto *InlinedAt = map(MLD->getInlinedAt());
619  if (MLD->isDistinct())
620  return DILocation::getDistinct(MLD->getContext(), MLD->getLine(),
621  MLD->getColumn(), Scope, InlinedAt);
622  return DILocation::get(MLD->getContext(), MLD->getLine(), MLD->getColumn(),
623  Scope, InlinedAt);
624  }
625 
626  /// Create a new generic MDNode, to replace the one given
627  MDNode *getReplacementMDNode(MDNode *N) {
629  Ops.reserve(N->getNumOperands());
630  for (auto &I : N->operands())
631  if (I)
632  Ops.push_back(map(I));
633  auto *Ret = MDNode::get(N->getContext(), Ops);
634  return Ret;
635  }
636 
637  /// Attempt to re-map N to a newly created node.
638  void remap(MDNode *N) {
639  if (Replacements.count(N))
640  return;
641 
642  auto doRemap = [&](MDNode *N) -> MDNode * {
643  if (!N)
644  return nullptr;
645  if (auto *MDSub = dyn_cast<DISubprogram>(N)) {
646  remap(MDSub->getUnit());
647  return getReplacementSubprogram(MDSub);
648  }
649  if (isa<DISubroutineType>(N))
650  return EmptySubroutineType;
651  if (auto *CU = dyn_cast<DICompileUnit>(N))
652  return getReplacementCU(CU);
653  if (isa<DIFile>(N))
654  return N;
655  if (auto *MDLB = dyn_cast<DILexicalBlockBase>(N))
656  // Remap to our referenced scope (recursively).
657  return mapNode(MDLB->getScope());
658  if (auto *MLD = dyn_cast<DILocation>(N))
659  return getReplacementMDLocation(MLD);
660 
661  // Otherwise, if we see these, just drop them now. Not strictly necessary,
662  // but this speeds things up a little.
663  if (isa<DINode>(N))
664  return nullptr;
665 
666  return getReplacementMDNode(N);
667  };
668  Replacements[N] = doRemap(N);
669  }
670 
671  /// Do the remapping traversal.
672  void traverse(MDNode *);
673 };
674 
675 } // end anonymous namespace
676 
677 void DebugTypeInfoRemoval::traverse(MDNode *N) {
678  if (!N || Replacements.count(N))
679  return;
680 
681  // To avoid cycles, as well as for efficiency sake, we will sometimes prune
682  // parts of the graph.
683  auto prune = [](MDNode *Parent, MDNode *Child) {
684  if (auto *MDS = dyn_cast<DISubprogram>(Parent))
685  return Child == MDS->getRetainedNodes().get();
686  return false;
687  };
688 
690  DenseSet<MDNode *> Opened;
691 
692  // Visit each node starting at N in post order, and map them.
693  ToVisit.push_back(N);
694  while (!ToVisit.empty()) {
695  auto *N = ToVisit.back();
696  if (!Opened.insert(N).second) {
697  // Close it.
698  remap(N);
699  ToVisit.pop_back();
700  continue;
701  }
702  for (auto &I : N->operands())
703  if (auto *MDN = dyn_cast_or_null<MDNode>(I))
704  if (!Opened.count(MDN) && !Replacements.count(MDN) && !prune(N, MDN) &&
705  !isa<DICompileUnit>(MDN))
706  ToVisit.push_back(MDN);
707  }
708 }
709 
711  bool Changed = false;
712 
713  // First off, delete the debug intrinsics.
714  auto RemoveUses = [&](StringRef Name) {
715  if (auto *DbgVal = M.getFunction(Name)) {
716  while (!DbgVal->use_empty())
717  cast<Instruction>(DbgVal->user_back())->eraseFromParent();
718  DbgVal->eraseFromParent();
719  Changed = true;
720  }
721  };
722  RemoveUses("llvm.dbg.addr");
723  RemoveUses("llvm.dbg.declare");
724  RemoveUses("llvm.dbg.label");
725  RemoveUses("llvm.dbg.value");
726 
727  // Delete non-CU debug info named metadata nodes.
728  for (auto NMI = M.named_metadata_begin(), NME = M.named_metadata_end();
729  NMI != NME;) {
730  NamedMDNode *NMD = &*NMI;
731  ++NMI;
732  // Specifically keep dbg.cu around.
733  if (NMD->getName() == "llvm.dbg.cu")
734  continue;
735  }
736 
737  // Drop all dbg attachments from global variables.
738  for (auto &GV : M.globals())
739  GV.eraseMetadata(LLVMContext::MD_dbg);
740 
741  DebugTypeInfoRemoval Mapper(M.getContext());
742  auto remap = [&](MDNode *Node) -> MDNode * {
743  if (!Node)
744  return nullptr;
745  Mapper.traverseAndRemap(Node);
746  auto *NewNode = Mapper.mapNode(Node);
747  Changed |= Node != NewNode;
748  Node = NewNode;
749  return NewNode;
750  };
751 
752  // Rewrite the DebugLocs to be equivalent to what
753  // -gline-tables-only would have created.
754  for (auto &F : M) {
755  if (auto *SP = F.getSubprogram()) {
756  Mapper.traverseAndRemap(SP);
757  auto *NewSP = cast<DISubprogram>(Mapper.mapNode(SP));
758  Changed |= SP != NewSP;
759  F.setSubprogram(NewSP);
760  }
761  for (auto &BB : F) {
762  for (auto &I : BB) {
763  auto remapDebugLoc = [&](const DebugLoc &DL) -> DebugLoc {
764  auto *Scope = DL.getScope();
765  MDNode *InlinedAt = DL.getInlinedAt();
766  Scope = remap(Scope);
767  InlinedAt = remap(InlinedAt);
768  return DILocation::get(M.getContext(), DL.getLine(), DL.getCol(),
769  Scope, InlinedAt);
770  };
771 
772  if (I.getDebugLoc() != DebugLoc())
773  I.setDebugLoc(remapDebugLoc(I.getDebugLoc()));
774 
775  // Remap DILocations in llvm.loop attachments.
777  if (auto *Loc = dyn_cast_or_null<DILocation>(MD))
778  return remapDebugLoc(Loc).get();
779  return MD;
780  });
781 
782  // Strip heapallocsite attachments, they point into the DIType system.
783  if (I.hasMetadataOtherThanDebugLoc())
784  I.setMetadata("heapallocsite", nullptr);
785  }
786  }
787  }
788 
789  // Create a new llvm.dbg.cu, which is equivalent to the one
790  // -gline-tables-only would have created.
791  for (auto &NMD : M.getNamedMDList()) {
793  for (MDNode *Op : NMD.operands())
794  Ops.push_back(remap(Op));
795 
796  if (!Changed)
797  continue;
798 
799  NMD.clearOperands();
800  for (auto *Op : Ops)
801  if (Op)
802  NMD.addOperand(Op);
803  }
804  return Changed;
805 }
806 
808  if (auto *Val = mdconst::dyn_extract_or_null<ConstantInt>(
809  M.getModuleFlag("Debug Info Version")))
810  return Val->getZExtValue();
811  return 0;
812 }
813 
815  const DILocation *LocB) {
816  setDebugLoc(DILocation::getMergedLocation(LocA, LocB));
817 }
818 
819 void Instruction::updateLocationAfterHoist() { dropLocation(); }
820 
822  const DebugLoc &DL = getDebugLoc();
823  if (!DL)
824  return;
825 
826  // If this isn't a call, drop the location to allow a location from a
827  // preceding instruction to propagate.
828  if (!isa<CallBase>(this)) {
829  setDebugLoc(DebugLoc());
830  return;
831  }
832 
833  // Set a line 0 location for calls to preserve scope information in case
834  // inlining occurs.
836  if (SP)
837  // If a function scope is available, set it on the line 0 location. When
838  // hoisting a call to a predecessor block, using the function scope avoids
839  // making it look like the callee was reached earlier than it should be.
840  setDebugLoc(DILocation::get(getContext(), 0, 0, SP));
841  else
842  // The parent function has no scope. Go ahead and drop the location. If
843  // the parent function is inlined, and the callee has a subprogram, the
844  // inliner will attach a location to the call.
845  //
846  // One alternative is to set a line 0 location with the existing scope and
847  // inlinedAt info. The location might be sensitive to when inlining occurs.
848  setDebugLoc(DebugLoc());
849 }
850 
851 //===----------------------------------------------------------------------===//
852 // LLVM C API implementations.
853 //===----------------------------------------------------------------------===//
854 
856  switch (lang) {
857 #define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \
858  case LLVMDWARFSourceLanguage##NAME: \
859  return ID;
860 #include "llvm/BinaryFormat/Dwarf.def"
861 #undef HANDLE_DW_LANG
862  }
863  llvm_unreachable("Unhandled Tag");
864 }
865 
866 template <typename DIT> DIT *unwrapDI(LLVMMetadataRef Ref) {
867  return (DIT *)(Ref ? unwrap<MDNode>(Ref) : nullptr);
868 }
869 
871  return static_cast<DINode::DIFlags>(Flags);
872 }
873 
875  return static_cast<LLVMDIFlags>(Flags);
876 }
877 
879 pack_into_DISPFlags(bool IsLocalToUnit, bool IsDefinition, bool IsOptimized) {
880  return DISubprogram::toSPFlags(IsLocalToUnit, IsDefinition, IsOptimized);
881 }
882 
884  return DEBUG_METADATA_VERSION;
885 }
886 
888  return wrap(new DIBuilder(*unwrap(M), false));
889 }
890 
892  return wrap(new DIBuilder(*unwrap(M)));
893 }
894 
897 }
898 
900  return StripDebugInfo(*unwrap(M));
901 }
902 
904  delete unwrap(Builder);
905 }
906 
908  unwrap(Builder)->finalize();
909 }
910 
912  LLVMMetadataRef subprogram) {
913  unwrap(Builder)->finalizeSubprogram(unwrapDI<DISubprogram>(subprogram));
914 }
915 
918  LLVMMetadataRef FileRef, const char *Producer, size_t ProducerLen,
919  LLVMBool isOptimized, const char *Flags, size_t FlagsLen,
920  unsigned RuntimeVer, const char *SplitName, size_t SplitNameLen,
921  LLVMDWARFEmissionKind Kind, unsigned DWOId, LLVMBool SplitDebugInlining,
922  LLVMBool DebugInfoForProfiling, const char *SysRoot, size_t SysRootLen,
923  const char *SDK, size_t SDKLen) {
924  auto File = unwrapDI<DIFile>(FileRef);
925 
926  return wrap(unwrap(Builder)->createCompileUnit(
928  StringRef(Producer, ProducerLen), isOptimized, StringRef(Flags, FlagsLen),
929  RuntimeVer, StringRef(SplitName, SplitNameLen),
930  static_cast<DICompileUnit::DebugEmissionKind>(Kind), DWOId,
931  SplitDebugInlining, DebugInfoForProfiling,
933  StringRef(SysRoot, SysRootLen), StringRef(SDK, SDKLen)));
934 }
935 
938  size_t FilenameLen, const char *Directory,
939  size_t DirectoryLen) {
940  return wrap(unwrap(Builder)->createFile(StringRef(Filename, FilenameLen),
941  StringRef(Directory, DirectoryLen)));
942 }
943 
946  const char *Name, size_t NameLen,
947  const char *ConfigMacros, size_t ConfigMacrosLen,
948  const char *IncludePath, size_t IncludePathLen,
949  const char *APINotesFile, size_t APINotesFileLen) {
950  return wrap(unwrap(Builder)->createModule(
951  unwrapDI<DIScope>(ParentScope), StringRef(Name, NameLen),
952  StringRef(ConfigMacros, ConfigMacrosLen),
953  StringRef(IncludePath, IncludePathLen),
954  StringRef(APINotesFile, APINotesFileLen)));
955 }
956 
958  LLVMMetadataRef ParentScope,
959  const char *Name, size_t NameLen,
960  LLVMBool ExportSymbols) {
961  return wrap(unwrap(Builder)->createNameSpace(
962  unwrapDI<DIScope>(ParentScope), StringRef(Name, NameLen), ExportSymbols));
963 }
964 
967  size_t NameLen, const char *LinkageName, size_t LinkageNameLen,
968  LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty,
969  LLVMBool IsLocalToUnit, LLVMBool IsDefinition,
970  unsigned ScopeLine, LLVMDIFlags Flags, LLVMBool IsOptimized) {
971  return wrap(unwrap(Builder)->createFunction(
972  unwrapDI<DIScope>(Scope), {Name, NameLen}, {LinkageName, LinkageNameLen},
973  unwrapDI<DIFile>(File), LineNo, unwrapDI<DISubroutineType>(Ty), ScopeLine,
974  map_from_llvmDIFlags(Flags),
975  pack_into_DISPFlags(IsLocalToUnit, IsDefinition, IsOptimized), nullptr,
976  nullptr, nullptr));
977 }
978 
979 
982  LLVMMetadataRef File, unsigned Line, unsigned Col) {
983  return wrap(unwrap(Builder)->createLexicalBlock(unwrapDI<DIScope>(Scope),
984  unwrapDI<DIFile>(File),
985  Line, Col));
986 }
987 
992  unsigned Discriminator) {
993  return wrap(unwrap(Builder)->createLexicalBlockFile(unwrapDI<DIScope>(Scope),
994  unwrapDI<DIFile>(File),
995  Discriminator));
996 }
997 
1001  LLVMMetadataRef NS,
1003  unsigned Line) {
1004  return wrap(unwrap(Builder)->createImportedModule(unwrapDI<DIScope>(Scope),
1005  unwrapDI<DINamespace>(NS),
1006  unwrapDI<DIFile>(File),
1007  Line));
1008 }
1009 
1012  LLVMMetadataRef ImportedEntity, LLVMMetadataRef File, unsigned Line,
1013  LLVMMetadataRef *Elements, unsigned NumElements) {
1014  auto Elts =
1015  (NumElements > 0)
1016  ? unwrap(Builder)->getOrCreateArray({unwrap(Elements), NumElements})
1017  : nullptr;
1019  unwrapDI<DIScope>(Scope), unwrapDI<DIImportedEntity>(ImportedEntity),
1020  unwrapDI<DIFile>(File), Line, Elts));
1021 }
1022 
1025  LLVMMetadataRef File, unsigned Line, LLVMMetadataRef *Elements,
1026  unsigned NumElements) {
1027  auto Elts =
1028  (NumElements > 0)
1029  ? unwrap(Builder)->getOrCreateArray({unwrap(Elements), NumElements})
1030  : nullptr;
1032  unwrapDI<DIScope>(Scope), unwrapDI<DIModule>(M), unwrapDI<DIFile>(File),
1033  Line, Elts));
1034 }
1035 
1038  LLVMMetadataRef File, unsigned Line, const char *Name, size_t NameLen,
1039  LLVMMetadataRef *Elements, unsigned NumElements) {
1040  auto Elts =
1041  (NumElements > 0)
1042  ? unwrap(Builder)->getOrCreateArray({unwrap(Elements), NumElements})
1043  : nullptr;
1044  return wrap(unwrap(Builder)->createImportedDeclaration(
1045  unwrapDI<DIScope>(Scope), unwrapDI<DINode>(Decl), unwrapDI<DIFile>(File),
1046  Line, {Name, NameLen}, Elts));
1047 }
1048 
1051  unsigned Column, LLVMMetadataRef Scope,
1052  LLVMMetadataRef InlinedAt) {
1053  return wrap(DILocation::get(*unwrap(Ctx), Line, Column, unwrap(Scope),
1054  unwrap(InlinedAt)));
1055 }
1056 
1058  return unwrapDI<DILocation>(Location)->getLine();
1059 }
1060 
1062  return unwrapDI<DILocation>(Location)->getColumn();
1063 }
1064 
1066  return wrap(unwrapDI<DILocation>(Location)->getScope());
1067 }
1068 
1070  return wrap(unwrapDI<DILocation>(Location)->getInlinedAt());
1071 }
1072 
1074  return wrap(unwrapDI<DIScope>(Scope)->getFile());
1075 }
1076 
1077 const char *LLVMDIFileGetDirectory(LLVMMetadataRef File, unsigned *Len) {
1078  auto Dir = unwrapDI<DIFile>(File)->getDirectory();
1079  *Len = Dir.size();
1080  return Dir.data();
1081 }
1082 
1083 const char *LLVMDIFileGetFilename(LLVMMetadataRef File, unsigned *Len) {
1084  auto Name = unwrapDI<DIFile>(File)->getFilename();
1085  *Len = Name.size();
1086  return Name.data();
1087 }
1088 
1089 const char *LLVMDIFileGetSource(LLVMMetadataRef File, unsigned *Len) {
1090  if (auto Src = unwrapDI<DIFile>(File)->getSource()) {
1091  *Len = Src->size();
1092  return Src->data();
1093  }
1094  *Len = 0;
1095  return "";
1096 }
1097 
1099  LLVMMetadataRef ParentMacroFile,
1100  unsigned Line,
1102  const char *Name, size_t NameLen,
1103  const char *Value, size_t ValueLen) {
1104  return wrap(
1105  unwrap(Builder)->createMacro(unwrapDI<DIMacroFile>(ParentMacroFile), Line,
1106  static_cast<MacinfoRecordType>(RecordType),
1107  {Name, NameLen}, {Value, ValueLen}));
1108 }
1109 
1112  LLVMMetadataRef ParentMacroFile, unsigned Line,
1114  return wrap(unwrap(Builder)->createTempMacroFile(
1115  unwrapDI<DIMacroFile>(ParentMacroFile), Line, unwrapDI<DIFile>(File)));
1116 }
1117 
1119  const char *Name, size_t NameLen,
1120  int64_t Value,
1121  LLVMBool IsUnsigned) {
1122  return wrap(unwrap(Builder)->createEnumerator({Name, NameLen}, Value,
1123  IsUnsigned != 0));
1124 }
1125 
1128  size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
1129  uint64_t SizeInBits, uint32_t AlignInBits, LLVMMetadataRef *Elements,
1130  unsigned NumElements, LLVMMetadataRef ClassTy) {
1131 auto Elts = unwrap(Builder)->getOrCreateArray({unwrap(Elements),
1132  NumElements});
1133 return wrap(unwrap(Builder)->createEnumerationType(
1134  unwrapDI<DIScope>(Scope), {Name, NameLen}, unwrapDI<DIFile>(File),
1135  LineNumber, SizeInBits, AlignInBits, Elts, unwrapDI<DIType>(ClassTy)));
1136 }
1137 
1140  size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
1141  uint64_t SizeInBits, uint32_t AlignInBits, LLVMDIFlags Flags,
1142  LLVMMetadataRef *Elements, unsigned NumElements, unsigned RunTimeLang,
1143  const char *UniqueId, size_t UniqueIdLen) {
1144  auto Elts = unwrap(Builder)->getOrCreateArray({unwrap(Elements),
1145  NumElements});
1146  return wrap(unwrap(Builder)->createUnionType(
1147  unwrapDI<DIScope>(Scope), {Name, NameLen}, unwrapDI<DIFile>(File),
1148  LineNumber, SizeInBits, AlignInBits, map_from_llvmDIFlags(Flags),
1149  Elts, RunTimeLang, {UniqueId, UniqueIdLen}));
1150 }
1151 
1152 
1155  uint32_t AlignInBits, LLVMMetadataRef Ty,
1156  LLVMMetadataRef *Subscripts,
1157  unsigned NumSubscripts) {
1158  auto Subs = unwrap(Builder)->getOrCreateArray({unwrap(Subscripts),
1159  NumSubscripts});
1160  return wrap(unwrap(Builder)->createArrayType(Size, AlignInBits,
1161  unwrapDI<DIType>(Ty), Subs));
1162 }
1163 
1166  uint32_t AlignInBits, LLVMMetadataRef Ty,
1167  LLVMMetadataRef *Subscripts,
1168  unsigned NumSubscripts) {
1169  auto Subs = unwrap(Builder)->getOrCreateArray({unwrap(Subscripts),
1170  NumSubscripts});
1171  return wrap(unwrap(Builder)->createVectorType(Size, AlignInBits,
1172  unwrapDI<DIType>(Ty), Subs));
1173 }
1174 
1177  size_t NameLen, uint64_t SizeInBits,
1178  LLVMDWARFTypeEncoding Encoding,
1179  LLVMDIFlags Flags) {
1180  return wrap(unwrap(Builder)->createBasicType({Name, NameLen},
1181  SizeInBits, Encoding,
1182  map_from_llvmDIFlags(Flags)));
1183 }
1184 
1187  uint64_t SizeInBits, uint32_t AlignInBits, unsigned AddressSpace,
1188  const char *Name, size_t NameLen) {
1189  return wrap(unwrap(Builder)->createPointerType(unwrapDI<DIType>(PointeeTy),
1190  SizeInBits, AlignInBits,
1191  AddressSpace, {Name, NameLen}));
1192 }
1193 
1196  size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
1197  uint64_t SizeInBits, uint32_t AlignInBits, LLVMDIFlags Flags,
1198  LLVMMetadataRef DerivedFrom, LLVMMetadataRef *Elements,
1199  unsigned NumElements, unsigned RunTimeLang, LLVMMetadataRef VTableHolder,
1200  const char *UniqueId, size_t UniqueIdLen) {
1201  auto Elts = unwrap(Builder)->getOrCreateArray({unwrap(Elements),
1202  NumElements});
1203  return wrap(unwrap(Builder)->createStructType(
1204  unwrapDI<DIScope>(Scope), {Name, NameLen}, unwrapDI<DIFile>(File),
1205  LineNumber, SizeInBits, AlignInBits, map_from_llvmDIFlags(Flags),
1206  unwrapDI<DIType>(DerivedFrom), Elts, RunTimeLang,
1207  unwrapDI<DIType>(VTableHolder), {UniqueId, UniqueIdLen}));
1208 }
1209 
1212  size_t NameLen, LLVMMetadataRef File, unsigned LineNo, uint64_t SizeInBits,
1213  uint32_t AlignInBits, uint64_t OffsetInBits, LLVMDIFlags Flags,
1214  LLVMMetadataRef Ty) {
1215  return wrap(unwrap(Builder)->createMemberType(unwrapDI<DIScope>(Scope),
1216  {Name, NameLen}, unwrapDI<DIFile>(File), LineNo, SizeInBits, AlignInBits,
1217  OffsetInBits, map_from_llvmDIFlags(Flags), unwrapDI<DIType>(Ty)));
1218 }
1219 
1222  size_t NameLen) {
1223  return wrap(unwrap(Builder)->createUnspecifiedType({Name, NameLen}));
1224 }
1225 
1229  size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
1230  LLVMMetadataRef Type, LLVMDIFlags Flags, LLVMValueRef ConstantVal,
1231  uint32_t AlignInBits) {
1232  return wrap(unwrap(Builder)->createStaticMemberType(
1233  unwrapDI<DIScope>(Scope), {Name, NameLen},
1234  unwrapDI<DIFile>(File), LineNumber, unwrapDI<DIType>(Type),
1235  map_from_llvmDIFlags(Flags), unwrap<Constant>(ConstantVal),
1236  AlignInBits));
1237 }
1238 
1241  const char *Name, size_t NameLen,
1242  LLVMMetadataRef File, unsigned LineNo,
1243  uint64_t SizeInBits, uint32_t AlignInBits,
1244  uint64_t OffsetInBits, LLVMDIFlags Flags,
1245  LLVMMetadataRef Ty, LLVMMetadataRef PropertyNode) {
1246  return wrap(unwrap(Builder)->createObjCIVar(
1247  {Name, NameLen}, unwrapDI<DIFile>(File), LineNo,
1248  SizeInBits, AlignInBits, OffsetInBits,
1249  map_from_llvmDIFlags(Flags), unwrapDI<DIType>(Ty),
1250  unwrapDI<MDNode>(PropertyNode)));
1251 }
1252 
1255  const char *Name, size_t NameLen,
1256  LLVMMetadataRef File, unsigned LineNo,
1257  const char *GetterName, size_t GetterNameLen,
1258  const char *SetterName, size_t SetterNameLen,
1259  unsigned PropertyAttributes,
1260  LLVMMetadataRef Ty) {
1261  return wrap(unwrap(Builder)->createObjCProperty(
1262  {Name, NameLen}, unwrapDI<DIFile>(File), LineNo,
1263  {GetterName, GetterNameLen}, {SetterName, SetterNameLen},
1264  PropertyAttributes, unwrapDI<DIType>(Ty)));
1265 }
1266 
1270  return wrap(unwrap(Builder)->createObjectPointerType(unwrapDI<DIType>(Type)));
1271 }
1272 
1275  const char *Name, size_t NameLen,
1276  LLVMMetadataRef File, unsigned LineNo,
1277  LLVMMetadataRef Scope, uint32_t AlignInBits) {
1278  return wrap(unwrap(Builder)->createTypedef(
1279  unwrapDI<DIType>(Type), {Name, NameLen}, unwrapDI<DIFile>(File), LineNo,
1280  unwrapDI<DIScope>(Scope), AlignInBits));
1281 }
1282 
1285  LLVMMetadataRef Ty, LLVMMetadataRef BaseTy,
1286  uint64_t BaseOffset, uint32_t VBPtrOffset,
1287  LLVMDIFlags Flags) {
1288  return wrap(unwrap(Builder)->createInheritance(
1289  unwrapDI<DIType>(Ty), unwrapDI<DIType>(BaseTy),
1290  BaseOffset, VBPtrOffset, map_from_llvmDIFlags(Flags)));
1291 }
1292 
1295  LLVMDIBuilderRef Builder, unsigned Tag, const char *Name,
1296  size_t NameLen, LLVMMetadataRef Scope, LLVMMetadataRef File, unsigned Line,
1297  unsigned RuntimeLang, uint64_t SizeInBits, uint32_t AlignInBits,
1298  const char *UniqueIdentifier, size_t UniqueIdentifierLen) {
1299  return wrap(unwrap(Builder)->createForwardDecl(
1300  Tag, {Name, NameLen}, unwrapDI<DIScope>(Scope),
1301  unwrapDI<DIFile>(File), Line, RuntimeLang, SizeInBits,
1302  AlignInBits, {UniqueIdentifier, UniqueIdentifierLen}));
1303 }
1304 
1307  LLVMDIBuilderRef Builder, unsigned Tag, const char *Name,
1308  size_t NameLen, LLVMMetadataRef Scope, LLVMMetadataRef File, unsigned Line,
1309  unsigned RuntimeLang, uint64_t SizeInBits, uint32_t AlignInBits,
1310  LLVMDIFlags Flags, const char *UniqueIdentifier,
1311  size_t UniqueIdentifierLen) {
1312  return wrap(unwrap(Builder)->createReplaceableCompositeType(
1313  Tag, {Name, NameLen}, unwrapDI<DIScope>(Scope),
1314  unwrapDI<DIFile>(File), Line, RuntimeLang, SizeInBits,
1315  AlignInBits, map_from_llvmDIFlags(Flags),
1316  {UniqueIdentifier, UniqueIdentifierLen}));
1317 }
1318 
1322  return wrap(unwrap(Builder)->createQualifiedType(Tag,
1323  unwrapDI<DIType>(Type)));
1324 }
1325 
1329  return wrap(unwrap(Builder)->createReferenceType(Tag,
1330  unwrapDI<DIType>(Type)));
1331 }
1332 
1335  return wrap(unwrap(Builder)->createNullPtrType());
1336 }
1337 
1340  LLVMMetadataRef PointeeType,
1341  LLVMMetadataRef ClassType,
1342  uint64_t SizeInBits,
1343  uint32_t AlignInBits,
1344  LLVMDIFlags Flags) {
1345  return wrap(unwrap(Builder)->createMemberPointerType(
1346  unwrapDI<DIType>(PointeeType),
1347  unwrapDI<DIType>(ClassType), AlignInBits, SizeInBits,
1348  map_from_llvmDIFlags(Flags)));
1349 }
1350 
1354  const char *Name, size_t NameLen,
1355  LLVMMetadataRef File, unsigned LineNumber,
1356  uint64_t SizeInBits,
1357  uint64_t OffsetInBits,
1358  uint64_t StorageOffsetInBits,
1359  LLVMDIFlags Flags, LLVMMetadataRef Type) {
1360  return wrap(unwrap(Builder)->createBitFieldMemberType(
1361  unwrapDI<DIScope>(Scope), {Name, NameLen},
1362  unwrapDI<DIFile>(File), LineNumber,
1363  SizeInBits, OffsetInBits, StorageOffsetInBits,
1364  map_from_llvmDIFlags(Flags), unwrapDI<DIType>(Type)));
1365 }
1366 
1368  LLVMMetadataRef Scope, const char *Name, size_t NameLen,
1369  LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits,
1370  uint32_t AlignInBits, uint64_t OffsetInBits, LLVMDIFlags Flags,
1371  LLVMMetadataRef DerivedFrom,
1372  LLVMMetadataRef *Elements, unsigned NumElements,
1373  LLVMMetadataRef VTableHolder, LLVMMetadataRef TemplateParamsNode,
1374  const char *UniqueIdentifier, size_t UniqueIdentifierLen) {
1375  auto Elts = unwrap(Builder)->getOrCreateArray({unwrap(Elements),
1376  NumElements});
1377  return wrap(unwrap(Builder)->createClassType(
1378  unwrapDI<DIScope>(Scope), {Name, NameLen},
1379  unwrapDI<DIFile>(File), LineNumber,
1380  SizeInBits, AlignInBits, OffsetInBits,
1381  map_from_llvmDIFlags(Flags), unwrapDI<DIType>(DerivedFrom),
1382  Elts, unwrapDI<DIType>(VTableHolder),
1383  unwrapDI<MDNode>(TemplateParamsNode),
1384  {UniqueIdentifier, UniqueIdentifierLen}));
1385 }
1386 
1390  return wrap(unwrap(Builder)->createArtificialType(unwrapDI<DIType>(Type)));
1391 }
1392 
1393 const char *LLVMDITypeGetName(LLVMMetadataRef DType, size_t *Length) {
1394  StringRef Str = unwrap<DIType>(DType)->getName();
1395  *Length = Str.size();
1396  return Str.data();
1397 }
1398 
1400  return unwrapDI<DIType>(DType)->getSizeInBits();
1401 }
1402 
1404  return unwrapDI<DIType>(DType)->getOffsetInBits();
1405 }
1406 
1408  return unwrapDI<DIType>(DType)->getAlignInBits();
1409 }
1410 
1412  return unwrapDI<DIType>(DType)->getLine();
1413 }
1414 
1416  return map_to_llvmDIFlags(unwrapDI<DIType>(DType)->getFlags());
1417 }
1418 
1420  LLVMMetadataRef *Types,
1421  size_t Length) {
1422  return wrap(
1423  unwrap(Builder)->getOrCreateTypeArray({unwrap(Types), Length}).get());
1424 }
1425 
1429  LLVMMetadataRef *ParameterTypes,
1430  unsigned NumParameterTypes,
1431  LLVMDIFlags Flags) {
1432  auto Elts = unwrap(Builder)->getOrCreateTypeArray({unwrap(ParameterTypes),
1433  NumParameterTypes});
1434  return wrap(unwrap(Builder)->createSubroutineType(
1435  Elts, map_from_llvmDIFlags(Flags)));
1436 }
1437 
1439  uint64_t *Addr, size_t Length) {
1440  return wrap(
1441  unwrap(Builder)->createExpression(ArrayRef<uint64_t>(Addr, Length)));
1442 }
1443 
1446  uint64_t Value) {
1447  return wrap(unwrap(Builder)->createConstantValueExpression(Value));
1448 }
1449 
1452  size_t NameLen, const char *Linkage, size_t LinkLen, LLVMMetadataRef File,
1453  unsigned LineNo, LLVMMetadataRef Ty, LLVMBool LocalToUnit,
1454  LLVMMetadataRef Expr, LLVMMetadataRef Decl, uint32_t AlignInBits) {
1455  return wrap(unwrap(Builder)->createGlobalVariableExpression(
1456  unwrapDI<DIScope>(Scope), {Name, NameLen}, {Linkage, LinkLen},
1457  unwrapDI<DIFile>(File), LineNo, unwrapDI<DIType>(Ty), LocalToUnit,
1458  true, unwrap<DIExpression>(Expr), unwrapDI<MDNode>(Decl),
1459  nullptr, AlignInBits));
1460 }
1461 
1463  return wrap(unwrapDI<DIGlobalVariableExpression>(GVE)->getVariable());
1464 }
1465 
1467  LLVMMetadataRef GVE) {
1468  return wrap(unwrapDI<DIGlobalVariableExpression>(GVE)->getExpression());
1469 }
1470 
1472  return wrap(unwrapDI<DIVariable>(Var)->getFile());
1473 }
1474 
1476  return wrap(unwrapDI<DIVariable>(Var)->getScope());
1477 }
1478 
1480  return unwrapDI<DIVariable>(Var)->getLine();
1481 }
1482 
1484  size_t Count) {
1485  return wrap(
1486  MDTuple::getTemporary(*unwrap(Ctx), {unwrap(Data), Count}).release());
1487 }
1488 
1490  MDNode::deleteTemporary(unwrapDI<MDNode>(TempNode));
1491 }
1492 
1494  LLVMMetadataRef Replacement) {
1495  auto *Node = unwrapDI<MDNode>(TargetMetadata);
1496  Node->replaceAllUsesWith(unwrap<Metadata>(Replacement));
1498 }
1499 
1502  size_t NameLen, const char *Linkage, size_t LnkLen, LLVMMetadataRef File,
1503  unsigned LineNo, LLVMMetadataRef Ty, LLVMBool LocalToUnit,
1504  LLVMMetadataRef Decl, uint32_t AlignInBits) {
1505  return wrap(unwrap(Builder)->createTempGlobalVariableFwdDecl(
1506  unwrapDI<DIScope>(Scope), {Name, NameLen}, {Linkage, LnkLen},
1507  unwrapDI<DIFile>(File), LineNo, unwrapDI<DIType>(Ty), LocalToUnit,
1508  unwrapDI<MDNode>(Decl), nullptr, AlignInBits));
1509 }
1510 
1513  LLVMMetadataRef VarInfo, LLVMMetadataRef Expr,
1514  LLVMMetadataRef DL, LLVMValueRef Instr) {
1515  return wrap(unwrap(Builder)->insertDeclare(
1516  unwrap(Storage), unwrap<DILocalVariable>(VarInfo),
1517  unwrap<DIExpression>(Expr), unwrap<DILocation>(DL),
1518  unwrap<Instruction>(Instr)));
1519 }
1520 
1524  return wrap(unwrap(Builder)->insertDeclare(
1525  unwrap(Storage), unwrap<DILocalVariable>(VarInfo),
1526  unwrap<DIExpression>(Expr), unwrap<DILocation>(DL),
1527  unwrap(Block)));
1528 }
1529 
1531  LLVMValueRef Val,
1532  LLVMMetadataRef VarInfo,
1533  LLVMMetadataRef Expr,
1535  LLVMValueRef Instr) {
1536  return wrap(unwrap(Builder)->insertDbgValueIntrinsic(
1537  unwrap(Val), unwrap<DILocalVariable>(VarInfo),
1538  unwrap<DIExpression>(Expr), unwrap<DILocation>(DebugLoc),
1539  unwrap<Instruction>(Instr)));
1540 }
1541 
1543  LLVMValueRef Val,
1544  LLVMMetadataRef VarInfo,
1545  LLVMMetadataRef Expr,
1547  LLVMBasicBlockRef Block) {
1548  return wrap(unwrap(Builder)->insertDbgValueIntrinsic(
1549  unwrap(Val), unwrap<DILocalVariable>(VarInfo),
1550  unwrap<DIExpression>(Expr), unwrap<DILocation>(DebugLoc),
1551  unwrap(Block)));
1552 }
1553 
1556  size_t NameLen, LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty,
1557  LLVMBool AlwaysPreserve, LLVMDIFlags Flags, uint32_t AlignInBits) {
1558  return wrap(unwrap(Builder)->createAutoVariable(
1559  unwrap<DIScope>(Scope), {Name, NameLen}, unwrap<DIFile>(File),
1560  LineNo, unwrap<DIType>(Ty), AlwaysPreserve,
1561  map_from_llvmDIFlags(Flags), AlignInBits));
1562 }
1563 
1566  size_t NameLen, unsigned ArgNo, LLVMMetadataRef File, unsigned LineNo,
1567  LLVMMetadataRef Ty, LLVMBool AlwaysPreserve, LLVMDIFlags Flags) {
1568  return wrap(unwrap(Builder)->createParameterVariable(
1569  unwrap<DIScope>(Scope), {Name, NameLen}, ArgNo, unwrap<DIFile>(File),
1570  LineNo, unwrap<DIType>(Ty), AlwaysPreserve,
1571  map_from_llvmDIFlags(Flags)));
1572 }
1573 
1575  int64_t Lo, int64_t Count) {
1576  return wrap(unwrap(Builder)->getOrCreateSubrange(Lo, Count));
1577 }
1578 
1580  LLVMMetadataRef *Data,
1581  size_t Length) {
1582  Metadata **DataValue = unwrap(Data);
1583  return wrap(unwrap(Builder)->getOrCreateArray({DataValue, Length}).get());
1584 }
1585 
1587  return wrap(unwrap<Function>(Func)->getSubprogram());
1588 }
1589 
1591  unwrap<Function>(Func)->setSubprogram(unwrap<DISubprogram>(SP));
1592 }
1593 
1595  return unwrapDI<DISubprogram>(Subprogram)->getLine();
1596 }
1597 
1599  return wrap(unwrap<Instruction>(Inst)->getDebugLoc().getAsMDNode());
1600 }
1601 
1603  if (Loc)
1604  unwrap<Instruction>(Inst)->setDebugLoc(DebugLoc(unwrap<MDNode>(Loc)));
1605  else
1606  unwrap<Instruction>(Inst)->setDebugLoc(DebugLoc());
1607 }
1608 
1610  switch(unwrap(Metadata)->getMetadataID()) {
1611 #define HANDLE_METADATA_LEAF(CLASS) \
1612  case Metadata::CLASS##Kind: \
1613  return (LLVMMetadataKind)LLVM##CLASS##MetadataKind;
1614 #include "llvm/IR/Metadata.def"
1615  default:
1617  }
1618 }
llvm::Check::Size
@ Size
Definition: FileCheck.h:73
LLVMDILocationGetColumn
unsigned LLVMDILocationGetColumn(LLVMMetadataRef Location)
Get the column number of this debug location.
Definition: DebugInfo.cpp:1061
llvm::DIType::getScope
DIScope * getScope() const
Definition: DebugInfoMetadata.h:710
i
i
Definition: README.txt:29
LLVMDITypeGetOffsetInBits
uint64_t LLVMDITypeGetOffsetInBits(LLVMMetadataRef DType)
Get the offset of this DIType in bits.
Definition: DebugInfo.cpp:1403
LLVMDIBuilderCreateTempMacroFile
LLVMMetadataRef LLVMDIBuilderCreateTempMacroFile(LLVMDIBuilderRef Builder, LLVMMetadataRef ParentMacroFile, unsigned Line, LLVMMetadataRef File)
Create debugging information temporary entry for a macro file.
Definition: DebugInfo.cpp:1111
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:1306
llvm::StripDebugInfo
bool StripDebugInfo(Module &M)
Strip debug info in the module if it exists.
Definition: DebugInfo.cpp:475
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AllocatorList.h:23
LLVMDWARFSourceLanguage
LLVMDWARFSourceLanguage
Source languages known by DWARF.
Definition: DebugInfo.h:78
llvm::DIType
Base class for types.
Definition: DebugInfoMetadata.h:665
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:828
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::NamedMDNode
A tuple of MDNodes.
Definition: Metadata.h:1421
llvm::dwarf
Definition: Dwarf.h:35
LLVMDIScopeGetFile
LLVMMetadataRef LLVMDIScopeGetFile(LLVMMetadataRef Scope)
Get the metadata of the file associated with a given scope.
Definition: DebugInfo.cpp:1073
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:980
Metadata.h
llvm::GVMaterializer
Definition: GVMaterializer.h:28
LLVMDITypeGetAlignInBits
uint32_t LLVMDITypeGetAlignInBits(LLVMMetadataRef DType)
Get the alignment of this DIType in bits.
Definition: DebugInfo.cpp:1407
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
T
llvm::Function
Definition: Function.h:62
getFunction
static Function * getFunction(Constant *C)
Definition: Evaluator.cpp:235
LLVMDIBuilderCreateObjectPointerType
LLVMMetadataRef LLVMDIBuilderCreateObjectPointerType(LLVMDIBuilderRef Builder, LLVMMetadataRef Type)
Create a uniqued DIType* clone with FlagObjectPointer and FlagArtificial set.
Definition: DebugInfo.cpp:1268
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
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1177
llvm::FunctionLoweringInfo::StatepointRelocationRecord
Helper object to track which of three possible relocation mechanisms are used for a particular value ...
Definition: FunctionLoweringInfo.h:95
llvm::Function::getSubprogram
DISubprogram * getSubprogram() const
Get the attached subprogram.
Definition: Metadata.cpp:1541
llvm::MipsISD::Lo
@ Lo
Definition: MipsISelLowering.h:79
llvm::findDbgUsers
void findDbgUsers(SmallVectorImpl< DbgVariableIntrinsic * > &DbgInsts, Value *V)
Finds the debug info intrinsics describing a value.
Definition: DebugInfo.cpp:102
LLVMInstructionGetDebugLoc
LLVMMetadataRef LLVMInstructionGetDebugLoc(LLVMValueRef Inst)
Get the debug location for the given instruction.
Definition: DebugInfo.cpp:1598
llvm::DIScope::getName
StringRef getName() const
Definition: DebugInfoMetadata.cpp:262
LLVMTemporaryMDNode
LLVMMetadataRef LLVMTemporaryMDNode(LLVMContextRef Ctx, LLVMMetadataRef *Data, size_t Count)
Create a new temporary MDNode.
Definition: DebugInfo.cpp:1483
LLVMDIGlobalVariableExpressionGetExpression
LLVMMetadataRef LLVMDIGlobalVariableExpressionGetExpression(LLVMMetadataRef GVE)
Retrieves the DIExpression associated with this global variable expression.
Definition: DebugInfo.cpp:1466
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:989
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:1165
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:1010
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
Module.h
LLVMDisposeDIBuilder
void LLVMDisposeDIBuilder(LLVMDIBuilderRef Builder)
Deallocates the DIBuilder and everything it owns.
Definition: DebugInfo.cpp:903
llvm::DbgVariableIntrinsic::getVariable
DILocalVariable * getVariable() const
Definition: IntrinsicInst.h:253
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:1521
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
llvm::MipsISD::Ret
@ Ret
Definition: MipsISelLowering.h:116
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:855
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:1342
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:1739
llvm::Data
@ Data
Definition: SIMachineScheduler.h:55
llvm::MDNode::get
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition: Metadata.h:1233
F
#define F(x, y, z)
Definition: MD5.cpp:55
LLVMGetSubprogram
LLVMMetadataRef LLVMGetSubprogram(LLVMValueRef Func)
Get the metadata of the subprogram attached to a function.
Definition: DebugInfo.cpp:1586
LLVMDIBuilderCreateArtificialType
LLVMMetadataRef LLVMDIBuilderCreateArtificialType(LLVMDIBuilderRef Builder, LLVMMetadataRef Type)
Create a uniqued DIType* clone with FlagArtificial set.
Definition: DebugInfo.cpp:1388
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:58
llvm::MDNode::getNumOperands
unsigned getNumOperands() const
Return number of MDNode operands.
Definition: Metadata.h:1143
LLVMStripModuleDebugInfo
LLVMBool LLVMStripModuleDebugInfo(LLVMModuleRef M)
Strip debug info in the module if it exists.
Definition: DebugInfo.cpp:899
LLVMDIBuilderCreateImportedModuleFromNamespace
LLVMMetadataRef LLVMDIBuilderCreateImportedModuleFromNamespace(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, LLVMMetadataRef NS, LLVMMetadataRef File, unsigned Line)
Create a descriptor for an imported namespace.
Definition: DebugInfo.cpp:999
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:1327
Instruction.h
LLVMSetSubprogram
void LLVMSetSubprogram(LLVMValueRef Func, LLVMMetadataRef SP)
Set the subprogram attached to a function.
Definition: DebugInfo.cpp:1590
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:1649
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:1154
llvm::ModRefInfo::Ref
@ Ref
The access may reference the value stored in memory.
Constants.h
llvm::DbgValueInst
This represents the llvm.dbg.value instruction.
Definition: IntrinsicInst.h:347
LLVMDebugMetadataVersion
unsigned LLVMDebugMetadataVersion()
The current debug metadata version number.
Definition: DebugInfo.cpp:883
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
LLVMDIBuilderGetOrCreateTypeArray
LLVMMetadataRef LLVMDIBuilderGetOrCreateTypeArray(LLVMDIBuilderRef Builder, LLVMMetadataRef *Types, size_t Length)
Create a type array.
Definition: DebugInfo.cpp:1419
LLVMDISubprogramGetLine
unsigned LLVMDISubprogramGetLine(LLVMMetadataRef Subprogram)
Get the line associated with a given subprogram.
Definition: DebugInfo.cpp:1594
llvm::DICompileUnit::LineTablesOnly
@ LineTablesOnly
Definition: DebugInfoMetadata.h:1345
LLVMDIGlobalVariableExpressionGetVariable
LLVMMetadataRef LLVMDIGlobalVariableExpressionGetVariable(LLVMMetadataRef GVE)
Retrieves the DIVariable associated with this global variable expression.
Definition: DebugInfo.cpp:1462
llvm::TinyPtrVector::push_back
void push_back(EltTy NewVal)
Definition: TinyPtrVector.h:244
llvm::DISubprogram::DISPFlags
DISPFlags
Debug info subprogram flags.
Definition: DebugInfoMetadata.h:1841
llvm::MDTuple
Tuple of metadata.
Definition: Metadata.h:1174
LLVMBasicBlockRef
struct LLVMOpaqueBasicBlock * LLVMBasicBlockRef
Represents a basic block of instructions in LLVM IR.
Definition: Types.h:82
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:1138
llvm::Instruction::applyMergedLocation
void applyMergedLocation(const DILocation *LocA, const DILocation *LocB)
Merge 2 debug locations and apply it to the Instruction.
Definition: DebugInfo.cpp:814
LLVMMetadataReplaceAllUsesWith
void LLVMMetadataReplaceAllUsesWith(LLVMMetadataRef TargetMetadata, LLVMMetadataRef Replacement)
Replace all uses of temporary metadata.
Definition: DebugInfo.cpp:1493
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:1284
map_to_llvmDIFlags
static LLVMDIFlags map_to_llvmDIFlags(DINode::DIFlags Flags)
Definition: DebugInfo.cpp:874
GVMaterializer.h
DenseSet.h
LLVMDIFlags
LLVMDIFlags
Debug info flags.
Definition: DebugInfo.h:34
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:1450
llvm::Instruction
Definition: Instruction.h:45
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:1118
llvm::FindDbgDeclareUses
TinyPtrVector< DbgDeclareInst * > FindDbgDeclareUses(Value *V)
Like FindDbgAddrUses, but only returns dbg.declare intrinsics, not dbg.addr.
Definition: DebugInfo.cpp:68
LLVMDIBuilderCreateSubroutineType
LLVMMetadataRef LLVMDIBuilderCreateSubroutineType(LLVMDIBuilderRef Builder, LLVMMetadataRef File, LLVMMetadataRef *ParameterTypes, unsigned NumParameterTypes, LLVMDIFlags Flags)
Create subroutine type.
Definition: DebugInfo.cpp:1427
llvm::unwrap
Attribute unwrap(LLVMAttributeRef Attr)
Definition: Attributes.h:260
llvm::stripDebugInfo
bool stripDebugInfo(Function &F)
Definition: DebugInfo.cpp:441
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:1542
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:1240
DebugLoc.h
SmallPtrSet.h
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:1294
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:179
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.
LLVMDITypeGetSizeInBits
uint64_t LLVMDITypeGetSizeInBits(LLVMMetadataRef DType)
Get the size of this DIType in bits.
Definition: DebugInfo.cpp:1399
LLVMGetModuleDebugMetadataVersion
unsigned LLVMGetModuleDebugMetadataVersion(LLVMModuleRef M)
The version of debug metadata that's present in the provided Module.
Definition: DebugInfo.cpp:895
llvm::LocalAsMetadata::getIfExists
static LocalAsMetadata * getIfExists(Value *Local)
Definition: Metadata.h:449
unwrapDI
DIT * unwrapDI(LLVMMetadataRef Ref)
Definition: DebugInfo.cpp:866
LLVMDIBuilderCreateUnspecifiedType
LLVMMetadataRef LLVMDIBuilderCreateUnspecifiedType(LLVMDIBuilderRef Builder, const char *Name, size_t NameLen)
Create a DWARF unspecified type.
Definition: DebugInfo.cpp:1221
llvm::function_ref
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLExtras.h:223
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:1126
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:1137
llvm::DenseSet
Implements a dense probed hash-table based set.
Definition: DenseSet.h:268
LLVMDILocationGetInlinedAt
LLVMMetadataRef LLVMDILocationGetInlinedAt(LLVMMetadataRef Location)
Get the "inline at" location associated with this debug location.
Definition: DebugInfo.cpp:1069
BasicBlock.h
llvm::DbgVariableIntrinsic
This is the common base class for debug info intrinsics for variables.
Definition: IntrinsicInst.h:148
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:916
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:945
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:1339
llvm::StringRef::empty
constexpr LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:152
LLVMDWARFEmissionKind
LLVMDWARFEmissionKind
The amount of debug information to emit.
Definition: DebugInfo.h:128
uint64_t
D
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
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:1176
LLVMDIFileGetSource
const char * LLVMDIFileGetSource(LLVMMetadataRef File, unsigned *Len)
Get the source of a given file.
Definition: DebugInfo.cpp:1089
llvm::ARM_MB::ST
@ ST
Definition: ARMBaseInfo.h:73
Addr
uint64_t Addr
Definition: ELFObjHandler.cpp:79
DebugInfo.h
LLVMDIBuilderCreateQualifiedType
LLVMMetadataRef LLVMDIBuilderCreateQualifiedType(LLVMDIBuilderRef Builder, unsigned Tag, LLVMMetadataRef Type)
Create debugging information entry for a qualified type, e.g.
Definition: DebugInfo.cpp:1320
LLVMDIBuilderGetOrCreateSubrange
LLVMMetadataRef LLVMDIBuilderGetOrCreateSubrange(LLVMDIBuilderRef Builder, int64_t Lo, int64_t Count)
Create a descriptor for a value range.
Definition: DebugInfo.cpp:1574
LLVMDILocationGetLine
unsigned LLVMDILocationGetLine(LLVMMetadataRef Location)
Get the line number of this debug location.
Definition: DebugInfo.cpp:1057
LLVMDWARFMacinfoRecordType
LLVMDWARFMacinfoRecordType
Describes the kind of macro declaration used for LLVMDIBuilderCreateMacro.
Definition: DebugInfo.h:186
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:965
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:957
llvm::LLVMContext
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:67
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:1530
DebugInfo.h
I
#define I(x, y, z)
Definition: MD5.cpp:58
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:642
DIBuilder.h
llvm::DICompileUnit
Compile unit.
Definition: DebugInfoMetadata.h:1337
llvm::findDbgValues
void findDbgValues(SmallVectorImpl< DbgValueInst * > &DbgValues, Value *V)
Finds the llvm.dbg.value intrinsics describing a value.
Definition: DebugInfo.cpp:76
getSubprogram
static DISubprogram * getSubprogram(bool IsDistinct, Ts &&...Args)
Definition: DIBuilder.cpp:825
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:819
llvm::Instruction::dropLocation
void dropLocation()
Drop the instruction's debug location.
Definition: DebugInfo.cpp:821
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::DebugInfoFinder::processModule
void processModule(const Module &M)
Process entire module and collect debug info anchors.
Definition: DebugInfo.cpp:148
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:1050
LLVMDITypeGetLine
unsigned LLVMDITypeGetLine(LLVMMetadataRef DType)
Get the source line where this DIType is declared.
Definition: DebugInfo.cpp:1411
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:891
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:1254
LLVMDIVariableGetLine
unsigned LLVMDIVariableGetLine(LLVMMetadataRef Var)
Get the source line where this DIVariable is declared.
Definition: DebugInfo.cpp:1479
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
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:1036
LLVMDITypeGetFlags
LLVMDIFlags LLVMDITypeGetFlags(LLVMMetadataRef DType)
Get the flags associated with this DIType.
Definition: DebugInfo.cpp:1415
LLVMDIBuilderGetOrCreateArray
LLVMMetadataRef LLVMDIBuilderGetOrCreateArray(LLVMDIBuilderRef Builder, LLVMMetadataRef *Data, size_t Length)
Create an array of DI Nodes.
Definition: DebugInfo.cpp:1579
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:1512
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:650
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
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:1554
llvm::DISubroutineType
Type array for a subprogram.
Definition: DebugInfoMetadata.h:1283
llvm::wrap
LLVMAttributeRef wrap(Attribute Attr)
Definition: Attributes.h:255
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
llvm::DIScope::getScope
DIScope * getScope() const
Definition: DebugInfoMetadata.cpp:238
llvm::ArrayRef< uint64_t >
None.h
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:1274
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:57
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:1185
llvm::DINode
Tagged DWARF-like metadata node.
Definition: DebugInfoMetadata.h:127
LLVMDIFileGetDirectory
const char * LLVMDIFileGetDirectory(LLVMMetadataRef File, unsigned *Len)
Get the directory of a given file.
Definition: DebugInfo.cpp:1077
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:134
llvm::DebugInfoFinder::processVariable
void processVariable(const Module &M, const DbgVariableIntrinsic &DVI)
Process DbgVariableIntrinsic.
Definition: DebugInfo.cpp:281
LLVMDITypeGetName
const char * LLVMDITypeGetName(LLVMMetadataRef DType, size_t *Length)
Get the name of this DIType.
Definition: DebugInfo.cpp:1393
uint32_t
LLVMDIVariableGetFile
LLVMMetadataRef LLVMDIVariableGetFile(LLVMMetadataRef Var)
Get the metadata of the file associated with a given variable.
Definition: DebugInfo.cpp:1471
llvm::Value::getContext
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:991
LLVMGetMetadataKind
LLVMMetadataKind LLVMGetMetadataKind(LLVMMetadataRef Metadata)
Obtain the enumerated type of a Metadata instance.
Definition: DebugInfo.cpp:1609
DL
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Definition: AArch64SLSHardening.cpp:76
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
llvm::MDTuple::getTemporary
static TempMDTuple getTemporary(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Return a temporary node.
Definition: Metadata.h:1220
llvm::MDNode::getDistinct
static MDTuple * getDistinct(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition: Metadata.h:1241
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:1564
pack_into_DISPFlags
static DISubprogram::DISPFlags pack_into_DISPFlags(bool IsLocalToUnit, bool IsDefinition, bool IsOptimized)
Definition: DebugInfo.cpp:879
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:1500
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:1367
llvm::MDNode::getContext
LLVMContext & getContext() const
Definition: Metadata.h:967
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:1023
llvm::MDNode::isDistinct
bool isDistinct() const
Definition: Metadata.h:986
LLVMDIFileGetFilename
const char * LLVMDIFileGetFilename(LLVMMetadataRef File, unsigned *Len)
Get the name of a given file.
Definition: DebugInfo.cpp:1083
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
LLVMDIBuilderFinalize
void LLVMDIBuilderFinalize(LLVMDIBuilderRef Builder)
Construct any deferred debug info descriptors.
Definition: DebugInfo.cpp:907
LLVMBool
int LLVMBool
Definition: Types.h:28
llvm::DIScope
Base class for scope-like contexts.
Definition: DebugInfoMetadata.h:476
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:937
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:325
Casting.h
Function.h
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:1861
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:1098
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:1210
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:1352
llvm::DICompileUnit::DebugNameTableKind::Default
@ Default
llvm::MDNode::deleteTemporary
static void deleteTemporary(MDNode *N)
Deallocate a node created by getTemporary.
Definition: Metadata.cpp:849
llvm::DIGlobalVariableExpression
A pair of DIGlobalVariable and DIExpression.
Definition: DebugInfoMetadata.h:3408
llvm::MDNode::replaceOperandWith
void replaceOperandWith(unsigned I, Metadata *New)
Replace a specific operand.
Definition: Metadata.cpp:877
LLVMMetadataKind
unsigned LLVMMetadataKind
Definition: DebugInfo.h:174
LLVMDIBuilderRef
struct LLVMOpaqueDIBuilder * LLVMDIBuilderRef
Represents an LLVM debug info builder.
Definition: Types.h:117
LLVMDIVariableGetScope
LLVMMetadataRef LLVMDIVariableGetScope(LLVMMetadataRef Var)
Get the metadata of the scope associated with a given variable.
Definition: DebugInfo.cpp:1475
llvm::MetadataAsValue::getIfExists
static MetadataAsValue * getIfExists(LLVMContext &Context, Metadata *MD)
Definition: Metadata.cpp:114
SmallVector.h
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:1194
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:557
LLVMDIBuilderCreateNullPtrType
LLVMMetadataRef LLVMDIBuilderCreateNullPtrType(LLVMDIBuilderRef Builder)
Create C++11 nullptr type.
Definition: DebugInfo.cpp:1334
LLVMDIBuilderFinalizeSubprogram
void LLVMDIBuilderFinalizeSubprogram(LLVMDIBuilderRef Builder, LLVMMetadataRef subprogram)
Finalize a specific subprogram.
Definition: DebugInfo.cpp:911
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:1227
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:710
LLVMGenericDINodeMetadataKind
@ LLVMGenericDINodeMetadataKind
Definition: DebugInfo.h:146
llvm::DISubprogram
Subprogram description.
Definition: DebugInfoMetadata.h:1826
llvm::SmallVectorImpl
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:43
LLVMValueRef
struct LLVMOpaqueValue * LLVMValueRef
Represents an individual value in LLVM IR.
Definition: Types.h:75
llvm::SmallPtrSetImpl
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
Definition: SmallPtrSet.h:343
LLVMDIBuilderCreateConstantValueExpression
LLVMMetadataRef LLVMDIBuilderCreateConstantValueExpression(LLVMDIBuilderRef Builder, uint64_t Value)
Create a new descriptor for the specified variable that does not have an address, but does have a con...
Definition: DebugInfo.cpp:1445
llvm::getDebugMetadataVersionFromModule
unsigned getDebugMetadataVersionFromModule(const Module &M)
Return Debug Info Metadata Version by checking module flags.
Definition: DebugInfo.cpp:807
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
LLVMDWARFTypeEncoding
unsigned LLVMDWARFTypeEncoding
An LLVM DWARF type encoding.
Definition: DebugInfo.h:179
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
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:887
llvm::SmallVectorImpl::reserve
void reserve(size_type N)
Definition: SmallVector.h:634
LLVMDIBuilderCreateExpression
LLVMMetadataRef LLVMDIBuilderCreateExpression(LLVMDIBuilderRef Builder, uint64_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:1438
LLVMMetadataRef
struct LLVMOpaqueMetadata * LLVMMetadataRef
Represents an LLVM Metadata.
Definition: Types.h:89
map_from_llvmDIFlags
static DINode::DIFlags map_from_llvmDIFlags(LLVMDIFlags Flags)
Definition: DebugInfo.cpp:870
CU
Definition: AArch64AsmBackend.cpp:504
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::MDOperand::get
Metadata * get() const
Definition: Metadata.h:764
llvm::Value::users
iterator_range< user_iterator > users()
Definition: Value.h:421
LLVMDILocationGetScope
LLVMMetadataRef LLVMDILocationGetScope(LLVMMetadataRef Location)
Get the local scope associated with this debug location.
Definition: DebugInfo.cpp:1065
File
Instrumentation for Order File
Definition: InstrOrderFile.cpp:205
LLVMDisposeTemporaryMDNode
void LLVMDisposeTemporaryMDNode(LLVMMetadataRef TempNode)
Deallocate a temporary node.
Definition: DebugInfo.cpp:1489
llvm::MDOperand
Tracking metadata reference owned by Metadata.
Definition: Metadata.h:753
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
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
LLVMInstructionSetDebugLoc
void LLVMInstructionSetDebugLoc(LLVMValueRef Inst, LLVMMetadataRef Loc)
Set the debug location for the given instruction.
Definition: DebugInfo.cpp:1602