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