X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=tools%2Fllvm-readobj%2FARMEHABIPrinter.h;h=beb5fd4ea042b4aafcd20b62b6c62ad40e92fe40;hb=813f44a29fd0fd140127023222d0633e23783bcc;hp=754733f6b4266b00c95360b0926d350b5d7d55cc;hpb=fe097bffa73ee232ed23ce503a352556674aa4f3;p=oota-llvm.git

diff --git a/tools/llvm-readobj/ARMEHABIPrinter.h b/tools/llvm-readobj/ARMEHABIPrinter.h
index 754733f6b42..beb5fd4ea04 100644
--- a/tools/llvm-readobj/ARMEHABIPrinter.h
+++ b/tools/llvm-readobj/ARMEHABIPrinter.h
@@ -7,31 +7,313 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_READOBJ_ARMEHABI_PRINTER_H
-#define LLVM_READOBJ_ARMEHABI_PRINTER_H
+#ifndef LLVM_TOOLS_LLVM_READOBJ_ARMEHABIPRINTER_H
+#define LLVM_TOOLS_LLVM_READOBJ_ARMEHABIPRINTER_H
 
+#include "Error.h"
 #include "StreamWriter.h"
-
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/Object/ELF.h"
 #include "llvm/Object/ELFTypes.h"
 #include "llvm/Support/ARMEHABI.h"
+#include "llvm/Support/Debug.h"
 #include "llvm/Support/Endian.h"
