LCOV - code coverage report
Current view: top level - lib/IR - DebugInfo.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 356 483 73.7 %
Date: 2018-07-13 00:08:38 Functions: 66 107 61.7 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.13