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