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