1 //===-- DWARFDebugFrame.h - Parsing of .debug_frame -------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "llvm/DebugInfo/DWARF/DWARFDebugFrame.h" 11 #include "llvm/ADT/ArrayRef.h" 12 #include "llvm/ADT/DenseMap.h" 13 #include "llvm/ADT/SmallString.h" 14 #include "llvm/Support/Casting.h" 15 #include "llvm/Support/DataTypes.h" 16 #include "llvm/Support/Dwarf.h" 17 #include "llvm/Support/ErrorHandling.h" 18 #include "llvm/Support/Format.h" 19 #include "llvm/Support/raw_ostream.h" 20 #include <string> 21 #include <vector> 22 23 using namespace llvm; 24 using namespace dwarf; 25 26 27 /// \brief Abstract frame entry defining the common interface concrete 28 /// entries implement. 29 class llvm::FrameEntry { 30 public: 31 enum FrameKind {FK_CIE, FK_FDE}; 32 FrameEntry(FrameKind K, uint64_t Offset, uint64_t Length) 33 : Kind(K), Offset(Offset), Length(Length) {} 34 35 virtual ~FrameEntry() { 36 } 37 38 FrameKind getKind() const { return Kind; } 39 virtual uint64_t getOffset() const { return Offset; } 40 41 /// \brief Parse and store a sequence of CFI instructions from Data, 42 /// starting at *Offset and ending at EndOffset. If everything 43 /// goes well, *Offset should be equal to EndOffset when this method 44 /// returns. Otherwise, an error occurred. 45 virtual void parseInstructions(DataExtractor Data, uint32_t *Offset, 46 uint32_t EndOffset); 47 48 /// \brief Dump the entry header to the given output stream. 49 virtual void dumpHeader(raw_ostream &OS) const = 0; 50 51 /// \brief Dump the entry's instructions to the given output stream. 52 virtual void dumpInstructions(raw_ostream &OS) const; 53 54 protected: 55 const FrameKind Kind; 56 57 /// \brief Offset of this entry in the section. 58 uint64_t Offset; 59 60 /// \brief Entry length as specified in DWARF. 61 uint64_t Length; 62 63 /// An entry may contain CFI instructions. An instruction consists of an 64 /// opcode and an optional sequence of operands. 65 typedef std::vector<uint64_t> Operands; 66 struct Instruction { 67 Instruction(uint8_t Opcode) 68 : Opcode(Opcode) 69 {} 70 71 uint8_t Opcode; 72 Operands Ops; 73 }; 74 75 std::vector<Instruction> Instructions; 76 77 /// Convenience methods to add a new instruction with the given opcode and 78 /// operands to the Instructions vector. 79 void addInstruction(uint8_t Opcode) { 80 Instructions.push_back(Instruction(Opcode)); 81 } 82 83 void addInstruction(uint8_t Opcode, uint64_t Operand1) { 84 Instructions.push_back(Instruction(Opcode)); 85 Instructions.back().Ops.push_back(Operand1); 86 } 87 88 void addInstruction(uint8_t Opcode, uint64_t Operand1, uint64_t Operand2) { 89 Instructions.push_back(Instruction(Opcode)); 90 Instructions.back().Ops.push_back(Operand1); 91 Instructions.back().Ops.push_back(Operand2); 92 } 93 }; 94 95 96 // See DWARF standard v3, section 7.23 97 const uint8_t DWARF_CFI_PRIMARY_OPCODE_MASK = 0xc0; 98 const uint8_t DWARF_CFI_PRIMARY_OPERAND_MASK = 0x3f; 99 100 void FrameEntry::parseInstructions(DataExtractor Data, uint32_t *Offset, 101 uint32_t EndOffset) { 102 while (*Offset < EndOffset) { 103 uint8_t Opcode = Data.getU8(Offset); 104 // Some instructions have a primary opcode encoded in the top bits. 105 uint8_t Primary = Opcode & DWARF_CFI_PRIMARY_OPCODE_MASK; 106 107 if (Primary) { 108 // If it's a primary opcode, the first operand is encoded in the bottom 109 // bits of the opcode itself. 110 uint64_t Op1 = Opcode & DWARF_CFI_PRIMARY_OPERAND_MASK; 111 switch (Primary) { 112 default: llvm_unreachable("Impossible primary CFI opcode"); 113 case DW_CFA_advance_loc: 114 case DW_CFA_restore: 115 addInstruction(Primary, Op1); 116 break; 117 case DW_CFA_offset: 118 addInstruction(Primary, Op1, Data.getULEB128(Offset)); 119 break; 120 } 121 } else { 122 // Extended opcode - its value is Opcode itself. 123 switch (Opcode) { 124 default: llvm_unreachable("Invalid extended CFI opcode"); 125 case DW_CFA_nop: 126 case DW_CFA_remember_state: 127 case DW_CFA_restore_state: 128 case DW_CFA_GNU_window_save: 129 // No operands 130 addInstruction(Opcode); 131 break; 132 case DW_CFA_set_loc: 133 // Operands: Address 134 addInstruction(Opcode, Data.getAddress(Offset)); 135 break; 136 case DW_CFA_advance_loc1: 137 // Operands: 1-byte delta 138 addInstruction(Opcode, Data.getU8(Offset)); 139 break; 140 case DW_CFA_advance_loc2: 141 // Operands: 2-byte delta 142 addInstruction(Opcode, Data.getU16(Offset)); 143 break; 144 case DW_CFA_advance_loc4: 145 // Operands: 4-byte delta 146 addInstruction(Opcode, Data.getU32(Offset)); 147 break; 148 case DW_CFA_restore_extended: 149 case DW_CFA_undefined: 150 case DW_CFA_same_value: 151 case DW_CFA_def_cfa_register: 152 case DW_CFA_def_cfa_offset: 153 // Operands: ULEB128 154 addInstruction(Opcode, Data.getULEB128(Offset)); 155 break; 156 case DW_CFA_def_cfa_offset_sf: 157 // Operands: SLEB128 158 addInstruction(Opcode, Data.getSLEB128(Offset)); 159 break; 160 case DW_CFA_offset_extended: 161 case DW_CFA_register: 162 case DW_CFA_def_cfa: 163 case DW_CFA_val_offset: 164 // Operands: ULEB128, ULEB128 165 addInstruction(Opcode, Data.getULEB128(Offset), 166 Data.getULEB128(Offset)); 167 break; 168 case DW_CFA_offset_extended_sf: 169 case DW_CFA_def_cfa_sf: 170 case DW_CFA_val_offset_sf: 171 // Operands: ULEB128, SLEB128 172 addInstruction(Opcode, Data.getULEB128(Offset), 173 Data.getSLEB128(Offset)); 174 break; 175 case DW_CFA_def_cfa_expression: 176 case DW_CFA_expression: 177 case DW_CFA_val_expression: 178 // TODO: implement this 179 report_fatal_error("Values with expressions not implemented yet!"); 180 } 181 } 182 } 183 } 184 185 namespace { 186 /// \brief DWARF Common Information Entry (CIE) 187 class CIE : public FrameEntry { 188 public: 189 // CIEs (and FDEs) are simply container classes, so the only sensible way to 190 // create them is by providing the full parsed contents in the constructor. 191 CIE(uint64_t Offset, uint64_t Length, uint8_t Version, 192 SmallString<8> Augmentation, uint64_t CodeAlignmentFactor, 193 int64_t DataAlignmentFactor, uint64_t ReturnAddressRegister) 194 : FrameEntry(FK_CIE, Offset, Length), Version(Version), 195 Augmentation(std::move(Augmentation)), 196 CodeAlignmentFactor(CodeAlignmentFactor), 197 DataAlignmentFactor(DataAlignmentFactor), 198 ReturnAddressRegister(ReturnAddressRegister) {} 199 200 ~CIE() override {} 201 202 uint64_t getCodeAlignmentFactor() const { return CodeAlignmentFactor; } 203 int64_t getDataAlignmentFactor() const { return DataAlignmentFactor; } 204 205 void dumpHeader(raw_ostream &OS) const override { 206 OS << format("%08x %08x %08x CIE", 207 (uint32_t)Offset, (uint32_t)Length, DW_CIE_ID) 208 << "\n"; 209 OS << format(" Version: %d\n", Version); 210 OS << " Augmentation: \"" << Augmentation << "\"\n"; 211 OS << format(" Code alignment factor: %u\n", 212 (uint32_t)CodeAlignmentFactor); 213 OS << format(" Data alignment factor: %d\n", 214 (int32_t)DataAlignmentFactor); 215 OS << format(" Return address column: %d\n", 216 (int32_t)ReturnAddressRegister); 217 OS << "\n"; 218 } 219 220 static bool classof(const FrameEntry *FE) { 221 return FE->getKind() == FK_CIE; 222 } 223 224 private: 225 /// The following fields are defined in section 6.4.1 of the DWARF standard v3 226 uint8_t Version; 227 SmallString<8> Augmentation; 228 uint64_t CodeAlignmentFactor; 229 int64_t DataAlignmentFactor; 230 uint64_t ReturnAddressRegister; 231 }; 232 233 234 /// \brief DWARF Frame Description Entry (FDE) 235 class FDE : public FrameEntry { 236 public: 237 // Each FDE has a CIE it's "linked to". Our FDE contains is constructed with 238 // an offset to the CIE (provided by parsing the FDE header). The CIE itself 239 // is obtained lazily once it's actually required. 240 FDE(uint64_t Offset, uint64_t Length, int64_t LinkedCIEOffset, 241 uint64_t InitialLocation, uint64_t AddressRange, 242 CIE *Cie) 243 : FrameEntry(FK_FDE, Offset, Length), LinkedCIEOffset(LinkedCIEOffset), 244 InitialLocation(InitialLocation), AddressRange(AddressRange), 245 LinkedCIE(Cie) {} 246 247 ~FDE() override {} 248 249 CIE *getLinkedCIE() const { return LinkedCIE; } 250 251 void dumpHeader(raw_ostream &OS) const override { 252 OS << format("%08x %08x %08x FDE ", 253 (uint32_t)Offset, (uint32_t)Length, (int32_t)LinkedCIEOffset); 254 OS << format("cie=%08x pc=%08x...%08x\n", 255 (int32_t)LinkedCIEOffset, 256 (uint32_t)InitialLocation, 257 (uint32_t)InitialLocation + (uint32_t)AddressRange); 258 } 259 260 static bool classof(const FrameEntry *FE) { 261 return FE->getKind() == FK_FDE; 262 } 263 264 private: 265 /// The following fields are defined in section 6.4.1 of the DWARF standard v3 266 uint64_t LinkedCIEOffset; 267 uint64_t InitialLocation; 268 uint64_t AddressRange; 269 CIE *LinkedCIE; 270 }; 271 272 /// \brief Types of operands to CF instructions. 273 enum OperandType { 274 OT_Unset, 275 OT_None, 276 OT_Address, 277 OT_Offset, 278 OT_FactoredCodeOffset, 279 OT_SignedFactDataOffset, 280 OT_UnsignedFactDataOffset, 281 OT_Register, 282 OT_Expression 283 }; 284 285 } // end anonymous namespace 286 287 /// \brief Initialize the array describing the types of operands. 288 static ArrayRef<OperandType[2]> getOperandTypes() { 289 static OperandType OpTypes[DW_CFA_restore+1][2]; 290 291 #define DECLARE_OP2(OP, OPTYPE0, OPTYPE1) \ 292 do { \ 293 OpTypes[OP][0] = OPTYPE0; \ 294 OpTypes[OP][1] = OPTYPE1; \ 295 } while (0) 296 #define DECLARE_OP1(OP, OPTYPE0) DECLARE_OP2(OP, OPTYPE0, OT_None) 297 #define DECLARE_OP0(OP) DECLARE_OP1(OP, OT_None) 298 299 DECLARE_OP1(DW_CFA_set_loc, OT_Address); 300 DECLARE_OP1(DW_CFA_advance_loc, OT_FactoredCodeOffset); 301 DECLARE_OP1(DW_CFA_advance_loc1, OT_FactoredCodeOffset); 302 DECLARE_OP1(DW_CFA_advance_loc2, OT_FactoredCodeOffset); 303 DECLARE_OP1(DW_CFA_advance_loc4, OT_FactoredCodeOffset); 304 DECLARE_OP1(DW_CFA_MIPS_advance_loc8, OT_FactoredCodeOffset); 305 DECLARE_OP2(DW_CFA_def_cfa, OT_Register, OT_Offset); 306 DECLARE_OP2(DW_CFA_def_cfa_sf, OT_Register, OT_SignedFactDataOffset); 307 DECLARE_OP1(DW_CFA_def_cfa_register, OT_Register); 308 DECLARE_OP1(DW_CFA_def_cfa_offset, OT_Offset); 309 DECLARE_OP1(DW_CFA_def_cfa_offset_sf, OT_SignedFactDataOffset); 310 DECLARE_OP1(DW_CFA_def_cfa_expression, OT_Expression); 311 DECLARE_OP1(DW_CFA_undefined, OT_Register); 312 DECLARE_OP1(DW_CFA_same_value, OT_Register); 313 DECLARE_OP2(DW_CFA_offset, OT_Register, OT_UnsignedFactDataOffset); 314 DECLARE_OP2(DW_CFA_offset_extended, OT_Register, OT_UnsignedFactDataOffset); 315 DECLARE_OP2(DW_CFA_offset_extended_sf, OT_Register, OT_SignedFactDataOffset); 316 DECLARE_OP2(DW_CFA_val_offset, OT_Register, OT_UnsignedFactDataOffset); 317 DECLARE_OP2(DW_CFA_val_offset_sf, OT_Register, OT_SignedFactDataOffset); 318 DECLARE_OP2(DW_CFA_register, OT_Register, OT_Register); 319 DECLARE_OP2(DW_CFA_expression, OT_Register, OT_Expression); 320 DECLARE_OP2(DW_CFA_val_expression, OT_Register, OT_Expression); 321 DECLARE_OP1(DW_CFA_restore, OT_Register); 322 DECLARE_OP1(DW_CFA_restore_extended, OT_Register); 323 DECLARE_OP0(DW_CFA_remember_state); 324 DECLARE_OP0(DW_CFA_restore_state); 325 DECLARE_OP0(DW_CFA_GNU_window_save); 326 DECLARE_OP1(DW_CFA_GNU_args_size, OT_Offset); 327 DECLARE_OP0(DW_CFA_nop); 328 329 #undef DECLARE_OP0 330 #undef DECLARE_OP1 331 #undef DECLARE_OP2 332 return ArrayRef<OperandType[2]>(&OpTypes[0], DW_CFA_restore+1); 333 } 334 335 static ArrayRef<OperandType[2]> OpTypes = getOperandTypes(); 336 337 /// \brief Print \p Opcode's operand number \p OperandIdx which has 338 /// value \p Operand. 339 static void printOperand(raw_ostream &OS, uint8_t Opcode, unsigned OperandIdx, 340 uint64_t Operand, uint64_t CodeAlignmentFactor, 341 int64_t DataAlignmentFactor) { 342 assert(OperandIdx < 2); 343 OperandType Type = OpTypes[Opcode][OperandIdx]; 344 345 switch (Type) { 346 case OT_Unset: 347 OS << " Unsupported " << (OperandIdx ? "second" : "first") << " operand to"; 348 if (const char *OpcodeName = CallFrameString(Opcode)) 349 OS << " " << OpcodeName; 350 else 351 OS << format(" Opcode %x", Opcode); 352 break; 353 case OT_None: 354 break; 355 case OT_Address: 356 OS << format(" %" PRIx64, Operand); 357 break; 358 case OT_Offset: 359 // The offsets are all encoded in a unsigned form, but in practice 360 // consumers use them signed. It's most certainly legacy due to 361 // the lack of signed variants in the first Dwarf standards. 362 OS << format(" %+" PRId64, int64_t(Operand)); 363 break; 364 case OT_FactoredCodeOffset: // Always Unsigned 365 if (CodeAlignmentFactor) 366 OS << format(" %" PRId64, Operand * CodeAlignmentFactor); 367 else 368 OS << format(" %" PRId64 "*code_alignment_factor" , Operand); 369 break; 370 case OT_SignedFactDataOffset: 371 if (DataAlignmentFactor) 372 OS << format(" %" PRId64, int64_t(Operand) * DataAlignmentFactor); 373 else 374 OS << format(" %" PRId64 "*data_alignment_factor" , int64_t(Operand)); 375 break; 376 case OT_UnsignedFactDataOffset: 377 if (DataAlignmentFactor) 378 OS << format(" %" PRId64, Operand * DataAlignmentFactor); 379 else 380 OS << format(" %" PRId64 "*data_alignment_factor" , Operand); 381 break; 382 case OT_Register: 383 OS << format(" reg%" PRId64, Operand); 384 break; 385 case OT_Expression: 386 OS << " expression"; 387 break; 388 } 389 } 390 391 void FrameEntry::dumpInstructions(raw_ostream &OS) const { 392 uint64_t CodeAlignmentFactor = 0; 393 int64_t DataAlignmentFactor = 0; 394 const CIE *Cie = dyn_cast<CIE>(this); 395 396 if (!Cie) 397 Cie = cast<FDE>(this)->getLinkedCIE(); 398 if (Cie) { 399 CodeAlignmentFactor = Cie->getCodeAlignmentFactor(); 400 DataAlignmentFactor = Cie->getDataAlignmentFactor(); 401 } 402 403 for (const auto &Instr : Instructions) { 404 uint8_t Opcode = Instr.Opcode; 405 if (Opcode & DWARF_CFI_PRIMARY_OPCODE_MASK) 406 Opcode &= DWARF_CFI_PRIMARY_OPCODE_MASK; 407 OS << " " << CallFrameString(Opcode) << ":"; 408 for (unsigned i = 0; i < Instr.Ops.size(); ++i) 409 printOperand(OS, Opcode, i, Instr.Ops[i], CodeAlignmentFactor, 410 DataAlignmentFactor); 411 OS << '\n'; 412 } 413 } 414 415 DWARFDebugFrame::DWARFDebugFrame() { 416 } 417 418 DWARFDebugFrame::~DWARFDebugFrame() { 419 } 420 421 static void LLVM_ATTRIBUTE_UNUSED dumpDataAux(DataExtractor Data, 422 uint32_t Offset, int Length) { 423 errs() << "DUMP: "; 424 for (int i = 0; i < Length; ++i) { 425 uint8_t c = Data.getU8(&Offset); 426 errs().write_hex(c); errs() << " "; 427 } 428 errs() << "\n"; 429 } 430 431 432 void DWARFDebugFrame::parse(DataExtractor Data) { 433 uint32_t Offset = 0; 434 DenseMap<uint32_t, CIE *> CIEs; 435 436 while (Data.isValidOffset(Offset)) { 437 uint32_t StartOffset = Offset; 438 439 bool IsDWARF64 = false; 440 uint64_t Length = Data.getU32(&Offset); 441 uint64_t Id; 442 443 if (Length == UINT32_MAX) { 444 // DWARF-64 is distinguished by the first 32 bits of the initial length 445 // field being 0xffffffff. Then, the next 64 bits are the actual entry 446 // length. 447 IsDWARF64 = true; 448 Length = Data.getU64(&Offset); 449 } 450 451 // At this point, Offset points to the next field after Length. 452 // Length is the structure size excluding itself. Compute an offset one 453 // past the end of the structure (needed to know how many instructions to 454 // read). 455 // TODO: For honest DWARF64 support, DataExtractor will have to treat 456 // offset_ptr as uint64_t* 457 uint32_t EndStructureOffset = Offset + static_cast<uint32_t>(Length); 458 459 // The Id field's size depends on the DWARF format 460 Id = Data.getUnsigned(&Offset, IsDWARF64 ? 8 : 4); 461 bool IsCIE = ((IsDWARF64 && Id == DW64_CIE_ID) || Id == DW_CIE_ID); 462 463 if (IsCIE) { 464 // Note: this is specifically DWARFv3 CIE header structure. It was 465 // changed in DWARFv4. We currently don't support reading DWARFv4 466 // here because LLVM itself does not emit it (and LLDB doesn't 467 // support it either). 468 uint8_t Version = Data.getU8(&Offset); 469 const char *Augmentation = Data.getCStr(&Offset); 470 uint64_t CodeAlignmentFactor = Data.getULEB128(&Offset); 471 int64_t DataAlignmentFactor = Data.getSLEB128(&Offset); 472 uint64_t ReturnAddressRegister = Data.getULEB128(&Offset); 473 474 auto Cie = make_unique<CIE>(StartOffset, Length, Version, 475 StringRef(Augmentation), CodeAlignmentFactor, 476 DataAlignmentFactor, ReturnAddressRegister); 477 CIEs[StartOffset] = Cie.get(); 478 Entries.emplace_back(std::move(Cie)); 479 } else { 480 // FDE 481 uint64_t CIEPointer = Id; 482 uint64_t InitialLocation = Data.getAddress(&Offset); 483 uint64_t AddressRange = Data.getAddress(&Offset); 484 485 Entries.emplace_back(new FDE(StartOffset, Length, CIEPointer, 486 InitialLocation, AddressRange, 487 CIEs[CIEPointer])); 488 } 489 490 Entries.back()->parseInstructions(Data, &Offset, EndStructureOffset); 491 492 if (Offset != EndStructureOffset) { 493 std::string Str; 494 raw_string_ostream OS(Str); 495 OS << format("Parsing entry instructions at %lx failed", StartOffset); 496 report_fatal_error(Str); 497 } 498 } 499 } 500 501 502 void DWARFDebugFrame::dump(raw_ostream &OS) const { 503 OS << "\n"; 504 for (const auto &Entry : Entries) { 505 Entry->dumpHeader(OS); 506 Entry->dumpInstructions(OS); 507 OS << "\n"; 508 } 509 } 510 511