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, DIDumpOptions DumpOpts, 110 ArrayRef<uint8_t> Data, bool IsLittleEndian, 111 unsigned AddressSize, const MCRegisterInfo *MRI, 112 DWARFUnit *U) { 113 DWARFDataExtractor Extractor(Data, IsLittleEndian, AddressSize); 114 // Note. We do not pass any format to DWARFExpression, even if the 115 // corresponding unit is known. For now, there is only one operation, 116 // DW_OP_call_ref, which depends on the format; it is rarely used, and 117 // is unexpected in location tables. 118 DWARFExpression(Extractor, AddressSize).print(OS, DumpOpts, MRI, U); 119 } 120 121 bool DWARFLocationTable::dumpLocationList(uint64_t *Offset, raw_ostream &OS, 122 Optional<SectionedAddress> BaseAddr, 123 const MCRegisterInfo *MRI, 124 const DWARFObject &Obj, DWARFUnit *U, 125 DIDumpOptions DumpOpts, 126 unsigned Indent) const { 127 DWARFLocationInterpreter Interp( 128 BaseAddr, [U](uint32_t Index) -> Optional<SectionedAddress> { 129 if (U) 130 return U->getAddrOffsetSectionItem(Index); 131 return None; 132 }); 133 OS << format("0x%8.8" PRIx64 ": ", *Offset); 134 Error E = visitLocationList(Offset, [&](const DWARFLocationEntry &E) { 135 Expected<Optional<DWARFLocationExpression>> Loc = Interp.Interpret(E); 136 if (!Loc || DumpOpts.DisplayRawContents) 137 dumpRawEntry(E, OS, Indent, DumpOpts, Obj); 138 if (Loc && *Loc) { 139 OS << "\n"; 140 OS.indent(Indent); 141 if (DumpOpts.DisplayRawContents) 142 OS << " => "; 143 144 DIDumpOptions RangeDumpOpts(DumpOpts); 145 RangeDumpOpts.DisplayRawContents = false; 146 if (Loc.get()->Range) 147 Loc.get()->Range->dump(OS, Data.getAddressSize(), RangeDumpOpts, &Obj); 148 else 149 OS << "<default>"; 150 } 151 if (!Loc) 152 consumeError(Loc.takeError()); 153 154 if (E.Kind != dwarf::DW_LLE_base_address && 155 E.Kind != dwarf::DW_LLE_base_addressx && 156 E.Kind != dwarf::DW_LLE_end_of_list) { 157 OS << ": "; 158 dumpExpression(OS, DumpOpts, E.Loc, Data.isLittleEndian(), 159 Data.getAddressSize(), MRI, U); 160 } 161 return true; 162 }); 163 if (E) { 164 DumpOpts.RecoverableErrorHandler(std::move(E)); 165 return false; 166 } 167 return true; 168 } 169 170 Error DWARFLocationTable::visitAbsoluteLocationList( 171 uint64_t Offset, Optional<SectionedAddress> BaseAddr, 172 std::function<Optional<SectionedAddress>(uint32_t)> LookupAddr, 173 function_ref<bool(Expected<DWARFLocationExpression>)> Callback) const { 174 DWARFLocationInterpreter Interp(BaseAddr, std::move(LookupAddr)); 175 return visitLocationList(&Offset, [&](const DWARFLocationEntry &E) { 176 Expected<Optional<DWARFLocationExpression>> Loc = Interp.Interpret(E); 177 if (!Loc) 178 return Callback(Loc.takeError()); 179 if (*Loc) 180 return Callback(**Loc); 181 return true; 182 }); 183 } 184 185 void DWARFDebugLoc::dump(raw_ostream &OS, const MCRegisterInfo *MRI, 186 const DWARFObject &Obj, DIDumpOptions DumpOpts, 187 Optional<uint64_t> DumpOffset) const { 188 auto BaseAddr = None; 189 unsigned Indent = 12; 190 if (DumpOffset) { 191 dumpLocationList(&*DumpOffset, OS, BaseAddr, MRI, Obj, nullptr, DumpOpts, 192 Indent); 193 } else { 194 uint64_t Offset = 0; 195 StringRef Separator; 196 bool CanContinue = true; 197 while (CanContinue && Data.isValidOffset(Offset)) { 198 OS << Separator; 199 Separator = "\n"; 200 201 CanContinue = dumpLocationList(&Offset, OS, BaseAddr, MRI, Obj, nullptr, 202 DumpOpts, Indent); 203 OS << '\n'; 204 } 205 } 206 } 207 208 Error DWARFDebugLoc::visitLocationList( 209 uint64_t *Offset, 210 function_ref<bool(const DWARFLocationEntry &)> Callback) const { 211 DataExtractor::Cursor C(*Offset); 212 while (true) { 213 uint64_t SectionIndex; 214 uint64_t Value0 = Data.getRelocatedAddress(C); 215 uint64_t Value1 = Data.getRelocatedAddress(C, &SectionIndex); 216 217 DWARFLocationEntry E; 218 219 // The end of any given location list is marked by an end of list entry, 220 // which consists of a 0 for the beginning address offset and a 0 for the 221 // ending address offset. A beginning offset of 0xff...f marks the base 222 // address selection entry. 223 if (Value0 == 0 && Value1 == 0) { 224 E.Kind = dwarf::DW_LLE_end_of_list; 225 } else if (Value0 == (Data.getAddressSize() == 4 ? -1U : -1ULL)) { 226 E.Kind = dwarf::DW_LLE_base_address; 227 E.Value0 = Value1; 228 E.SectionIndex = SectionIndex; 229 } else { 230 E.Kind = dwarf::DW_LLE_offset_pair; 231 E.Value0 = Value0; 232 E.Value1 = Value1; 233 E.SectionIndex = SectionIndex; 234 unsigned Bytes = Data.getU16(C); 235 // A single location description describing the location of the object... 236 Data.getU8(C, E.Loc, Bytes); 237 } 238 239 if (!C) 240 return C.takeError(); 241 if (!Callback(E) || E.Kind == dwarf::DW_LLE_end_of_list) 242 break; 243 } 244 *Offset = C.tell(); 245 return Error::success(); 246 } 247 248 void DWARFDebugLoc::dumpRawEntry(const DWARFLocationEntry &Entry, 249 raw_ostream &OS, unsigned Indent, 250 DIDumpOptions DumpOpts, 251 const DWARFObject &Obj) const { 252 uint64_t Value0, Value1; 253 switch (Entry.Kind) { 254 case dwarf::DW_LLE_base_address: 255 Value0 = Data.getAddressSize() == 4 ? -1U : -1ULL; 256 Value1 = Entry.Value0; 257 break; 258 case dwarf::DW_LLE_offset_pair: 259 Value0 = Entry.Value0; 260 Value1 = Entry.Value1; 261 break; 262 case dwarf::DW_LLE_end_of_list: 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 } 407
Indexes created Thu Aug 13 00:25:44 UTC 2026