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