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_READOBJ_ARMEHABI_PRINTER_H
11 #define LLVM_READOBJ_ARMEHABI_PRINTER_H
13 #include "StreamWriter.h"
15 #include "llvm/Object/ELF.h"
16 #include "llvm/Object/ELFTypes.h"
17 #include "llvm/Support/ARMEHABI.h"
18 #include "llvm/Support/Endian.h"
19 #include "llvm/Support/type_traits.h"
24 template <typename ET>
25 class PrinterContext {
27 const object::ELFFile<ET> *ELF;
29 typedef typename object::ELFFile<ET>::Elf_Sym Elf_Sym;
30 typedef typename object::ELFFile<ET>::Elf_Shdr Elf_Shdr;
32 typedef typename object::ELFFile<ET>::Elf_Rel_Iter Elf_Rel_iterator;
33 typedef typename object::ELFFile<ET>::Elf_Sym_Iter Elf_Sym_iterator;
34 typedef typename object::ELFFile<ET>::Elf_Shdr_Iter Elf_Shdr_iterator;
36 static const size_t IndexTableEntrySize;
38 static uint64_t PREL31(uint32_t Address, uint32_t Place) {
39 uint64_t Location = Address & 0x7fffffff;
40 if (Location & 0x04000000)
41 Location |= (uint64_t) ~0x7fffffff;
42 return Location + Place;
45 ErrorOr<StringRef> FunctionAtAddress(unsigned Section, uint64_t Address) const;
46 const Elf_Shdr *FindExceptionTable(unsigned IndexTableIndex,
47 off_t IndexTableOffset) const;
49 void PrintIndexTable(unsigned SectionIndex, const Elf_Shdr *IT) const;
50 void PrintExceptionTable(const Elf_Shdr *IT, const Elf_Shdr *EHT,
51 uint64_t TableEntryOffset) const;
52 void PrintByteCode(const ArrayRef<uint8_t> ByteCode) const;
55 PrinterContext(StreamWriter &Writer, const object::ELFFile<ET> *File)
56 : SW(Writer), ELF(File) {}
58 void PrintUnwindInformation() const;
61 template <typename ET>
62 const size_t PrinterContext<ET>::IndexTableEntrySize = 8;
64 template <typename ET>
65 ErrorOr<StringRef> PrinterContext<ET>::FunctionAtAddress(unsigned Section,
66 uint64_t Address) const {
67 for (Elf_Sym_iterator SI = ELF->begin_symbols(), SE = ELF->end_symbols();
69 if (SI->st_shndx == Section && SI->st_value == Address &&
70 SI->getType() == ELF::STT_FUNC)
71 return ELF->getSymbolName(SI);
72 return readobj_error::unknown_symbol;
75 template <typename ET>
76 const typename object::ELFFile<ET>::Elf_Shdr *
77 PrinterContext<ET>::FindExceptionTable(unsigned IndexSectionIndex,
78 off_t IndexTableOffset) const {
79 /// Iterate through the sections, searching for the relocation section
80 /// associated with the unwind index table section specified by
81 /// IndexSectionIndex. Iterate the associated section searching for the
82 /// relocation associated with the index table entry specified by
83 /// IndexTableOffset. The symbol is the section symbol for the exception
84 /// handling table. Use this symbol to recover the actual exception handling
87 for (Elf_Shdr_iterator SI = ELF->begin_sections(), SE = ELF->end_sections();
89 if (SI->sh_type == ELF::SHT_REL && SI->sh_info == IndexSectionIndex) {
90 for (Elf_Rel_iterator RI = ELF->begin_rel(&*SI), RE = ELF->end_rel(&*SI);
92 if (RI->r_offset == IndexTableOffset) {
93 typename object::ELFFile<ET>::Elf_Rela RelA;
94 RelA.r_offset = RI->r_offset;
95 RelA.r_info = RI->r_info;
98 std::pair<const Elf_Shdr *, const Elf_Sym *> Symbol =
99 ELF->getRelocationSymbol(&(*SI), &RelA);
101 return ELF->getSection(Symbol.second);
109 template <typename ET>
110 void PrinterContext<ET>::PrintExceptionTable(const Elf_Shdr *IT,
112 uint64_t TableEntryOffset) const {
113 ErrorOr<ArrayRef<uint8_t> > Contents = ELF->getSectionContents(EHT);
117 /// ARM EHABI Section 6.2 - The generic model
119 /// An exception-handling table entry for the generic model is laid out as:
123 /// +-+------------------------------+
124 /// |0| personality routine offset |
125 /// +-+------------------------------+
126 /// | personality routine data ... |
129 /// ARM EHABI Section 6.3 - The ARM-defined compact model
131 /// An exception-handling table entry for the compact model looks like:
135 /// +-+---+----+-----------------------+
136 /// |1| 0 | Ix | data for pers routine |
137 /// +-+---+----+-----------------------+
138 /// | more personality routine data |
140 const support::ulittle32_t Word =
141 *reinterpret_cast<const support::ulittle32_t *>(Contents->data() + TableEntryOffset);
143 if (Word & 0x80000000) {
144 SW.printString("Model", StringRef("Compact"));
146 unsigned PersonalityIndex = (Word & 0x0f000000) >> 24;
147 SW.printNumber("PersonalityIndex", PersonalityIndex);
149 switch (PersonalityIndex) {
150 case AEABI_UNWIND_CPP_PR0:
151 PrintByteCode(Contents->slice(TableEntryOffset + 1, 3));
153 case AEABI_UNWIND_CPP_PR1:
154 case AEABI_UNWIND_CPP_PR2:
155 unsigned AdditionalWords = (Word & 0x00ff0000) >> 16;
157 SmallVector<uint8_t, 10> ByteCode;
158 ByteCode.reserve(2 + 4 * AdditionalWords);
160 for (unsigned WI = 1, WE = AdditionalWords; WI <= WE; ++WI)
161 ByteCode.append(Contents->data() + TableEntryOffset + 4 * WI,
162 Contents->data() + TableEntryOffset + 4 * WI + 4);
163 ByteCode.append(Contents->data() + TableEntryOffset,
164 Contents->data() + TableEntryOffset + 2);
166 PrintByteCode(ArrayRef<uint8_t>(ByteCode.begin(), ByteCode.end()));
170 SW.printString("Model", StringRef("Generic"));
172 uint64_t Address = PREL31(Word, EHT->sh_addr);
173 SW.printHex("PersonalityRoutineAddress", Address);
174 if (ErrorOr<StringRef> Name = FunctionAtAddress(EHT->sh_link, Address))
175 SW.printString("PersonalityRoutineName", *Name);
179 template <typename ET>
180 void PrinterContext<ET>::PrintByteCode(const ArrayRef<uint8_t> ByteCode) const {
181 ListScope BC(SW, "ByteCode");
182 for (unsigned BCI = 0, BCE = ByteCode.size(); BCI != BCE; ++BCI)
183 SW.printHex("Instruction", ByteCode[BCE - BCI - 1]);
186 template <typename ET>
187 void PrinterContext<ET>::PrintIndexTable(unsigned SectionIndex,
188 const Elf_Shdr *IT) const {
189 ErrorOr<ArrayRef<uint8_t> > Contents = ELF->getSectionContents(IT);
193 /// ARM EHABI Section 5 - Index Table Entries
194 /// * The first word contains a PREL31 offset to the start of a function with
196 /// * The second word contains one of:
197 /// - The PREL31 offset of the start of the table entry for the function,
198 /// with bit 31 clear
199 /// - The exception-handling table entry itself with bit 31 set
200 /// - The special bit pattern EXIDX_CANTUNWIND, indicating that associated
201 /// frames cannot be unwound
203 const support::ulittle32_t *Data =
204 reinterpret_cast<const support::ulittle32_t *>(Contents->data());
205 const unsigned Entries = IT->sh_size / IndexTableEntrySize;
207 ListScope E(SW, "Entries");
208 for (unsigned Entry = 0; Entry < Entries; ++Entry) {
209 DictScope E(SW, "Entry");
211 const support::ulittle32_t Word0 =
212 Data[Entry * (IndexTableEntrySize / sizeof(*Data)) + 0];
213 const support::ulittle32_t Word1 =
214 Data[Entry * (IndexTableEntrySize / sizeof(*Data)) + 1];
216 if (Word0 & 0x80000000) {
217 errs() << "corrupt unwind data in section " << SectionIndex << "\n";
221 const uint64_t Offset = PREL31(Word0, IT->sh_addr);
222 SW.printHex("FunctionAddress", Offset);
223 if (ErrorOr<StringRef> Name = FunctionAtAddress(IT->sh_link, Offset))
224 SW.printString("FunctionName", *Name);
226 if (Word1 == EXIDX_CANTUNWIND) {
227 SW.printString("Model", StringRef("CantUnwind"));
231 if (Word1 & 0x80000000) {
232 SW.printString("Model", StringRef("Compact (Inline)"));
234 unsigned PersonalityIndex = (Word1 & 0x0f000000) >> 24;
235 SW.printNumber("PersonalityIndex", PersonalityIndex);
237 PrintByteCode(Contents->slice(Entry * IndexTableEntrySize + 4, 3));
239 const Elf_Shdr *EHT =
240 FindExceptionTable(SectionIndex, Entry * IndexTableEntrySize + 4);
242 if (ErrorOr<StringRef> Name = ELF->getSectionName(EHT))
243 SW.printString("ExceptionHandlingTable", *Name);
245 uint64_t TableEntryOffset = PREL31(Word1, IT->sh_addr);
246 SW.printHex("TableEntryOffset", TableEntryOffset);
248 PrintExceptionTable(IT, EHT, TableEntryOffset);
253 template <typename ET>
254 void PrinterContext<ET>::PrintUnwindInformation() const {
255 DictScope UI(SW, "UnwindInformation");
257 int SectionIndex = 0;
258 for (Elf_Shdr_iterator SI = ELF->begin_sections(), SE = ELF->end_sections();
259 SI != SE; ++SI, ++SectionIndex) {
260 if (SI->sh_type == ELF::SHT_ARM_EXIDX) {
261 const Elf_Shdr *IT = &(*SI);
263 DictScope UIT(SW, "UnwindIndexTable");
265 SW.printNumber("SectionIndex", SectionIndex);
266 if (ErrorOr<StringRef> SectionName = ELF->getSectionName(IT))
267 SW.printString("SectionName", *SectionName);
268 SW.printHex("SectionOffset", IT->sh_offset);
270 PrintIndexTable(SectionIndex, IT);