LCOV - code coverage report
Current view: top level - lib/IR - DebugInfo.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 322 366 88.0 %
Date: 2017-09-14 15:23:50 Functions: 30 32 93.8 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- DebugInfo.cpp - Debug Information Helper Classes -------------------===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : //
      10             : // This file implements the helper classes used to build and interpret debug
      11             : // information in LLVM IR form.
      12             : //
      13             : //===----------------------------------------------------------------------===//
      14             : 
      15             : #include "llvm/IR/DebugInfo.h"
      16             : #include "llvm/ADT/DenseMap.h"
      17             : #include "llvm/ADT/DenseSet.h"
      18             : #include "llvm/ADT/None.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/Function.h"
      27             : #include "llvm/IR/GVMaterializer.h"
      28             : #include "llvm/IR/Instruction.h"
      29             : #include "llvm/IR/IntrinsicInst.h"
      30             : #include "llvm/IR/LLVMContext.h"
      31             : #include "llvm/IR/Metadata.h"
      32             : #include "llvm/IR/Module.h"
      33             : #include "llvm/Support/Casting.h"
      34             : #include <algorithm>
      35             : #include <cassert>
      36             : #include <utility>
      37             : 
      38             : using namespace llvm;
      39             : using namespace llvm::dwarf;
      40             : 
      41      258042 : DISubprogram *llvm::getDISubprogram(const MDNode *Scope) {
      42      258042 :   if (auto *LocalScope = dyn_cast_or_null<DILocalScope>(Scope))
      43      258042 :     return LocalScope->getSubprogram();
      44             :   return nullptr;
      45             : }
      46             : 
      47             : //===----------------------------------------------------------------------===//
      48             : // DebugInfoFinder implementations.
      49             : //===----------------------------------------------------------------------===//
      50             : 
      51           0 : void DebugInfoFinder::reset() {
      52           0 :   CUs.clear();
      53           0 :   SPs.clear();
      54           0 :   GVs.clear();
      55           0 :   TYs.clear();
      56           0 :   Scopes.clear();
      57           0 :   NodesSeen.clear();
      58           0 : }
      59             : 
      60         245 : void DebugInfoFinder::processModule(const Module &M) {
      61         245 :   for (auto *CU : M.debug_compile_units()) {
      62          20 :     addCompileUnit(CU);
      63          67 :     for (auto DIG : CU->getGlobalVariables()) {
      64           7 :       if (!addGlobalVariable(DIG))
      65           0 :         continue;
      66           7 :       auto *GV = DIG->getVariable();
      67          14 :       processScope(GV->getScope());
      68          21 :       processType(GV->getType().resolve());
      69             :     }
      70          60 :     for (auto *ET : CU->getEnumTypes())
      71           0 :       processType(ET);
      72          60 :     for (auto *RT : CU->getRetainedTypes())
      73           0 :       if (auto *T = dyn_cast<DIType>(RT))
      74           0 :         processType(T);
      75             :       else
      76           0 :         processSubprogram(cast<DISubprogram>(RT));
      77          60 :     for (auto *Import : CU->getImportedEntities()) {
      78           0 :       auto *Entity = Import->getEntity().resolve();
      79           0 :       if (auto *T = dyn_cast<DIType>(Entity))
      80           0 :         processType(T);
      81           0 :       else if (auto *SP = dyn_cast<DISubprogram>(Entity))
      82           0 :         processSubprogram(SP);
      83           0 :       else if (auto *NS = dyn_cast<DINamespace>(Entity))
      84           0 :         processScope(NS->getScope());
      85           0 :       else if (auto *M = dyn_cast<DIModule>(Entity))
      86           0 :         processScope(M->getScope());
      87             :     }
      88             :   }
      89        2257 :   for (auto &F : M.functions()) {
      90        2029 :     if (auto *SP = cast_or_null<DISubprogram>(F.getSubprogram()))
      91          17 :       processSubprogram(SP);
      92             :     // There could be subprograms from inlined functions referenced from
      93             :     // instructions only. Walk the function to find them.
      94        7634 :     for (const BasicBlock &BB : F) {
      95        9463 :       for (const Instruction &I : BB) {
      96        9338 :         if (!I.getDebugLoc())
      97        4603 :           continue;
      98          66 :         processLocation(M, I.getDebugLoc().get());
      99             :       }
     100             :     }
     101             :   }
     102         245 : }
     103             : 
     104         410 : void DebugInfoFinder::processLocation(const Module &M, const DILocation *Loc) {
     105         864 :   if (!Loc)
     106             :     return;
     107         454 :   processScope(Loc->getScope());
     108         454 :   processLocation(M, Loc->getInlinedAt());
     109             : }
     110             : 
     111         112 : void DebugInfoFinder::processType(DIType *DT) {
     112         121 :   if (!addType(DT))
     113             :     return;
     114         130 :   processScope(DT->getScope().resolve());
     115          35 :   if (auto *ST = dyn_cast<DISubroutineType>(DT)) {
     116         128 :     for (DITypeRef Ref : ST->getTypeArray())
     117          23 :       processType(Ref.resolve());
     118             :     return;
     119             :   }
     120           6 :   if (auto *DCT = dyn_cast<DICompositeType>(DT)) {
     121          12 :     processType(DCT->getBaseType().resolve());
     122          19 :     for (Metadata *D : DCT->getElements()) {
     123           1 :       if (auto *T = dyn_cast<DIType>(D))
     124           1 :         processType(T);
     125           0 :       else if (auto *SP = dyn_cast<DISubprogram>(D))
     126           0 :         processSubprogram(SP);
     127             :     }
     128             :     return;
     129             :   }
     130           9 :   if (auto *DDT = dyn_cast<DIDerivedType>(DT)) {
     131          18 :     processType(DDT->getBaseType().resolve());
     132             :   }
     133             : }
     134             : 
     135         600 : void DebugInfoFinder::processScope(DIScope *Scope) {
     136         641 :   if (!Scope)
     137             :     return;
     138         554 :   if (auto *Ty = dyn_cast<DIType>(Scope)) {
     139           1 :     processType(Ty);
     140           1 :     return;
     141             :   }
     142         553 :   if (auto *CU = dyn_cast<DICompileUnit>(Scope)) {
     143           1 :     addCompileUnit(CU);
     144           1 :     return;
     145             :   }
     146         552 :   if (auto *SP = dyn_cast<DISubprogram>(Scope)) {
     147         393 :     processSubprogram(SP);
     148         393 :     return;
     149             :   }
     150         159 :   if (!addScope(Scope))
     151             :     return;
     152          66 :   if (auto *LB = dyn_cast<DILexicalBlockBase>(Scope)) {
     153          41 :     processScope(LB->getScope());
     154          25 :   } else if (auto *NS = dyn_cast<DINamespace>(Scope)) {
     155           0 :     processScope(NS->getScope());
     156           0 :   } else if (auto *M = dyn_cast<DIModule>(Scope)) {
     157           0 :     processScope(M->getScope());
     158             :   }
     159             : }
     160             : 
     161         410 : void DebugInfoFinder::processSubprogram(DISubprogram *SP) {
     162         410 :   if (!addSubprogram(SP))
     163             :     return;
     164         102 :   processScope(SP->getScope().resolve());
     165          51 :   processType(SP->getType());
     166         153 :   for (auto *Element : SP->getTemplateParams()) {
     167           0 :     if (auto *TType = dyn_cast<DITemplateTypeParameter>(Element)) {
     168           0 :       processType(TType->getType().resolve());
     169           0 :     } else if (auto *TVal = dyn_cast<DITemplateValueParameter>(Element)) {
     170           0 :       processType(TVal->getType().resolve());
     171             :     }
     172             :   }
     173             : }
     174             : 
     175           8 : void DebugInfoFinder::processDeclare(const Module &M,
     176             :                                      const DbgDeclareInst *DDI) {
     177          24 :   auto *N = dyn_cast<MDNode>(DDI->getVariable());
     178           8 :   if (!N)
     179             :     return;
     180             : 
     181           8 :   auto *DV = dyn_cast<DILocalVariable>(N);
     182             :   if (!DV)
     183             :     return;
     184             : 
     185           8 :   if (!NodesSeen.insert(DV).second)
     186             :     return;
     187           8 :   processScope(DV->getScope());
     188          24 :   processType(DV->getType().resolve());
     189             : }
     190             : 
     191          31 : void DebugInfoFinder::processValue(const Module &M, const DbgValueInst *DVI) {
     192          93 :   auto *N = dyn_cast<MDNode>(DVI->getVariable());
     193          31 :   if (!N)
     194             :     return;
     195             : 
     196          31 :   auto *DV = dyn_cast<DILocalVariable>(N);
     197             :   if (!DV)
     198             :     return;
     199             : 
     200          31 :   if (!NodesSeen.insert(DV).second)
     201             :     return;
     202          15 :   processScope(DV->getScope());
     203          45 :   processType(DV->getType().resolve());
     204             : }
     205             : 
     206         121 : bool DebugInfoFinder::addType(DIType *DT) {
     207         121 :   if (!DT)
     208             :     return false;
     209             : 
     210         104 :   if (!NodesSeen.insert(DT).second)
     211             :     return false;
     212             : 
     213          65 :   TYs.push_back(const_cast<DIType *>(DT));
     214          65 :   return true;
     215             : }
     216             : 
     217          21 : bool DebugInfoFinder::addCompileUnit(DICompileUnit *CU) {
     218          21 :   if (!CU)
     219             :     return false;
     220          21 :   if (!NodesSeen.insert(CU).second)
     221             :     return false;
     222             : 
     223          20 :   CUs.push_back(CU);
     224          20 :   return true;
     225             : }
     226             : 
     227           7 : bool DebugInfoFinder::addGlobalVariable(DIGlobalVariableExpression *DIG) {
     228           7 :   if (!NodesSeen.insert(DIG).second)
     229             :     return false;
     230             : 
     231           7 :   GVs.push_back(DIG);
     232           7 :   return true;
     233             : }
     234             : 
     235         410 : bool DebugInfoFinder::addSubprogram(DISubprogram *SP) {
     236         410 :   if (!SP)
     237             :     return false;
     238             : 
     239         410 :   if (!NodesSeen.insert(SP).second)
     240             :     return false;
     241             : 
     242          51 :   SPs.push_back(SP);
     243          51 :   return true;
     244             : }
     245             : 
     246         159 : bool DebugInfoFinder::addScope(DIScope *Scope) {
     247         159 :   if (!Scope)
     248             :     return false;
     249             :   // FIXME: Ocaml binding generates a scope with no content, we treat it
     250             :   // as null for now.
     251         159 :   if (Scope->getNumOperands() == 0)
     252             :     return false;
     253         159 :   if (!NodesSeen.insert(Scope).second)
     254             :     return false;
     255          66 :   Scopes.push_back(Scope);
     256          66 :   return true;
     257             : }
     258             : 
     259         128 : static MDNode *stripDebugLocFromLoopID(MDNode *N) {
     260             :   assert(N->op_begin() != N->op_end() && "Missing self reference?");
     261             : 
     262             :   // if there is no debug location, we do not have to rewrite this MDNode.
     263         384 :   if (std::none_of(N->op_begin() + 1, N->op_end(), [](const MDOperand &Op) {
     264         151 :         return isa<DILocation>(Op.get());
     265             :       }))
     266             :     return N;
     267             : 
     268             :   // If there is only the debug location without any actual loop metadata, we
     269             :   // can remove the metadata.
     270          12 :   if (std::none_of(N->op_begin() + 1, N->op_end(), [](const MDOperand &Op) {
     271           8 :         return !isa<DILocation>(Op.get());
     272             :       }))
     273             :     return nullptr;
     274             : 
     275           2 :   SmallVector<Metadata *, 4> Args;
     276             :   // Reserve operand 0 for loop id self reference.
     277           8 :   auto TempNode = MDNode::getTemporary(N->getContext(), None);
     278           2 :   Args.push_back(TempNode.get());
     279             :   // Add all non-debug location operands back.
     280          14 :   for (auto Op = N->op_begin() + 1; Op != N->op_end(); Op++) {
     281           5 :     if (!isa<DILocation>(*Op))
     282           2 :       Args.push_back(*Op);
     283             :   }
     284             : 
     285             :   // Set the first operand to itself.
     286           6 :   MDNode *LoopID = MDNode::get(N->getContext(), Args);
     287           2 :   LoopID->replaceOperandWith(0, LoopID);
     288           2 :   return LoopID;
     289             : }
     290             : 
     291      237837 : bool llvm::stripDebugInfo(Function &F) {
     292      237837 :   bool Changed = false;
     293      237837 :   if (F.getSubprogram()) {
     294          35 :     Changed = true;
     295          35 :     F.setSubprogram(nullptr);
     296             :   }
     297             : 
     298      475675 :   DenseMap<MDNode*, MDNode*> LoopIDsMap;
     299      981428 :   for (BasicBlock &BB : F) {
     300      535834 :     for (auto II = BB.begin(), End = BB.end(); II != End;) {
     301     3585207 :       Instruction &I = *II++; // We may delete the instruction, increment now.
     302     1199794 :       if (isa<DbgInfoIntrinsic>(&I)) {
     303        4725 :         I.eraseFromParent();
     304        4725 :         Changed = true;
     305        4725 :         continue;
     306             :       }
     307     2380688 :       if (I.getDebugLoc()) {
     308        4902 :         Changed = true;
     309       19608 :         I.setDebugLoc(DebugLoc());
     310             :       }
     311             :     }
     312             : 
     313      267917 :     auto *TermInst = BB.getTerminator();
     314      267917 :     if (!TermInst)
     315             :       // This is invalid IR, but we may not have run the verifier yet
     316           0 :       continue;
     317      535834 :     if (auto *LoopID = TermInst->getMetadata(LLVMContext::MD_loop)) {
     318         278 :       auto *NewLoopID = LoopIDsMap.lookup(LoopID);
     319          11 :       if (!NewLoopID)
     320         256 :         NewLoopID = LoopIDsMap[LoopID] = stripDebugLocFromLoopID(LoopID);
     321         139 :       if (NewLoopID != LoopID)
     322           5 :         TermInst->setMetadata(LLVMContext::MD_loop, NewLoopID);
     323             :     }
     324             :   }
     325      475675 :   return Changed;
     326             : }
     327             : 
     328       29537 : bool llvm::StripDebugInfo(Module &M) {
     329       29537 :   bool Changed = false;
     330             : 
     331       29537 :   for (Module::named_metadata_iterator NMI = M.named_metadata_begin(),
     332       29537 :          NME = M.named_metadata_end(); NMI != NME;) {
     333        1806 :     NamedMDNode *NMD = &*NMI;
     334        1806 :     ++NMI;
     335             : 
     336             :     // We're stripping debug info, and without them, coverage information
     337             :     // doesn't quite make sense.
     338        3540 :     if (NMD->getName().startswith("llvm.dbg.") ||
     339        1735 :         NMD->getName() == "llvm.gcov") {
     340          72 :       NMD->eraseFromParent();
     341          72 :       Changed = true;
     342             :     }
     343             :   }
     344             : 
     345      325995 :   for (Function &F : M)
     346      237384 :     Changed |= stripDebugInfo(F);
     347             : 
     348       59535 :   for (auto &GV : M.globals()) {
     349       59996 :     SmallVector<MDNode *, 1> MDs;
     350       29998 :     GV.getMetadata(LLVMContext::MD_dbg, MDs);
     351       29998 :     if (!MDs.empty()) {
     352           8 :       GV.eraseMetadata(LLVMContext::MD_dbg);
     353           8 :       Changed = true;
     354             :     }
     355             :   }
     356             : 
     357       29537 :   if (GVMaterializer *Materializer = M.getMaterializer())
     358         549 :     Materializer->setStripDebugInfo();
     359             : 
     360       29537 :   return Changed;
     361             : }
     362             : 
     363             : namespace {
     364             : 
     365             : /// Helper class to downgrade -g metadata to -gline-tables-only metadata.
     366          39 : class DebugTypeInfoRemoval {
     367             :   DenseMap<Metadata *, Metadata *> Replacements;
     368             : 
     369             : public:
     370             :   /// The (void)() type.
     371             :   MDNode *EmptySubroutineType;
     372             : 
     373             : private:
     374             :   /// Remember what linkage name we originally had before stripping. If we end
     375             :   /// up making two subprograms identical who originally had different linkage
     376             :   /// names, then we need to make one of them distinct, to avoid them getting
     377             :   /// uniqued. Maps the new node to the old linkage name.
     378             :   DenseMap<DISubprogram *, StringRef> NewToLinkageName;
     379             : 
     380             :   // TODO: Remember the distinct subprogram we created for a given linkage name,
     381             :   // so that we can continue to unique whenever possible. Map <newly created
     382             :   // node, old linkage name> to the first (possibly distinct) mdsubprogram
     383             :   // created for that combination. This is not strictly needed for correctness,
     384             :   // but can cut down on the number of MDNodes and let us diff cleanly with the
     385             :   // output of -gline-tables-only.
     386             : 
     387             : public:
     388          13 :   DebugTypeInfoRemoval(LLVMContext &C)
     389          26 :       : EmptySubroutineType(DISubroutineType::get(C, DINode::FlagZero, 0,
     390          65 :                                                   MDNode::get(C, {}))) {}
     391             : 
     392         183 :   Metadata *map(Metadata *M) {
     393         183 :     if (!M)
     394             :       return nullptr;
     395         171 :     auto Replacement = Replacements.find(M);
     396         513 :     if (Replacement != Replacements.end())
     397         114 :       return Replacement->second;
     398             : 
     399             :     return M;
     400             :   }
     401         132 :   MDNode *mapNode(Metadata *N) { return dyn_cast_or_null<MDNode>(map(N)); }
     402             : 
     403             :   /// Recursively remap N and all its referenced children. Does a DF post-order
     404             :   /// traversal, so as to remap bottoms up.
     405          66 :   void traverseAndRemap(MDNode *N) { traverse(N); }
     406             : 
     407             : private:
     408             :   // Create a new DISubprogram, to replace the one given.
     409           8 :   DISubprogram *getReplacementSubprogram(DISubprogram *MDS) {
     410          24 :     auto *FileAndScope = cast_or_null<DIFile>(map(MDS->getFile()));
     411          17 :     StringRef LinkageName = MDS->getName().empty() ? MDS->getLinkageName() : "";
     412           8 :     DISubprogram *Declaration = nullptr;
     413          24 :     auto *Type = cast_or_null<DISubroutineType>(map(MDS->getType()));
     414          24 :     DITypeRef ContainingType(map(MDS->getContainingType()));
     415          24 :     auto *Unit = cast_or_null<DICompileUnit>(map(MDS->getUnit()));
     416           8 :     auto Variables = nullptr;
     417           8 :     auto TemplateParams = nullptr;
     418             : 
     419             :     // Make a distinct DISubprogram, for situations that warrent it.
     420           6 :     auto distinctMDSubprogram = [&]() {
     421          90 :       return DISubprogram::getDistinct(
     422          30 :           MDS->getContext(), FileAndScope, MDS->getName(), LinkageName,
     423          18 :           FileAndScope, MDS->getLine(), Type, MDS->isLocalToUnit(),
     424          18 :           MDS->isDefinition(), MDS->getScopeLine(), ContainingType,
     425             :           MDS->getVirtuality(), MDS->getVirtualIndex(),
     426          18 :           MDS->getThisAdjustment(), MDS->getFlags(), MDS->isOptimized(), Unit,
     427           6 :           TemplateParams, Declaration, Variables);
     428          14 :     };
     429             : 
     430           8 :     if (MDS->isDistinct())
     431           6 :       return distinctMDSubprogram();
     432             : 
     433          16 :     auto *NewMDS = DISubprogram::get(
     434             :         MDS->getContext(), FileAndScope, MDS->getName(), LinkageName,
     435           4 :         FileAndScope, MDS->getLine(), Type, MDS->isLocalToUnit(),
     436           4 :         MDS->isDefinition(), MDS->getScopeLine(), ContainingType,
     437             :         MDS->getVirtuality(), MDS->getVirtualIndex(), MDS->getThisAdjustment(),
     438           4 :         MDS->getFlags(), MDS->isOptimized(), Unit, TemplateParams, Declaration,
     439           2 :         Variables);
     440             : 
     441           4 :     StringRef OldLinkageName = MDS->getLinkageName();
     442             : 
     443             :     // See if we need to make a distinct one.
     444           2 :     auto OrigLinkage = NewToLinkageName.find(NewMDS);
     445           6 :     if (OrigLinkage != NewToLinkageName.end()) {
     446           0 :       if (OrigLinkage->second == OldLinkageName)
     447             :         // We're good.
     448             :         return NewMDS;
     449             : 
     450             :       // Otherwise, need to make a distinct one.
     451             :       // TODO: Query the map to see if we already have one.
     452           0 :       return distinctMDSubprogram();
     453             :     }
     454             : 
     455           8 :     NewToLinkageName.insert({NewMDS, MDS->getLinkageName()});
     456           2 :     return NewMDS;
     457             :   }
     458             : 
     459             :   /// Create a new compile unit, to replace the one given
     460          19 :   DICompileUnit *getReplacementCU(DICompileUnit *CU) {
     461             :     // Drop skeleton CUs.
     462          19 :     if (CU->getDWOId())
     463             :       return nullptr;
     464             : 
     465          54 :     auto *File = cast_or_null<DIFile>(map(CU->getFile()));
     466          18 :     MDTuple *EnumTypes = nullptr;
     467          18 :     MDTuple *RetainedTypes = nullptr;
     468          18 :     MDTuple *GlobalVariables = nullptr;
     469          18 :     MDTuple *ImportedEntities = nullptr;
     470         162 :     return DICompileUnit::getDistinct(
     471             :         CU->getContext(), CU->getSourceLanguage(), File, CU->getProducer(),
     472          18 :         CU->isOptimized(), CU->getFlags(), CU->getRuntimeVersion(),
     473             :         CU->getSplitDebugFilename(), DICompileUnit::LineTablesOnly, EnumTypes,
     474             :         RetainedTypes, GlobalVariables, ImportedEntities, CU->getMacros(),
     475          18 :         CU->getDWOId(), CU->getSplitDebugInlining(),
     476          54 :         CU->getDebugInfoForProfiling(), CU->getGnuPubnames());
     477             :   }
     478             : 
     479           0 :   DILocation *getReplacementMDLocation(DILocation *MLD) {
     480           0 :     auto *Scope = map(MLD->getScope());
     481           0 :     auto *InlinedAt = map(MLD->getInlinedAt());
     482           0 :     if (MLD->isDistinct())
     483           0 :       return DILocation::getDistinct(MLD->getContext(), MLD->getLine(),
     484           0 :                                      MLD->getColumn(), Scope, InlinedAt);
     485           0 :     return DILocation::get(MLD->getContext(), MLD->getLine(), MLD->getColumn(),
     486           0 :                            Scope, InlinedAt);
     487             :   }
     488             : 
     489             :   /// Create a new generic MDNode, to replace the one given
     490          31 :   MDNode *getReplacementMDNode(MDNode *N) {
     491          62 :     SmallVector<Metadata *, 8> Ops;
     492          31 :     Ops.reserve(N->getNumOperands());
     493         102 :     for (auto &I : N->operands())
     494          71 :       if (I)
     495          67 :         Ops.push_back(map(I));
     496          93 :     auto *Ret = MDNode::get(N->getContext(), Ops);
     497          62 :     return Ret;
     498             :   }
     499             : 
     500             :   /// Attempt to re-map N to a newly created node.
     501         102 :   void remap(MDNode *N) {
     502         204 :     if (Replacements.count(N))
     503          13 :       return;
     504             : 
     505          89 :     auto doRemap = [&](MDNode *N) -> MDNode * {
     506          89 :       if (!N)
     507             :         return nullptr;
     508         176 :       if (auto *MDSub = dyn_cast<DISubprogram>(N)) {
     509          73 :         remap(MDSub->getUnit());
     510           8 :         return getReplacementSubprogram(MDSub);
     511             :       }
     512         160 :       if (isa<DISubroutineType>(N))
     513           7 :         return EmptySubroutineType;
     514         146 :       if (auto *CU = dyn_cast<DICompileUnit>(N))
     515          19 :         return getReplacementCU(CU);
     516         108 :       if (isa<DIFile>(N))
     517             :         return N;
     518          92 :       if (auto *MDLB = dyn_cast<DILexicalBlockBase>(N))
     519             :         // Remap to our referenced scope (recursively).
     520           0 :         return mapNode(MDLB->getScope());
     521          92 :       if (auto *MLD = dyn_cast<DILocation>(N))
     522           0 :         return getReplacementMDLocation(MLD);
     523             : 
     524             :       // Otherwise, if we see these, just drop them now. Not strictly necessary,
     525             :       // but this speeds things up a little.
     526          46 :       if (isa<DINode>(N))
     527             :         return nullptr;
     528             : 
     529          31 :       return getReplacementMDNode(N);
     530          89 :     };
     531         178 :     Replacements[N] = doRemap(N);
     532             :   }
     533             : 
     534             :   /// Do the remapping traversal.
     535             :   void traverse(MDNode *);
     536             : };
     537             : 
     538             : } // end anonymous namespace
     539             : 
     540          66 : void DebugTypeInfoRemoval::traverse(MDNode *N) {
     541          92 :   if (!N || Replacements.count(N))
     542          26 :     return;
     543             : 
     544             :   // To avoid cycles, as well as for efficiency sake, we will sometimes prune
     545             :   // parts of the graph.
     546             :   auto prune = [](MDNode *Parent, MDNode *Child) {
     547          29 :     if (auto *MDS = dyn_cast<DISubprogram>(Parent))
     548          29 :       return Child == MDS->getVariables().get();
     549             :     return false;
     550             :   };
     551             : 
     552          80 :   SmallVector<MDNode *, 16> ToVisit;
     553          80 :   DenseSet<MDNode *> Opened;
     554             : 
     555             :   // Visit each node starting at N in post order, and map them.
     556          40 :   ToVisit.push_back(N);
     557         216 :   while (!ToVisit.empty()) {
     558         352 :     auto *N = ToVisit.back();
     559         270 :     if (!Opened.insert(N).second) {
     560             :       // Close it.
     561          94 :       remap(N);
     562          94 :       ToVisit.pop_back();
     563          94 :       continue;
     564             :     }
     565         550 :     for (auto &I : N->operands())
     566         386 :       if (auto *MDN = dyn_cast_or_null<MDNode>(I))
     567         269 :         if (!Opened.count(MDN) && !Replacements.count(MDN) && !prune(N, MDN) &&
     568          61 :             !isa<DICompileUnit>(MDN))
     569          54 :           ToVisit.push_back(MDN);
     570             :   }
     571             : }
     572             : 
     573          13 : bool llvm::stripNonLineTableDebugInfo(Module &M) {
     574          13 :   bool Changed = false;
     575             : 
     576             :   // First off, delete the debug intrinsics.
     577          26 :   auto RemoveUses = [&](StringRef Name) {
     578          26 :     if (auto *DbgVal = M.getFunction(Name)) {
     579          15 :       while (!DbgVal->use_empty())
     580           9 :         cast<Instruction>(DbgVal->user_back())->eraseFromParent();
     581           3 :       DbgVal->eraseFromParent();
     582           3 :       Changed = true;
     583             :     }
     584          39 :   };
     585          13 :   RemoveUses("llvm.dbg.declare");
     586          13 :   RemoveUses("llvm.dbg.value");
     587             : 
     588             :   // Delete non-CU debug info named metadata nodes.
     589          26 :   for (auto NMI = M.named_metadata_begin(), NME = M.named_metadata_end();
     590          35 :        NMI != NME;) {
     591          22 :     NamedMDNode *NMD = &*NMI;
     592          22 :     ++NMI;
     593             :     // Specifically keep dbg.cu around.
     594          22 :     if (NMD->getName() == "llvm.dbg.cu")
     595             :       continue;
     596             :   }
     597             : 
     598             :   // Drop all dbg attachments from global variables.
     599          15 :   for (auto &GV : M.globals())
     600           2 :     GV.eraseMetadata(LLVMContext::MD_dbg);
     601             : 
     602          26 :   DebugTypeInfoRemoval Mapper(M.getContext());
     603          76 :   auto remap = [&](MDNode *Node) -> MDNode * {
     604          76 :     if (!Node)
     605             :       return nullptr;
     606         122 :     Mapper.traverseAndRemap(Node);
     607          61 :     auto *NewNode = Mapper.mapNode(Node);
     608          61 :     Changed |= Node != NewNode;
     609          61 :     Node = NewNode;
     610          61 :     return NewNode;
     611          13 :   };
     612             : 
     613             :   // Rewrite the DebugLocs to be equivalent to what
     614             :   // -gline-tables-only would have created.
     615          58 :   for (auto &F : M) {
     616          19 :     if (auto *SP = F.getSubprogram()) {
     617           5 :       Mapper.traverseAndRemap(SP);
     618          10 :       auto *NewSP = cast<DISubprogram>(Mapper.mapNode(SP));
     619           5 :       Changed |= SP != NewSP;
     620           5 :       F.setSubprogram(NewSP);
     621             :     }
     622          72 :     for (auto &BB : F) {
     623          75 :       for (auto &I : BB) {
     624          15 :         auto remapDebugLoc = [&](DebugLoc DL) -> DebugLoc {
     625          15 :           auto *Scope = DL.getScope();
     626          15 :           MDNode *InlinedAt = DL.getInlinedAt();
     627          15 :           Scope = remap(Scope);
     628          15 :           InlinedAt = remap(InlinedAt);
     629          15 :           return DebugLoc::get(DL.getLine(), DL.getCol(), Scope, InlinedAt);
     630          30 :         };
     631             : 
     632         120 :         if (I.getDebugLoc() != DebugLoc())
     633          65 :           I.setDebugLoc(remapDebugLoc(I.getDebugLoc()));
     634             : 
     635             :         // Remap DILocations in untyped MDNodes (e.g., llvm.loop).
     636          60 :         SmallVector<std::pair<unsigned, MDNode *>, 2> MDs;
     637          30 :         I.getAllMetadata(MDs);
     638         108 :         for (auto Attachment : MDs)
     639          18 :           if (auto *T = dyn_cast_or_null<MDTuple>(Attachment.second))
     640          27 :             for (unsigned N = 0; N < T->getNumOperands(); ++N)
     641          24 :               if (auto *Loc = dyn_cast_or_null<DILocation>(T->getOperand(N)))
     642           8 :                 if (Loc != DebugLoc())
     643           8 :                   T->replaceOperandWith(N, remapDebugLoc(Loc));
     644             :       }
     645             :     }
     646             :   }
     647             : 
     648             :   // Create a new llvm.dbg.cu, which is equivalent to the one
     649             :   // -gline-tables-only would have created.
     650          61 :   for (auto &NMD : M.getNamedMDList()) {
     651          43 :     SmallVector<MDNode *, 8> Ops;
     652          68 :     for (MDNode *Op : NMD.operands())
     653          46 :       Ops.push_back(remap(Op));
     654             :  
     655          22 :     if (!Changed)
     656           1 :       continue;
     657             :  
     658          21 :     NMD.clearOperands();
     659         108 :     for (auto *Op : Ops)
     660          45 :       if (Op)
     661          44 :         NMD.addOperand(Op);
     662             :   }
     663          26 :   return Changed;
     664             : }
     665             : 
     666       31088 : unsigned llvm::getDebugMetadataVersionFromModule(const Module &M) {
     667             :   if (auto *Val = mdconst::dyn_extract_or_null<ConstantInt>(
     668       60544 :           M.getModuleFlag("Debug Info Version")))
     669        1631 :     return Val->getZExtValue();
     670             :   return 0;
     671             : }

Generated by: LCOV version 1.13