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(N->op_begin() != N->op_end() && "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.getMetadata(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     SmallVector<MDNode *, 1> MDs;
373     GV.getMetadata(LLVMContext::MD_dbg, MDs);
374     if (!MDs.empty()) {
375       GV.eraseMetadata(LLVMContext::MD_dbg);
376       Changed = true;
377     }
378   }
379 
380   if (GVMaterializer *Materializer = M.getMaterializer())
381     Materializer->setStripDebugInfo();
382 
383   return Changed;
384 }
385 
386 namespace {
387 
388 /// Helper class to downgrade -g metadata to -gline-tables-only metadata.
389 class DebugTypeInfoRemoval {
390   DenseMap<Metadata *, Metadata *> Replacements;
391 
392 public:
393   /// The (void)() type.
394   MDNode *EmptySubroutineType;
395 
396 private:
397   /// Remember what linkage name we originally had before stripping. If we end
398   /// up making two subprograms identical who originally had different linkage
399   /// names, then we need to make one of them distinct, to avoid them getting
400   /// uniqued. Maps the new node to the old linkage name.
401   DenseMap<DISubprogram *, StringRef> NewToLinkageName;
402 
403   // TODO: Remember the distinct subprogram we created for a given linkage name,
404   // so that we can continue to unique whenever possible. Map <newly created
405   // node, old linkage name> to the first (possibly distinct) mdsubprogram
406   // created for that combination. This is not strictly needed for correctness,
407   // but can cut down on the number of MDNodes and let us diff cleanly with the
408   // output of -gline-tables-only.
409 
410 public:
411   DebugTypeInfoRemoval(LLVMContext &C)
412       : EmptySubroutineType(DISubroutineType::get(C, DINode::FlagZero, 0,
413                                                   MDNode::get(C, {}))) {}
414 
415   Metadata *map(Metadata *M) {
416     if (!M)
417       return nullptr;
418     auto Replacement = Replacements.find(M);
419     if (Replacement != Replacements.end())
420       return Replacement->second;
421 
422     return M;
423   }
424   MDNode *mapNode(Metadata *N) { return dyn_cast_or_null<MDNode>(map(N)); }
425 
426   /// Recursively remap N and all its referenced children. Does a DF post-order
427   /// traversal, so as to remap bottoms up.
428   void traverseAndRemap(MDNode *N) { traverse(N); }
429 
430 private:
431   // Create a new DISubprogram, to replace the one given.
432   DISubprogram *getReplacementSubprogram(DISubprogram *MDS) {
433     auto *FileAndScope = cast_or_null<DIFile>(map(MDS->getFile()));
434     StringRef LinkageName = MDS->getName().empty() ? MDS->getLinkageName() : "";
435     DISubprogram *Declaration = nullptr;
436     auto *Type = cast_or_null<DISubroutineType>(map(MDS->getType()));
437     DITypeRef ContainingType(map(MDS->getContainingType()));
438     auto *Unit = cast_or_null<DICompileUnit>(map(MDS->getUnit()));
439     auto Variables = nullptr;
440     auto TemplateParams = nullptr;
441 
442     // Make a distinct DISubprogram, for situations that warrent it.
443     auto distinctMDSubprogram = [&]() {
444       return DISubprogram::getDistinct(
445           MDS->getContext(), FileAndScope, MDS->getName(), LinkageName,
446           FileAndScope, MDS->getLine(), Type, MDS->isLocalToUnit(),
447           MDS->isDefinition(), MDS->getScopeLine(), ContainingType,
448           MDS->getVirtuality(), MDS->getVirtualIndex(),
449           MDS->getThisAdjustment(), MDS->getFlags(), MDS->isOptimized(), Unit,
450           TemplateParams, Declaration, Variables);
451     };
452 
453     if (MDS->isDistinct())
454       return distinctMDSubprogram();
455 
456     auto *NewMDS = DISubprogram::get(
457         MDS->getContext(), FileAndScope, MDS->getName(), LinkageName,
458         FileAndScope, MDS->getLine(), Type, MDS->isLocalToUnit(),
459         MDS->isDefinition(), MDS->getScopeLine(), ContainingType,
460         MDS->getVirtuality(), MDS->getVirtualIndex(), MDS->getThisAdjustment(),
461         MDS->getFlags(), MDS->isOptimized(), Unit, TemplateParams, Declaration,
462         Variables);
463 
464     StringRef OldLinkageName = MDS->getLinkageName();
465 
466     // See if we need to make a distinct one.
467     auto OrigLinkage = NewToLinkageName.find(NewMDS);
468     if (OrigLinkage != NewToLinkageName.end()) {
469       if (OrigLinkage->second == OldLinkageName)
470         // We're good.
471         return NewMDS;
472 
473       // Otherwise, need to make a distinct one.
474       // TODO: Query the map to see if we already have one.
475       return distinctMDSubprogram();
476     }
477 
478     NewToLinkageName.insert({NewMDS, MDS->getLinkageName()});
479     return NewMDS;
480   }
481 
482   /// Create a new compile unit, to replace the one given
483   DICompileUnit *getReplacementCU(DICompileUnit *CU) {
484     // Drop skeleton CUs.
485     if (CU->getDWOId())
486       return nullptr;
487 
488     auto *File = cast_or_null<DIFile>(map(CU->getFile()));
489     MDTuple *EnumTypes = nullptr;
490     MDTuple *RetainedTypes = nullptr;
491     MDTuple *GlobalVariables = nullptr;
492     MDTuple *ImportedEntities = nullptr;
493     return DICompileUnit::getDistinct(
494         CU->getContext(), CU->getSourceLanguage(), File, CU->getProducer(),
495         CU->isOptimized(), CU->getFlags(), CU->getRuntimeVersion(),
496         CU->getSplitDebugFilename(), DICompileUnit::LineTablesOnly, EnumTypes,
497         RetainedTypes, GlobalVariables, ImportedEntities, CU->getMacros(),
498         CU->getDWOId(), CU->getSplitDebugInlining(),
499         CU->getDebugInfoForProfiling(), CU->getGnuPubnames());
500   }
501 
502   DILocation *getReplacementMDLocation(DILocation *MLD) {
503     auto *Scope = map(MLD->getScope());
504     auto *InlinedAt = map(MLD->getInlinedAt());
505     if (MLD->isDistinct())
506       return DILocation::getDistinct(MLD->getContext(), MLD->getLine(),
507                                      MLD->getColumn(), Scope, InlinedAt);
508     return DILocation::get(MLD->getContext(), MLD->getLine(), MLD->getColumn(),
509                            Scope, InlinedAt);
510   }
511 
512   /// Create a new generic MDNode, to replace the one given
513   MDNode *getReplacementMDNode(MDNode *N) {
514     SmallVector<Metadata *, 8> Ops;
515     Ops.reserve(N->getNumOperands());
516     for (auto &I : N->operands())
517       if (I)
518         Ops.push_back(map(I));
519     auto *Ret = MDNode::get(N->getContext(), Ops);
520     return Ret;
521   }
522 
523   /// Attempt to re-map N to a newly created node.
524   void remap(MDNode *N) {
525     if (Replacements.count(N))
526       return;
527 
528     auto doRemap = [&](MDNode *N) -> MDNode * {
529       if (!N)
530         return nullptr;
531       if (auto *MDSub = dyn_cast<DISubprogram>(N)) {
532         remap(MDSub->getUnit());
533         return getReplacementSubprogram(MDSub);
534       }
535       if (isa<DISubroutineType>(N))
536         return EmptySubroutineType;
537       if (auto *CU = dyn_cast<DICompileUnit>(N))
538         return getReplacementCU(CU);
539       if (isa<DIFile>(N))
540         return N;
541       if (auto *MDLB = dyn_cast<DILexicalBlockBase>(N))
542         // Remap to our referenced scope (recursively).
543         return mapNode(MDLB->getScope());
544       if (auto *MLD = dyn_cast<DILocation>(N))
545         return getReplacementMDLocation(MLD);
546 
547       // Otherwise, if we see these, just drop them now. Not strictly necessary,
548       // but this speeds things up a little.
549       if (isa<DINode>(N))
550         return nullptr;
551 
552       return getReplacementMDNode(N);
553     };
554     Replacements[N] = doRemap(N);
555   }
556 
557   /// Do the remapping traversal.
558   void traverse(MDNode *);
559 };
560 
561 } // end anonymous namespace
562 
563 void DebugTypeInfoRemoval::traverse(MDNode *N) {
564   if (!N || Replacements.count(N))
565     return;
566 
567   // To avoid cycles, as well as for efficiency sake, we will sometimes prune
568   // parts of the graph.
569   auto prune = [](MDNode *Parent, MDNode *Child) {
570     if (auto *MDS = dyn_cast<DISubprogram>(Parent))
571       return Child == MDS->getVariables().get();
572     return false;
573   };
574 
575   SmallVector<MDNode *, 16> ToVisit;
576   DenseSet<MDNode *> Opened;
577 
578   // Visit each node starting at N in post order, and map them.
579   ToVisit.push_back(N);
580   while (!ToVisit.empty()) {
581     auto *N = ToVisit.back();
582     if (!Opened.insert(N).second) {
583       // Close it.
584       remap(N);
585       ToVisit.pop_back();
586       continue;
587     }
588     for (auto &I : N->operands())
589       if (auto *MDN = dyn_cast_or_null<MDNode>(I))
590         if (!Opened.count(MDN) && !Replacements.count(MDN) && !prune(N, MDN) &&
591             !isa<DICompileUnit>(MDN))
592           ToVisit.push_back(MDN);
593   }
594 }
595 
596 bool llvm::stripNonLineTableDebugInfo(Module &M) {
597   bool Changed = false;
598 
599   // First off, delete the debug intrinsics.
600   auto RemoveUses = [&](StringRef Name) {
601     if (auto *DbgVal = M.getFunction(Name)) {
602       while (!DbgVal->use_empty())
603         cast<Instruction>(DbgVal->user_back())->eraseFromParent();
604       DbgVal->eraseFromParent();
605       Changed = true;
606     }
607   };
608   RemoveUses("llvm.dbg.declare");
609   RemoveUses("llvm.dbg.value");
610 
611   // Delete non-CU debug info named metadata nodes.
612   for (auto NMI = M.named_metadata_begin(), NME = M.named_metadata_end();
613        NMI != NME;) {
614     NamedMDNode *NMD = &*NMI;
615     ++NMI;
616     // Specifically keep dbg.cu around.
617     if (NMD->getName() == "llvm.dbg.cu")
618       continue;
619   }
620 
621   // Drop all dbg attachments from global variables.
622   for (auto &GV : M.globals())
623     GV.eraseMetadata(LLVMContext::MD_dbg);
624 
625   DebugTypeInfoRemoval Mapper(M.getContext());
626   auto remap = [&](MDNode *Node) -> MDNode * {
627     if (!Node)
628       return nullptr;
629     Mapper.traverseAndRemap(Node);
630     auto *NewNode = Mapper.mapNode(Node);
631     Changed |= Node != NewNode;
632     Node = NewNode;
633     return NewNode;
634   };
635 
636   // Rewrite the DebugLocs to be equivalent to what
637   // -gline-tables-only would have created.
638   for (auto &F : M) {
639     if (auto *SP = F.getSubprogram()) {
640       Mapper.traverseAndRemap(SP);
641       auto *NewSP = cast<DISubprogram>(Mapper.mapNode(SP));
642       Changed |= SP != NewSP;
643       F.setSubprogram(NewSP);
644     }
645     for (auto &BB : F) {
646       for (auto &I : BB) {
647         auto remapDebugLoc = [&](DebugLoc DL) -> DebugLoc {
648           auto *Scope = DL.getScope();
649           MDNode *InlinedAt = DL.getInlinedAt();
650           Scope = remap(Scope);
651           InlinedAt = remap(InlinedAt);
652           return DebugLoc::get(DL.getLine(), DL.getCol(), Scope, InlinedAt);
653         };
654 
655         if (I.getDebugLoc() != DebugLoc())
656           I.setDebugLoc(remapDebugLoc(I.getDebugLoc()));
657 
658         // Remap DILocations in untyped MDNodes (e.g., llvm.loop).
659         SmallVector<std::pair<unsigned, MDNode *>, 2> MDs;
660         I.getAllMetadata(MDs);
661         for (auto Attachment : MDs)
662           if (auto *T = dyn_cast_or_null<MDTuple>(Attachment.second))
663             for (unsigned N = 0; N < T->getNumOperands(); ++N)
664               if (auto *Loc = dyn_cast_or_null<DILocation>(T->getOperand(N)))
665                 if (Loc != DebugLoc())
666                   T->replaceOperandWith(N, remapDebugLoc(Loc));
667       }
668     }
669   }
670 
671   // Create a new llvm.dbg.cu, which is equivalent to the one
672   // -gline-tables-only would have created.
673   for (auto &NMD : M.getNamedMDList()) {
674     SmallVector<MDNode *, 8> Ops;
675     for (MDNode *Op : NMD.operands())
676       Ops.push_back(remap(Op));
677 
678     if (!Changed)
679       continue;
680 
681     NMD.clearOperands();
682     for (auto *Op : Ops)
683       if (Op)
684         NMD.addOperand(Op);
685   }
686   return Changed;
687 }
688 
689 unsigned llvm::getDebugMetadataVersionFromModule(const Module &M) {
690   if (auto *Val = mdconst::dyn_extract_or_null<ConstantInt>(
691           M.getModuleFlag("Debug Info Version")))
692     return Val->getZExtValue();
693   return 0;
694 }
695 
696 void Instruction::applyMergedLocation(const DILocation *LocA,
697                                       const DILocation *LocB) {
698   setDebugLoc(DILocation::getMergedLocation(LocA, LocB,
699                                             DILocation::WithGeneratedLocation));
700 }
701 
702 //===----------------------------------------------------------------------===//
703 // LLVM C API implementations.
704 //===----------------------------------------------------------------------===//
705 
706 static unsigned map_from_llvmDWARFsourcelanguage(LLVMDWARFSourceLanguage lang) {
707   switch (lang) {
708 #define HANDLE_DW_LANG(ID, NAME, VERSION, VENDOR) \
709 case LLVMDWARFSourceLanguage##NAME: return ID;
710 #include "llvm/BinaryFormat/Dwarf.def"
711 #undef HANDLE_DW_LANG
712   }
713   llvm_unreachable("Unhandled Tag");
714 }
715 
716 template <typename DIT> DIT *unwrapDI(LLVMMetadataRef Ref) {
717   return (DIT *)(Ref ? unwrap<MDNode>(Ref) : nullptr);
718 }
719 
720 static DINode::DIFlags map_from_llvmDIFlags(LLVMDIFlags Flags) {
721   return static_cast<DINode::DIFlags>(Flags);
722 }
723 
724 unsigned LLVMDebugMetadataVersion() {
725   return DEBUG_METADATA_VERSION;
726 }
727 
728 LLVMDIBuilderRef LLVMCreateDIBuilderDisallowUnresolved(LLVMModuleRef M) {
729   return wrap(new DIBuilder(*unwrap(M), false));
730 }
731 
732 LLVMDIBuilderRef LLVMCreateDIBuilder(LLVMModuleRef M) {
733   return wrap(new DIBuilder(*unwrap(M)));
734 }
735 
736 unsigned LLVMGetModuleDebugMetadataVersion(LLVMModuleRef M) {
737   return getDebugMetadataVersionFromModule(*unwrap(M));
738 }
739 
740 LLVMBool LLVMStripModuleDebugInfo(LLVMModuleRef M) {
741   return StripDebugInfo(*unwrap(M));
742 }
743 
744 void LLVMDisposeDIBuilder(LLVMDIBuilderRef Builder) {
745   delete unwrap(Builder);
746 }
747 
748 void LLVMDIBuilderFinalize(LLVMDIBuilderRef Builder) {
749   unwrap(Builder)->finalize();
750 }
751 
752 LLVMMetadataRef LLVMDIBuilderCreateCompileUnit(
753     LLVMDIBuilderRef Builder, LLVMDWARFSourceLanguage Lang,
754     LLVMMetadataRef FileRef, const char *Producer, size_t ProducerLen,
755     LLVMBool isOptimized, const char *Flags, size_t FlagsLen,
756     unsigned RuntimeVer, const char *SplitName, size_t SplitNameLen,
757     LLVMDWARFEmissionKind Kind, unsigned DWOId, LLVMBool SplitDebugInlining,
758     LLVMBool DebugInfoForProfiling) {
759   auto File = unwrapDI<DIFile>(FileRef);
760 
761   return wrap(unwrap(Builder)->createCompileUnit(
762                  map_from_llvmDWARFsourcelanguage(Lang), File,
763                  StringRef(Producer, ProducerLen), isOptimized,
764                  StringRef(Flags, FlagsLen), RuntimeVer,
765                  StringRef(SplitName, SplitNameLen),
766                  static_cast<DICompileUnit::DebugEmissionKind>(Kind), DWOId,
767                  SplitDebugInlining, DebugInfoForProfiling));
768 }
769 
770 LLVMMetadataRef
771 LLVMDIBuilderCreateFile(LLVMDIBuilderRef Builder, const char *Filename,
772                         size_t FilenameLen, const char *Directory,
773                         size_t DirectoryLen) {
774   return wrap(unwrap(Builder)->createFile(StringRef(Filename, FilenameLen),
775                                           StringRef(Directory, DirectoryLen)));
776 }
777 
778 LLVMMetadataRef LLVMDIBuilderCreateFunction(
779     LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
780     size_t NameLen, const char *LinkageName, size_t LinkageNameLen,
781     LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty,
782     LLVMBool IsLocalToUnit, LLVMBool IsDefinition,
783     unsigned ScopeLine, LLVMDIFlags Flags, LLVMBool IsOptimized) {
784   return wrap(unwrap(Builder)->createFunction(
785       unwrapDI<DIScope>(Scope), {Name, NameLen}, {LinkageName, LinkageNameLen},
786       unwrapDI<DIFile>(File), LineNo, unwrapDI<DISubroutineType>(Ty),
787       IsLocalToUnit, IsDefinition, ScopeLine, map_from_llvmDIFlags(Flags),
788       IsOptimized, nullptr, nullptr, nullptr));
789 }
790 
791 
792 LLVMMetadataRef LLVMDIBuilderCreateLexicalBlock(
793     LLVMDIBuilderRef Builder, LLVMMetadataRef Scope,
794     LLVMMetadataRef File, unsigned Line, unsigned Col) {
795   return wrap(unwrap(Builder)->createLexicalBlock(unwrapDI<DIScope>(Scope),
796                                                   unwrapDI<DIFile>(File),
797                                                   Line, Col));
798 }
799 
800 LLVMMetadataRef
801 LLVMDIBuilderCreateLexicalBlockFile(LLVMDIBuilderRef Builder,
802                                     LLVMMetadataRef Scope,
803                                     LLVMMetadataRef File,
804                                     unsigned Discriminator) {
805   return wrap(unwrap(Builder)->createLexicalBlockFile(unwrapDI<DIScope>(Scope),
806                                                       unwrapDI<DIFile>(File),
807                                                       Discriminator));
808 }
809 
810 LLVMMetadataRef
811 LLVMDIBuilderCreateDebugLocation(LLVMContextRef Ctx, unsigned Line,
812                                  unsigned Column, LLVMMetadataRef Scope,
813                                  LLVMMetadataRef InlinedAt) {
814   return wrap(DILocation::get(*unwrap(Ctx), Line, Column, unwrap(Scope),
815                               unwrap(InlinedAt)));
816 }
817 
818 LLVMMetadataRef LLVMDIBuilderCreateEnumerationType(
819   LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
820   size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
821   unsigned SizeInBits, unsigned AlignInBits, LLVMMetadataRef *Elements,
822   unsigned NumElements, LLVMMetadataRef ClassTy) {
823 auto Elts = unwrap(Builder)->getOrCreateArray({unwrap(Elements),
824                                                NumElements});
825 return wrap(unwrap(Builder)->createEnumerationType(
826     unwrapDI<DIScope>(Scope), {Name, NameLen}, unwrapDI<DIFile>(File),
827     LineNumber, SizeInBits, AlignInBits, Elts, unwrapDI<DIType>(ClassTy)));
828 }
829 
830 LLVMMetadataRef LLVMDIBuilderCreateUnionType(
831   LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
832   size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
833   unsigned SizeInBits, unsigned AlignInBits, LLVMDIFlags Flags,
834   LLVMMetadataRef *Elements, unsigned NumElements, unsigned RunTimeLang,
835   const char *UniqueId, size_t UniqueIdLen) {
836   auto Elts = unwrap(Builder)->getOrCreateArray({unwrap(Elements),
837                                                  NumElements});
838   return wrap(unwrap(Builder)->createUnionType(
839      unwrapDI<DIScope>(Scope), {Name, NameLen}, unwrapDI<DIFile>(File),
840      LineNumber, SizeInBits, AlignInBits, map_from_llvmDIFlags(Flags),
841      Elts, RunTimeLang, {UniqueId, UniqueIdLen}));
842 }
843 
844 
845 LLVMMetadataRef
846 LLVMDIBuilderCreateArrayType(LLVMDIBuilderRef Builder, unsigned Size,
847                              unsigned AlignInBits, LLVMMetadataRef Ty,
848                              LLVMMetadataRef *Subscripts,
849                              unsigned NumSubscripts) {
850   auto Subs = unwrap(Builder)->getOrCreateArray({unwrap(Subscripts),
851                                                  NumSubscripts});
852   return wrap(unwrap(Builder)->createArrayType(Size, AlignInBits,
853                                                unwrapDI<DIType>(Ty), Subs));
854 }
855 
856 LLVMMetadataRef
857 LLVMDIBuilderCreateVectorType(LLVMDIBuilderRef Builder, unsigned Size,
858                               unsigned AlignInBits, LLVMMetadataRef Ty,
859                               LLVMMetadataRef *Subscripts,
860                               unsigned NumSubscripts) {
861   auto Subs = unwrap(Builder)->getOrCreateArray({unwrap(Subscripts),
862                                                  NumSubscripts});
863   return wrap(unwrap(Builder)->createVectorType(Size, AlignInBits,
864                                                 unwrapDI<DIType>(Ty), Subs));
865 }
866 
867 LLVMMetadataRef
868 LLVMDIBuilderCreateBasicType(LLVMDIBuilderRef Builder, const char *Name,
869                              size_t NameLen, unsigned SizeInBits,
870                              LLVMDWARFTypeEncoding Encoding) {
871   return wrap(unwrap(Builder)->createBasicType({Name, NameLen},
872                                                SizeInBits, Encoding));
873 }
874 
875 LLVMMetadataRef LLVMDIBuilderCreatePointerType(
876     LLVMDIBuilderRef Builder, LLVMMetadataRef PointeeTy,
877     unsigned SizeInBits, unsigned AlignInBits, unsigned AddressSpace,
878     const char *Name, size_t NameLen) {
879   return wrap(unwrap(Builder)->createPointerType(unwrapDI<DIType>(PointeeTy),
880                                          SizeInBits, AlignInBits,
881                                          AddressSpace, {Name, NameLen}));
882 }
883 
884 LLVMMetadataRef LLVMDIBuilderCreateStructType(
885     LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
886     size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
887     unsigned SizeInBits, unsigned AlignInBits, LLVMDIFlags Flags,
888     LLVMMetadataRef DerivedFrom, LLVMMetadataRef *Elements,
889     unsigned NumElements, unsigned RunTimeLang, LLVMMetadataRef VTableHolder,
890     const char *UniqueId, size_t UniqueIdLen) {
891   auto Elts = unwrap(Builder)->getOrCreateArray({unwrap(Elements),
892                                                  NumElements});
893   return wrap(unwrap(Builder)->createStructType(
894       unwrapDI<DIScope>(Scope), {Name, NameLen}, unwrapDI<DIFile>(File),
895       LineNumber, SizeInBits, AlignInBits, map_from_llvmDIFlags(Flags),
896       unwrapDI<DIType>(DerivedFrom), Elts, RunTimeLang,
897       unwrapDI<DIType>(VTableHolder), {UniqueId, UniqueIdLen}));
898 }
899 
900 LLVMMetadataRef LLVMDIBuilderCreateMemberType(
901     LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
902     size_t NameLen, LLVMMetadataRef File, unsigned LineNo, unsigned SizeInBits,
903     unsigned AlignInBits, unsigned OffsetInBits, LLVMDIFlags Flags,
904     LLVMMetadataRef Ty) {
905   return wrap(unwrap(Builder)->createMemberType(unwrapDI<DIScope>(Scope),
906       {Name, NameLen}, unwrapDI<DIFile>(File), LineNo, SizeInBits, AlignInBits,
907       OffsetInBits, map_from_llvmDIFlags(Flags), unwrapDI<DIType>(Ty)));
908 }
909 
910 LLVMMetadataRef
911 LLVMDIBuilderCreateUnspecifiedType(LLVMDIBuilderRef Builder, const char *Name,
912                                    size_t NameLen) {
913   return wrap(unwrap(Builder)->createUnspecifiedType({Name, NameLen}));
914 }
915 
916 LLVMMetadataRef
917 LLVMDIBuilderCreateStaticMemberType(
918     LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
919     size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
920     LLVMMetadataRef Type, LLVMDIFlags Flags, LLVMValueRef ConstantVal,
921     unsigned AlignInBits) {
922   return wrap(unwrap(Builder)->createStaticMemberType(
923                   unwrapDI<DIScope>(Scope), {Name, NameLen},
924                   unwrapDI<DIFile>(File), LineNumber, unwrapDI<DIType>(Type),
925                   map_from_llvmDIFlags(Flags), unwrap<Constant>(ConstantVal),
926                   AlignInBits));
927 }
928 
929 LLVMMetadataRef
930 LLVMDIBuilderCreateObjectPointerType(LLVMDIBuilderRef Builder,
931                                      LLVMMetadataRef Type) {
932   return wrap(unwrap(Builder)->createObjectPointerType(unwrapDI<DIType>(Type)));
933 }
934 
935 LLVMMetadataRef
936 LLVMDIBuilderCreateReplaceableCompositeType(
937     LLVMDIBuilderRef Builder, unsigned Tag, const char *Name,
938     size_t NameLen, LLVMMetadataRef Scope, LLVMMetadataRef File, unsigned Line,
939     unsigned RuntimeLang, unsigned SizeInBits, unsigned AlignInBits,
940     LLVMDIFlags Flags, const char *UniqueIdentifier,
941     size_t UniqueIdentifierLen) {
942   return wrap(unwrap(Builder)->createReplaceableCompositeType(
943                   Tag, {Name, NameLen}, unwrapDI<DIScope>(Scope),
944                   unwrapDI<DIFile>(File), Line, RuntimeLang, SizeInBits,
945                   AlignInBits, map_from_llvmDIFlags(Flags),
946                   {UniqueIdentifier, UniqueIdentifierLen}));
947 }
948 
949 LLVMMetadataRef
950 LLVMDIBuilderCreateQualifiedType(LLVMDIBuilderRef Builder, unsigned Tag,
951                                  LLVMMetadataRef Type) {
952   return wrap(unwrap(Builder)->createQualifiedType(Tag,
953                                                    unwrapDI<DIType>(Type)));
954 }
955 
956 LLVMMetadataRef
957 LLVMDIBuilderCreateReferenceType(LLVMDIBuilderRef Builder, unsigned Tag,
958                                  LLVMMetadataRef Type) {
959   return wrap(unwrap(Builder)->createReferenceType(Tag,
960                                                    unwrapDI<DIType>(Type)));
961 }
962 
963 LLVMMetadataRef
964 LLVMDIBuilderCreateNullPtrType(LLVMDIBuilderRef Builder) {
965   return wrap(unwrap(Builder)->createNullPtrType());
966 }
967 
968 LLVMMetadataRef
969 LLVMDIBuilderCreateMemberPointerType(LLVMDIBuilderRef Builder,
970                                      LLVMMetadataRef PointeeType,
971                                      LLVMMetadataRef ClassType,
972                                      unsigned SizeInBits,
973                                      unsigned AlignInBits,
974                                      LLVMDIFlags Flags) {
975   return wrap(unwrap(Builder)->createMemberPointerType(
976                   unwrapDI<DIType>(PointeeType),
977                   unwrapDI<DIType>(ClassType), AlignInBits, SizeInBits,
978                   map_from_llvmDIFlags(Flags)));
979 }
980 
981 LLVMMetadataRef
982 LLVMDIBuilderCreateArtificialType(LLVMDIBuilderRef Builder,
983                                   LLVMMetadataRef Type) {
984   return wrap(unwrap(Builder)->createArtificialType(unwrapDI<DIType>(Type)));
985 }
986 
987 LLVMMetadataRef
988 LLVMDIBuilderCreateSubroutineType(LLVMDIBuilderRef Builder,
989                                   LLVMMetadataRef File,
990                                   LLVMMetadataRef *ParameterTypes,
991                                   unsigned NumParameterTypes,
992                                   LLVMDIFlags Flags) {
993   auto Elts = unwrap(Builder)->getOrCreateTypeArray({unwrap(ParameterTypes),
994                                                      NumParameterTypes});
995   return wrap(unwrap(Builder)->createSubroutineType(
996     Elts, map_from_llvmDIFlags(Flags)));
997 }
998 
999 LLVMMetadataRef LLVMGetSubprogram(LLVMValueRef Func) {
1000   return wrap(unwrap<Function>(Func)->getSubprogram());
1001 }
1002 
1003 void LLVMSetSubprogram(LLVMValueRef Func, LLVMMetadataRef SP) {
1004   unwrap<Function>(Func)->setSubprogram(unwrap<DISubprogram>(SP));
1005 }
1006