lib/IR/DebugInfo.cpp

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