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