1 //===--- ARMEHABIPrinter.h - ARM EHABI Unwind Information Printer ----------===// 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 #ifndef LLVM_TOOLS_LLVM_READOBJ_ARMEHABIPRINTER_H 10 #define LLVM_TOOLS_LLVM_READOBJ_ARMEHABIPRINTER_H 11 12 #include "Error.h" 13 #include "llvm-readobj.h" 14 #include "llvm/ADT/STLExtras.h" 15 #include "llvm/Object/ELF.h" 16 #include "llvm/Object/ELFTypes.h" 17 #include "llvm/Support/ARMEHABI.h" 18 #include "llvm/Support/Debug.h" 19 #include "llvm/Support/Endian.h" 20 #include "llvm/Support/Format.h" 21 #include "llvm/Support/ScopedPrinter.h" 22 #include "llvm/Support/type_traits.h" 23 24 namespace llvm { 25 namespace ARM { 26 namespace EHABI { 27 28 class OpcodeDecoder { 29 ScopedPrinter &SW; 30 raw_ostream &OS; 31 32 struct RingEntry { 33 uint8_t Mask; 34 uint8_t Value; 35 void (OpcodeDecoder::*Routine)(const uint8_t *Opcodes, unsigned &OI); 36 }; 37 static ArrayRef<RingEntry> ring(); 38 39 void Decode_00xxxxxx(const uint8_t *Opcodes, unsigned &OI); 40 void Decode_01xxxxxx(const uint8_t *Opcodes, unsigned &OI); 41 void Decode_1000iiii_iiiiiiii(const uint8_t *Opcodes, unsigned &OI); 42 void Decode_10011101(const uint8_t *Opcodes, unsigned &OI); 43 void Decode_10011111(const uint8_t *Opcodes, unsigned &OI); 44 void Decode_1001nnnn(const uint8_t *Opcodes, unsigned &OI); 45 void Decode_10100nnn(const uint8_t *Opcodes, unsigned &OI); 46 void Decode_10101nnn(const uint8_t *Opcodes, unsigned &OI); 47 void Decode_10110000(const uint8_t *Opcodes, unsigned &OI); 48 void Decode_10110001_0000iiii(const uint8_t *Opcodes, unsigned &OI); 49 void Decode_10110010_uleb128(const uint8_t *Opcodes, unsigned &OI); 50 void Decode_10110011_sssscccc(const uint8_t *Opcodes, unsigned &OI); 51 void Decode_101101nn(const uint8_t *Opcodes, unsigned &OI); 52 void Decode_10111nnn(const uint8_t *Opcodes, unsigned &OI); 53 void Decode_11000110_sssscccc(const uint8_t *Opcodes, unsigned &OI); 54 void Decode_11000111_0000iiii(const uint8_t *Opcodes, unsigned &OI); 55 void Decode_11001000_sssscccc(const uint8_t *Opcodes, unsigned &OI); 56 void Decode_11001001_sssscccc(const uint8_t *Opcodes, unsigned &OI); 57 void Decode_11001yyy(const uint8_t *Opcodes, unsigned &OI); 58 void Decode_11000nnn(const uint8_t *Opcodes, unsigned &OI); 59 void Decode_11010nnn(const uint8_t *Opcodes, unsigned &OI); 60 void Decode_11xxxyyy(const uint8_t *Opcodes, unsigned &OI); 61 62 void PrintGPR(uint16_t GPRMask); 63 void PrintRegisters(uint32_t Mask, StringRef Prefix); 64 65 public: 66 OpcodeDecoder(ScopedPrinter &SW) : SW(SW), OS(SW.getOStream()) {} 67 void Decode(const uint8_t *Opcodes, off_t Offset, size_t Length); 68 }; 69 70 inline ArrayRef<OpcodeDecoder::RingEntry> OpcodeDecoder::ring() { 71 static const OpcodeDecoder::RingEntry Ring[] = { 72 {0xc0, 0x00, &OpcodeDecoder::Decode_00xxxxxx}, 73 {0xc0, 0x40, &OpcodeDecoder::Decode_01xxxxxx}, 74 {0xf0, 0x80, &OpcodeDecoder::Decode_1000iiii_iiiiiiii}, 75 {0xff, 0x9d, &OpcodeDecoder::Decode_10011101}, 76 {0xff, 0x9f, &OpcodeDecoder::Decode_10011111}, 77 {0xf0, 0x90, &OpcodeDecoder::Decode_1001nnnn}, 78 {0xf8, 0xa0, &OpcodeDecoder::Decode_10100nnn}, 79 {0xf8, 0xa8, &OpcodeDecoder::Decode_10101nnn}, 80 {0xff, 0xb0, &OpcodeDecoder::Decode_10110000}, 81 {0xff, 0xb1, &OpcodeDecoder::Decode_10110001_0000iiii}, 82 {0xff, 0xb2, &OpcodeDecoder::Decode_10110010_uleb128}, 83 {0xff, 0xb3, &OpcodeDecoder::Decode_10110011_sssscccc}, 84 {0xfc, 0xb4, &OpcodeDecoder::Decode_101101nn}, 85 {0xf8, 0xb8, &OpcodeDecoder::Decode_10111nnn}, 86 {0xff, 0xc6, &OpcodeDecoder::Decode_11000110_sssscccc}, 87 {0xff, 0xc7, &OpcodeDecoder::Decode_11000111_0000iiii}, 88 {0xff, 0xc8, &OpcodeDecoder::Decode_11001000_sssscccc}, 89 {0xff, 0xc9, &OpcodeDecoder::Decode_11001001_sssscccc}, 90 {0xc8, 0xc8, &OpcodeDecoder::Decode_11001yyy}, 91 {0xf8, 0xc0, &OpcodeDecoder::Decode_11000nnn}, 92 {0xf8, 0xd0, &OpcodeDecoder::Decode_11010nnn}, 93 {0xc0, 0xc0, &OpcodeDecoder::Decode_11xxxyyy}, 94 }; 95 return makeArrayRef(Ring); 96 } 97 98 inline void OpcodeDecoder::Decode_00xxxxxx(const uint8_t *Opcodes, 99 unsigned &OI) { 100 uint8_t Opcode = Opcodes[OI++ ^ 3]; 101 SW.startLine() << format("0x%02X ; vsp = vsp + %u\n", Opcode, 102 ((Opcode & 0x3f) << 2) + 4); 103 } 104 inline void OpcodeDecoder::Decode_01xxxxxx(const uint8_t *Opcodes, 105 unsigned &OI) { 106 uint8_t Opcode = Opcodes[OI++ ^ 3]; 107 SW.startLine() << format("0x%02X ; vsp = vsp - %u\n", Opcode, 108 ((Opcode & 0x3f) << 2) + 4); 109 } 110 inline void OpcodeDecoder::Decode_1000iiii_iiiiiiii(const uint8_t *Opcodes, 111 unsigned &OI) { 112 uint8_t Opcode0 = Opcodes[OI++ ^ 3]; 113 uint8_t Opcode1 = Opcodes[OI++ ^ 3]; 114 115 uint16_t GPRMask = (Opcode1 << 4) | ((Opcode0 & 0x0f) << 12); 116 SW.startLine() 117 << format("0x%02X 0x%02X ; %s", 118 Opcode0, Opcode1, GPRMask ? "pop " : "refuse to unwind"); 119 if (GPRMask) 120 PrintGPR(GPRMask); 121 OS << '\n'; 122 } 123 inline void OpcodeDecoder::Decode_10011101(const uint8_t *Opcodes, 124 unsigned &OI) { 125 uint8_t Opcode = Opcodes[OI++ ^ 3]; 126 SW.startLine() << format("0x%02X ; reserved (ARM MOVrr)\n", Opcode); 127 } 128 inline void OpcodeDecoder::Decode_10011111(const uint8_t *Opcodes, 129 unsigned &OI) { 130 uint8_t Opcode = Opcodes[OI++ ^ 3]; 131 SW.startLine() << format("0x%02X ; reserved (WiMMX MOVrr)\n", Opcode); 132 } 133 inline void OpcodeDecoder::Decode_1001nnnn(const uint8_t *Opcodes, 134 unsigned &OI) { 135 uint8_t Opcode = Opcodes[OI++ ^ 3]; 136 SW.startLine() << format("0x%02X ; vsp = r%u\n", Opcode, (Opcode & 0x0f)); 137 } 138 inline void OpcodeDecoder::Decode_10100nnn(const uint8_t *Opcodes, 139 unsigned &OI) { 140 uint8_t Opcode = Opcodes[OI++ ^ 3]; 141 SW.startLine() << format("0x%02X ; pop ", Opcode); 142 PrintGPR((((1 << ((Opcode & 0x7) + 1)) - 1) << 4)); 143 OS << '\n'; 144 } 145 inline void OpcodeDecoder::Decode_10101nnn(const uint8_t *Opcodes, 146 unsigned &OI) { 147 uint8_t Opcode = Opcodes[OI++ ^ 3]; 148 SW.startLine() << format("0x%02X ; pop ", Opcode); 149 PrintGPR((((1 << ((Opcode & 0x7) + 1)) - 1) << 4) | (1 << 14)); 150 OS << '\n'; 151 } 152 inline void OpcodeDecoder::Decode_10110000(const uint8_t *Opcodes, 153 unsigned &OI) { 154 uint8_t Opcode = Opcodes[OI++ ^ 3]; 155 SW.startLine() << format("0x%02X ; finish\n", Opcode); 156 } 157 inline void OpcodeDecoder::Decode_10110001_0000iiii(const uint8_t *Opcodes, 158 unsigned &OI) { 159 uint8_t Opcode0 = Opcodes[OI++ ^ 3]; 160 uint8_t Opcode1 = Opcodes[OI++ ^ 3]; 161 162 SW.startLine() 163 << format("0x%02X 0x%02X ; %s", Opcode0, Opcode1, 164 ((Opcode1 & 0xf0) || Opcode1 == 0x00) ? "spare" : "pop "); 165 if (((Opcode1 & 0xf0) == 0x00) && Opcode1) 166 PrintGPR((Opcode1 & 0x0f)); 167 OS << '\n'; 168 } 169 inline void OpcodeDecoder::Decode_10110010_uleb128(const uint8_t *Opcodes, 170 unsigned &OI) { 171 uint8_t Opcode = Opcodes[OI++ ^ 3]; 172 SW.startLine() << format("0x%02X ", Opcode); 173 174 SmallVector<uint8_t, 4> ULEB; 175 do { ULEB.push_back(Opcodes[OI ^ 3]); } while (Opcodes[OI++ ^ 3] & 0x80); 176 177 for (unsigned BI = 0, BE = ULEB.size(); BI != BE; ++BI) 178 OS << format("0x%02X ", ULEB[BI]); 179 180 uint64_t Value = 0; 181 for (unsigned BI = 0, BE = ULEB.size(); BI != BE; ++BI) 182 Value = Value | ((ULEB[BI] & 0x7f) << (7 * BI)); 183 184 OS << format("; vsp = vsp + %" PRIu64 "\n", 0x204 + (Value << 2)); 185 } 186 inline void OpcodeDecoder::Decode_10110011_sssscccc(const uint8_t *Opcodes, 187 unsigned &OI) { 188 uint8_t Opcode0 = Opcodes[OI++ ^ 3]; 189 uint8_t Opcode1 = Opcodes[OI++ ^ 3]; 190 SW.startLine() << format("0x%02X 0x%02X ; pop ", Opcode0, Opcode1); 191 uint8_t Start = ((Opcode1 & 0xf0) >> 4); 192 uint8_t Count = ((Opcode1 & 0x0f) >> 0); 193 PrintRegisters((((1 << (Count + 1)) - 1) << Start), "d"); 194 OS << '\n'; 195 } 196 inline void OpcodeDecoder::Decode_101101nn(const uint8_t *Opcodes, 197 unsigned &OI) { 198 uint8_t Opcode = Opcodes[OI++ ^ 3]; 199 SW.startLine() << format("0x%02X ; spare\n", Opcode); 200 } 201 inline void OpcodeDecoder::Decode_10111nnn(const uint8_t *Opcodes, 202 unsigned &OI) { 203 uint8_t Opcode = Opcodes[OI++ ^ 3]; 204 SW.startLine() << format("0x%02X ; pop ", Opcode); 205 PrintRegisters((((1 << ((Opcode & 0x07) + 1)) - 1) << 8), "d"); 206 OS << '\n'; 207 } 208 inline void OpcodeDecoder::Decode_11000110_sssscccc(const uint8_t *Opcodes, 209 unsigned &OI) { 210 uint8_t Opcode0 = Opcodes[OI++ ^ 3]; 211 uint8_t Opcode1 = Opcodes[OI++ ^ 3]; 212 SW.startLine() << format("0x%02X 0x%02X ; pop ", Opcode0, Opcode1); 213 uint8_t Start = ((Opcode1 & 0xf0) >> 4); 214 uint8_t Count = ((Opcode1 & 0x0f) >> 0); 215 PrintRegisters((((1 << (Count + 1)) - 1) << Start), "wR"); 216 OS << '\n'; 217 } 218 inline void OpcodeDecoder::Decode_11000111_0000iiii(const uint8_t *Opcodes, 219 unsigned &OI) { 220 uint8_t Opcode0 = Opcodes[OI++ ^ 3]; 221 uint8_t Opcode1 = Opcodes[OI++ ^ 3]; 222 SW.startLine() 223 << format("0x%02X 0x%02X ; %s", Opcode0, Opcode1, 224 ((Opcode1 & 0xf0) || Opcode1 == 0x00) ? "spare" : "pop "); 225 if ((Opcode1 & 0xf0) == 0x00 && Opcode1) 226 PrintRegisters(Opcode1 & 0x0f, "wCGR"); 227 OS << '\n'; 228 } 229 inline void OpcodeDecoder::Decode_11001000_sssscccc(const uint8_t *Opcodes, 230 unsigned &OI) { 231 uint8_t Opcode0 = Opcodes[OI++ ^ 3]; 232 uint8_t Opcode1 = Opcodes[OI++ ^ 3]; 233 SW.startLine() << format("0x%02X 0x%02X ; pop ", Opcode0, Opcode1); 234 uint8_t Start = 16 + ((Opcode1 & 0xf0) >> 4); 235 uint8_t Count = ((Opcode1 & 0x0f) >> 0); 236 PrintRegisters((((1 << (Count + 1)) - 1) << Start), "d"); 237 OS << '\n'; 238 } 239 inline void OpcodeDecoder::Decode_11001001_sssscccc(const uint8_t *Opcodes, 240 unsigned &OI) { 241 uint8_t Opcode0 = Opcodes[OI++ ^ 3]; 242 uint8_t Opcode1 = Opcodes[OI++ ^ 3]; 243 SW.startLine() << format("0x%02X 0x%02X ; pop ", Opcode0, Opcode1); 244 uint8_t Start = ((Opcode1 & 0xf0) >> 4); 245 uint8_t Count = ((Opcode1 & 0x0f) >> 0); 246 PrintRegisters((((1 << (Count + 1)) - 1) << Start), "d"); 247 OS << '\n'; 248 } 249 inline void OpcodeDecoder::Decode_11001yyy(const uint8_t *Opcodes, 250 unsigned &OI) { 251 uint8_t Opcode = Opcodes[OI++ ^ 3]; 252 SW.startLine() << format("0x%02X ; spare\n", Opcode); 253 } 254 inline void OpcodeDecoder::Decode_11000nnn(const uint8_t *Opcodes, 255 unsigned &OI) { 256 uint8_t Opcode = Opcodes[OI++ ^ 3]; 257 SW.startLine() << format("0x%02X ; pop ", Opcode); 258 PrintRegisters((((1 << ((Opcode & 0x07) + 1)) - 1) << 10), "wR"); 259 OS << '\n'; 260 } 261 inline void OpcodeDecoder::Decode_11010nnn(const uint8_t *Opcodes, 262 unsigned &OI) { 263 uint8_t Opcode = Opcodes[OI++ ^ 3]; 264 SW.startLine() << format("0x%02X ; pop ", Opcode); 265 PrintRegisters((((1 << ((Opcode & 0x07) + 1)) - 1) << 8), "d"); 266 OS << '\n'; 267 } 268 inline void OpcodeDecoder::Decode_11xxxyyy(const uint8_t *Opcodes, 269 unsigned &OI) { 270 uint8_t Opcode = Opcodes[OI++ ^ 3]; 271 SW.startLine() << format("0x%02X ; spare\n", Opcode); 272 } 273 274 inline void OpcodeDecoder::PrintGPR(uint16_t GPRMask) { 275 static const char *GPRRegisterNames[16] = { 276 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10", 277 "fp", "ip", "sp", "lr", "pc" 278 }; 279 280 OS << '{'; 281 bool Comma = false; 282 for (unsigned RI = 0, RE = 17; RI < RE; ++RI) { 283 if (GPRMask & (1 << RI)) { 284 if (Comma) 285 OS << ", "; 286 OS << GPRRegisterNames[RI]; 287 Comma = true; 288 } 289 } 290 OS << '}'; 291 } 292 293 inline void OpcodeDecoder::PrintRegisters(uint32_t VFPMask, StringRef Prefix) { 294 OS << '{'; 295 bool Comma = false; 296 for (unsigned RI = 0, RE = 32; RI < RE; ++RI) { 297 if (VFPMask & (1 << RI)) { 298 if (Comma) 299 OS << ", "; 300 OS << Prefix << RI; 301 Comma = true; 302 } 303 } 304 OS << '}'; 305 } 306 307 inline void OpcodeDecoder::Decode(const uint8_t *Opcodes, off_t Offset, 308 size_t Length) { 309 for (unsigned OCI = Offset; OCI < Length + Offset; ) { 310 bool Decoded = false; 311 for (const auto &RE : ring()) { 312 if ((Opcodes[OCI ^ 3] & RE.Mask) == RE.Value) { 313 (this->*RE.Routine)(Opcodes, OCI); 314 Decoded = true; 315 break; 316 } 317 } 318 if (!Decoded) 319 SW.startLine() << format("0x%02X ; reserved\n", Opcodes[OCI++ ^ 3]); 320 } 321 } 322 323 template <typename ET> 324 class PrinterContext { 325 typedef typename ET::Sym Elf_Sym; 326 typedef typename ET::Shdr Elf_Shdr; 327 typedef typename ET::Rel Elf_Rel; 328 typedef typename ET::Word Elf_Word; 329 330 ScopedPrinter &SW; 331 const object::ELFFile<ET> *ELF; 332 const Elf_Shdr *Symtab; 333 ArrayRef<Elf_Word> ShndxTable; 334 335 static const size_t IndexTableEntrySize; 336 337 static uint64_t PREL31(uint32_t Address, uint32_t Place) { 338 uint64_t Location = Address & 0x7fffffff; 339 if (Location & 0x04000000) 340 Location |= (uint64_t) ~0x7fffffff; 341 return Location + Place; 342 } 343 344 ErrorOr<StringRef> FunctionAtAddress(unsigned Section, uint64_t Address) const; 345 const Elf_Shdr *FindExceptionTable(unsigned IndexTableIndex, 346 off_t IndexTableOffset) const; 347 348 void PrintIndexTable(unsigned SectionIndex, const Elf_Shdr *IT) const; 349 void PrintExceptionTable(const Elf_Shdr *IT, const Elf_Shdr *EHT, 350 uint64_t TableEntryOffset) const; 351 void PrintOpcodes(const uint8_t *Entry, size_t Length, off_t Offset) const; 352 353 public: 354 PrinterContext(ScopedPrinter &SW, const object::ELFFile<ET> *ELF, 355 const Elf_Shdr *Symtab) 356 : SW(SW), ELF(ELF), Symtab(Symtab) {} 357 358 void PrintUnwindInformation() const; 359 }; 360 361 template <typename ET> 362 const size_t PrinterContext<ET>::IndexTableEntrySize = 8; 363 364 template <typename ET> 365 ErrorOr<StringRef> 366 PrinterContext<ET>::FunctionAtAddress(unsigned Section, 367 uint64_t Address) const { 368 if (!Symtab) 369 return readobj_error::unknown_symbol; 370 auto StrTableOrErr = ELF->getStringTableForSymtab(*Symtab); 371 if (!StrTableOrErr) 372 error(StrTableOrErr.takeError()); 373 StringRef StrTable = *StrTableOrErr; 374 375 for (const Elf_Sym &Sym : unwrapOrError(ELF->symbols(Symtab))) 376 if (Sym.st_shndx == Section && Sym.st_value == Address && 377 Sym.getType() == ELF::STT_FUNC) { 378 auto NameOrErr = Sym.getName(StrTable); 379 if (!NameOrErr) { 380 // TODO: Actually report errors helpfully. 381 consumeError(NameOrErr.takeError()); 382 return readobj_error::unknown_symbol; 383 } 384 return *NameOrErr; 385 } 386 return readobj_error::unknown_symbol; 387 } 388 389 template <typename ET> 390 const typename ET::Shdr * 391 PrinterContext<ET>::FindExceptionTable(unsigned IndexSectionIndex, 392 off_t IndexTableOffset) const { 393 /// Iterate through the sections, searching for the relocation section 394 /// associated with the unwind index table section specified by 395 /// IndexSectionIndex. Iterate the associated section searching for the 396 /// relocation associated with the index table entry specified by 397 /// IndexTableOffset. The symbol is the section symbol for the exception 398 /// handling table. Use this symbol to recover the actual exception handling 399 /// table. 400 401 for (const Elf_Shdr &Sec : unwrapOrError(ELF->sections())) { 402 if (Sec.sh_type != ELF::SHT_REL || Sec.sh_info != IndexSectionIndex) 403 continue; 404 405 auto SymTabOrErr = ELF->getSection(Sec.sh_link); 406 if (!SymTabOrErr) 407 error(SymTabOrErr.takeError()); 408 const Elf_Shdr *SymTab = *SymTabOrErr; 409 410 for (const Elf_Rel &R : unwrapOrError(ELF->rels(&Sec))) { 411 if (R.r_offset != static_cast<unsigned>(IndexTableOffset)) 412 continue; 413 414 typename ET::Rela RelA; 415 RelA.r_offset = R.r_offset; 416 RelA.r_info = R.r_info; 417 RelA.r_addend = 0; 418 419 const Elf_Sym *Symbol = 420 unwrapOrError(ELF->getRelocationSymbol(&RelA, SymTab)); 421 422 auto Ret = ELF->getSection(Symbol, SymTab, ShndxTable); 423 if (!Ret) 424 report_fatal_error(errorToErrorCode(Ret.takeError()).message()); 425 return *Ret; 426 } 427 } 428 return nullptr; 429 } 430 431 template <typename ET> 432 void PrinterContext<ET>::PrintExceptionTable(const Elf_Shdr *IT, 433 const Elf_Shdr *EHT, 434 uint64_t TableEntryOffset) const { 435 Expected<ArrayRef<uint8_t>> Contents = ELF->getSectionContents(EHT); 436 if (!Contents) 437 return; 438 439 /// ARM EHABI Section 6.2 - The generic model 440 /// 441 /// An exception-handling table entry for the generic model is laid out as: 442 /// 443 /// 3 3 444 /// 1 0 0 445 /// +-+------------------------------+ 446 /// |0| personality routine offset | 447 /// +-+------------------------------+ 448 /// | personality routine data ... | 449 /// 450 /// 451 /// ARM EHABI Section 6.3 - The ARM-defined compact model 452 /// 453 /// An exception-handling table entry for the compact model looks like: 454 /// 455 /// 3 3 2 2 2 2 456 /// 1 0 8 7 4 3 0 457 /// +-+---+----+-----------------------+ 458 /// |1| 0 | Ix | data for pers routine | 459 /// +-+---+----+-----------------------+ 460 /// | more personality routine data | 461 462 const support::ulittle32_t Word = 463 *reinterpret_cast<const support::ulittle32_t *>(Contents->data() + TableEntryOffset); 464 465 if (Word & 0x80000000) { 466 SW.printString("Model", StringRef("Compact")); 467 468 unsigned PersonalityIndex = (Word & 0x0f000000) >> 24; 469 SW.printNumber("PersonalityIndex", PersonalityIndex); 470 471 switch (PersonalityIndex) { 472 case AEABI_UNWIND_CPP_PR0: 473 PrintOpcodes(Contents->data() + TableEntryOffset, 3, 1); 474 break; 475 case AEABI_UNWIND_CPP_PR1: 476 case AEABI_UNWIND_CPP_PR2: 477 unsigned AdditionalWords = (Word & 0x00ff0000) >> 16; 478 PrintOpcodes(Contents->data() + TableEntryOffset, 2 + 4 * AdditionalWords, 479 2); 480 break; 481 } 482 } else { 483 SW.printString("Model", StringRef("Generic")); 484 485 uint64_t Address = PREL31(Word, EHT->sh_addr); 486 SW.printHex("PersonalityRoutineAddress", Address); 487 if (ErrorOr<StringRef> Name = FunctionAtAddress(EHT->sh_link, Address)) 488 SW.printString("PersonalityRoutineName", *Name); 489 } 490 } 491 492 template <typename ET> 493 void PrinterContext<ET>::PrintOpcodes(const uint8_t *Entry, 494 size_t Length, off_t Offset) const { 495 ListScope OCC(SW, "Opcodes"); 496 OpcodeDecoder(OCC.W).Decode(Entry, Offset, Length); 497 } 498 499 template <typename ET> 500 void PrinterContext<ET>::PrintIndexTable(unsigned SectionIndex, 501 const Elf_Shdr *IT) const { 502 Expected<ArrayRef<uint8_t>> Contents = ELF->getSectionContents(IT); 503 if (!Contents) 504 return; 505 506 /// ARM EHABI Section 5 - Index Table Entries 507 /// * The first word contains a PREL31 offset to the start of a function with 508 /// bit 31 clear 509 /// * The second word contains one of: 510 /// - The PREL31 offset of the start of the table entry for the function, 511 /// with bit 31 clear 512 /// - The exception-handling table entry itself with bit 31 set 513 /// - The special bit pattern EXIDX_CANTUNWIND, indicating that associated 514 /// frames cannot be unwound 515 516 const support::ulittle32_t *Data = 517 reinterpret_cast<const support::ulittle32_t *>(Contents->data()); 518 const unsigned Entries = IT->sh_size / IndexTableEntrySize; 519 520 ListScope E(SW, "Entries"); 521 for (unsigned Entry = 0; Entry < Entries; ++Entry) { 522 DictScope E(SW, "Entry"); 523 524 const support::ulittle32_t Word0 = 525 Data[Entry * (IndexTableEntrySize / sizeof(*Data)) + 0]; 526 const support::ulittle32_t Word1 = 527 Data[Entry * (IndexTableEntrySize / sizeof(*Data)) + 1]; 528 529 if (Word0 & 0x80000000) { 530 errs() << "corrupt unwind data in section " << SectionIndex << "\n"; 531 continue; 532 } 533 534 const uint64_t Offset = PREL31(Word0, IT->sh_addr); 535 SW.printHex("FunctionAddress", Offset); 536 if (ErrorOr<StringRef> Name = FunctionAtAddress(IT->sh_link, Offset)) 537 SW.printString("FunctionName", *Name); 538 539 if (Word1 == EXIDX_CANTUNWIND) { 540 SW.printString("Model", StringRef("CantUnwind")); 541 continue; 542 } 543 544 if (Word1 & 0x80000000) { 545 SW.printString("Model", StringRef("Compact (Inline)")); 546 547 unsigned PersonalityIndex = (Word1 & 0x0f000000) >> 24; 548 SW.printNumber("PersonalityIndex", PersonalityIndex); 549 550 PrintOpcodes(Contents->data() + Entry * IndexTableEntrySize + 4, 3, 1); 551 } else { 552 const Elf_Shdr *EHT = 553 FindExceptionTable(SectionIndex, Entry * IndexTableEntrySize + 4); 554 555 if (EHT) 556 if (auto Name = ELF->getSectionName(EHT)) 557 SW.printString("ExceptionHandlingTable", *Name); 558 559 uint64_t TableEntryOffset = PREL31(Word1, IT->sh_addr); 560 SW.printHex("TableEntryOffset", TableEntryOffset); 561 562 if (EHT) 563 PrintExceptionTable(IT, EHT, TableEntryOffset); 564 } 565 } 566 } 567 568 template <typename ET> 569 void PrinterContext<ET>::PrintUnwindInformation() const { 570 DictScope UI(SW, "UnwindInformation"); 571 572 int SectionIndex = 0; 573 for (const Elf_Shdr &Sec : unwrapOrError(ELF->sections())) { 574 if (Sec.sh_type == ELF::SHT_ARM_EXIDX) { 575 DictScope UIT(SW, "UnwindIndexTable"); 576 577 SW.printNumber("SectionIndex", SectionIndex); 578 if (auto SectionName = ELF->getSectionName(&Sec)) 579 SW.printString("SectionName", *SectionName); 580 SW.printHex("SectionOffset", Sec.sh_offset); 581 582 PrintIndexTable(SectionIndex, &Sec); 583 } 584 ++SectionIndex; 585 } 586 } 587 } 588 } 589 } 590 591 #endif 592