+#include "llvm/Support/Format.h"
 #include "llvm/Support/type_traits.h"
 
 namespace llvm {
 namespace ARM {
 namespace EHABI {
-template <typename ET>
-class PrinterContext {
+
+class OpcodeDecoder {
   StreamWriter &SW;
-  const object::ELFFile<ET> *ELF;
+  raw_ostream &OS;
+
+  struct RingEntry {
+    uint8_t Mask;
+    uint8_t Value;
+    void (OpcodeDecoder::*Routine)(const uint8_t *Opcodes, unsigned &OI);
+  };
+  static const RingEntry Ring[];
+
+  void Decode_00xxxxxx(const uint8_t *Opcodes, unsigned &OI);
+  void Decode_01xxxxxx(const uint8_t *Opcodes, unsigned &OI);
+  void Decode_1000iiii_iiiiiiii(const uint8_t *Opcodes, unsigned &OI);
+  void Decode_10011101(const uint8_t *Opcodes, unsigned &OI);
+  void Decode_10011111(const uint8_t *Opcodes, unsigned &OI);
+  void Decode_1001nnnn(const uint8_t *Opcodes, unsigned &OI);
+  void Decode_10100nnn(const uint8_t *Opcodes, unsigned &OI);
+  void Decode_10101nnn(const uint8_t *Opcodes, unsigned &OI);
+  void Decode_10110000(const uint8_t *Opcodes, unsigned &OI);
+  void Decode_10110001_0000iiii(const uint8_t *Opcodes, unsigned &OI);
+  void Decode_10110010_uleb128(const uint8_t *Opcodes, unsigned &OI);
+  void Decode_10110011_sssscccc(const uint8_t *Opcodes, unsigned &OI);
+  void Decode_101101nn(const uint8_t *Opcodes, unsigned &OI);
+  void Decode_10111nnn(const uint8_t *Opcodes, unsigned &OI);
+  void Decode_11000110_sssscccc(const uint8_t *Opcodes, unsigned &OI);
+  void Decode_11000111_0000iiii(const uint8_t *Opcodes, unsigned &OI);
+  void Decode_11001000_sssscccc(const uint8_t *Opcodes, unsigned &OI);
+  void Decode_11001001_sssscccc(const uint8_t *Opcodes, unsigned &OI);
+  void Decode_11001yyy(const uint8_t *Opcodes, unsigned &OI);
+  void Decode_11000nnn(const uint8_t *Opcodes, unsigned &OI);
+  void Decode_11010nnn(const uint8_t *Opcodes, unsigned &OI);
+  void Decode_11xxxyyy(const uint8_t *Opcodes, unsigned &OI);
+
+  void PrintGPR(uint16_t GPRMask);
+  void PrintRegisters(uint32_t Mask, StringRef Prefix);
 
+public:
+  OpcodeDecoder(StreamWriter &SW) : SW(SW), OS(SW.getOStream()) {}
+  void Decode(const uint8_t *Opcodes, off_t Offset, size_t Length);
+};
+
+const OpcodeDecoder::RingEntry OpcodeDecoder::Ring[] = {
+  { 0xc0, 0x00, &OpcodeDecoder::Decode_00xxxxxx },
+  { 0xc0, 0x40, &OpcodeDecoder::Decode_01xxxxxx },
+  { 0xf0, 0x80, &OpcodeDecoder::Decode_1000iiii_iiiiiiii },
+  { 0xff, 0x9d, &OpcodeDecoder::Decode_10011101 },
+  { 0xff, 0x9f, &OpcodeDecoder::Decode_10011111 },
+  { 0xf0, 0x90, &OpcodeDecoder::Decode_1001nnnn },
+  { 0xf8, 0xa0, &OpcodeDecoder::Decode_10100nnn },
+  { 0xf8, 0xa8, &OpcodeDecoder::Decode_10101nnn },
+  { 0xff, 0xb0, &OpcodeDecoder::Decode_10110000 },
+  { 0xff, 0xb1, &OpcodeDecoder::Decode_10110001_0000iiii },
+  { 0xff, 0xb2, &OpcodeDecoder::Decode_10110010_uleb128 },
+  { 0xff, 0xb3, &OpcodeDecoder::Decode_10110011_sssscccc },
+  { 0xfc, 0xb4, &OpcodeDecoder::Decode_101101nn },
+  { 0xf8, 0xb8, &OpcodeDecoder::Decode_10111nnn },
+  { 0xff, 0xc6, &OpcodeDecoder::Decode_11000110_sssscccc },
+  { 0xff, 0xc7, &OpcodeDecoder::Decode_11000111_0000iiii },
+  { 0xff, 0xc8, &OpcodeDecoder::Decode_11001000_sssscccc },
+  { 0xff, 0xc9, &OpcodeDecoder::Decode_11001001_sssscccc },
+  { 0xc8, 0xc8, &OpcodeDecoder::Decode_11001yyy },
+  { 0xf8, 0xc0, &OpcodeDecoder::Decode_11000nnn },
+  { 0xf8, 0xd0, &OpcodeDecoder::Decode_11010nnn },
+  { 0xc0, 0xc0, &OpcodeDecoder::Decode_11xxxyyy },
+};
+
+void OpcodeDecoder::Decode_00xxxxxx(const uint8_t *Opcodes, unsigned &OI) {
+  uint8_t Opcode = Opcodes[OI++ ^ 3];
+  SW.startLine() << format("0x%02X      ; vsp = vsp + %u\n", Opcode,
+                           ((Opcode & 0x3f) << 2) + 4);
+}
+void OpcodeDecoder::Decode_01xxxxxx(const uint8_t *Opcodes, unsigned &OI) {
+  uint8_t Opcode = Opcodes[OI++ ^ 3];
+  SW.startLine() << format("0x%02X      ; vsp = vsp - %u\n", Opcode,
+                           ((Opcode & 0x3f) << 2) + 4);
+}
+void OpcodeDecoder::Decode_1000iiii_iiiiiiii(const uint8_t *Opcodes,
+                                             unsigned &OI) {
+  uint8_t Opcode0 = Opcodes[OI++ ^ 3];
+  uint8_t Opcode1 = Opcodes[OI++ ^ 3];
+
+  uint16_t GPRMask = (Opcode1 << 4) | ((Opcode0 & 0x0f) << 12);
+  SW.startLine()
+    << format("0x%02X 0x%02X ; %s",
+              Opcode0, Opcode1, GPRMask ? "pop " : "refuse to unwind");
+  if (GPRMask)
+    PrintGPR(GPRMask);
+  OS << '\n';
+}
+void OpcodeDecoder::Decode_10011101(const uint8_t *Opcodes, unsigned &OI) {
+  uint8_t Opcode = Opcodes[OI++ ^ 3];
+  SW.startLine() << format("0x%02X      ; reserved (ARM MOVrr)\n", Opcode);
+}
+void OpcodeDecoder::Decode_10011111(const uint8_t *Opcodes, unsigned &OI) {
+  uint8_t Opcode = Opcodes[OI++ ^ 3];
+  SW.startLine() << format("0x%02X      ; reserved (WiMMX MOVrr)\n", Opcode);
+}
+void OpcodeDecoder::Decode_1001nnnn(const uint8_t *Opcodes, unsigned &OI) {
+  uint8_t Opcode = Opcodes[OI++ ^ 3];
+  SW.startLine() << format("0x%02X      ; vsp = r%u\n", Opcode, (Opcode & 0x0f));
+}
+void OpcodeDecoder::Decode_10100nnn(const uint8_t *Opcodes, unsigned &OI) {
+  uint8_t Opcode = Opcodes[OI++ ^ 3];
+  SW.startLine() << format("0x%02X      ; pop ", Opcode);
+  PrintGPR((((1 << ((Opcode & 0x7) + 1)) - 1) << 4));
+  OS << '\n';
+}
+void OpcodeDecoder::Decode_10101nnn(const uint8_t *Opcodes, unsigned &OI) {
+  uint8_t Opcode = Opcodes[OI++ ^ 3];
+  SW.startLine() << format("0x%02X      ; pop ", Opcode);
+  PrintGPR((((1 << ((Opcode & 0x7) + 1)) - 1) << 4) | (1 << 14));
+  OS << '\n';
+}
+void OpcodeDecoder::Decode_10110000(const uint8_t *Opcodes, unsigned &OI) {
+  uint8_t Opcode = Opcodes[OI++ ^ 3];
+  SW.startLine() << format("0x%02X      ; finish\n", Opcode);
+}
+void OpcodeDecoder::Decode_10110001_0000iiii(const uint8_t *Opcodes,
+                                             unsigned &OI) {
+  uint8_t Opcode0 = Opcodes[OI++ ^ 3];
+  uint8_t Opcode1 = Opcodes[OI++ ^ 3];
+
+  SW.startLine()
+    << format("0x%02X 0x%02X ; %s", Opcode0, Opcode1,
+              ((Opcode1 & 0xf0) || Opcode1 == 0x00) ? "spare" : "pop ");
+  if (((Opcode1 & 0xf0) == 0x00) && Opcode1)
+    PrintGPR((Opcode1 & 0x0f));
+  OS << '\n';
+}
+void OpcodeDecoder::Decode_10110010_uleb128(const uint8_t *Opcodes,
+                                            unsigned &OI) {
+  uint8_t Opcode = Opcodes[OI++ ^ 3];
+  SW.startLine() << format("0x%02X ", Opcode);
+
+  SmallVector<uint8_t, 4> ULEB;
+  do { ULEB.push_back(Opcodes[OI ^ 3]); } while (Opcodes[OI++ ^ 3] & 0x80);
+
+  for (unsigned BI = 0, BE = ULEB.size(); BI != BE; ++BI)
+    OS << format("0x%02X ", ULEB[BI]);
+
+  uint64_t Value = 0;
+  for (unsigned BI = 0, BE = ULEB.size(); BI != BE; ++BI)
+    Value = Value | ((ULEB[BI] & 0x7f) << (7 * BI));
+
+  OS << format("; vsp = vsp + %" PRIu64 "\n", 0x204 + (Value << 2));
+}
+void OpcodeDecoder::Decode_10110011_sssscccc(const uint8_t *Opcodes,
+                                             unsigned &OI) {
+  uint8_t Opcode0 = Opcodes[OI++ ^ 3];
+  uint8_t Opcode1 = Opcodes[OI++ ^ 3];
+  SW.startLine() << format("0x%02X 0x%02X ; pop ", Opcode0, Opcode1);
+  uint8_t Start = ((Opcode1 & 0xf0) >> 4);
+  uint8_t Count = ((Opcode1 & 0x0f) >> 0);
+  PrintRegisters((((1 << (Count + 1)) - 1) << Start), "d");
+  OS << '\n';
+}
+void OpcodeDecoder::Decode_101101nn(const uint8_t *Opcodes, unsigned &OI) {
+  uint8_t Opcode = Opcodes[OI++ ^ 3];
+  SW.startLine() << format("0x%02X      ; spare\n", Opcode);
+}
+void OpcodeDecoder::Decode_10111nnn(const uint8_t *Opcodes, unsigned &OI) {
+  uint8_t Opcode = Opcodes[OI++ ^ 3];
+  SW.startLine() << format("0x%02X      ; pop ", Opcode);
+  PrintRegisters((((1 << ((Opcode & 0x07) + 1)) - 1) << 8), "d");
+  OS << '\n';
+}
+void OpcodeDecoder::Decode_11000110_sssscccc(const uint8_t *Opcodes,
+                                             unsigned &OI) {
+  uint8_t Opcode0 = Opcodes[OI++ ^ 3];
+  uint8_t Opcode1 = Opcodes[OI++ ^ 3];
+  SW.startLine() << format("0x%02X 0x%02X ; pop ", Opcode0, Opcode1);
+  uint8_t Start = ((Opcode1 & 0xf0) >> 4);
+  uint8_t Count = ((Opcode1 & 0x0f) >> 0);
+  PrintRegisters((((1 << (Count + 1)) - 1) << Start), "wR");
+  OS << '\n';
+}
+void OpcodeDecoder::Decode_11000111_0000iiii(const uint8_t *Opcodes,
+                                             unsigned &OI) {
+  uint8_t Opcode0 = Opcodes[OI++ ^ 3];
+  uint8_t Opcode1 = Opcodes[OI++ ^ 3];
+  SW.startLine()
+    << format("0x%02X 0x%02X ; %s", Opcode0, Opcode1,
+              ((Opcode1 & 0xf0) || Opcode1 == 0x00) ? "spare" : "pop ");
+  if ((Opcode1 & 0xf0) == 0x00 && Opcode1)
+      PrintRegisters(Opcode1 & 0x0f, "wCGR");
+  OS << '\n';
+}
+void OpcodeDecoder::Decode_11001000_sssscccc(const uint8_t *Opcodes,
+                                             unsigned &OI) {
+  uint8_t Opcode0 = Opcodes[OI++ ^ 3];
+  uint8_t Opcode1 = Opcodes[OI++ ^ 3];
+  SW.startLine() << format("0x%02X 0x%02X ; pop ", Opcode0, Opcode1);
+  uint8_t Start = 16 + ((Opcode1 & 0xf0) >> 4);
+  uint8_t Count = ((Opcode1 & 0x0f) >> 0);
+  PrintRegisters((((1 << (Count + 1)) - 1) << Start), "d");
+  OS << '\n';
+}
+void OpcodeDecoder::Decode_11001001_sssscccc(const uint8_t *Opcodes,
+                                             unsigned &OI) {
+  uint8_t Opcode0 = Opcodes[OI++ ^ 3];
+  uint8_t Opcode1 = Opcodes[OI++ ^ 3];
+  SW.startLine() << format("0x%02X 0x%02X ; pop ", Opcode0, Opcode1);
+  uint8_t Start = ((Opcode1 & 0xf0) >> 4);
+  uint8_t Count = ((Opcode1 & 0x0f) >> 0);
+  PrintRegisters((((1 << (Count + 1)) - 1) << Start), "d");
+  OS << '\n';
+}
+void OpcodeDecoder::Decode_11001yyy(const uint8_t *Opcodes, unsigned &OI) {
+  uint8_t Opcode = Opcodes[OI++ ^ 3];
+  SW.startLine() << format("0x%02X      ; spare\n", Opcode);
+}
+void OpcodeDecoder::Decode_11000nnn(const uint8_t *Opcodes, unsigned &OI) {
+  uint8_t Opcode = Opcodes[OI++ ^ 3];
+  SW.startLine() << format("0x%02X      ; pop ", Opcode);
+  PrintRegisters((((1 << ((Opcode & 0x07) + 1)) - 1) << 10), "wR");
+  OS << '\n';
+}
+void OpcodeDecoder::Decode_11010nnn(const uint8_t *Opcodes, unsigned &OI) {
+  uint8_t Opcode = Opcodes[OI++ ^ 3];
+  SW.startLine() << format("0x%02X      ; pop ", Opcode);
+  PrintRegisters((((1 << ((Opcode & 0x07) + 1)) - 1) << 8), "d");
+  OS << '\n';
+}
+void OpcodeDecoder::Decode_11xxxyyy(const uint8_t *Opcodes, unsigned &OI) {
+  uint8_t Opcode = Opcodes[OI++ ^ 3];
+  SW.startLine() << format("0x%02X      ; spare\n", Opcode);
+}
+
+void OpcodeDecoder::PrintGPR(uint16_t GPRMask) {
+  static const char *GPRRegisterNames[16] = {
+    "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10",
+    "fp", "ip", "sp", "lr", "pc"
+  };
+
+  OS << '{';
+  bool Comma = false;
+  for (unsigned RI = 0, RE = 17; RI < RE; ++RI) {
+    if (GPRMask & (1 << RI)) {
+      if (Comma)
+        OS << ", ";
+      OS << GPRRegisterNames[RI];
+      Comma = true;
+    }
+  }
+  OS << '}';
+}
+
+void OpcodeDecoder::PrintRegisters(uint32_t VFPMask, StringRef Prefix) {
+  OS << '{';
+  bool Comma = false;
+  for (unsigned RI = 0, RE = 32; RI < RE; ++RI) {
+    if (VFPMask & (1 << RI)) {
+      if (Comma)
+        OS << ", ";
+      OS << Prefix << RI;
+      Comma = true;
+    }
+  }
+  OS << '}';
+}
+
+void OpcodeDecoder::Decode(const uint8_t *Opcodes, off_t Offset, size_t Length) {
+  for (unsigned OCI = Offset; OCI < Length + Offset; ) {
+    bool Decoded = false;
+    for (unsigned REI = 0, REE = array_lengthof(Ring);
+         REI != REE && !Decoded; ++REI) {
+      if ((Opcodes[OCI ^ 3] & Ring[REI].Mask) == Ring[REI].Value) {
+        (this->*Ring[REI].Routine)(Opcodes, OCI);
+        Decoded = true;
+        break;
+      }
+    }
+    if (!Decoded)
+      SW.startLine() << format("0x%02X      ; reserved\n", Opcodes[OCI++ ^ 3]);
+  }
+}
+
+template <typename ET>
+class PrinterContext {
   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 Elf_Rel;
+  typedef typename object::ELFFile<ET>::Elf_Word Elf_Word;
 
-  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;
+  StreamWriter &SW;
+  const object::ELFFile<ET> *ELF;
+  const Elf_Shdr *Symtab;
+  ArrayRef<Elf_Word> ShndxTable;
 
   static const size_t IndexTableEntrySize;
 
@@ -49,11 +331,12 @@ class PrinterContext {
   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;
+  void PrintOpcodes(const uint8_t *Entry, size_t Length, off_t Offset) const;
 
 public:
-  PrinterContext(StreamWriter &Writer, const object::ELFFile<ET> *File)
-    : SW(Writer), ELF(File) {}
+  PrinterContext(StreamWriter &SW, const object::ELFFile<ET> *ELF,
+                 const Elf_Shdr *Symtab)
+      : SW(SW), ELF(ELF), Symtab(Symtab) {}
 
   void PrintUnwindInformation() const;
 };
@@ -62,13 +345,17 @@ 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);
+ErrorOr<StringRef>
+PrinterContext<ET>::FunctionAtAddress(unsigned Section,
+                                      uint64_t Address) const {
+  ErrorOr<StringRef> StrTableOrErr = ELF->getStringTableForSymtab(*Symtab);
+  error(StrTableOrErr.getError());
+  StringRef StrTable = *StrTableOrErr;
+
+  for (const Elf_Sym &Sym : ELF->symbols(Symtab))
+    if (Sym.st_shndx == Section && Sym.st_value == Address &&
+        Sym.getType() == ELF::STT_FUNC)
+      return Sym.getName(StrTable);
   return readobj_error::unknown_symbol;
 }
 
@@ -84,26 +371,33 @@ PrinterContext<ET>::FindExceptionTable(unsigned IndexSectionIndex,
   /// 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);
-        }
-      }
+  for (const Elf_Shdr &Sec : ELF->sections()) {
+    if (Sec.sh_type != ELF::SHT_REL || Sec.sh_info != IndexSectionIndex)
+      continue;
+
+    ErrorOr<const Elf_Shdr *> SymTabOrErr = ELF->getSection(Sec.sh_link);
+    error(SymTabOrErr.getError());
+    const Elf_Shdr *SymTab = *SymTabOrErr;
+
+    for (const Elf_Rel &R : ELF->rels(&Sec)) {
+      if (R.r_offset != static_cast<unsigned>(IndexTableOffset))
+        continue;
+
+      typename object::ELFFile<ET>::Elf_Rela RelA;
+      RelA.r_offset = R.r_offset;
+      RelA.r_info = R.r_info;
+      RelA.r_addend = 0;
+
+      const Elf_Sym *Symbol = ELF->getRelocationSymbol(&RelA, SymTab);
+
+      ErrorOr<const Elf_Shdr *> Ret =
+          ELF->getSection(Symbol, SymTab, ShndxTable);
+      if (std::error_code EC = Ret.getError())
+        report_fatal_error(EC.message());
+      return *Ret;
     }
   }
-  return NULL;
+  return nullptr;
 }
 
 template <typename ET>
@@ -148,22 +442,13 @@ void PrinterContext<ET>::PrintExceptionTable(const Elf_Shdr *IT,
 
     switch (PersonalityIndex) {
     case AEABI_UNWIND_CPP_PR0:
-      PrintByteCode(Contents->slice(TableEntryOffset + 1, 3));
+      PrintOpcodes(Contents->data() + TableEntryOffset, 3, 1);
       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()));
+      PrintOpcodes(Contents->data() + TableEntryOffset, 2 + 4 * AdditionalWords,
+                   2);
       break;
     }
   } else {
@@ -177,10 +462,10 @@ void PrinterContext<ET>::PrintExceptionTable(const Elf_Shdr *IT,
 }
 
 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]);
