contrib/llvm/lib/IR/DebugInfo.cpp

   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 "LLVMContextImpl.h"
  17 #include "llvm/ADT/STLExtras.h"
  18 #include "llvm/ADT/SmallPtrSet.h"
  19 #include "llvm/IR/Constants.h"
  20 #include "llvm/IR/DIBuilder.h"
  21 #include "llvm/IR/DerivedTypes.h"
  22 #include "llvm/IR/GVMaterializer.h"
  23 #include "llvm/IR/Instructions.h"
  24 #include "llvm/IR/IntrinsicInst.h"
  25 #include "llvm/IR/Intrinsics.h"
  26 #include "llvm/IR/Module.h"
  27 #include "llvm/IR/ValueHandle.h"
  28 #include "llvm/Support/Debug.h"
  29 #include "llvm/Support/Dwarf.h"
  30 #include "llvm/Support/raw_ostream.h"
  31 using namespace llvm;
  32 using namespace llvm::dwarf;
  33
  34 DISubprogram *llvm::getDISubprogram(const MDNode *Scope) {
  35   if (auto *LocalScope = dyn_cast_or_null<DILocalScope>(Scope))
  36     return LocalScope->getSubprogram();
  37   return nullptr;
  38 }
  39
  40 //===----------------------------------------------------------------------===//
  41 // DebugInfoFinder implementations.
  42 //===----------------------------------------------------------------------===//
  43
  44 void DebugInfoFinder::reset() {
  45   CUs.clear();
  46   SPs.clear();
  47   GVs.clear();
  48   TYs.clear();
  49   Scopes.clear();
  50   NodesSeen.clear();
  51 }
  52
  53 void DebugInfoFinder::processModule(const Module &M) {
  54   for (auto *CU : M.debug_compile_units()) {
  55     addCompileUnit(CU);
  56     for (auto *DIG : CU->getGlobalVariables()) {
  57       if (addGlobalVariable(DIG)) {
  58         processScope(DIG->getScope());
  59         processType(DIG->getType().resolve());
  60       }
  61     }
  62     for (auto *ET : CU->getEnumTypes())
  63       processType(ET);
  64     for (auto *RT : CU->getRetainedTypes())
  65       if (auto *T = dyn_cast<DIType>(RT))
  66         processType(T);
  67       else
  68         processSubprogram(cast<DISubprogram>(RT));
  69     for (auto *Import : CU->getImportedEntities()) {
  70       auto *Entity = Import->getEntity().resolve();
  71       if (auto *T = dyn_cast<DIType>(Entity))
  72         processType(T);
  73       else if (auto *SP = dyn_cast<DISubprogram>(Entity))
  74         processSubprogram(SP);
  75       else if (auto *NS = dyn_cast<DINamespace>(Entity))
  76         processScope(NS->getScope());
  77       else if (auto *M = dyn_cast<DIModule>(Entity))
  78         processScope(M->getScope());
  79     }
  80   }
  81   for (auto &F : M.functions())
  82     if (auto *SP = cast_or_null<DISubprogram>(F.getSubprogram()))
  83       processSubprogram(SP);
  84 }
  85
  86 void DebugInfoFinder::processLocation(const Module &M, const DILocation *Loc) {
  87   if (!Loc)
  88     return;
  89   processScope(Loc->getScope());
  90   processLocation(M, Loc->getInlinedAt());
  91 }
  92
  93 void DebugInfoFinder::processType(DIType *DT) {
  94   if (!addType(DT))
  95     return;
  96   processScope(DT->getScope().resolve());
  97   if (auto *ST = dyn_cast<DISubroutineType>(DT)) {
  98     for (DITypeRef Ref : ST->getTypeArray())
  99       processType(Ref.resolve());
 100     return;
 101   }
 102   if (auto *DCT = dyn_cast<DICompositeType>(DT)) {
 103     processType(DCT->getBaseType().resolve());
 104     for (Metadata *D : DCT->getElements()) {
 105       if (auto *T = dyn_cast<DIType>(D))
 106         processType(T);
 107       else if (auto *SP = dyn_cast<DISubprogram>(D))
 108         processSubprogram(SP);
 109     }
 110     return;
 111   }
 112   if (auto *DDT = dyn_cast<DIDerivedType>(DT)) {
 113     processType(DDT->getBaseType().resolve());
 114   }
 115 }
 116
 117 void DebugInfoFinder::processScope(DIScope *Scope) {
 118   if (!Scope)
 119     return;
 120   if (auto *Ty = dyn_cast<DIType>(Scope)) {
 121     processType(Ty);
 122     return;
 123   }
 124   if (auto *CU = dyn_cast<DICompileUnit>(Scope)) {
 125     addCompileUnit(CU);
 126     return;
 127   }
 128   if (auto *SP = dyn_cast<DISubprogram>(Scope)) {
 129     processSubprogram(SP);
 130     return;
 131   }
 132   if (!addScope(Scope))
 133     return;
 134   if (auto *LB = dyn_cast<DILexicalBlockBase>(Scope)) {
 135     processScope(LB->getScope());
 136   } else if (auto *NS = dyn_cast<DINamespace>(Scope)) {
 137     processScope(NS->getScope());
 138   } else if (auto *M = dyn_cast<DIModule>(Scope)) {
 139     processScope(M->getScope());
 140   }
 141 }
 142
 143 void DebugInfoFinder::processSubprogram(DISubprogram *SP) {
 144   if (!addSubprogram(SP))
 145     return;
 146   processScope(SP->getScope().resolve());
 147   processType(SP->getType());
 148   for (auto *Element : SP->getTemplateParams()) {
 149     if (auto *TType = dyn_cast<DITemplateTypeParameter>(Element)) {
 150       processType(TType->getType().resolve());
 151     } else if (auto *TVal = dyn_cast<DITemplateValueParameter>(Element)) {
 152       processType(TVal->getType().resolve());
 153     }
 154   }
 155 }
 156
 157 void DebugInfoFinder::processDeclare(const Module &M,
 158                                      const DbgDeclareInst *DDI) {
 159   auto *N = dyn_cast<MDNode>(DDI->getVariable());
 160   if (!N)
 161     return;
 162
 163   auto *DV = dyn_cast<DILocalVariable>(N);
 164   if (!DV)
 165     return;
 166
 167   if (!NodesSeen.insert(DV).second)
 168     return;
 169   processScope(DV->getScope());
 170   processType(DV->getType().resolve());
 171 }
 172
 173 void DebugInfoFinder::processValue(const Module &M, const DbgValueInst *DVI) {
 174   auto *N = dyn_cast<MDNode>(DVI->getVariable());
 175   if (!N)
 176     return;
 177
 178   auto *DV = dyn_cast<DILocalVariable>(N);
 179   if (!DV)
 180     return;
 181
 182   if (!NodesSeen.insert(DV).second)
 183     return;
 184   processScope(DV->getScope());
 185   processType(DV->getType().resolve());
 186 }
 187
 188 bool DebugInfoFinder::addType(DIType *DT) {
 189   if (!DT)
 190     return false;
 191
 192   if (!NodesSeen.insert(DT).second)
 193     return false;
 194
 195   TYs.push_back(const_cast<DIType *>(DT));
 196   return true;
 197 }
 198
 199 bool DebugInfoFinder::addCompileUnit(DICompileUnit *CU) {
 200   if (!CU)
 201     return false;
 202   if (!NodesSeen.insert(CU).second)
 203     return false;
 204
 205   CUs.push_back(CU);
 206   return true;
 207 }
 208
 209 bool DebugInfoFinder::addGlobalVariable(DIGlobalVariable *DIG) {
 210   if (!DIG)
 211     return false;
 212
 213   if (!NodesSeen.insert(DIG).second)
 214     return false;
 215
 216   GVs.push_back(DIG);
 217   return true;
 218 }
 219
 220 bool DebugInfoFinder::addSubprogram(DISubprogram *SP) {
 221   if (!SP)
 222     return false;
 223
 224   if (!NodesSeen.insert(SP).second)
 225     return false;
 226
 227   SPs.push_back(SP);
 228   return true;
 229 }
 230
 231 bool DebugInfoFinder::addScope(DIScope *Scope) {
 232   if (!Scope)
 233     return false;
 234   // FIXME: Ocaml binding generates a scope with no content, we treat it
 235   // as null for now.
 236   if (Scope->getNumOperands() == 0)
 237     return false;
 238   if (!NodesSeen.insert(Scope).second)
 239     return false;
 240   Scopes.push_back(Scope);
 241   return true;
 242 }
 243
 244 bool llvm::stripDebugInfo(Function &F) {
 245   bool Changed = false;
 246   if (F.getSubprogram()) {
 247     Changed = true;
 248     F.setSubprogram(nullptr);
 249   }
 250
 251   for (BasicBlock &BB : F) {
 252     for (auto II = BB.begin(), End = BB.end(); II != End;) {
 253       Instruction &I = *II++; // We may delete the instruction, increment now.
 254       if (isa<DbgInfoIntrinsic>(&I)) {
 255         I.eraseFromParent();
 256         Changed = true;
 257         continue;
 258       }
 259       if (I.getDebugLoc()) {
 260         Changed = true;
 261         I.setDebugLoc(DebugLoc());
 262       }
 263     }
 264   }
 265   return Changed;
 266 }
 267
 268 bool llvm::StripDebugInfo(Module &M) {
 269   bool Changed = false;
 270
 271   for (Module::named_metadata_iterator NMI = M.named_metadata_begin(),
 272          NME = M.named_metadata_end(); NMI != NME;) {
 273     NamedMDNode *NMD = &*NMI;
 274     ++NMI;
 275     if (NMD->getName().startswith("llvm.dbg.")) {
 276       NMD->eraseFromParent();
 277       Changed = true;
 278     }
 279   }
 280
 281   for (Function &F : M)
 282     Changed |= stripDebugInfo(F);
 283
 284   if (GVMaterializer *Materializer = M.getMaterializer())
 285     Materializer->setStripDebugInfo();
 286
 287   return Changed;
 288 }
 289
 290 unsigned llvm::getDebugMetadataVersionFromModule(const Module &M) {
 291   if (auto *Val = mdconst::dyn_extract_or_null<ConstantInt>(
 292           M.getModuleFlag("Debug Info Version")))
 293     return Val->getZExtValue();
 294   return 0;
 295 }