[LLVM-C] Expose functions to create debug locations via DIBuilder.
[lldb.git] / llvm / lib / IR / DebugInfo.cpp
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 "LLVMContextImpl.h"
17 #include "llvm/ADT/DenseMap.h"
18 #include "llvm/ADT/DenseSet.h"
19 #include "llvm/ADT/None.h"
20 #include "llvm/ADT/STLExtras.h"
21 #include "llvm/ADT/SmallPtrSet.h"
22 #include "llvm/ADT/SmallVector.h"
23 #include "llvm/ADT/StringRef.h"
24 #include "llvm/IR/BasicBlock.h"
25 #include "llvm/IR/Constants.h"
26 #include "llvm/IR/DebugInfoMetadata.h"
27 #include "llvm/IR/DebugLoc.h"
28 #include "llvm/IR/DebugInfo.h"
29 #include "llvm/IR/DIBuilder.h"
30 #include "llvm/IR/Function.h"
31 #include "llvm/IR/GVMaterializer.h"
32 #include "llvm/IR/Instruction.h"
33 #include "llvm/IR/IntrinsicInst.h"
34 #include "llvm/IR/LLVMContext.h"
35 #include "llvm/IR/Metadata.h"
36 #include "llvm/IR/Module.h"
37 #include "llvm/Support/Casting.h"
38 #include <algorithm>
39 #include <cassert>
40 #include <utility>
41
42 using namespace llvm;
43 using namespace llvm::dwarf;
44
45 DISubprogram *llvm::getDISubprogram(const MDNode *Scope) {
46   if (auto *LocalScope = dyn_cast_or_null<DILocalScope>(Scope))
47     return LocalScope->getSubprogram();
48   return nullptr;
49 }
50
51 //===----------------------------------------------------------------------===//
52 // DebugInfoFinder implementations.
53 //===----------------------------------------------------------------------===//
54
55 void DebugInfoFinder::reset() {
56   CUs.clear();
57   SPs.clear();
58   GVs.clear();
59   TYs.clear();
60   Scopes.clear();
61   NodesSeen.clear();
62 }
63
64 void DebugInfoFinder::processModule(const Module &M) {
65   for (auto *CU : M.debug_compile_units()) {
66     addCompileUnit(CU);
67     for (auto DIG : CU->getGlobalVariables()) {
68       if (!addGlobalVariable(DIG))
69         continue;
70       auto *GV = DIG->getVariable();
71       processScope(GV->getScope());
72       processType(GV->getType().resolve());
73     }
74     for (auto *ET : CU->getEnumTypes())
75       processType(ET);
76     for (auto *RT : CU->getRetainedTypes())
77       if (auto *T = dyn_cast<DIType>(RT))
78         processType(T);
79       else
80         processSubprogram(cast<DISubprogram>(RT));
81     for (auto *Import : CU->getImportedEntities()) {
82       auto *Entity = Import->getEntity().resolve();
83       if (auto *T = dyn_cast<DIType>(Entity))
84         processType(T);
85       else if (auto *SP = dyn_cast<DISubprogram>(Entity))
86         processSubprogram(SP);
87       else if (auto *NS = dyn_cast<DINamespace>(Entity))
88         processScope(NS->getScope());
89       else if (auto *M = dyn_cast<DIModule>(Entity))
90         processScope(M->getScope());
91     }
92   }
93   for (auto &F : M.functions()) {
94     if (auto *SP = cast_or_null<DISubprogram>(F.getSubprogram()))
95       processSubprogram(SP);
96     // There could be subprograms from inlined functions referenced from
97     // instructions only. Walk the function to find them.
98     for (const BasicBlock &BB : F) {
99       for (const Instruction &I : BB) {
100         if (!I.getDebugLoc())
101           continue;
102         processLocation(M, I.getDebugLoc().get());
103       }
104     }
105   }
106 }
107
108 void DebugInfoFinder::processLocation(const Module &M, const DILocation *Loc) {
109   if (!Loc)
110     return;
111   processScope(Loc->getScope());
112   processLocation(M, Loc->getInlinedAt());
113 }
114
115 void DebugInfoFinder::processType(DIType *DT) {
116   if (!addType(DT))
117     return;
118   processScope(DT->getScope().resolve());
119   if (auto *ST = dyn_cast<DISubroutineType>(DT)) {
120     for (DITypeRef Ref : ST->getTypeArray())
121       processType(Ref.resolve());
122     return;
123   }
124   if (auto *DCT = dyn_cast<DICompositeType>(DT)) {
125     processType(DCT->getBaseType().resolve());
126     for (Metadata *D : DCT->getElements()) {
127       if (auto *T = dyn_cast<DIType>(D))
128         processType(T);
129       else if (auto *SP = dyn_cast<DISubprogram>(D))
130         processSubprogram(SP);
131     }
132     return;
133   }
134   if (auto *DDT = dyn_cast<DIDerivedType>(DT)) {
135     processType(DDT->getBaseType().resolve());
136   }
137 }
138
139 void DebugInfoFinder::processScope(DIScope *Scope) {
140   if (!Scope)
141     return;
142   if (auto *Ty = dyn_cast<DIType>(Scope)) {
143     processType(Ty);
144     return;
145   }
146   if (auto *CU = dyn_cast<DICompileUnit>(Scope)) {
147     addCompileUnit(CU);
148     return;
149   }
150   if (auto *SP = dyn_cast<DISubprogram>(Scope)) {
151     processSubprogram(SP);
152     return;
153   }
154   if (!addScope(Scope))
155     return;
156   if (auto *LB = dyn_cast<DILexicalBlockBase>(Scope)) {
157     processScope(LB->getScope());
158   } else if (auto *NS = dyn_cast<DINamespace>(Scope)) {
159     processScope(NS->getScope());
160   } else if (auto *M = dyn_cast<DIModule>(Scope)) {
161     processScope(M->getScope());
162   }
163 }
164
165 void DebugInfoFinder::processSubprogram(DISubprogram *SP) {
166   if (!addSubprogram(SP))
167     return;
168   processScope(SP->getScope().resolve());
169   processType(SP->getType());
170   for (auto *Element : SP->getTemplateParams()) {
171     if (auto *TType = dyn_cast<DITemplateTypeParameter>(Element)) {
172       processType(TType->getType().resolve());
173     } else if (auto *TVal = dyn_cast<DITemplateValueParameter>(Element)) {
174       processType(TVal->getType().resolve());
175     }
176   }
177 }
178
179 void DebugInfoFinder::processDeclare(const Module &M,
180                                      const DbgDeclareInst *DDI) {
181   auto *N = dyn_cast<MDNode>(DDI->getVariable());
182   if (!N)
183     return;
184
185   auto *DV = dyn_cast<DILocalVariable>(N);
186   if (!DV)
187     return;
188
189   if (!NodesSeen.insert(DV).second)
190     return;
191   processScope(DV->getScope());
192   processType(DV->getType().resolve());
193 }
194
195 void DebugInfoFinder::processValue(const Module &M, const DbgValueInst *DVI) {
196   auto *N = dyn_cast<MDNode>(DVI->getVariable());
197   if (!N)
198     return;
199
200   auto *DV = dyn_cast<DILocalVariable>(N);
201   if (!DV)
202     return;
203
204   if (!NodesSeen.insert(DV).second)
205     return;
206   processScope(DV->getScope());
207   processType(DV->getType().resolve());
208 }
209
210 bool DebugInfoFinder::addType(DIType *DT) {
211   if (!DT)
212     return false;
213
214   if (!NodesSeen.insert(DT).second)
215     return false;
216
217   TYs.push_back(const_cast<DIType *>(DT));
218   return true;
219 }
220
221 bool DebugInfoFinder::addCompileUnit(DICompileUnit *CU) {
222   if (!CU)
223     return false;
224   if (!NodesSeen.insert(CU).second)
225     return false;
226
227   CUs.push_back(CU);
228   return true;
229 }
230
231 bool DebugInfoFinder::addGlobalVariable(DIGlobalVariableExpression *DIG) {
232   if (!NodesSeen.insert(DIG).second)
233     return false;
234
235   GVs.push_back(DIG);
236   return true;
237 }
238
239 bool DebugInfoFinder::addSubprogram(DISubprogram *SP) {
240   if (!SP)
241     return false;
242
243   if (!NodesSeen.insert(SP).second)
244     return false;
245
246   SPs.push_back(SP);
247   return true;
248 }
249
250 bool DebugInfoFinder::addScope(DIScope *Scope) {
251   if (!Scope)
252     return false;
253   // FIXME: Ocaml binding generates a scope with no content, we treat it
254   // as null for now.
255   if (Scope->getNumOperands() == 0)
256     return false;
257   if (!NodesSeen.insert(Scope).second)
258     return false;
259   Scopes.push_back(Scope);
260   return true;
261 }
262
263 static MDNode *stripDebugLocFromLoopID(MDNode *N) {
264   assert(N->op_begin() != N->op_end() && "Missing self reference?");
265
266   // if there is no debug location, we do not have to rewrite this MDNode.
267   if (std::none_of(N->op_begin() + 1, N->op_end(), [](const MDOperand &Op) {
268         return isa<DILocation>(Op.get());
269       }))
270     return N;
271
272   // If there is only the debug location without any actual loop metadata, we
273   // can remove the metadata.
274   if (std::none_of(N->op_begin() + 1, N->op_end(), [](const MDOperand &Op) {
275         return !isa<DILocation>(Op.get());
276       }))
277     return nullptr;
278
279   SmallVector<Metadata *, 4> Args;
280   // Reserve operand 0 for loop id self reference.
281   auto TempNode = MDNode::getTemporary(N->getContext(), None);
282   Args.push_back(TempNode.get());
283   // Add all non-debug location operands back.
284   for (auto Op = N->op_begin() + 1; Op != N->op_end(); Op++) {
285     if (!isa<DILocation>(*Op))
286       Args.push_back(*Op);
287   }
288
289   // Set the first operand to itself.
290   MDNode *LoopID = MDNode::get(N->getContext(), Args);
291   LoopID->replaceOperandWith(0, LoopID);
292   return LoopID;
293 }
294
295 bool llvm::stripDebugInfo(Function &F) {
296   bool Changed = false;
297   if (F.getMetadata(LLVMContext::MD_dbg)) {
298     Changed = true;
299     F.setSubprogram(nullptr);
300   }
301
302   DenseMap<MDNode*, MDNode*> LoopIDsMap;
303   for (BasicBlock &BB : F) {
304     for (auto II = BB.begin(), End = BB.end(); II != End;) {
305       Instruction &I = *II++; // We may delete the instruction, increment now.
306       if (isa<DbgInfoIntrinsic>(&I)) {
307         I.eraseFromParent();
308         Changed = true;
309         continue;
310       }
311       if (I.getDebugLoc()) {
312         Changed = true;
313         I.setDebugLoc(DebugLoc());
314       }
315     }
316
317     auto *TermInst = BB.getTerminator();
318     if (!TermInst)
319       // This is invalid IR, but we may not have run the verifier yet
320       continue;
321     if (auto *LoopID = TermInst->getMetadata(LLVMContext::MD_loop)) {
322       auto *NewLoopID = LoopIDsMap.lookup(LoopID);
323       if (!NewLoopID)
324         NewLoopID = LoopIDsMap[LoopID] = stripDebugLocFromLoopID(LoopID);
325       if (NewLoopID != LoopID)
326         TermInst->setMetadata(LLVMContext::MD_loop, NewLoopID);
327     }
328   }
329   return Changed;
330 }
331
332 bool llvm::StripDebugInfo(Module &M) {
333   bool Changed = false;
334
335   for (Module::named_metadata_iterator NMI = M.named_metadata_begin(),
336          NME = M.named_metadata_end(); NMI != NME;) {
337     NamedMDNode *NMD = &*NMI;
338     ++NMI;
339
340     // We're stripping debug info, and without them, coverage information
341     // doesn't quite make sense.
342     if (NMD->getName().startswith("llvm.dbg.") ||
343         NMD->getName() == "llvm.gcov") {
344       NMD->eraseFromParent();
345       Changed = true;
346     }
347   }
348
349   for (Function &F : M)
350     Changed |= stripDebugInfo(F);
351
352   for (auto &GV : M.globals()) {
353     SmallVector<MDNode *, 1> MDs;
354     GV.getMetadata(LLVMContext::MD_dbg, MDs);
355     if (!MDs.empty()) {
356       GV.eraseMetadata(LLVMContext::MD_dbg);
357       Changed = true;
358     }
359   }
360
361   if (GVMaterializer *Materializer = M.getMaterializer())
362     Materializer->setStripDebugInfo();
363
364   return Changed;
365 }
366
367 namespace {
368
369 /// Helper class to downgrade -g metadata to -gline-tables-only metadata.
370 class DebugTypeInfoRemoval {
371   DenseMap<Metadata *, Metadata *> Replacements;
372
373 public:
374   /// The (void)() type.
375   MDNode *EmptySubroutineType;
376
377 private:
378   /// Remember what linkage name we originally had before stripping. If we end
379   /// up making two subprograms identical who originally had different linkage
380   /// names, then we need to make one of them distinct, to avoid them getting
381   /// uniqued. Maps the new node to the old linkage name.
382   DenseMap<DISubprogram *, StringRef> NewToLinkageName;
383
384   // TODO: Remember the distinct subprogram we created for a given linkage name,
385   // so that we can continue to unique whenever possible. Map <newly created
386   // node, old linkage name> to the first (possibly distinct) mdsubprogram
387   // created for that combination. This is not strictly needed for correctness,
388   // but can cut down on the number of MDNodes and let us diff cleanly with the
389   // output of -gline-tables-only.
390
391 public:
392   DebugTypeInfoRemoval(LLVMContext &C)
393       : EmptySubroutineType(DISubroutineType::get(C, DINode::FlagZero, 0,
394                                                   MDNode::get(C, {}))) {}
395
396   Metadata *map(Metadata *M) {
397     if (!M)
398       return nullptr;
399     auto Replacement = Replacements.find(M);
400     if (Replacement != Replacements.end())
401       return Replacement->second;
402
403     return M;
404   }
405   MDNode *mapNode(Metadata *N) { return dyn_cast_or_null<MDNode>(map(N)); }
406
407   /// Recursively remap N and all its referenced children. Does a DF post-order
408   /// traversal, so as to remap bottoms up.
409   void traverseAndRemap(MDNode *N) { traverse(N); }
410
411 private:
412   // Create a new DISubprogram, to replace the one given.
413   DISubprogram *getReplacementSubprogram(DISubprogram *MDS) {
414     auto *FileAndScope = cast_or_null<DIFile>(map(MDS->getFile()));
415     StringRef LinkageName = MDS->getName().empty() ? MDS->getLinkageName() : "";
416     DISubprogram *Declaration = nullptr;
417     auto *Type = cast_or_null<DISubroutineType>(map(MDS->getType()));
418     DITypeRef ContainingType(map(MDS->getContainingType()));
419     auto *Unit = cast_or_null<DICompileUnit>(map(MDS->getUnit()));
420     auto Variables = nullptr;
421     auto TemplateParams = nullptr;
422
423     // Make a distinct DISubprogram, for situations that warrent it.
424     auto distinctMDSubprogram = [&]() {
425       return DISubprogram::getDistinct(
426           MDS->getContext(), FileAndScope, MDS->getName(), LinkageName,
427           FileAndScope, MDS->getLine(), Type, MDS->isLocalToUnit(),
428           MDS->isDefinition(), MDS->getScopeLine(), ContainingType,
429           MDS->getVirtuality(), MDS->getVirtualIndex(),
430           MDS->getThisAdjustment(), MDS->getFlags(), MDS->isOptimized(), Unit,
431           TemplateParams, Declaration, Variables);
432     };
433
434     if (MDS->isDistinct())
435       return distinctMDSubprogram();
436
437     auto *NewMDS = DISubprogram::get(
438         MDS->getContext(), FileAndScope, MDS->getName(), LinkageName,
439         FileAndScope, MDS->getLine(), Type, MDS->isLocalToUnit(),
440         MDS->isDefinition(), MDS->getScopeLine(), ContainingType,
441         MDS->getVirtuality(), MDS->getVirtualIndex(), MDS->getThisAdjustment(),
442         MDS->getFlags(), MDS->isOptimized(), Unit, TemplateParams, Declaration,
443         Variables);
444
445     StringRef OldLinkageName = MDS->getLinkageName();
446
447     // See if we need to make a distinct one.
448     auto OrigLinkage = NewToLinkageName.find(NewMDS);
449     if (OrigLinkage != NewToLinkageName.end()) {
450       if (OrigLinkage->second == OldLinkageName)
451         // We're good.
452         return NewMDS;
453
454       // Otherwise, need to make a distinct one.
455       // TODO: Query the map to see if we already have one.
456       return distinctMDSubprogram();
457     }
458
459     NewToLinkageName.insert({NewMDS, MDS->getLinkageName()});
460     return NewMDS;
461   }
462
463   /// Create a new compile unit, to replace the one given
464   DICompileUnit *getReplacementCU(DICompileUnit *CU) {
465     // Drop skeleton CUs.
466     if (CU->getDWOId())
467       return nullptr;
468
469     auto *File = cast_or_null<DIFile>(map(CU->getFile()));
470     MDTuple *EnumTypes = nullptr;
471     MDTuple *RetainedTypes = nullptr;
472     MDTuple *GlobalVariables = nullptr;
473     MDTuple *ImportedEntities = nullptr;
474     return DICompileUnit::getDistinct(
475         CU->getContext(), CU->getSourceLanguage(), File, CU->getProducer(),
476         CU->isOptimized(), CU->getFlags(), CU->getRuntimeVersion(),
477         CU->getSplitDebugFilename(), DICompileUnit::LineTablesOnly, EnumTypes,
478         RetainedTypes, GlobalVariables, ImportedEntities, CU->getMacros(),
479         CU->getDWOId(), CU->getSplitDebugInlining(),
480         CU->getDebugInfoForProfiling(), CU->getGnuPubnames());
481   }
482
483   DILocation *getReplacementMDLocation(DILocation *MLD) {
484     auto *Scope = map(MLD->getScope());
485     auto *InlinedAt = map(MLD->getInlinedAt());
486     if (MLD->isDistinct())
487       return DILocation::getDistinct(MLD->getContext(), MLD->getLine(),
488                                      MLD->getColumn(), Scope, InlinedAt);
489     return DILocation::get(MLD->getContext(), MLD->getLine(), MLD->getColumn(),
490                            Scope, InlinedAt);
491   }
492
493   /// Create a new generic MDNode, to replace the one given
494   MDNode *getReplacementMDNode(MDNode *N) {
495     SmallVector<Metadata *, 8> Ops;
496     Ops.reserve(N->getNumOperands());
497     for (auto &I : N->operands())
498       if (I)
499         Ops.push_back(map(I));
500     auto *Ret = MDNode::get(N->getContext(), Ops);
501     return Ret;
502   }
503
504   /// Attempt to re-map N to a newly created node.
505   void remap(MDNode *N) {
506     if (Replacements.count(N))
507       return;
508
509     auto doRemap = [&](MDNode *N) -> MDNode * {
510       if (!N)
511         return nullptr;
512       if (auto *MDSub = dyn_cast<DISubprogram>(N)) {
513         remap(MDSub->getUnit());
514         return getReplacementSubprogram(MDSub);
515       }
516       if (isa<DISubroutineType>(N))
517         return EmptySubroutineType;
518       if (auto *CU = dyn_cast<DICompileUnit>(N))
519         return getReplacementCU(CU);
520       if (isa<DIFile>(N))
521         return N;
522       if (auto *MDLB = dyn_cast<DILexicalBlockBase>(N))
523         // Remap to our referenced scope (recursively).
524         return mapNode(MDLB->getScope());
525       if (auto *MLD = dyn_cast<DILocation>(N))
526         return getReplacementMDLocation(MLD);
527
528       // Otherwise, if we see these, just drop them now. Not strictly necessary,
529       // but this speeds things up a little.
530       if (isa<DINode>(N))
531         return nullptr;
532
533       return getReplacementMDNode(N);
534     };
535     Replacements[N] = doRemap(N);
536   }
537
538   /// Do the remapping traversal.
539   void traverse(MDNode *);
540 };
541
542 } // end anonymous namespace
543
544 void DebugTypeInfoRemoval::traverse(MDNode *N) {
545   if (!N || Replacements.count(N))
546     return;
547
548   // To avoid cycles, as well as for efficiency sake, we will sometimes prune
549   // parts of the graph.
550   auto prune = [](MDNode *Parent, MDNode *Child) {
551     if (auto *MDS = dyn_cast<DISubprogram>(Parent))
552       return Child == MDS->getVariables().get();
553     return false;
554   };
555
556   SmallVector<MDNode *, 16> ToVisit;
557   DenseSet<MDNode *> Opened;
558
559   // Visit each node starting at N in post order, and map them.
560   ToVisit.push_back(N);
561   while (!ToVisit.empty()) {
562     auto *N = ToVisit.back();
563     if (!Opened.insert(N).second) {
564       // Close it.
565       remap(N);
566       ToVisit.pop_back();
567       continue;
568     }
569     for (auto &I : N->operands())
570       if (auto *MDN = dyn_cast_or_null<MDNode>(I))
571         if (!Opened.count(MDN) && !Replacements.count(MDN) && !prune(N, MDN) &&
572             !isa<DICompileUnit>(MDN))
573           ToVisit.push_back(MDN);
574   }
575 }
576
577 bool llvm::stripNonLineTableDebugInfo(Module &M) {
578   bool Changed = false;
579
580   // First off, delete the debug intrinsics.
581   auto RemoveUses = [&](StringRef Name) {
582     if (auto *DbgVal = M.getFunction(Name)) {
583       while (!DbgVal->use_empty())
584         cast<Instruction>(DbgVal->user_back())->eraseFromParent();
585       DbgVal->eraseFromParent();
586       Changed = true;
587     }
588   };
589   RemoveUses("llvm.dbg.declare");
590   RemoveUses("llvm.dbg.value");
591
592   // Delete non-CU debug info named metadata nodes.
593   for (auto NMI = M.named_metadata_begin(), NME = M.named_metadata_end();
594        NMI != NME;) {
595     NamedMDNode *NMD = &*NMI;
596     ++NMI;
597     // Specifically keep dbg.cu around.
598     if (NMD->getName() == "llvm.dbg.cu")
599       continue;
600   }
601
602   // Drop all dbg attachments from global variables.
603   for (auto &GV : M.globals())
604     GV.eraseMetadata(LLVMContext::MD_dbg);
605
606   DebugTypeInfoRemoval Mapper(M.getContext());
607   auto remap = [&](MDNode *Node) -> MDNode * {
608     if (!Node)
609       return nullptr;
610     Mapper.traverseAndRemap(Node);
611     auto *NewNode = Mapper.mapNode(Node);
612     Changed |= Node != NewNode;
613     Node = NewNode;
614     return NewNode;
615   };
616
617   // Rewrite the DebugLocs to be equivalent to what
618   // -gline-tables-only would have created.
619   for (auto &F : M) {
620     if (auto *SP = F.getSubprogram()) {
621       Mapper.traverseAndRemap(SP);
622       auto *NewSP = cast<DISubprogram>(Mapper.mapNode(SP));
623       Changed |= SP != NewSP;
624       F.setSubprogram(NewSP);
625     }
626     for (auto &BB : F) {
627       for (auto &I : BB) {
628         auto remapDebugLoc = [&](DebugLoc DL) -> DebugLoc {
629           auto *Scope = DL.getScope();
630           MDNode *InlinedAt = DL.getInlinedAt();
631           Scope = remap(Scope);
632           InlinedAt = remap(InlinedAt);
633           return DebugLoc::get(DL.getLine(), DL.getCol(), Scope, InlinedAt);
634         };
635
636         if (I.getDebugLoc() != DebugLoc())
637           I.setDebugLoc(remapDebugLoc(I.getDebugLoc()));
638
639         // Remap DILocations in untyped MDNodes (e.g., llvm.loop).
640         SmallVector<std::pair<unsigned, MDNode *>, 2> MDs;
641         I.getAllMetadata(MDs);
642         for (auto Attachment : MDs)
643           if (auto *T = dyn_cast_or_null<MDTuple>(Attachment.second))
644             for (unsigned N = 0; N < T->getNumOperands(); ++N)
645               if (auto *Loc = dyn_cast_or_null<DILocation>(T->getOperand(N)))
646                 if (Loc != DebugLoc())
647                   T->replaceOperandWith(N, remapDebugLoc(Loc));
648       }
649     }
650   }
651
652   // Create a new llvm.dbg.cu, which is equivalent to the one
653   // -gline-tables-only would have created.
654   for (auto &NMD : M.getNamedMDList()) {
655     SmallVector<MDNode *, 8> Ops;
656     for (MDNode *Op : NMD.operands())
657       Ops.push_back(remap(Op));
658  
659     if (!Changed)
660       continue;
661  
662     NMD.clearOperands();
663     for (auto *Op : Ops)
664       if (Op)
665         NMD.addOperand(Op);
666   }
667   return Changed;
668 }
669
670 unsigned llvm::getDebugMetadataVersionFromModule(const Module &M) {
671   if (auto *Val = mdconst::dyn_extract_or_null<ConstantInt>(
672           M.getModuleFlag("Debug Info Version")))
673     return Val->getZExtValue();
674   return 0;
675 }
676
677 void Instruction::applyMergedLocation(const DILocation *LocA,
678                                       const DILocation *LocB) {
679   if (LocA && LocB && (LocA == LocB || !LocA->canDiscriminate(*LocB))) {
680     setDebugLoc(LocA);
681     return;
682   }
683   if (!LocA || !LocB || !isa<CallInst>(this)) {
684     setDebugLoc(nullptr);
685     return;
686   }
687   SmallPtrSet<DILocation *, 5> InlinedLocationsA;
688   for (DILocation *L = LocA->getInlinedAt(); L; L = L->getInlinedAt())
689     InlinedLocationsA.insert(L);
690   const DILocation *Result = LocB;
691   for (DILocation *L = LocB->getInlinedAt(); L; L = L->getInlinedAt()) {
692     Result = L;
693     if (InlinedLocationsA.count(L))
694       break;
695   }
696   setDebugLoc(DILocation::get(
697       Result->getContext(), 0, 0, Result->getScope(), Result->getInlinedAt()));
698 }
699
700 //===----------------------------------------------------------------------===//
701 // LLVM C API implementations.
702 //===----------------------------------------------------------------------===//
703
704 static unsigned map_from_llvmDWARFsourcelanguage(LLVMDWARFSourceLanguage lang) {
705   switch (lang) {
706 #define HANDLE_DW_LANG(ID, NAME, VERSION, VENDOR) \
707 case LLVMDWARFSourceLanguage##NAME: return ID;
708 #include "llvm/BinaryFormat/Dwarf.def"
709 #undef HANDLE_DW_LANG
710   }
711   llvm_unreachable("Unhandled Tag");
712 }
713
714 unsigned LLVMDebugMetadataVersion() {
715   return DEBUG_METADATA_VERSION;
716 }
717
718 LLVMDIBuilderRef LLVMCreateDIBuilderDisallowUnresolved(LLVMModuleRef M) {
719   return wrap(new DIBuilder(*unwrap(M), false));
720 }
721
722 LLVMDIBuilderRef LLVMCreateDIBuilder(LLVMModuleRef M) {
723   return wrap(new DIBuilder(*unwrap(M)));
724 }
725
726 unsigned LLVMGetModuleDebugMetadataVersion(LLVMModuleRef M) {
727   return getDebugMetadataVersionFromModule(*unwrap(M));
728 }
729
730 LLVMBool LLVMStripModuleDebugInfo(LLVMModuleRef M) {
731   return StripDebugInfo(*unwrap(M));
732 }
733
734 void LLVMDisposeDIBuilder(LLVMDIBuilderRef Builder) {
735   delete unwrap(Builder);
736 }
737
738 void LLVMDIBuilderFinalize(LLVMDIBuilderRef Builder) {
739   unwrap(Builder)->finalize();
740 }
741
742 LLVMMetadataRef LLVMDIBuilderCreateCompileUnit(
743     LLVMDIBuilderRef Builder, LLVMDWARFSourceLanguage Lang,
744     LLVMMetadataRef FileRef, const char *Producer, size_t ProducerLen,
745     LLVMBool isOptimized, const char *Flags, size_t FlagsLen,
746     unsigned RuntimeVer, const char *SplitName, size_t SplitNameLen,
747     LLVMDWARFEmissionKind Kind, unsigned DWOId, LLVMBool SplitDebugInlining,
748     LLVMBool DebugInfoForProfiling) {
749   auto File = unwrap<DIFile>(FileRef);
750
751   return wrap(unwrap(Builder)->createCompileUnit(
752                  map_from_llvmDWARFsourcelanguage(Lang), File,
753                  StringRef(Producer, ProducerLen), isOptimized,
754                  StringRef(Flags, FlagsLen), RuntimeVer,
755                  StringRef(SplitName, SplitNameLen),
756                  static_cast<DICompileUnit::DebugEmissionKind>(Kind), DWOId,
757                  SplitDebugInlining, DebugInfoForProfiling));
758 }
759
760 LLVMMetadataRef
761 LLVMDIBuilderCreateFile(LLVMDIBuilderRef Builder, const char *Filename,
762                         size_t FilenameLen, const char *Directory,
763                         size_t DirectoryLen) {
764   return wrap(unwrap(Builder)->createFile(StringRef(Filename, FilenameLen),
765                                           StringRef(Directory, DirectoryLen)));
766 }
767
768 LLVMMetadataRef
769 LLVMDIBuilderCreateDebugLocation(LLVMContextRef Ctx, unsigned Line,
770                                  unsigned Column, LLVMMetadataRef Scope,
771                                  LLVMMetadataRef InlinedAt) {
772   return wrap(DILocation::get(*unwrap(Ctx), Line, Column, unwrap(Scope),
773                               unwrap(InlinedAt)));
774 }