llvm/lib/DebugInfo/DWARF/DWARFDebugMacro.cpp

   1 //===- DWARFDebugMacro.cpp ------------------------------------------------===//
   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 #include "llvm/DebugInfo/DWARF/DWARFDebugMacro.h"
  10 #include "llvm/BinaryFormat/Dwarf.h"
  11 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
  12 #include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
  13 #include "llvm/Support/WithColor.h"
  14 #include "llvm/Support/raw_ostream.h"
  15 #include <cstdint>
  16
  17 using namespace llvm;
  18 using namespace dwarf;
  19
  20 DwarfFormat DWARFDebugMacro::MacroHeader::getDwarfFormat() const {
  21   return Flags & MACRO_OFFSET_SIZE ? DWARF64 : DWARF32;
  22 }
  23
  24 uint8_t DWARFDebugMacro::MacroHeader::getOffsetByteSize() const {
  25   return getDwarfOffsetByteSize(getDwarfFormat());
  26 }
  27
  28 void DWARFDebugMacro::MacroHeader::dumpMacroHeader(raw_ostream &OS) const {
  29   // FIXME: Add support for dumping opcode_operands_table
  30   OS << format("macro header: version = 0x%04" PRIx16, Version)
  31      << format(", flags = 0x%02" PRIx8, Flags)
  32      << ", format = " << FormatString(getDwarfFormat());
  33   if (Flags & MACRO_DEBUG_LINE_OFFSET)
  34     OS << format(", debug_line_offset = 0x%0*" PRIx64, 2 * getOffsetByteSize(),
  35                  DebugLineOffset);
  36   OS << "\n";
  37 }
  38
  39 void DWARFDebugMacro::dump(raw_ostream &OS) const {
  40   unsigned IndLevel = 0;
  41   for (const auto &Macros : MacroLists) {
  42     OS << format("0x%08" PRIx64 ":\n", Macros.Offset);
  43     if (Macros.IsDebugMacro)
  44       Macros.Header.dumpMacroHeader(OS);
  45     for (const Entry &E : Macros.Macros) {
  46       // There should not be DW_MACINFO_end_file when IndLevel is Zero. However,
  47       // this check handles the case of corrupted ".debug_macinfo" section.
  48       if (IndLevel > 0)
  49         IndLevel -= (E.Type == DW_MACINFO_end_file);
  50       // Print indentation.
  51       for (unsigned I = 0; I < IndLevel; I++)
  52         OS << "  ";
  53       IndLevel += (E.Type == DW_MACINFO_start_file);
  54       // Based on which version we are handling choose appropriate macro forms.
  55       if (Macros.IsDebugMacro)
  56         WithColor(OS, HighlightColor::Macro).get()
  57             << (Macros.Header.Version < 5 ? GnuMacroString(E.Type)
  58                                           : MacroString(E.Type));
  59       else
  60         WithColor(OS, HighlightColor::Macro).get() << MacinfoString(E.Type);
  61       switch (E.Type) {
  62       default:
  63         // Got a corrupted ".debug_macinfo/.debug_macro" section (invalid
  64         // macinfo type).
  65         break;
  66         // debug_macro and debug_macinfo share some common encodings.
  67         // DW_MACRO_define     == DW_MACINFO_define
  68         // DW_MACRO_undef      == DW_MACINFO_undef
  69         // DW_MACRO_start_file == DW_MACINFO_start_file
  70         // DW_MACRO_end_file   == DW_MACINFO_end_file
  71         // For readability/uniformity we are using DW_MACRO_*.
  72         //
  73         // The GNU .debug_macro extension's entries have the same encoding
  74         // as DWARF 5's DW_MACRO_* entries, so we only use the latter here.
  75       case DW_MACRO_define:
  76       case DW_MACRO_undef:
  77       case DW_MACRO_define_strp:
  78       case DW_MACRO_undef_strp:
  79       case DW_MACRO_define_strx:
  80       case DW_MACRO_undef_strx:
  81         OS << " - lineno: " << E.Line;
  82         OS << " macro: " << E.MacroStr;
  83         break;
  84       case DW_MACRO_start_file:
  85         OS << " - lineno: " << E.Line;
  86         OS << " filenum: " << E.File;
  87         break;
  88       case DW_MACRO_import:
  89         OS << format(" - import offset: 0x%0*" PRIx64,
  90                      2 * Macros.Header.getOffsetByteSize(), E.ImportOffset);
  91         break;
  92       case DW_MACRO_end_file:
  93         break;
  94       case DW_MACINFO_vendor_ext:
  95         OS << " - constant: " << E.ExtConstant;
  96         OS << " string: " << E.ExtStr;
  97         break;
  98       }
  99       OS << "\n";
 100     }
 101   }
 102 }
 103
 104 Error DWARFDebugMacro::parseImpl(
 105     Optional<DWARFUnitVector::compile_unit_range> Units,
 106     Optional<DataExtractor> StringExtractor, DWARFDataExtractor Data,
 107     bool IsMacro) {
 108   uint64_t Offset = 0;
 109   MacroList *M = nullptr;
 110   using MacroToUnitsMap = DenseMap<uint64_t, DWARFUnit *>;
 111   MacroToUnitsMap MacroToUnits;
 112   if (IsMacro && Data.isValidOffset(Offset)) {
 113     // Keep a mapping from Macro contribution to CUs, this will
 114     // be needed while retrieving macro from DW_MACRO_define_strx form.
 115     for (const auto &U : Units.getValue())
 116       if (auto CUDIE = U->getUnitDIE())
 117         // Skip units which does not contibutes to macro section.
 118         if (auto MacroOffset = toSectionOffset(CUDIE.find(DW_AT_macros)))
 119           MacroToUnits.try_emplace(*MacroOffset, U.get());
 120   }
 121   while (Data.isValidOffset(Offset)) {
 122     if (!M) {
 123       MacroLists.emplace_back();
 124       M = &MacroLists.back();
 125       M->Offset = Offset;
 126       M->IsDebugMacro = IsMacro;
 127       if (IsMacro) {
 128         auto Err = M->Header.parseMacroHeader(Data, &Offset);
 129         if (Err)
 130           return Err;
 131       }
 132     }
 133     // A macro list entry consists of:
 134     M->Macros.emplace_back();
 135     Entry &E = M->Macros.back();
 136     // 1. Macinfo type
 137     E.Type = Data.getULEB128(&Offset);
 138
 139     if (E.Type == 0) {
 140       // Reached end of a ".debug_macinfo/debug_macro" section contribution.
 141       M = nullptr;
 142       continue;
 143     }
 144
 145     switch (E.Type) {
 146     default:
 147       // Got a corrupted ".debug_macinfo" section (invalid macinfo type).
 148       // Push the corrupted entry to the list and halt parsing.
 149       E.Type = DW_MACINFO_invalid;
 150       return Error::success();
 151     // debug_macro and debug_macinfo share some common encodings.
 152     // DW_MACRO_define     == DW_MACINFO_define
 153     // DW_MACRO_undef      == DW_MACINFO_undef
 154     // DW_MACRO_start_file == DW_MACINFO_start_file
 155     // DW_MACRO_end_file   == DW_MACINFO_end_file
 156     // For readibility/uniformity we are using DW_MACRO_*.
 157     case DW_MACRO_define:
 158     case DW_MACRO_undef:
 159       // 2. Source line
 160       E.Line = Data.getULEB128(&Offset);
 161       // 3. Macro string
 162       E.MacroStr = Data.getCStr(&Offset);
 163       break;
 164     case DW_MACRO_define_strp:
 165     case DW_MACRO_undef_strp: {
 166       if (!IsMacro) {
 167         // DW_MACRO_define_strp is a new form introduced in DWARFv5, it is
 168         // not supported in debug_macinfo[.dwo] sections. Assume it as an
 169         // invalid entry, push it and halt parsing.
 170         E.Type = DW_MACINFO_invalid;
 171         return Error::success();
 172       }
 173       uint64_t StrOffset = 0;
 174       // 2. Source line
 175       E.Line = Data.getULEB128(&Offset);
 176       // 3. Macro string
 177       StrOffset =
 178           Data.getRelocatedValue(M->Header.getOffsetByteSize(), &Offset);
 179       assert(StringExtractor && "String Extractor not found");
 180       E.MacroStr = StringExtractor->getCStr(&StrOffset);
 181       break;
 182     }
 183     case DW_MACRO_define_strx:
 184     case DW_MACRO_undef_strx: {
 185       if (!IsMacro) {
 186         // DW_MACRO_define_strx is a new form introduced in DWARFv5, it is
 187         // not supported in debug_macinfo[.dwo] sections. Assume it as an
 188         // invalid entry, push it and halt parsing.
 189         E.Type = DW_MACINFO_invalid;
 190         return Error::success();
 191       }
 192       E.Line = Data.getULEB128(&Offset);
 193       auto MacroContributionOffset = MacroToUnits.find(M->Offset);
 194       if (MacroContributionOffset == MacroToUnits.end())
 195         return createStringError(errc::invalid_argument,
 196                                  "Macro contribution of the unit not found");
 197       Optional<uint64_t> StrOffset =
 198           MacroContributionOffset->second->getStringOffsetSectionItem(
 199               Data.getULEB128(&Offset));
 200       if (!StrOffset)
 201         return createStringError(
 202             errc::invalid_argument,
 203             "String offsets contribution of the unit not found");
 204       E.MacroStr =
 205           MacroContributionOffset->second->getStringExtractor().getCStr(
 206               &*StrOffset);
 207       break;
 208     }
 209     case DW_MACRO_start_file:
 210       // 2. Source line
 211       E.Line = Data.getULEB128(&Offset);
 212       // 3. Source file id
 213       E.File = Data.getULEB128(&Offset);
 214       break;
 215     case DW_MACRO_end_file:
 216       break;
 217     case DW_MACRO_import:
 218       E.ImportOffset =
 219           Data.getRelocatedValue(M->Header.getOffsetByteSize(), &Offset);
 220       break;
 221     case DW_MACINFO_vendor_ext:
 222       // 2. Vendor extension constant
 223       E.ExtConstant = Data.getULEB128(&Offset);
 224       // 3. Vendor extension string
 225       E.ExtStr = Data.getCStr(&Offset);
 226       break;
 227     }
 228   }
 229   return Error::success();
 230 }
 231
 232 Error DWARFDebugMacro::MacroHeader::parseMacroHeader(DWARFDataExtractor Data,
 233                                                      uint64_t *Offset) {
 234   Version = Data.getU16(Offset);
 235   uint8_t FlagData = Data.getU8(Offset);
 236
 237   // FIXME: Add support for parsing opcode_operands_table
 238   if (FlagData & MACRO_OPCODE_OPERANDS_TABLE)
 239     return createStringError(errc::not_supported,
 240                              "opcode_operands_table is not supported");
 241   Flags = FlagData;
 242   if (Flags & MACRO_DEBUG_LINE_OFFSET)
 243     DebugLineOffset = Data.getUnsigned(Offset, getOffsetByteSize());
 244   return Error::success();
 245 }