+void PrinterContext<ET>::PrintOpcodes(const uint8_t *Entry,
+                                      size_t Length, off_t Offset) const {
+  ListScope OCC(SW, "Opcodes");
+  OpcodeDecoder(OCC.W).Decode(Entry, Offset, Length);
 }
 
 template <typename ET>
@@ -234,7 +519,7 @@ void PrinterContext<ET>::PrintIndexTable(unsigned SectionIndex,
       unsigned PersonalityIndex = (Word1 & 0x0f000000) >> 24;
       SW.printNumber("PersonalityIndex", PersonalityIndex);
 
-      PrintByteCode(Contents->slice(Entry * IndexTableEntrySize + 4, 3));
+      PrintOpcodes(Contents->data() + Entry * IndexTableEntrySize + 4, 3, 1);
     } else {
       const Elf_Shdr *EHT =
         FindExceptionTable(SectionIndex, Entry * IndexTableEntrySize + 4);
@@ -255,20 +540,18 @@ 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);
-
+  for (const Elf_Shdr &Sec : ELF->sections()) {
+    if (Sec.sh_type == ELF::SHT_ARM_EXIDX) {
       DictScope UIT(SW, "UnwindIndexTable");
 
       SW.printNumber("SectionIndex", SectionIndex);
-      if (ErrorOr<StringRef> SectionName = ELF->getSectionName(IT))
+      if (ErrorOr<StringRef> SectionName = ELF->getSectionName(&Sec))
         SW.printString("SectionName", *SectionName);
-      SW.printHex("SectionOffset", IT->sh_offset);
+      SW.printHex("SectionOffset", Sec.sh_offset);
 
-      PrintIndexTable(SectionIndex, IT);
+      PrintIndexTable(SectionIndex, &Sec);
     }
+    ++SectionIndex;
   }
 }
 }