contrib/llvm-project/llvm/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp

   1 //===- DWARFDebugLoc.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/DWARFDebugLoc.h"
  10 #include "llvm/ADT/StringRef.h"
  11 #include "llvm/BinaryFormat/Dwarf.h"
  12 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
  13 #include "llvm/DebugInfo/DWARF/DWARFExpression.h"
  14 #include "llvm/DebugInfo/DWARF/DWARFRelocMap.h"
  15 #include "llvm/DebugInfo/DWARF/DWARFUnit.h"
  16 #include "llvm/Support/Compiler.h"
  17 #include "llvm/Support/Format.h"
  18 #include "llvm/Support/WithColor.h"
  19 #include "llvm/Support/raw_ostream.h"
  20 #include <algorithm>
  21 #include <cinttypes>
  22 #include <cstdint>
  23
  24 using namespace llvm;
  25 using object::SectionedAddress;
  26
  27 namespace {
  28 class DWARFLocationInterpreter {
  29   Optional<object::SectionedAddress> Base;
  30   std::function<Optional<object::SectionedAddress>(uint32_t)> LookupAddr;
  31
  32 public:
  33   DWARFLocationInterpreter(
  34       Optional<object::SectionedAddress> Base,
  35       std::function<Optional<object::SectionedAddress>(uint32_t)> LookupAddr)
  36       : Base(Base), LookupAddr(std::move(LookupAddr)) {}
  37
  38   Expected<Optional<DWARFLocationExpression>>
  39   Interpret(const DWARFLocationEntry &E);
  40 };
  41 } // namespace
  42
  43 static Error createResolverError(uint32_t Index, unsigned Kind) {
  44   return createStringError(errc::invalid_argument,
  45                            "Unable to resolve indirect address %u for: %s",
  46                            Index, dwarf::LocListEncodingString(Kind).data());
  47 }
  48
  49 Expected<Optional<DWARFLocationExpression>>
  50 DWARFLocationInterpreter::Interpret(const DWARFLocationEntry &E) {
  51   switch (E.Kind) {
  52   case dwarf::DW_LLE_end_of_list:
  53     return None;
  54   case dwarf::DW_LLE_base_addressx: {
  55     Base = LookupAddr(E.Value0);
  56     if (!Base)
  57       return createResolverError(E.Value0, E.Kind);
  58     return None;
  59   }
  60   case dwarf::DW_LLE_startx_endx: {
  61     Optional<SectionedAddress> LowPC = LookupAddr(E.Value0);
  62     if (!LowPC)
  63       return createResolverError(E.Value0, E.Kind);
  64     Optional<SectionedAddress> HighPC = LookupAddr(E.Value1);
  65     if (!HighPC)
  66       return createResolverError(E.Value1, E.Kind);
  67     return DWARFLocationExpression{
  68         DWARFAddressRange{LowPC->Address, HighPC->Address, LowPC->SectionIndex},
  69         E.Loc};
  70   }
  71   case dwarf::DW_LLE_startx_length: {
  72     Optional<SectionedAddress> LowPC = LookupAddr(E.Value0);
  73     if (!LowPC)
  74       return createResolverError(E.Value0, E.Kind);
  75     return DWARFLocationExpression{DWARFAddressRange{LowPC->Address,
  76                                                      LowPC->Address + E.Value1,
  77                                                      LowPC->SectionIndex},
  78                                    E.Loc};
  79   }
  80   case dwarf::DW_LLE_offset_pair: {
  81     if (!Base) {
  82       return createStringError(inconvertibleErrorCode(),
  83                                "Unable to resolve location list offset pair: "
  84                                "Base address not defined");
  85     }
  86     DWARFAddressRange Range{Base->Address + E.Value0, Base->Address + E.Value1,
  87                             Base->SectionIndex};
  88     if (Range.SectionIndex == SectionedAddress::UndefSection)
  89       Range.SectionIndex = E.SectionIndex;
  90     return DWARFLocationExpression{Range, E.Loc};
  91   }
  92   case dwarf::DW_LLE_default_location:
  93     return DWARFLocationExpression{None, E.Loc};
  94   case dwarf::DW_LLE_base_address:
  95     Base = SectionedAddress{E.Value0, E.SectionIndex};
  96     return None;
  97   case dwarf::DW_LLE_start_end:
  98     return DWARFLocationExpression{
  99         DWARFAddressRange{E.Value0, E.Value1, E.SectionIndex}, E.Loc};
 100   case dwarf::DW_LLE_start_length:
 101     return DWARFLocationExpression{
 102         DWARFAddressRange{E.Value0, E.Value0 + E.Value1, E.SectionIndex},
 103         E.Loc};
 104   default:
 105     llvm_unreachable("unreachable locations list kind");
 106   }
 107 }
 108
 109 static void dumpExpression(raw_ostream &OS, ArrayRef<uint8_t> Data,
 110                            bool IsLittleEndian, unsigned AddressSize,
 111                            const MCRegisterInfo *MRI, DWARFUnit *U) {
 112   DWARFDataExtractor Extractor(Data, IsLittleEndian, AddressSize);
 113   // Note. We do not pass any format to DWARFExpression, even if the
 114   // corresponding unit is known. For now, there is only one operation,
 115   // DW_OP_call_ref, which depends on the format; it is rarely used, and
 116   // is unexpected in location tables.
 117   DWARFExpression(Extractor, AddressSize).print(OS, MRI, U);
 118 }
 119
 120 bool DWARFLocationTable::dumpLocationList(uint64_t *Offset, raw_ostream &OS,
 121                                           Optional<SectionedAddress> BaseAddr,
 122                                           const MCRegisterInfo *MRI,
 123                                           const DWARFObject &Obj, DWARFUnit *U,
 124                                           DIDumpOptions DumpOpts,
 125                                           unsigned Indent) const {
 126   DWARFLocationInterpreter Interp(
 127       BaseAddr, [U](uint32_t Index) -> Optional<SectionedAddress> {
 128         if (U)
 129           return U->getAddrOffsetSectionItem(Index);
 130         return None;
 131       });
 132   OS << format("0x%8.8" PRIx64 ": ", *Offset);
 133   Error E = visitLocationList(Offset, [&](const DWARFLocationEntry &E) {
 134     Expected<Optional<DWARFLocationExpression>> Loc = Interp.Interpret(E);
 135     if (!Loc || DumpOpts.DisplayRawContents)
 136       dumpRawEntry(E, OS, Indent, DumpOpts, Obj);
 137     if (Loc && *Loc) {
 138       OS << "\n";
 139       OS.indent(Indent);
 140       if (DumpOpts.DisplayRawContents)
 141         OS << "          => ";
 142
 143       DIDumpOptions RangeDumpOpts(DumpOpts);
 144       RangeDumpOpts.DisplayRawContents = false;
 145       if (Loc.get()->Range)
 146         Loc.get()->Range->dump(OS, Data.getAddressSize(), RangeDumpOpts, &Obj);
 147       else
 148         OS << "<default>";
 149     }
 150     if (!Loc)
 151       consumeError(Loc.takeError());
 152
 153     if (E.Kind != dwarf::DW_LLE_base_address &&
 154         E.Kind != dwarf::DW_LLE_base_addressx &&
 155         E.Kind != dwarf::DW_LLE_end_of_list) {
 156       OS << ": ";
 157       dumpExpression(OS, E.Loc, Data.isLittleEndian(), Data.getAddressSize(),
 158                      MRI, U);
 159     }
 160     return true;
 161   });
 162   if (E) {
 163     DumpOpts.RecoverableErrorHandler(std::move(E));
 164     return false;
 165   }
 166   return true;
 167 }
 168
 169 Error DWARFLocationTable::visitAbsoluteLocationList(
 170     uint64_t Offset, Optional<SectionedAddress> BaseAddr,
 171     std::function<Optional<SectionedAddress>(uint32_t)> LookupAddr,
 172     function_ref<bool(Expected<DWARFLocationExpression>)> Callback) const {
 173   DWARFLocationInterpreter Interp(BaseAddr, std::move(LookupAddr));
 174   return visitLocationList(&Offset, [&](const DWARFLocationEntry &E) {
 175     Expected<Optional<DWARFLocationExpression>> Loc = Interp.Interpret(E);
 176     if (!Loc)
 177       return Callback(Loc.takeError());
 178     if (*Loc)
 179       return Callback(**Loc);
 180     return true;
 181   });
 182 }
 183
 184 void DWARFDebugLoc::dump(raw_ostream &OS, const MCRegisterInfo *MRI,
 185                          const DWARFObject &Obj, DIDumpOptions DumpOpts,
 186                          Optional<uint64_t> DumpOffset) const {
 187   auto BaseAddr = None;
 188   unsigned Indent = 12;
 189   if (DumpOffset) {
 190     dumpLocationList(&*DumpOffset, OS, BaseAddr, MRI, Obj, nullptr, DumpOpts,
 191                      Indent);
 192   } else {
 193     uint64_t Offset = 0;
 194     StringRef Separator;
 195     bool CanContinue = true;
 196     while (CanContinue && Data.isValidOffset(Offset)) {
 197       OS << Separator;
 198       Separator = "\n";
 199
 200       CanContinue = dumpLocationList(&Offset, OS, BaseAddr, MRI, Obj, nullptr,
 201                                      DumpOpts, Indent);
 202       OS << '\n';
 203     }
 204   }
 205 }
 206
 207 Error DWARFDebugLoc::visitLocationList(
 208     uint64_t *Offset,
 209     function_ref<bool(const DWARFLocationEntry &)> Callback) const {
 210   DataExtractor::Cursor C(*Offset);
 211   while (true) {
 212     uint64_t SectionIndex;
 213     uint64_t Value0 = Data.getRelocatedAddress(C);
 214     uint64_t Value1 = Data.getRelocatedAddress(C, &SectionIndex);
 215
 216     DWARFLocationEntry E;
 217
 218     // The end of any given location list is marked by an end of list entry,
 219     // which consists of a 0 for the beginning address offset and a 0 for the
 220     // ending address offset. A beginning offset of 0xff...f marks the base
 221     // address selection entry.
 222     if (Value0 == 0 && Value1 == 0) {
 223       E.Kind = dwarf::DW_LLE_end_of_list;
 224     } else if (Value0 == (Data.getAddressSize() == 4 ? -1U : -1ULL)) {
 225       E.Kind = dwarf::DW_LLE_base_address;
 226       E.Value0 = Value1;
 227       E.SectionIndex = SectionIndex;
 228     } else {
 229       E.Kind = dwarf::DW_LLE_offset_pair;
 230       E.Value0 = Value0;
 231       E.Value1 = Value1;
 232       E.SectionIndex = SectionIndex;
 233       unsigned Bytes = Data.getU16(C);
 234       // A single location description describing the location of the object...
 235       Data.getU8(C, E.Loc, Bytes);
 236     }
 237
 238     if (!C)
 239       return C.takeError();
 240     if (!Callback(E) || E.Kind == dwarf::DW_LLE_end_of_list)
 241       break;
 242   }
 243   *Offset = C.tell();
 244   return Error::success();
 245 }
 246
 247 void DWARFDebugLoc::dumpRawEntry(const DWARFLocationEntry &Entry,
 248                                  raw_ostream &OS, unsigned Indent,
 249                                  DIDumpOptions DumpOpts,
 250                                  const DWARFObject &Obj) const {
 251   uint64_t Value0, Value1;
 252   switch (Entry.Kind) {
 253   case dwarf::DW_LLE_base_address:
 254     Value0 = Data.getAddressSize() == 4 ? -1U : -1ULL;
 255     Value1 = Entry.Value0;
 256     break;
 257   case dwarf::DW_LLE_offset_pair:
 258     Value0 = Entry.Value0;
 259     Value1 = Entry.Value1;
 260     break;
 261   case dwarf::DW_LLE_end_of_list:
 262     Value0 = Value1 = 0;
 263     return;
 264   default:
 265     llvm_unreachable("Not possible in DWARF4!");
 266   }
 267   OS << '\n';
 268   OS.indent(Indent);
 269   OS << '(' << format_hex(Value0, 2 + Data.getAddressSize() * 2) << ", "
 270      << format_hex(Value1, 2 + Data.getAddressSize() * 2) << ')';
 271   DWARFFormValue::dumpAddressSection(Obj, OS, DumpOpts, Entry.SectionIndex);
 272 }
 273
 274 Error DWARFDebugLoclists::visitLocationList(
 275     uint64_t *Offset, function_ref<bool(const DWARFLocationEntry &)> F) const {
 276
 277   DataExtractor::Cursor C(*Offset);
 278   bool Continue = true;
 279   while (Continue) {
 280     DWARFLocationEntry E;
 281     E.Kind = Data.getU8(C);
 282     switch (E.Kind) {
 283     case dwarf::DW_LLE_end_of_list:
 284       break;
 285     case dwarf::DW_LLE_base_addressx:
 286       E.Value0 = Data.getULEB128(C);
 287       break;
 288     case dwarf::DW_LLE_startx_endx:
 289       E.Value0 = Data.getULEB128(C);
 290       E.Value1 = Data.getULEB128(C);
 291       break;
 292     case dwarf::DW_LLE_startx_length:
 293       E.Value0 = Data.getULEB128(C);
 294       // Pre-DWARF 5 has different interpretation of the length field. We have
 295       // to support both pre- and standartized styles for the compatibility.
 296       if (Version < 5)
 297         E.Value1 = Data.getU32(C);
 298       else
 299         E.Value1 = Data.getULEB128(C);
 300       break;
 301     case dwarf::DW_LLE_offset_pair:
 302       E.Value0 = Data.getULEB128(C);
 303       E.Value1 = Data.getULEB128(C);
 304       E.SectionIndex = SectionedAddress::UndefSection;
 305       break;
 306     case dwarf::DW_LLE_default_location:
 307       break;
 308     case dwarf::DW_LLE_base_address:
 309       E.Value0 = Data.getRelocatedAddress(C, &E.SectionIndex);
 310       break;
 311     case dwarf::DW_LLE_start_end:
 312       E.Value0 = Data.getRelocatedAddress(C, &E.SectionIndex);
 313       E.Value1 = Data.getRelocatedAddress(C);
 314       break;
 315     case dwarf::DW_LLE_start_length:
 316       E.Value0 = Data.getRelocatedAddress(C, &E.SectionIndex);
 317       E.Value1 = Data.getULEB128(C);
 318       break;
 319     default:
 320       cantFail(C.takeError());
 321       return createStringError(errc::illegal_byte_sequence,
 322                                "LLE of kind %x not supported", (int)E.Kind);
 323     }
 324
 325     if (E.Kind != dwarf::DW_LLE_base_address &&
 326         E.Kind != dwarf::DW_LLE_base_addressx &&
 327         E.Kind != dwarf::DW_LLE_end_of_list) {
 328       unsigned Bytes = Version >= 5 ? Data.getULEB128(C) : Data.getU16(C);
 329       // A single location description describing the location of the object...
 330       Data.getU8(C, E.Loc, Bytes);
 331     }
 332
 333     if (!C)
 334       return C.takeError();
 335     Continue = F(E) && E.Kind != dwarf::DW_LLE_end_of_list;
 336   }
 337   *Offset = C.tell();
 338   return Error::success();
 339 }
 340
 341 void DWARFDebugLoclists::dumpRawEntry(const DWARFLocationEntry &Entry,
 342                                       raw_ostream &OS, unsigned Indent,
 343                                       DIDumpOptions DumpOpts,
 344                                       const DWARFObject &Obj) const {
 345   size_t MaxEncodingStringLength = 0;
 346 #define HANDLE_DW_LLE(ID, NAME)                                                \
 347   MaxEncodingStringLength = std::max(MaxEncodingStringLength,                  \
 348                                      dwarf::LocListEncodingString(ID).size());
 349 #include "llvm/BinaryFormat/Dwarf.def"
 350
 351   OS << "\n";
 352   OS.indent(Indent);
 353   StringRef EncodingString = dwarf::LocListEncodingString(Entry.Kind);
 354   // Unsupported encodings should have been reported during parsing.
 355   assert(!EncodingString.empty() && "Unknown loclist entry encoding");
 356   OS << format("%-*s(", MaxEncodingStringLength, EncodingString.data());
 357   unsigned FieldSize = 2 + 2 * Data.getAddressSize();
 358   switch (Entry.Kind) {
 359   case dwarf::DW_LLE_end_of_list:
 360   case dwarf::DW_LLE_default_location:
 361     break;
 362   case dwarf::DW_LLE_startx_endx:
 363   case dwarf::DW_LLE_startx_length:
 364   case dwarf::DW_LLE_offset_pair:
 365   case dwarf::DW_LLE_start_end:
 366   case dwarf::DW_LLE_start_length:
 367     OS << format_hex(Entry.Value0, FieldSize) << ", "
 368        << format_hex(Entry.Value1, FieldSize);
 369     break;
 370   case dwarf::DW_LLE_base_addressx:
 371   case dwarf::DW_LLE_base_address:
 372     OS << format_hex(Entry.Value0, FieldSize);
 373     break;
 374   }
 375   OS << ')';
 376   switch (Entry.Kind) {
 377   case dwarf::DW_LLE_base_address:
 378   case dwarf::DW_LLE_start_end:
 379   case dwarf::DW_LLE_start_length:
 380     DWARFFormValue::dumpAddressSection(Obj, OS, DumpOpts, Entry.SectionIndex);
 381     break;
 382   default:
 383     break;
 384   }
 385 }
 386
 387 void DWARFDebugLoclists::dumpRange(uint64_t StartOffset, uint64_t Size,
 388                                    raw_ostream &OS, const MCRegisterInfo *MRI,
 389                                    const DWARFObject &Obj,
 390                                    DIDumpOptions DumpOpts) {
 391   if (!Data.isValidOffsetForDataOfSize(StartOffset, Size))  {
 392     OS << "Invalid dump range\n";
 393     return;
 394   }
 395   uint64_t Offset = StartOffset;
 396   StringRef Separator;
 397   bool CanContinue = true;
 398   while (CanContinue && Offset < StartOffset + Size) {
 399     OS << Separator;
 400     Separator = "\n";
 401
 402     CanContinue = dumpLocationList(&Offset, OS, /*BaseAddr=*/None, MRI, Obj,
 403                                    nullptr, DumpOpts, /*Indent=*/12);
 404     OS << '\n';
 405   }
 406 }