2 files changed, 291 insertions, 0 deletions

diff --git a/tools/llvm-readobj/ARMEHABIPrinter.h b/tools/llvm-readobj/ARMEHABIPrinter.h
new file mode 100644
index 0000000000..f6c14b9610
--- /dev/null
+++ b/tools/llvm-readobj/ARMEHABIPrinter.h
@@ -0,0 +1,278 @@
+//===--- ARMEHABIPrinter.h - ARM EHABI Unwind Information Printer ----------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_READOBJ_ARMEHABI_PRINTER_H
+#define LLVM_READOBJ_ARMEHABI_PRINTER_H
+
+#include "StreamWriter.h"
+
+#include "llvm/Object/ELF.h"
+#include "llvm/Object/ELFTypes.h"
+#include "llvm/Support/ARMEHABI.h"
+#include "llvm/Support/Endian.h"
+#include "llvm/Support/type_traits.h"
+
+namespace llvm {
+namespace ARM {
+namespace EHABI {
+template <typename ET>
+class PrinterContext {
+  StreamWriter &SW;
+  const object::ELFFile<ET> *ELF;
+
+  typedef typename object::ELFFile<ET>::Elf_Sym Elf_Sym;
+  typedef typename object::ELFFile<ET>::Elf_Shdr Elf_Shdr;
+
+  typedef typename object::ELFFile<ET>::Elf_Rel_Iter Elf_Rel_iterator;
+  typedef typename object::ELFFile<ET>::Elf_Sym_Iter Elf_Sym_iterator;
+  typedef typename object::ELFFile<ET>::Elf_Shdr_Iter Elf_Shdr_iterator;
+
+  static const size_t IndexTableEntrySize;
+
+  static uint64_t PREL31(uint32_t Address, uint32_t Place) {
+    uint64_t Location = Address & 0x7fffffff;
+    if (Location & 0x04000000)
+      Location |= (uint64_t) ~0x7fffffff;
+    return Location + Place;
+  }
+
+  ErrorOr<StringRef> FunctionAtAddress(unsigned Section, uint64_t Address) const;
+  const Elf_Shdr *FindExceptionTable(unsigned IndexTableIndex,
+                                     off_t IndexTableOffset) const;
+
+  void PrintIndexTable(unsigned SectionIndex, const Elf_Shdr *IT) const;
+  void PrintExceptionTable(const Elf_Shdr *IT, const Elf_Shdr *EHT,
+                           uint64_t TableEntryOffset) const;
+  void PrintByteCode(const ArrayRef<uint8_t> ByteCode) const;
+
+public:
+  PrinterContext(StreamWriter &Writer, const object::ELFFile<ET> *File)
+    : SW(Writer), ELF(File) {}
+
+  void PrintUnwindInformation() const;
+};
+
+template <typename ET>
+const size_t PrinterContext<ET>::IndexTableEntrySize = 8;
+
+template <typename ET>
+ErrorOr<StringRef> PrinterContext<ET>::FunctionAtAddress(unsigned Section,
+                                                         uint64_t Address) const {
+  for (Elf_Sym_iterator SI = ELF->begin_symbols(), SE = ELF->end_symbols();
+       SI != SE; ++SI)
+    if (SI->st_shndx == Section && SI->st_value == Address &&
+        SI->getType() == ELF::STT_FUNC)
+      return ELF->getSymbolName(SI);
+  return readobj_error::unknown_symbol;
+}
+
+template <typename ET>
+const typename object::ELFFile<ET>::Elf_Shdr *
+PrinterContext<ET>::FindExceptionTable(unsigned IndexSectionIndex,
+                                       off_t IndexTableOffset) const {
+  /// Iterate through the sections, searching for the relocation section
+  /// associated with the unwind index table section specified by
+  /// IndexSectionIndex.  Iterate the associated section searching for the
+  /// relocation associated with the index table entry specified by
+  /// IndexTableOffset.  The symbol is the section symbol for the exception
+  /// handling table.  Use this symbol to recover the actual exception handling
+  /// table.
+
+  for (Elf_Shdr_iterator SI = ELF->begin_sections(), SE = ELF->end_sections();
+       SI != SE; ++SI) {
+    if (SI->sh_type == ELF::SHT_REL && SI->sh_info == IndexSectionIndex) {
+      for (Elf_Rel_iterator RI = ELF->begin_rel(&*SI), RE = ELF->end_rel(&*SI);
+           RI != RE; ++RI) {
+        if (RI->r_offset == IndexTableOffset) {
+          typename object::ELFFile<ET>::Elf_Rela RelA;
+          RelA.r_offset = RI->r_offset;
+          RelA.r_info = RI->r_info;
+          RelA.r_addend = 0;
+
+          std::pair<const Elf_Shdr *, const Elf_Sym *> Symbol =
+            ELF->getRelocationSymbol(&(*SI), &RelA);
+
+          return ELF->getSection(Symbol.second);
+        }
+      }
+    }
+  }
+  return NULL;
+}
+
+template <typename ET>
+void PrinterContext<ET>::PrintExceptionTable(const Elf_Shdr *IT,
+                                             const Elf_Shdr *EHT,
+                                             uint64_t TableEntryOffset) const {
+  ErrorOr<ArrayRef<uint8_t> > Contents = ELF->getSectionContents(EHT);
+  if (!Contents)
+    return;
+
+  /// ARM EHABI Section 6.2 - The generic model
+  ///
+  /// An exception-handling table entry for the generic model is laid out as:
+  ///
+  ///  3 3
+  ///  1 0                            0
+  /// +-+------------------------------+
+  /// |0|  personality routine offset  |
+  /// +-+------------------------------+
+  /// |  personality routine data ...  |
+  ///
+  ///
+  /// ARM EHABI Section 6.3 - The ARM-defined compact model
+  ///
+  /// An exception-handling table entry for the compact model looks like:
+  ///
+  ///  3 3 2 2  2 2
+  ///  1 0 8 7  4 3                     0
+  /// +-+---+----+-----------------------+
+  /// |1| 0 | Ix | data for pers routine |
+  /// +-+---+----+-----------------------+
+  /// |  more personality routine data   |
+
+  const uint32_t Word =
+    *reinterpret_cast<const uint32_t *>(Contents->data() + TableEntryOffset);
+
+  if (Word & 0x80000000) {
+    SW.printString("Model", StringRef("Compact"));
+
+    unsigned PersonalityIndex = (Word & 0x0f000000) >> 24;
+    SW.printNumber("PersonalityIndex", PersonalityIndex);
+
+    switch (PersonalityIndex) {
+    case AEABI_UNWIND_CPP_PR0:
+      PrintByteCode(Contents->slice(TableEntryOffset + 1, 3));
+      break;
+    case AEABI_UNWIND_CPP_PR1:
+    case AEABI_UNWIND_CPP_PR2:
+      unsigned AdditionalWords = (Word & 0x00ff0000) >> 16;
+
+      SmallVector<uint8_t, 10> ByteCode;
+      ByteCode.reserve(2 + 4 * AdditionalWords);
+
+      for (unsigned WI = 1, WE = AdditionalWords; WI <= WE; ++WI)
+        ByteCode.append(Contents->data() + TableEntryOffset + 4 * WI,
+                        Contents->data() + TableEntryOffset + 4 * WI + 4);
+      ByteCode.append(Contents->data() + TableEntryOffset,
+                      Contents->data() + TableEntryOffset + 2);
+
+      PrintByteCode(ArrayRef<uint8_t>(ByteCode.begin(), ByteCode.end()));
+      break;
+    }
+  } else {
+    SW.printString("Model", StringRef("Generic"));
+
+    uint64_t Address = PREL31(Word, EHT->sh_addr);
+    SW.printHex("PersonalityRoutineAddress", Address);
+    if (ErrorOr<StringRef> Name = FunctionAtAddress(EHT->sh_link, Address))
+      SW.printString("PersonalityRoutineName", *Name);
+  }
+}
+
+template <typename ET>
+void PrinterContext<ET>::PrintByteCode(const ArrayRef<uint8_t> ByteCode) const {
+  ListScope BC(SW, "ByteCode");
+  for (unsigned BCI = 0, BCE = ByteCode.size(); BCI != BCE; ++BCI)
+    SW.printHex("Instruction", ByteCode[BCE - BCI - 1]);
+}
+
+template <typename ET>
+void PrinterContext<ET>::PrintIndexTable(unsigned SectionIndex,
+                                         const Elf_Shdr *IT) const {
+  ErrorOr<ArrayRef<uint8_t> > Contents = ELF->getSectionContents(IT);
+  if (!Contents)
+    return;
+
+  /// ARM EHABI Section 5 - Index Table Entries
+  /// * The first word contains a PREL31 offset to the start of a function with
+  ///   bit 31 clear
+  /// * The second word contains one of:
+  ///   - The PREL31 offset of the start of the table entry for the function,
+  ///     with bit 31 clear
+  ///   - The exception-handling table entry itself with bit 31 set
+  ///   - The special bit pattern EXIDX_CANTUNWIND, indicating that associated
+  ///     frames cannot be unwound
+
+  const uint32_t *Data = reinterpret_cast<const uint32_t *>(Contents->data());
+  const unsigned Entries = IT->sh_size / IndexTableEntrySize;
+
+  ListScope E(SW, "Entries");
+  for (unsigned Entry = 0; Entry < Entries; ++Entry) {
+    DictScope E(SW, "Entry");
+
+    const uint32_t Word0 =
+      Data[Entry * (IndexTableEntrySize / sizeof(*Data)) + 0];
+    const uint32_t Word1 =
+      Data[Entry * (IndexTableEntrySize / sizeof(*Data)) + 1];
+
+    if (Word0 & 0x80000000) {
+      errs() << "corrupt unwind data in section " << SectionIndex << "\n";
+      continue;
+    }
+
+    const uint64_t Offset = PREL31(Word0, IT->sh_addr);
+    SW.printHex("FunctionAddress", Offset);
+    if (ErrorOr<StringRef> Name = FunctionAtAddress(IT->sh_link, Offset))
+      SW.printString("FunctionName", *Name);
+
+    if (Word1 == EXIDX_CANTUNWIND) {
+      SW.printString("Model", StringRef("CantUnwind"));
+      continue;
+    }
+
+    if (Word1 & 0x80000000) {
+      SW.printString("Model", StringRef("Compact (Inline)"));
+
+      unsigned PersonalityIndex = (Word1 & 0x0f000000) >> 24;
+      SW.printNumber("PersonalityIndex", PersonalityIndex);
+
+      PrintByteCode(Contents->slice(Entry * IndexTableEntrySize + 4, 3));
+    } else {
+      const Elf_Shdr *EHT =
+        FindExceptionTable(SectionIndex, Entry * IndexTableEntrySize + 4);
+
+      if (ErrorOr<StringRef> Name = ELF->getSectionName(EHT))
+        SW.printString("ExceptionHandlingTable", *Name);
+
+      uint64_t TableEntryOffset = PREL31(Word1, IT->sh_addr);
+      SW.printHex("TableEntryOffset", TableEntryOffset);
+
+      PrintExceptionTable(IT, EHT, TableEntryOffset);
+    }
+  }
+}
+
+template <typename ET>
+void PrinterContext<ET>::PrintUnwindInformation() const {
+  DictScope UI(SW, "UnwindInformation");
+
+  int SectionIndex = 0;
+  for (Elf_Shdr_iterator SI = ELF->begin_sections(), SE = ELF->end_sections();
+       SI != SE; ++SI, ++SectionIndex) {
+    if (SI->sh_type == ELF::SHT_ARM_EXIDX) {
+      const Elf_Shdr *IT = &(*SI);
+
+      DictScope UIT(SW, "UnwindIndexTable");
+
+      SW.printNumber("SectionIndex", SectionIndex);
+      if (ErrorOr<StringRef> SectionName = ELF->getSectionName(IT))
+        SW.printString("SectionName", *SectionName);
+      SW.printHex("SectionOffset", IT->sh_offset);
+
+      PrintIndexTable(SectionIndex, IT);
+    }
+  }
+}
+}
+}
+}
+
+#endif
+
diff --git a/tools/llvm-readobj/ELFDumper.cpp b/tools/llvm-readobj/ELFDumper.cpp
index 0e0c0e08c0..b82cecdd4d 100644
--- a/tools/llvm-readobj/ELFDumper.cpp
+++ b/tools/llvm-readobj/ELFDumper.cpp
@@ -16,6 +16,7 @@
 #include "Error.h"
 #include "ObjDumper.h"
 #include "StreamWriter.h"
+#include "ARMEHABIPrinter.h"
 
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Object/ELFObjectFile.h"
@@ -774,6 +775,18 @@ void ELFDumper<ELFT>::printUnwindInfo() {
   W.startLine() << "UnwindInfo not implemented.\n";
 }
 
+namespace {
+template <>
+void ELFDumper<ELFType<support::little, 2, false> >::printUnwindInfo() {
+  const unsigned Machine = Obj->getHeader()->e_machine;
+  if (Machine == EM_ARM) {
+    ARM::EHABI::PrinterContext<ELFType<support::little, 2, false> > Ctx(W, Obj);
+    return Ctx.PrintUnwindInformation();
+  }
+  W.startLine() << "UnwindInfo not implemented.\n";
+}
+}
+
 template<class ELFT>
 void ELFDumper<ELFT>::printDynamicTable() {
   typedef typename ELFO::Elf_Dyn_Iter EDI;