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