ARM: generation of .ARM.exidx/.ARM.extab sections

[lenykholodov]

Summary

This patch provides generation of .ARM.exidx & .ARM.extab sections which are used for unwinding. The patch adds new content type typeARMExidx for atoms from .ARM.exidx section and integration of atoms with such type to the ELF ReaderWriter. Most of changes were done for only ARM component. However, some changes have to be implemented in common headers.

[ruiu]

LGTM with nits

lib/ReaderWriter/ELF/ARM/ARMELFFile.h

29 ↗

(On Diff #24552)

nit: I'd remove this blank line (and other two lines below after dangling if).

lib/ReaderWriter/ELF/ARM/ARMExecutableWriter.h

70 ↗

(On Diff #24552)

Can you keep and update the comment, so that it's clear what we are doing here?

lib/ReaderWriter/ELF/ARM/ARMTargetHandler.h

23 ↗

(On Diff #24552)

A brief comment about what this class is for would be needed.

81 ↗

(On Diff #24552)

Does just "TargetLayout" (without <>) work?

90 ↗

(On Diff #24552)

Ditto

[denis-protivensky]

lib/Core/DefinedAtom.cpp

46 ↗

(On Diff #24552)

Just a general note to think about:

Maybe it's a good time to introduce doPermissions method for descendants and handle specific types there?

lib/ReaderWriter/ELF/ARM/ARMELFFile.h

33 ↗

(On Diff #24552)

This should work as ELFDefinedAtom::permissions(). Please, check it.

41 ↗

(On Diff #24552)

Ditto.

lib/ReaderWriter/ELF/ARM/ARMExecutableWriter.h

74 ↗

(On Diff #24552)

There's startEnd lambda function in the ExecutableWriter::finalizeDefaultAtomValues() that does *almost* the same thing, you may adapt it to be a proper function and use here.

lib/ReaderWriter/ELF/ARM/ARMTargetHandler.h

38 ↗

(On Diff #24552)

Remove this blank line.

39 ↗

(On Diff #24552)

asserts should have description of a failure provided.

42 ↗

(On Diff #24552)

This variable is not used in this context. Please, move it to the place where it's actually needed.

71 ↗

(On Diff #24552)

TargetLayout without <> should work here as well.

[lenykholodov]

lib/Core/DefinedAtom.cpp

46 ↗

(On Diff #24552)

I agree but I believe it should be implemented as separate patch.

lib/ReaderWriter/ELF/ARM/ARMELFFile.h

33 ↗

(On Diff #24552)

I'll move the implementation to ELFDefinedAtom.

[lenykholodov]

• implementations of permissions() and doContentType() were moved to base class ELFDefinedAtom;
• ARMELFDefinedAtomBase was removed;
• assert message was added;
• minor code changes, comments and formatting after review.

[denis-protivensky]

lib/ReaderWriter/ELF/ARM/ARMExecutableWriter.h

76 ↗

(On Diff #24952)

That's now copy'n'pasting of the functionality. I actually wanted you to convert base class's lambda into member method and call it from here. Please, remove code duplication.

lib/ReaderWriter/ELF/ARM/ARMTargetHandler.h

23 ↗

(On Diff #24952)

It should be a doxygen-style comment. See here: http://llvm.org/docs/CodingStandards.html#commenting

[lenykholodov]

• startEnd as a separate method in ExecutableWriter;
• comment style changes.

[denis-protivensky]

LGTM with nits.

lib/ReaderWriter/ELF/ARM/ARMTargetHandler.h

23 ↗

(On Diff #25144)

/// \brief ARM ...

lib/ReaderWriter/ELF/ExecutableWriter.h

29 ↗

(On Diff #25144)

Please, consider more meaningful name.

lld/trunk/include/lld/Core/DefinedAtom.h

enum ContentType {
     typeMachHeader,         // atom representing mach_header [Darwin]
     typeThreadZeroFill,     // Uninitialized thread local data(TBSS) [ELF]
     typeThreadData,         // Initialized thread local data(TDATA) [ELF]
     typeRONote,             // Identifies readonly note sections [ELF]
     typeRWNote,             // Identifies readwrite note sections [ELF]
     typeNoAlloc,            // Identifies non allocatable sections [ELF]
     typeGroupComdat,        // Identifies a section group [ELF, COFF]
     typeGnuLinkOnce,        // Identifies a gnu.linkonce section [ELF]
+    typeARMExidx,           // Identifies a ARM_EXIDX section [ELF/ARM]
   };
 
   // Permission bits for atoms and segments. The order of these values are
   // important, because the layout pass may sort atoms by permission if other
   // attributes are the same.
   enum ContentPermissions {
     perm___  = 0,           // mapped as unaccessible
     permR__  = 8,           // mapped read-only

lld/trunk/lib/Core/DefinedAtom.cpp

DefinedAtom::ContentPermissions DefinedAtom::permissions(ContentType type) {
   case typeLiteral4:
   case typeLiteral8:
   case typeLiteral16:
   case typeDTraceDOF:
   case typeCompactUnwindInfo:
   case typeProcessedUnwindInfo:
   case typeRONote:
   case typeNoAlloc:
+  case typeARMExidx:
     return permR__;
 
   case typeData:
   case typeDataFast:
   case typeZeroFill:
   case typeZeroFillFast:
   case typeObjC1Class:
   case typeLazyPointer:

lld/trunk/lib/ReaderWriter/ELF/ARM/ARMExecutableWriter.h

void ARMExecutableWriter::finalizeDefaultAtomValues() {
   if (gotAtom) {
     if (auto gotpltSection = _armLayout.findOutputSection(".got.plt"))
       gotAtom->_virtualAddr = gotpltSection->virtualAddr();
     else if (auto gotSection = _armLayout.findOutputSection(".got"))
       gotAtom->_virtualAddr = gotSection->virtualAddr();
     else
       gotAtom->_virtualAddr = 0;
   }
-  // TODO: resolve addresses of __exidx_start/_end atoms
+
+  // Set required by gcc libc __ehdr_start symbol with pointer to ELF header
+  if (auto ehdr = _armLayout.findAbsoluteAtom("__ehdr_start"))
+    ehdr->_virtualAddr = _elfHeader->virtualAddr();
+
+  // Set required by gcc libc symbols __exidx_start/__exidx_end
+  updateScopeAtomValues("exidx", ".ARM.exidx");
 }
 
 unique_bump_ptr<SymbolTable<ELF32LE>> ARMExecutableWriter::createSymbolTable() {
   return unique_bump_ptr<SymbolTable<ELF32LE>>(new (_alloc)
                                                    ARMSymbolTable(_ctx));
 }
 
 void ARMExecutableWriter::processUndefinedSymbol(
     StringRef symName, RuntimeFile<ELF32LE> &file) const {
   if (symName == gotSymbol) {
     file.addAbsoluteAtom(gotSymbol);
   } else if (symName.startswith("__exidx")) {
     file.addAbsoluteAtom("__exidx_start");
     file.addAbsoluteAtom("__exidx_end");
+  } else if (symName == "__ehdr_start") {
+    file.addAbsoluteAtom("__ehdr_start");
   }
 }
 
 std::error_code ARMExecutableWriter::setELFHeader() {
   if (std::error_code ec = ExecutableWriter::setELFHeader())
     return ec;
 
   // Set ARM-specific flags.

lld/trunk/lib/ReaderWriter/ELF/ARM/ARMSymbolTable.h

 
 ARMSymbolTable::ARMSymbolTable(const ELFLinkingContext &ctx)
     : SymbolTable(ctx, ".symtab", TargetLayout<ELF32LE>::ORDER_SYMBOL_TABLE) {}
 
 void ARMSymbolTable::addDefinedAtom(Elf_Sym &sym, const DefinedAtom *da,
                                     int64_t addr) {
   SymbolTable::addDefinedAtom(sym, da, addr);
 
+  if (da->contentType() == DefinedAtom::typeARMExidx)
+    sym.st_value = addr;
+
   // Set zero bit to distinguish real symbols addressing Thumb instructions.
   // Don't care about mapping symbols like $t and others.
   if (DefinedAtom::codeARMThumb == da->codeModel())
     sym.st_value = static_cast<int64_t>(sym.st_value) | 0x1;
 
   // Mapping symbols should have special values of binding, type and size set.
   if ((DefinedAtom::codeARM_a == da->codeModel()) ||
       (DefinedAtom::codeARM_d == da->codeModel()) ||

lld/trunk/lib/ReaderWriter/ELF/ARM/ARMTargetHandler.h

 #include "ELFReader.h"
 #include "TargetLayout.h"
 
 namespace lld {
 class ELFLinkingContext;
 
 namespace elf {
 
+/// \brief ARM specific section (.ARM.exidx) with indexes to exception handlers
+class ARMExidxSection : public AtomSection<ELF32LE> {
+  typedef AtomSection<ELF32LE> Base;
+
+public:
+  ARMExidxSection(const ELFLinkingContext &ctx, StringRef sectionName,
+                  int32_t permissions, int32_t order)
+      : Base(ctx, sectionName, DefinedAtom::typeARMExidx, permissions, order) {
+    this->_type = SHT_ARM_EXIDX;
+    this->_isLoadedInMemory = true;
+  }
+
+  bool hasOutputSegment() const override { return true; }
+
+  const AtomLayout *appendAtom(const Atom *atom) override {
+    const DefinedAtom *definedAtom = cast<DefinedAtom>(atom);
+    assert(atom->contentType() == DefinedAtom::typeARMExidx &&
+           "atom content type for .ARM.exidx section has to be typeARMExidx");
+
+    DefinedAtom::Alignment atomAlign = definedAtom->alignment();
+    uint64_t fOffset = alignOffset(this->fileSize(), atomAlign);
+    uint64_t mOffset = alignOffset(this->memSize(), atomAlign);
+
+    _atoms.push_back(new (_alloc) AtomLayout(atom, fOffset, 0));
+    this->_fsize = fOffset + definedAtom->size();
+    this->_msize = mOffset + definedAtom->size();
+    DEBUG_WITH_TYPE("Section", llvm::dbgs()
+                                   << "[" << this->name() << " " << this << "] "
+                                   << "Adding atom: " << atom->name() << "@"
+                                   << fOffset << "\n");
+
+    uint64_t alignment = atomAlign.value;
+    if (this->_alignment < alignment)
+      this->_alignment = alignment;
+
+    return _atoms.back();
+  }
+};
+
 class ARMTargetLayout : public TargetLayout<ELF32LE> {
 public:
   ARMTargetLayout(ELFLinkingContext &ctx) : TargetLayout(ctx) {}
 
+  SectionOrder getSectionOrder(StringRef name, int32_t contentType,
+                               int32_t contentPermissions) override {
+    switch (contentType) {
+    case DefinedAtom::typeARMExidx:
+      return ORDER_ARM_EXIDX;
+    default:
+      return TargetLayout::getSectionOrder(name, contentType,
+                                           contentPermissions);
+    }
+  }
+
+  StringRef getOutputSectionName(StringRef archivePath, StringRef memberPath,
+                                 StringRef inputSectionName) const override {
+    return llvm::StringSwitch<StringRef>(inputSectionName)
+        .StartsWith(".ARM.exidx", ".ARM.exidx")
+        .StartsWith(".ARM.extab", ".ARM.extab")
+        .Default(TargetLayout::getOutputSectionName(archivePath, memberPath,
+                                                    inputSectionName));
+  }
+
+  SegmentType getSegmentType(Section<ELF32LE> *section) const override {
+    switch (section->order()) {
+    case ORDER_ARM_EXIDX:
+      return llvm::ELF::PT_ARM_EXIDX;
+    default:
+      return TargetLayout::getSegmentType(section);
+    }
+  }
+
+  AtomSection<ELF32LE> *
+  createSection(StringRef name, int32_t contentType,
+                DefinedAtom::ContentPermissions contentPermissions,
+                SectionOrder sectionOrder) override {
+    if (contentType == DefinedAtom::typeARMExidx)
+      return new ARMExidxSection(_ctx, name, contentPermissions, sectionOrder);
+
+    return TargetLayout::createSection(name, contentType, contentPermissions,
+                                       sectionOrder);
+  }
+
   uint64_t getGOTSymAddr() {
     std::call_once(_gotSymOnce, [this]() {
       if (AtomLayout *gotAtom = findAbsoluteAtom("_GLOBAL_OFFSET_TABLE_"))
         _gotSymAddr = gotAtom->_virtualAddr;
     });
     return _gotSymAddr;
   }
 

lld/trunk/lib/ReaderWriter/ELF/Atoms.cpp

DefinedAtom::ContentType ELFDefinedAtom<ELFT>::doContentType() const {
 
   if (_section->sh_flags == SHF_ALLOC && _section->sh_type == SHT_PROGBITS)
     return _contentType = typeConstant;
   if (_symbol->getType() == STT_GNU_IFUNC)
     return _contentType = typeResolver;
   if (_symbol->st_shndx == SHN_COMMON)
     return _contentType = typeZeroFill;
 
+  if (_section->sh_type == SHT_ARM_EXIDX)
+    return typeARMExidx;
   if (_section->sh_type == SHT_PROGBITS) {
     flags &= ~SHF_ALLOC;
     flags &= ~SHF_GROUP;
     if ((flags & SHF_STRINGS) || (flags & SHF_MERGE))
       return typeConstant;
     if (flags == SHF_WRITE)
       return typeData;
     return typeCode;
DefinedAtom::ContentPermissions ELFDefinedAtom<ELFT>::permissions() const {
 
   case llvm::ELF::SHT_NOBITS:
     return _permissions = permRW_;
 
   case llvm::ELF::SHT_INIT_ARRAY:
   case llvm::ELF::SHT_FINI_ARRAY:
     return _permissions = permRW_;
 
+  case llvm::ELF::SHT_ARM_EXIDX:
+    return _permissions = permR__;
+
   default:
     return _permissions = perm___;
   }
 }
 
 template <class ELFT>
 DefinedAtom::reference_iterator ELFDefinedAtom<ELFT>::begin() const {
   uintptr_t index = _referenceStartIndex;

lld/trunk/lib/ReaderWriter/ELF/ExecutableWriter.h

 //===----------------------------------------------------------------------===//
 template<class ELFT>
 class ExecutableWriter : public OutputELFWriter<ELFT> {
 public:
   ExecutableWriter(ELFLinkingContext &ctx, TargetLayout<ELFT> &layout)
       : OutputELFWriter<ELFT>(ctx, layout) {}
 
 protected:
+  void updateScopeAtomValues(StringRef sym, StringRef sec);
   void buildDynamicSymbolTable(const File &file) override;
   void createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
   void finalizeDefaultAtomValues() override;
   void createDefaultSections() override;
 
   bool isNeededTagRequired(const SharedLibraryAtom *sla) const override {
     return this->_layout.isCopied(sla);
   }
 
   unique_bump_ptr<InterpSection<ELFT>> _interpSection;
 
 private:
   std::unique_ptr<RuntimeFile<ELFT>> createRuntimeFile();
 };
 
 //===----------------------------------------------------------------------===//
 //  ExecutableWriter
 //===----------------------------------------------------------------------===//
-template<class ELFT>
+template <class ELFT>
+void ExecutableWriter<ELFT>::updateScopeAtomValues(StringRef sym,
+                                                   StringRef sec) {
+  std::string start = ("__" + sym + "_start").str();
+  std::string end = ("__" + sym + "_end").str();
+  AtomLayout *s = this->_layout.findAbsoluteAtom(start);
+  AtomLayout *e = this->_layout.findAbsoluteAtom(end);
+  OutputSection<ELFT> *section = this->_layout.findOutputSection(sec);
+  if (!s || !e)
+    return;
+  if (section) {
+    s->_virtualAddr = section->virtualAddr();
+    e->_virtualAddr = section->virtualAddr() + section->memSize();
+  } else {
+    s->_virtualAddr = 0;
+    e->_virtualAddr = 0;
+  }
+}
+
+template<class ELFT>
 void ExecutableWriter<ELFT>::buildDynamicSymbolTable(const File &file) {
   for (auto sec : this->_layout.sections())
     if (auto section = dyn_cast<AtomSection<ELFT>>(sec))
       for (const auto &atom : section->atoms()) {
         const DefinedAtom *da = dyn_cast<const DefinedAtom>(atom->_atom);
         if (!da)
           continue;
         if (da->dynamicExport() != DefinedAtom::dynamicExportAlways &&
template <class ELFT> void ExecutableWriter<ELFT>::finalizeDefaultAtomValues() {
   AtomLayout *bssStartAtom = this->_layout.findAbsoluteAtom("__bss_start");
   AtomLayout *bssEndAtom = this->_layout.findAbsoluteAtom("__bss_end");
   AtomLayout *underScoreEndAtom = this->_layout.findAbsoluteAtom("_end");
   AtomLayout *endAtom = this->_layout.findAbsoluteAtom("end");
 
   assert((bssStartAtom || bssEndAtom || underScoreEndAtom || endAtom) &&
          "Unable to find the absolute atoms that have been added by lld");
 
-  auto startEnd = [&](StringRef sym, StringRef sec) -> void {
-    std::string start = ("__" + sym + "_start").str();
-    std::string end = ("__" + sym + "_end").str();
-    AtomLayout *s = this->_layout.findAbsoluteAtom(start);
-    AtomLayout *e = this->_layout.findAbsoluteAtom(end);
-    OutputSection<ELFT> *section = this->_layout.findOutputSection(sec);
-    if (section) {
-      s->_virtualAddr = section->virtualAddr();
-      e->_virtualAddr = section->virtualAddr() + section->memSize();
-    } else {
-      s->_virtualAddr = 0;
-      e->_virtualAddr = 0;
-    }
-  };
-
-  startEnd("preinit_array", ".preinit_array");
-  startEnd("init_array", ".init_array");
+  updateScopeAtomValues("preinit_array", ".preinit_array");
+  updateScopeAtomValues("init_array", ".init_array");
   if (this->_ctx.isRelaOutputFormat())
-    startEnd("rela_iplt", ".rela.plt");
+    updateScopeAtomValues("rela_iplt", ".rela.plt");
   else
-    startEnd("rel_iplt", ".rel.plt");
-  startEnd("fini_array", ".fini_array");
+    updateScopeAtomValues("rel_iplt", ".rel.plt");
+  updateScopeAtomValues("fini_array", ".fini_array");
 
   auto bssSection = this->_layout.findOutputSection(".bss");
 
   // If we don't find a bss section, then don't set these values
   if (bssSection) {
     bssStartAtom->_virtualAddr = bssSection->virtualAddr();
     bssEndAtom->_virtualAddr =
         bssSection->virtualAddr() + bssSection->memSize();

lld/trunk/lib/ReaderWriter/ELF/TargetLayout.h

enum DefaultSectionOrder {
     ORDER_DYNAMIC_RELOCS = 52,
     ORDER_DYNAMIC_PLT_RELOCS = 54,
     ORDER_INIT = 60,
     ORDER_PLT = 70,
     ORDER_TEXT = 80,
     ORDER_FINI = 90,
     ORDER_REL = 95,
     ORDER_RODATA = 100,
+    ORDER_ARM_EXIDX = 105,
     ORDER_EH_FRAME = 110,
     ORDER_EH_FRAMEHDR = 120,
     ORDER_TDATA = 124,
     ORDER_TBSS = 128,
     ORDER_CTORS = 130,
     ORDER_DTORS = 140,
     ORDER_INIT_ARRAY = 150,
     ORDER_FINI_ARRAY = 160,

lld/trunk/test/elf/ARM/exidx.test

+# .ARM.exidx contents checking
+# RUN: yaml2obj -format=elf %s > %t.o
+# RUN: lld -flavor gnu -target arm-none-linux-eabi -static -o %t %t.o
+# RUN: llvm-objdump -s -t -section-headers %t | FileCheck %s
+#
+# CHECK: Sections:
+# CHECK: Idx Name          Size      Address          Type
+# CHECK: 2 .ARM.extab    0000000c 00000000004000b4 DATA
+# CHECK: 3 .ARM.exidx    00000018 00000000004000c0
+# CHECK: Contents of section .text:
+# CHECK: 4000a4 1846aff3 00801846 0837bd46 80bd00bf
+#                                             ^
+#  4000b0:  bd80        pop {r7, pc}
+# CHECK: Contents of section .ARM.extab:
+# CHECK: 4000b4 01970181 b0b00884 00000000
+# CHECK: Contents of section .ARM.exidx:
+# CHECK: 4000c0 b4ffff7f 08809780 bcffff7f 08809780
+#                 ^ offset to 400074 (__aeabi_unwind_cpp_pr0)
+# CHECK: 4000d0 c4ffff7f e0ffff7f
+#                  ^           ^
+#  offset to 400094 (_start)   handler at 4000B0
+#
+# CHECK: SYMBOL TABLE:
+# CHECK: 004000b4         .ARM.extab  00000000 $d.2
+# CHECK: 004000c0         .ARM.exidx  00000000 $d.1
+# CHECK: 00400074 g     F .text 00000010 __aeabi_unwind_cpp_pr0
+# CHECK: 00400094 g     F .text 00000020 _start
+
+---
+FileHeader:
+  Class:           ELFCLASS32
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_ARM
+  Flags:           [ EF_ARM_EABI_VER5 ]
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:    0x0000000000000004
+    Content:         80B400AF00231846BD465DF8047B704780B400AF00231846BD465DF8047B704780B582B000AF3B1D1846FFF7FEFF3B1D1846FFF7FEFF18460837BD4680BD00BF
+  - Name:            .rel.text
+    Type:            SHT_REL
+    Link:            .symtab
+    AddressAlign:    0x0000000000000004
+    Info:            .text
+    Relocations:
+      - Offset:          0x000000000000002A
+        Symbol:          _ZN1AILi1EEC1Ev
+        Type:            R_ARM_THM_CALL
+      - Offset:          0x0000000000000032
+        Symbol:          _ZN1AILi1EED1Ev
+        Type:            R_ARM_THM_CALL
+  - Name:            .ARM.extab
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+    AddressAlign:    0x0000000000000004
+    Content:         01970181B0B0088400000000
+  - Name:            .ARM.exidx
+    Type:            SHT_ARM_EXIDX
+    Flags:           [ SHF_ALLOC, SHF_LINK_ORDER ]
+    Link:            .text
+    AddressAlign:    0x0000000000000004
+    Content:         '000000000880978010000000088097802000000000000000'
+  - Name:            .rel.ARM.exidx
+    Type:            SHT_REL
+    Link:            .symtab
+    AddressAlign:    0x0000000000000004
+    Info:            .ARM.exidx
+    Relocations:
+      - Offset:          0x0000000000000000
+        Symbol:          .text
+        Type:            R_ARM_PREL31
+      - Offset:          0x0000000000000000
+        Symbol:          __aeabi_unwind_cpp_pr0
+        Type:            R_ARM_NONE
+      - Offset:          0x0000000000000008
+        Symbol:          .text
+        Type:            R_ARM_PREL31
+      - Offset:          0x0000000000000010
+        Symbol:          .text
+        Type:            R_ARM_PREL31
+      - Offset:          0x0000000000000010
+        Symbol:          __aeabi_unwind_cpp_pr1
+        Type:            R_ARM_NONE
+      - Offset:          0x0000000000000014
+        Symbol:          .ARM.extab
+        Type:            R_ARM_PREL31
+  - Name:            .text._ZN1AILi1EEC2Ev
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR, SHF_GROUP ]
+    AddressAlign:    0x0000000000000004
+    Content:         80B582B000AF78600120FFF7FEFF7B6818460837BD4680BD
+  - Name:            .rel.text._ZN1AILi1EEC2Ev
+    Type:            SHT_REL
+    Link:            .symtab
+    AddressAlign:    0x0000000000000004
+    Info:            .text._ZN1AILi1EEC2Ev
+    Relocations:
+      - Offset:          0x000000000000000A
+        Symbol:          f
+        Type:            R_ARM_THM_CALL
+  - Name:            .ARM.extab.text._ZN1AILi1EEC2Ev
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_GROUP ]
+    AddressAlign:    0x0000000000000004
+    Content:         01970181B0B0088400000000
+  - Name:            .ARM.exidx.text._ZN1AILi1EEC2Ev
+    Type:            SHT_ARM_EXIDX
+    Flags:           [ SHF_ALLOC, SHF_LINK_ORDER, SHF_GROUP ]
+    Link:            .text._ZN1AILi1EEC2Ev
+    AddressAlign:    0x0000000000000004
+    Content:         '0000000000000000'
+  - Name:            .rel.ARM.exidx.text._ZN1AILi1EEC2Ev
+    Type:            SHT_REL
+    Link:            .symtab
+    AddressAlign:    0x0000000000000004
+    Info:            .ARM.exidx.text._ZN1AILi1EEC2Ev
+    Relocations:
+      - Offset:          0x0000000000000000
+        Symbol:          .text._ZN1AILi1EEC2Ev
+        Type:            R_ARM_PREL31
+      - Offset:          0x0000000000000000
+        Symbol:          __aeabi_unwind_cpp_pr1
+        Type:            R_ARM_NONE
+      - Offset:          0x0000000000000004
+        Symbol:          .ARM.extab.text._ZN1AILi1EEC2Ev
+        Type:            R_ARM_PREL31
+  - Name:            .text._ZN1AILi1EED2Ev
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR, SHF_GROUP ]
+    AddressAlign:    0x0000000000000004
+    Content:         80B582B000AF78604FF0FF30FFF7FEFF7B6818460837BD4680BD00BF
+  - Name:            .rel.text._ZN1AILi1EED2Ev
+    Type:            SHT_REL
+    Link:            .symtab
+    AddressAlign:    0x0000000000000004
+    Info:            .text._ZN1AILi1EED2Ev
+    Relocations:
+      - Offset:          0x000000000000000C
+        Symbol:          f
+        Type:            R_ARM_THM_CALL
+  - Name:            .ARM.extab.text._ZN1AILi1EED2Ev
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_GROUP ]
+    AddressAlign:    0x0000000000000004
+    Content:         01970181B0B0088400000000
+  - Name:            .ARM.exidx.text._ZN1AILi1EED2Ev
+    Type:            SHT_ARM_EXIDX
+    Flags:           [ SHF_ALLOC, SHF_LINK_ORDER, SHF_GROUP ]
+    Link:            .text._ZN1AILi1EED2Ev
+    AddressAlign:    0x0000000000000004
+    Content:         '0000000000000000'
+  - Name:            .rel.ARM.exidx.text._ZN1AILi1EED2Ev
+    Type:            SHT_REL
+    Link:            .symtab
+    AddressAlign:    0x0000000000000004
+    Info:            .ARM.exidx.text._ZN1AILi1EED2Ev
+    Relocations:
+      - Offset:          0x0000000000000000
+        Symbol:          .text._ZN1AILi1EED2Ev
+        Type:            R_ARM_PREL31
+      - Offset:          0x0000000000000000
+        Symbol:          __aeabi_unwind_cpp_pr1
+        Type:            R_ARM_NONE
+      - Offset:          0x0000000000000004
+        Symbol:          .ARM.extab.text._ZN1AILi1EED2Ev
+        Type:            R_ARM_PREL31
+Symbols:
+  Local:
+    - Name:            .text
+      Type:            STT_SECTION
+      Section:         .text
+    - Name:            '$t.1'
+      Section:         .text
+    - Name:            .ARM.extab
+      Type:            STT_SECTION
+      Section:         .ARM.extab
+    - Name:            .ARM.exidx
+      Type:            STT_SECTION
+      Section:         .ARM.exidx
+    - Name:            '$d.1'
+      Section:         .ARM.exidx
+    - Name:            '$d.2'
+      Section:         .ARM.extab
+    - Name:            .text._ZN1AILi1EEC2Ev
+      Type:            STT_SECTION
+      Section:         .text._ZN1AILi1EEC2Ev
+    - Name:            '$t.2'
+      Section:         .text._ZN1AILi1EEC2Ev
+    - Name:            .ARM.extab.text._ZN1AILi1EEC2Ev
+      Type:            STT_SECTION
+      Section:         .ARM.extab.text._ZN1AILi1EEC2Ev
+    - Name:            '$d.3'
+      Section:         .ARM.extab.text._ZN1AILi1EEC2Ev
+    - Name:            .ARM.exidx.text._ZN1AILi1EEC2Ev
+      Type:            STT_SECTION
+      Section:         .ARM.exidx.text._ZN1AILi1EEC2Ev
+    - Name:            '$d.4'
+      Section:         .ARM.exidx.text._ZN1AILi1EEC2Ev
+    - Name:            .text._ZN1AILi1EED2Ev
+      Type:            STT_SECTION
+      Section:         .text._ZN1AILi1EED2Ev
+    - Name:            '$t.3'
+      Section:         .text._ZN1AILi1EED2Ev
+    - Name:            .ARM.extab.text._ZN1AILi1EED2Ev
+      Type:            STT_SECTION
+      Section:         .ARM.extab.text._ZN1AILi1EED2Ev
+    - Name:            '$d.5'
+      Section:         .ARM.extab.text._ZN1AILi1EED2Ev
+    - Name:            .ARM.exidx.text._ZN1AILi1EED2Ev
+      Type:            STT_SECTION
+      Section:         .ARM.exidx.text._ZN1AILi1EED2Ev
+    - Name:            '$d.6'
+      Section:         .ARM.exidx.text._ZN1AILi1EED2Ev
+  Global:
+    - Name:            __aeabi_unwind_cpp_pr0
+      Type:            STT_FUNC
+      Section:         .text
+      Value:           0x0000000000000001
+      Size:            0x0000000000000010
+    - Name:            __aeabi_unwind_cpp_pr1
+      Type:            STT_FUNC
+      Section:         .text
+      Value:           0x0000000000000011
+      Size:            0x0000000000000010
+    - Name:            _start
+      Type:            STT_FUNC
+      Section:         .text
+      Value:           0x0000000000000021
+      Size:            0x000000000000001E
+  Weak:
+    - Name:            _ZN1AILi1EEC1Ev
+      Type:            STT_FUNC
+      Section:         .text._ZN1AILi1EEC2Ev
+      Value:           0x0000000000000001
+      Size:            0x0000000000000018
+    - Name:            _ZN1AILi1EED1Ev
+      Type:            STT_FUNC
+      Section:         .text._ZN1AILi1EED2Ev
+      Value:           0x0000000000000001
+      Size:            0x000000000000001A
+    - Name:            _ZN1AILi1EEC2Ev
+      Type:            STT_FUNC
+      Section:         .text._ZN1AILi1EEC2Ev
+      Value:           0x0000000000000001
+      Size:            0x0000000000000018
+    - Name:            f
+    - Name:            _ZN1AILi1EED2Ev
+      Type:            STT_FUNC
+      Section:         .text._ZN1AILi1EED2Ev
+      Value:           0x0000000000000001
+      Size:            0x000000000000001A
+...