1 //===--- ARMEHABIPrinter.h - ARM EHABI Unwind Information Printer ----------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #ifndef LLVM_TOOLS_LLVM_READOBJ_ARMEHABIPRINTER_H
11 #define LLVM_TOOLS_LLVM_READOBJ_ARMEHABIPRINTER_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"
35 void (OpcodeDecoder::*Routine)(const uint8_t *Opcodes, unsigned &OI);
37 static const RingEntry Ring[];
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);
62 void PrintGPR(uint16_t GPRMask);
63 void PrintRegisters(uint32_t Mask, StringRef Prefix);
66 OpcodeDecoder(StreamWriter &SW) : SW(SW), OS(SW.getOStream()) {}
67 void Decode(const uint8_t *Opcodes, off_t Offset, size_t Length);
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 },
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);
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);
105 void OpcodeDecoder::Decode_1000iiii_iiiiiiii(const uint8_t *Opcodes,
107 uint8_t Opcode0 = Opcodes[OI++ ^ 3];
108 uint8_t Opcode1 = Opcodes[OI++ ^ 3];
110 uint16_t GPRMask = (Opcode1 << 4) | ((Opcode0 & 0x0f) << 12);
112 << format("0x%02X 0x%02X ; %s",
113 Opcode0, Opcode1, GPRMask ? "pop " : "refuse to unwind");
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);
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);
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));
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));
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));
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);
146 void OpcodeDecoder::Decode_10110001_0000iiii(const uint8_t *Opcodes,
148 uint8_t Opcode0 = Opcodes[OI++ ^ 3];
149 uint8_t Opcode1 = Opcodes[OI++ ^ 3];
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));
158 void OpcodeDecoder::Decode_10110010_uleb128(const uint8_t *Opcodes,
160 uint8_t Opcode = Opcodes[OI++ ^ 3];
161 SW.startLine() << format("0x%02X ", Opcode);
163 SmallVector<uint8_t, 4> ULEB;
164 do { ULEB.push_back(Opcodes[OI ^ 3]); } while (Opcodes[OI++ ^ 3] & 0x80);
166 for (unsigned BI = 0, BE = ULEB.size(); BI != BE; ++BI)
167 OS << format("0x%02X ", ULEB[BI]);
170 for (unsigned BI = 0, BE = ULEB.size(); BI != BE; ++BI)
171 Value = Value | ((ULEB[BI] & 0x7f) << (7 * BI));
173 OS << format("; vsp = vsp + %" PRIu64 "\n", 0x204 + (Value << 2));
175 void OpcodeDecoder::Decode_10110011_sssscccc(const uint8_t *Opcodes,
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");
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);
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");
195 void OpcodeDecoder::Decode_11000110_sssscccc(const uint8_t *Opcodes,
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");
205 void OpcodeDecoder::Decode_11000111_0000iiii(const uint8_t *Opcodes,
207 uint8_t Opcode0 = Opcodes[OI++ ^ 3];
208 uint8_t Opcode1 = Opcodes[OI++ ^ 3];
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");
216 void OpcodeDecoder::Decode_11001000_sssscccc(const uint8_t *Opcodes,
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");
226 void OpcodeDecoder::Decode_11001001_sssscccc(const uint8_t *Opcodes,
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");
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);
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");
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");
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);
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"
265 for (unsigned RI = 0, RE = 17; RI < RE; ++RI) {
266 if (GPRMask & (1 << RI)) {
269 OS << GPRRegisterNames[RI];
276 void OpcodeDecoder::PrintRegisters(uint32_t VFPMask, StringRef Prefix) {
279 for (unsigned RI = 0, RE = 32; RI < RE; ++RI) {
280 if (VFPMask & (1 << RI)) {
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);
302 SW.startLine() << format("0x%02X ; reserved\n", Opcodes[OCI++ ^ 3]);
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;
314 const object::ELFFile<ET> *ELF;
315 const Elf_Shdr *Symtab;
316 ArrayRef<Elf_Word> ShndxTable;
318 static const size_t IndexTableEntrySize;
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;
327 ErrorOr<StringRef> FunctionAtAddress(unsigned Section, uint64_t Address) const;
328 const Elf_Shdr *FindExceptionTable(unsigned IndexTableIndex,
329 off_t IndexTableOffset) const;
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;
337 PrinterContext(StreamWriter &SW, const object::ELFFile<ET> *ELF,
338 const Elf_Shdr *Symtab)
339 : SW(SW), ELF(ELF), Symtab(Symtab) {}
341 void PrintUnwindInformation() const;
344 template <typename ET>
345 const size_t PrinterContext<ET>::IndexTableEntrySize = 8;
347 template <typename ET>
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;
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;
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
374 for (const Elf_Shdr &Sec : ELF->sections()) {
375 if (Sec.sh_type != ELF::SHT_REL || Sec.sh_info != IndexSectionIndex)
378 ErrorOr<const Elf_Shdr *> SymTabOrErr = ELF->getSection(Sec.sh_link);
379 error(SymTabOrErr.getError());
380 const Elf_Shdr *SymTab = *SymTabOrErr;
382 for (const Elf_Rel &R : ELF->rels(&Sec)) {
383 if (R.r_offset != static_cast<unsigned>(IndexTableOffset))
386 typename object::ELFFile<ET>::Elf_Rela RelA;
387 RelA.r_offset = R.r_offset;
388 RelA.r_info = R.r_info;
391 const Elf_Sym *Symbol = ELF->getRelocationSymbol(&RelA, SymTab);
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());
403 template <typename ET>
404 void PrinterContext<ET>::PrintExceptionTable(const Elf_Shdr *IT,
406 uint64_t TableEntryOffset) const {
407 ErrorOr<ArrayRef<uint8_t> > Contents = ELF->getSectionContents(EHT);
411 /// ARM EHABI Section 6.2 - The generic model
413 /// An exception-handling table entry for the generic model is laid out as:
417 /// +-+------------------------------+
418 /// |0| personality routine offset |
419 /// +-+------------------------------+
420 /// | personality routine data ... |
423 /// ARM EHABI Section 6.3 - The ARM-defined compact model
425 /// An exception-handling table entry for the compact model looks like:
429 /// +-+---+----+-----------------------+
430 /// |1| 0 | Ix | data for pers routine |
431 /// +-+---+----+-----------------------+
432 /// | more personality routine data |
434 const support::ulittle32_t Word =
435 *reinterpret_cast<const support::ulittle32_t *>(Contents->data() + TableEntryOffset);
437 if (Word & 0x80000000) {
438 SW.printString("Model", StringRef("Compact"));
440 unsigned PersonalityIndex = (Word & 0x0f000000) >> 24;
441 SW.printNumber("PersonalityIndex", PersonalityIndex);
443 switch (PersonalityIndex) {
444 case AEABI_UNWIND_CPP_PR0:
445 PrintOpcodes(Contents->data() + TableEntryOffset, 3, 1);
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,
455 SW.printString("Model", StringRef("Generic"));
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);
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);
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);
478 /// ARM EHABI Section 5 - Index Table Entries
479 /// * The first word contains a PREL31 offset to the start of a function with
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
488 const support::ulittle32_t *Data =
489 reinterpret_cast<const support::ulittle32_t *>(Contents->data());
490 const unsigned Entries = IT->sh_size / IndexTableEntrySize;
492 ListScope E(SW, "Entries");
493 for (unsigned Entry = 0; Entry < Entries; ++Entry) {
494 DictScope E(SW, "Entry");
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];
501 if (Word0 & 0x80000000) {
502 errs() << "corrupt unwind data in section " << SectionIndex << "\n";
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);
511 if (Word1 == EXIDX_CANTUNWIND) {
512 SW.printString("Model", StringRef("CantUnwind"));
516 if (Word1 & 0x80000000) {
517 SW.printString("Model", StringRef("Compact (Inline)"));
519 unsigned PersonalityIndex = (Word1 & 0x0f000000) >> 24;
520 SW.printNumber("PersonalityIndex", PersonalityIndex);
522 PrintOpcodes(Contents->data() + Entry * IndexTableEntrySize + 4, 3, 1);
524 const Elf_Shdr *EHT =
525 FindExceptionTable(SectionIndex, Entry * IndexTableEntrySize + 4);
527 if (ErrorOr<StringRef> Name = ELF->getSectionName(EHT))
528 SW.printString("ExceptionHandlingTable", *Name);
530 uint64_t TableEntryOffset = PREL31(Word1, IT->sh_addr);
531 SW.printHex("TableEntryOffset", TableEntryOffset);
533 PrintExceptionTable(IT, EHT, TableEntryOffset);
538 template <typename ET>
539 void PrinterContext<ET>::PrintUnwindInformation() const {
540 DictScope UI(SW, "UnwindInformation");
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");
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);
552 PrintIndexTable(SectionIndex, &Sec);