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