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 } 1434