lib/DebugInfo/DWARFContext.cpp

   1 //===-- DWARFContext.cpp --------------------------------------------------===//
   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 #include "DWARFContext.h"
  11 #include "llvm/ADT/SmallString.h"
  12 #include "llvm/Support/Dwarf.h"
  13 #include "llvm/Support/Format.h"
  14 #include "llvm/Support/Path.h"
  15 #include "llvm/Support/raw_ostream.h"
  16 #include <algorithm>
  17 using namespace llvm;
  18 using namespace dwarf;
  19
  20 void DWARFContext::dump(raw_ostream &OS) {
  21   OS << ".debug_abbrev contents:\n";
  22   getDebugAbbrev()->dump(OS);
  23
  24   OS << "\n.debug_info contents:\n";
  25   for (unsigned i = 0, e = getNumCompileUnits(); i != e; ++i)
  26     getCompileUnitAtIndex(i)->dump(OS);
  27
  28   OS << "\n.debug_aranges contents:\n";
  29   DataExtractor arangesData(getARangeSection(), isLittleEndian(), 0);
  30   uint32_t offset = 0;
  31   DWARFDebugArangeSet set;
  32   while (set.extract(arangesData, &offset))
  33     set.dump(OS);
  34
  35   uint8_t savedAddressByteSize = 0;
  36   OS << "\n.debug_lines contents:\n";
  37   for (unsigned i = 0, e = getNumCompileUnits(); i != e; ++i) {
  38     DWARFCompileUnit *cu = getCompileUnitAtIndex(i);
  39     savedAddressByteSize = cu->getAddressByteSize();
  40     unsigned stmtOffset =
  41       cu->getCompileUnitDIE()->getAttributeValueAsUnsigned(cu, DW_AT_stmt_list,
  42                                                            -1U);
  43     if (stmtOffset != -1U) {
  44       DataExtractor lineData(getLineSection(), isLittleEndian(),
  45                              savedAddressByteSize);
  46       DWARFDebugLine::DumpingState state(OS);
  47       DWARFDebugLine::parseStatementTable(lineData, &stmtOffset, state);
  48     }
  49   }
  50
  51   OS << "\n.debug_str contents:\n";
  52   DataExtractor strData(getStringSection(), isLittleEndian(), 0);
  53   offset = 0;
  54   uint32_t lastOffset = 0;
  55   while (const char *s = strData.getCStr(&offset)) {
  56     OS << format("0x%8.8x: \"%s\"\n", lastOffset, s);
  57     lastOffset = offset;
  58   }
  59
  60   OS << "\n.debug_ranges contents:\n";
  61   // In fact, different compile units may have different address byte
  62   // sizes, but for simplicity we just use the address byte size of the last
  63   // compile unit (there is no easy and fast way to associate address range
  64   // list and the compile unit it describes).
  65   DataExtractor rangesData(getRangeSection(), isLittleEndian(),
  66                            savedAddressByteSize);
  67   offset = 0;
  68   DWARFDebugRangeList rangeList;
  69   while (rangeList.extract(rangesData, &offset))
  70     rangeList.dump(OS);
  71 }
  72
  73 const DWARFDebugAbbrev *DWARFContext::getDebugAbbrev() {
  74   if (Abbrev)
  75     return Abbrev.get();
  76
  77   DataExtractor abbrData(getAbbrevSection(), isLittleEndian(), 0);
  78
  79   Abbrev.reset(new DWARFDebugAbbrev());
  80   Abbrev->parse(abbrData);
  81   return Abbrev.get();
  82 }
  83
  84 const DWARFDebugAranges *DWARFContext::getDebugAranges() {
  85   if (Aranges)
  86     return Aranges.get();
  87
  88   DataExtractor arangesData(getARangeSection(), isLittleEndian(), 0);
  89
  90   Aranges.reset(new DWARFDebugAranges());
  91   Aranges->extract(arangesData);
  92   if (Aranges->isEmpty()) // No aranges in file, generate them from the DIEs.
  93     Aranges->generate(this);
  94   return Aranges.get();
  95 }
  96
  97 const DWARFDebugLine::LineTable *
  98 DWARFContext::getLineTableForCompileUnit(DWARFCompileUnit *cu) {
  99   if (!Line)
 100     Line.reset(new DWARFDebugLine());
 101
 102   unsigned stmtOffset =
 103     cu->getCompileUnitDIE()->getAttributeValueAsUnsigned(cu, DW_AT_stmt_list,
 104                                                          -1U);
 105   if (stmtOffset == -1U)
 106     return 0; // No line table for this compile unit.
 107
 108   // See if the line table is cached.
 109   if (const DWARFDebugLine::LineTable *lt = Line->getLineTable(stmtOffset))
 110     return lt;
 111
 112   // We have to parse it first.
 113   DataExtractor lineData(getLineSection(), isLittleEndian(),
 114                          cu->getAddressByteSize());
 115   return Line->getOrParseLineTable(lineData, stmtOffset);
 116 }
 117
 118 void DWARFContext::parseCompileUnits() {
 119   uint32_t offset = 0;
 120   const DataExtractor &debug_info_data = DataExtractor(getInfoSection(),
 121                                                        isLittleEndian(), 0);
 122   while (debug_info_data.isValidOffset(offset)) {
 123     CUs.push_back(DWARFCompileUnit(*this));
 124     if (!CUs.back().extract(debug_info_data, &offset)) {
 125       CUs.pop_back();
 126       break;
 127     }
 128
 129     offset = CUs.back().getNextCompileUnitOffset();
 130   }
 131 }
 132
 133 namespace {
 134   struct OffsetComparator {
 135     bool operator()(const DWARFCompileUnit &LHS,
 136                     const DWARFCompileUnit &RHS) const {
 137       return LHS.getOffset() < RHS.getOffset();
 138     }
 139     bool operator()(const DWARFCompileUnit &LHS, uint32_t RHS) const {
 140       return LHS.getOffset() < RHS;
 141     }
 142     bool operator()(uint32_t LHS, const DWARFCompileUnit &RHS) const {
 143       return LHS < RHS.getOffset();
 144     }
 145   };
 146 }
 147
 148 DWARFCompileUnit *DWARFContext::getCompileUnitForOffset(uint32_t Offset) {
 149   if (CUs.empty())
 150     parseCompileUnits();
 151
 152   DWARFCompileUnit *CU = std::lower_bound(CUs.begin(), CUs.end(), Offset,
 153                                           OffsetComparator());
 154   if (CU != CUs.end())
 155     return &*CU;
 156   return 0;
 157 }
 158
 159 DWARFCompileUnit *DWARFContext::getCompileUnitForAddress(uint64_t Address) {
 160   // First, get the offset of the compile unit.
 161   uint32_t CUOffset = getDebugAranges()->findAddress(Address);
 162   // Retrieve the compile unit.
 163   return getCompileUnitForOffset(CUOffset);
 164 }
 165
 166 static bool getFileNameForCompileUnit(
 167     DWARFCompileUnit *CU, const DWARFDebugLine::LineTable *LineTable,
 168     uint64_t FileIndex, bool NeedsAbsoluteFilePath, std::string &FileName) {
 169   if (CU == 0 ||
 170       LineTable == 0 ||
 171       !LineTable->getFileNameByIndex(FileIndex, NeedsAbsoluteFilePath,
 172                                      FileName))
 173     return false;
 174   if (NeedsAbsoluteFilePath && sys::path::is_relative(FileName)) {
 175     // We may still need to append compilation directory of compile unit.
 176     SmallString<16> AbsolutePath;
 177     if (const char *CompilationDir = CU->getCompilationDir()) {
 178       sys::path::append(AbsolutePath, CompilationDir);
 179     }
 180     sys::path::append(AbsolutePath, FileName);
 181     FileName = AbsolutePath.str();
 182   }
 183   return true;
 184 }
 185
 186 static bool getFileLineInfoForCompileUnit(
 187     DWARFCompileUnit *CU, const DWARFDebugLine::LineTable *LineTable,
 188     uint64_t Address, bool NeedsAbsoluteFilePath, std::string &FileName,
 189     uint32_t &Line, uint32_t &Column) {
 190   if (CU == 0 || LineTable == 0)
 191     return false;
 192   // Get the index of row we're looking for in the line table.
 193   uint32_t RowIndex = LineTable->lookupAddress(Address);
 194   if (RowIndex == -1U)
 195     return false;
 196   // Take file number and line/column from the row.
 197   const DWARFDebugLine::Row &Row = LineTable->Rows[RowIndex];
 198   if (!getFileNameForCompileUnit(CU, LineTable, Row.File,
 199                                  NeedsAbsoluteFilePath, FileName))
 200     return false;
 201   Line = Row.Line;
 202   Column = Row.Column;
 203   return true;
 204 }
 205
 206 DILineInfo DWARFContext::getLineInfoForAddress(uint64_t Address,
 207     DILineInfoSpecifier Specifier) {
 208   DWARFCompileUnit *CU = getCompileUnitForAddress(Address);
 209   if (!CU)
 210     return DILineInfo();
 211   std::string FileName = "<invalid>";
 212   std::string FunctionName = "<invalid>";
 213   uint32_t Line = 0;
 214   uint32_t Column = 0;
 215   if (Specifier.needs(DILineInfoSpecifier::FunctionName)) {
 216     // The address may correspond to instruction in some inlined function,
 217     // so we have to build the chain of inlined functions and take the
 218     // name of the topmost function in it.
 219     const DWARFDebugInfoEntryMinimal::InlinedChain &InlinedChain =
 220         CU->getInlinedChainForAddress(Address);
 221     if (InlinedChain.size() > 0) {
 222       const DWARFDebugInfoEntryMinimal &TopFunctionDIE = InlinedChain[0];
 223       if (const char *Name = TopFunctionDIE.getSubroutineName(CU))
 224         FunctionName = Name;
 225     }
 226   }
 227   if (Specifier.needs(DILineInfoSpecifier::FileLineInfo)) {
 228     const DWARFDebugLine::LineTable *LineTable =
 229         getLineTableForCompileUnit(CU);
 230     const bool NeedsAbsoluteFilePath =
 231         Specifier.needs(DILineInfoSpecifier::AbsoluteFilePath);
 232     getFileLineInfoForCompileUnit(CU, LineTable, Address,
 233                                   NeedsAbsoluteFilePath,
 234                                   FileName, Line, Column);
 235   }
 236   return DILineInfo(StringRef(FileName), StringRef(FunctionName),
 237                     Line, Column);
 238 }
 239
 240 DIInliningInfo DWARFContext::getInliningInfoForAddress(uint64_t Address,
 241     DILineInfoSpecifier Specifier) {
 242   DWARFCompileUnit *CU = getCompileUnitForAddress(Address);
 243   if (!CU)
 244     return DIInliningInfo();
 245
 246   const DWARFDebugInfoEntryMinimal::InlinedChain &InlinedChain =
 247       CU->getInlinedChainForAddress(Address);
 248   if (InlinedChain.size() == 0)
 249     return DIInliningInfo();
 250
 251   DIInliningInfo InliningInfo;
 252   uint32_t CallFile = 0, CallLine = 0, CallColumn = 0;
 253   const DWARFDebugLine::LineTable *LineTable = 0;
 254   for (uint32_t i = 0, n = InlinedChain.size(); i != n; i++) {
 255     const DWARFDebugInfoEntryMinimal &FunctionDIE = InlinedChain[i];
 256     std::string FileName = "<invalid>";
 257     std::string FunctionName = "<invalid>";
 258     uint32_t Line = 0;
 259     uint32_t Column = 0;
 260     // Get function name if necessary.
 261     if (Specifier.needs(DILineInfoSpecifier::FunctionName)) {
 262       if (const char *Name = FunctionDIE.getSubroutineName(CU))
 263         FunctionName = Name;
 264     }
 265     if (Specifier.needs(DILineInfoSpecifier::FileLineInfo)) {
 266       const bool NeedsAbsoluteFilePath =
 267           Specifier.needs(DILineInfoSpecifier::AbsoluteFilePath);
 268       if (i == 0) {
 269         // For the topmost frame, initialize the line table of this
 270         // compile unit and fetch file/line info from it.
 271         LineTable = getLineTableForCompileUnit(CU);
 272         // For the topmost routine, get file/line info from line table.
 273         getFileLineInfoForCompileUnit(CU, LineTable, Address,
 274                                       NeedsAbsoluteFilePath,
 275                                       FileName, Line, Column);
 276       } else {
 277         // Otherwise, use call file, call line and call column from
 278         // previous DIE in inlined chain.
 279         getFileNameForCompileUnit(CU, LineTable, CallFile,
 280                                   NeedsAbsoluteFilePath, FileName);
 281         Line = CallLine;
 282         Column = CallColumn;
 283       }
 284       // Get call file/line/column of a current DIE.
 285       if (i + 1 < n) {
 286         FunctionDIE.getCallerFrame(CU, CallFile, CallLine, CallColumn);
 287       }
 288     }
 289     DILineInfo Frame(StringRef(FileName), StringRef(FunctionName),
 290                      Line, Column);
 291     InliningInfo.addFrame(Frame);
 292   }
 293   return InliningInfo;
 294 }
 295
 296 void DWARFContextInMemory::anchor() { }