[lld][ARM] Handle mapping symbols

[denis-protivensky]

Summary

Mapping symbols should have their own code models, and in some places must be treated in a specific way.
Make $t denote Thumb code, and $a and $d denote ARM code.
Set size, binding and type of mapping symbols to what the specification says.

[• shankar.easwaran]

LGTM

[ruiu]

LGTM

lib/ReaderWriter/ELF/ARM/ARMELFFile.h

55

remove "this->"

63

Ditto

119

wrong indentation

[meadori]

Otherwise, LGTM.

lib/ReaderWriter/ELF/ARM/ARMELFFile.h

33

Should we inherit constructors here like Rui just proposed with D8612?

[meadori]

lib/ReaderWriter/ELF/ARM/ARMELFFile.h

33

Nevermind. I see where D8612 just got abandoned.

[denis-protivensky]

lib/ReaderWriter/ELF/ARM/ARMELFFile.h

55

I'd want to, but gcc doesn't resolve template dependent names otherwise.

119

Will fix.

include/lld/Core/DefinedAtom.h

enum DynamicExport {
     dynamicExportNormal,
     /// \brief The linker will always export this atom dynamically.
     dynamicExportAlways,
   };
 
   // Attributes describe a code model used by the atom.
   enum CodeModel {
     codeNA,           // no specific code model
+    // MIPS code models
     codeMipsPIC,      // PIC function in a PIC / non-PIC mixed file
     codeMipsMicro,    // microMIPS instruction encoding
     codeMipsMicroPIC, // microMIPS instruction encoding + PIC
     codeMips16,       // MIPS-16 instruction encoding
+    // ARM code models
     codeARMThumb,     // ARM Thumb instruction set
+    codeARM_a,        // $a-like mapping symbol (for ARM code)
+    codeARM_d,        // $d-like mapping symbol (for data)
+    codeARM_t,        // $t-like mapping symbol (for Thumb code)
   };
 
   struct Alignment {
     Alignment(int p2, int m = 0)
       : powerOf2(p2)
       , modulus(m) {}
 
     uint16_t powerOf2;

lib/ReaderWriter/ELF/ARM/ARMELFFile.h

 
 #include "ELFReader.h"
 
 namespace lld {
 namespace elf {
 
 class ARMLinkingContext;
 
+template <class ELFT, DefinedAtom::CodeModel Model>
+class ARMELFMappingAtom : public ELFDefinedAtom<ELFT> {
+  typedef llvm::object::Elf_Sym_Impl<ELFT> Elf_Sym;
+  typedef llvm::object::Elf_Shdr_Impl<ELFT> Elf_Shdr;
+
+public:
+  ARMELFMappingAtom(const ELFFile<ELFT> &file, StringRef symbolName,
+                 StringRef sectionName, const Elf_Sym *symbol,
+                 const Elf_Shdr *section, ArrayRef<uint8_t> contentData,
+                 unsigned int referenceStart, unsigned int referenceEnd,
+                 std::vector<ELFReference<ELFT> *> &referenceList)
+      : ELFDefinedAtom<ELFT>(file, symbolName, sectionName, symbol, section,
+                             contentData, referenceStart, referenceEnd,
+                             referenceList) {}
+
+  DefinedAtom::CodeModel codeModel() const override {
+    return Model;
+  }
+};
+
 template <class ELFT> class ARMELFDefinedAtom : public ELFDefinedAtom<ELFT> {
   typedef llvm::object::Elf_Sym_Impl<ELFT> Elf_Sym;
   typedef llvm::object::Elf_Shdr_Impl<ELFT> Elf_Shdr;
 
 public:
   ARMELFDefinedAtom(const ELFFile<ELFT> &file, StringRef symbolName,
                  StringRef sectionName, const Elf_Sym *symbol,
                  const Elf_Shdr *section, ArrayRef<uint8_t> contentData,
                  unsigned int referenceStart, unsigned int referenceEnd,
                  std::vector<ELFReference<ELFT> *> &referenceList)
       : ELFDefinedAtom<ELFT>(file, symbolName, sectionName, symbol, section,
                              contentData, referenceStart, referenceEnd,
                              referenceList) {}
 
-  bool isThumbFunc(const Elf_Sym *symbol) const {
+  bool isThumbFunc() const {
+    const Elf_Sym* symbol = this->_symbol;
     return symbol->getType() == llvm::ELF::STT_FUNC &&
         (static_cast<uint64_t>(symbol->st_value) & 0x1);
   }
 
   /// Correct st_value for symbols addressing Thumb instructions
   /// by removing its zero bit.
-  uint64_t getSymbolValue(const Elf_Sym *symbol) const override {
-    const auto value = static_cast<uint64_t>(symbol->st_value);
-    return isThumbFunc(symbol) ? value & ~0x1 : value;
+  uint64_t getSymbolValue() const override {
+    const auto value = static_cast<uint64_t>(this->_symbol->st_value);
+    return isThumbFunc() ? value & ~0x1 : value;
   }
 
   DefinedAtom::CodeModel codeModel() const override {
-    if (isThumbFunc(this->_symbol))
-      return DefinedAtom::codeARMThumb;
-    return DefinedAtom::codeNA;
+    return isThumbFunc() ? DefinedAtom::codeARMThumb : DefinedAtom::codeNA;
   }
 };
 
 template <class ELFT> class ARMELFFile : public ELFFile<ELFT> {
 public:
   ARMELFFile(std::unique_ptr<MemoryBuffer> mb, ARMLinkingContext &ctx)
       : ELFFile<ELFT>(std::move(mb), ctx) {}
 
private:
 
   /// Process the Defined symbol and create an atom for it.
   ErrorOr<ELFDefinedAtom<ELFT> *> handleDefinedSymbol(StringRef symName,
           StringRef sectionName,
           const Elf_Sym *sym, const Elf_Shdr *sectionHdr,
           ArrayRef<uint8_t> contentData,
           unsigned int referenceStart, unsigned int referenceEnd,
           std::vector<ELFReference<ELFT> *> &referenceList) override {
+    if (symName.size() >= 2 && symName[0] == '$') {
+      switch (symName[1]) {
+      case 'a':
+        return new (this->_readerStorage)
+            ARMELFMappingAtom<ELFT, DefinedAtom::codeARM_a>(
+                *this, symName, sectionName, sym, sectionHdr, contentData,
+                referenceStart, referenceEnd, referenceList);
+      case 'd':
+        return new (this->_readerStorage)
+            ARMELFMappingAtom<ELFT, DefinedAtom::codeARM_d>(
+                *this, symName, sectionName, sym, sectionHdr, contentData,
+                referenceStart, referenceEnd, referenceList);
+      case 't':
+        return new (this->_readerStorage)
+            ARMELFMappingAtom<ELFT, DefinedAtom::codeARM_t>(
+                *this, symName, sectionName, sym, sectionHdr, contentData,
+                referenceStart, referenceEnd, referenceList);
+      default:
+      // Fall through and create regular defined atom.
+      break;
+      }
+    }
     return new (this->_readerStorage) ARMELFDefinedAtom<ELFT>(
         *this, symName, sectionName, sym, sectionHdr, contentData,
         referenceStart, referenceEnd, referenceList);
   }
 };
 
 template <class ELFT> class ARMDynamicFile : public DynamicFile<ELFT> {
 public:
   ARMDynamicFile(const ARMLinkingContext &context, StringRef name)
       : DynamicFile<ELFT>(context, name) {}
 };
 
 } // elf
 } // lld
 
 #endif // LLD_READER_WRITER_ELF_ARM_ARM_ELF_FILE_H

lib/ReaderWriter/ELF/ARM/ARMLinkingContext.h

public:
   void addPasses(PassManager &) override;
 
   uint64_t getBaseAddress() const override {
     if (_baseAddress == 0)
       return 0x400000;
     return _baseAddress;
   }
 };
+
+// Special methods to check code model of atoms.
+bool isARMCode(const DefinedAtom *atom);
+bool isARMCode(DefinedAtom::CodeModel codeModel);
+bool isThumbCode(const DefinedAtom *atom);
+bool isThumbCode(DefinedAtom::CodeModel codeModel);
+
 } // end namespace elf
 } // end namespace lld
 
 #endif

lib/ReaderWriter/ELF/ARM/ARMLinkingContext.cpp

: ELFLinkingContext(triple, std::unique_ptr<TargetHandlerBase>(
                         new ARMTargetHandler(*this))) {}
 
 void elf::ARMLinkingContext::addPasses(PassManager &pm) {
   auto pass = createARMRelocationPass(*this);
   if (pass)
     pm.add(std::move(pass));
   ELFLinkingContext::addPasses(pm);
 }
+
+bool elf::isARMCode(const DefinedAtom *atom) {
+  return isARMCode(atom->codeModel());
+}
+
+bool elf::isARMCode(DefinedAtom::CodeModel codeModel) {
+  return !isThumbCode(codeModel);
+}
+
+bool elf::isThumbCode(const DefinedAtom *atom) {
+  return isThumbCode(atom->codeModel());
+}
+
+bool elf::isThumbCode(DefinedAtom::CodeModel codeModel) {
+  return codeModel == DefinedAtom::codeARMThumb ||
+         codeModel == DefinedAtom::codeARM_t;
+}

lib/ReaderWriter/ELF/ARM/ARMRelocationHandler.cpp

std::error_code ARMTargetRelocationHandler::applyRelocation(
   // Calculate proper initial addend for the relocation
   const Reference::Addend addend =
       readAddend(location, ref.kindValue());
 
   // Flags that the relocation addresses Thumb instruction
   bool addressesThumb = false;
 
   if (const auto *definedAtom = dyn_cast<DefinedAtom>(ref.target())) {
-    addressesThumb = (DefinedAtom::codeARMThumb == definedAtom->codeModel());
+    addressesThumb = isThumbCode(definedAtom);
   }
 
   switch (ref.kindValue()) {
   case R_ARM_NONE:
     break;
   case R_ARM_ABS32:
     relocR_ARM_ABS32(location, relocVAddress, targetVAddress, addend,
                      addressesThumb);

lib/ReaderWriter/ELF/ARM/ARMRelocationPass.cpp

void handleReference(const DefinedAtom &atom, const Reference &ref) {
     }
   }
 
 protected:
   std::error_code handleVeneer(const DefinedAtom &atom, const Reference &ref) {
     // Target symbol and relocated place should have different
     // instruction sets in order a veneer to be generated in between.
     const auto *target = dyn_cast<DefinedAtom>(ref.target());
-    if (!target || target->codeModel() == atom.codeModel())
+    if (!target || isThumbCode(target) == isThumbCode(&atom))
       return std::error_code();
 
     // TODO: For unconditional jump instructions (R_ARM_CALL and R_ARM_THM_CALL)
     // fixup isn't possible without veneer generation for archs below ARMv5.
 
     // Veneers may only be generated for STT_FUNC target symbols
     // or for symbols located in sections different to the place of relocation.
     const auto kindValue = ref.kindValue();

lib/ReaderWriter/ELF/ARM/ARMSymbolTable.h

ARMSymbolTable<ELFT>::ARMSymbolTable(const ELFLinkingContext &context)
     : SymbolTable<ELFT>(context, ".symtab",
                         DefaultLayout<ELFT>::ORDER_SYMBOL_TABLE) {}
 
 template <class ELFT>
 void ARMSymbolTable<ELFT>::addDefinedAtom(Elf_Sym &sym, const DefinedAtom *da,
                                           int64_t addr) {
   SymbolTable<ELFT>::addDefinedAtom(sym, da, addr);
 
-  // Set zero bit to distinguish symbols addressing Thumb instructions
+  // 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()) ||
+      (DefinedAtom::codeARM_t == da->codeModel())) {
+    sym.setBindingAndType(llvm::ELF::STB_LOCAL, llvm::ELF::STT_NOTYPE);
+    sym.st_size = 0;
+  }
 }
 
 } // elf
 } // lld
 
 #endif // LLD_READER_WRITER_ELF_ARM_ARM_SYMBOL_TABLE_H

lib/ReaderWriter/ELF/Atoms.h

ContentType contentType() const override {
     return _contentType = ret;
   }
 
   Alignment alignment() const override {
     if (!_symbol)
       return Alignment(0);
 
     // Obtain proper value of st_value field.
-    const auto symValue = getSymbolValue(_symbol);
+    const auto symValue = getSymbolValue();
 
     // Unallocated common symbols specify their alignment constraints in
     // st_value.
     if ((_symbol->getType() == llvm::ELF::STT_COMMON) ||
         _symbol->st_shndx == llvm::ELF::SHN_COMMON) {
       return Alignment(llvm::Log2_64(symValue));
     }
     if (_section->sh_addralign == 0) {
void addReference(ELFReference<ELFT> *reference) {
     _referenceEndIndex = _referenceList.size();
   }
 
   virtual void setOrdinal(uint64_t ord) { _ordinal = ord; }
 
 protected:
   /// Returns correct st_value for the symbol depending on the architecture.
   /// For most architectures it's just a regular st_value with no changes.
-  virtual uint64_t getSymbolValue(const Elf_Sym *symbol) const {
-    return symbol->st_value;
+  virtual uint64_t getSymbolValue() const {
+    return _symbol->st_value;
   }
 
 protected:
   const ELFFile<ELFT> &_owningFile;
   StringRef _symbolName;
   StringRef _sectionName;
   const Elf_Sym *_symbol;
   const Elf_Shdr *_section;

lib/ReaderWriter/YAML/ReaderWriterYAML.cpp

 template <> struct ScalarEnumerationTraits<lld::DefinedAtom::CodeModel> {
   static void enumeration(IO &io, lld::DefinedAtom::CodeModel &value) {
     io.enumCase(value, "none", lld::DefinedAtom::codeNA);
     io.enumCase(value, "mips-pic", lld::DefinedAtom::codeMipsPIC);
     io.enumCase(value, "mips-micro", lld::DefinedAtom::codeMipsMicro);
     io.enumCase(value, "mips-micro-pic", lld::DefinedAtom::codeMipsMicroPIC);
     io.enumCase(value, "mips-16", lld::DefinedAtom::codeMips16);
     io.enumCase(value, "arm-thumb", lld::DefinedAtom::codeARMThumb);
+    io.enumCase(value, "arm-a", lld::DefinedAtom::codeARM_a);
+    io.enumCase(value, "arm-d", lld::DefinedAtom::codeARM_d);
+    io.enumCase(value, "arm-t", lld::DefinedAtom::codeARM_t);
   }
 };
 
 template <>
 struct ScalarEnumerationTraits<lld::DefinedAtom::ContentPermissions> {
   static void enumeration(IO &io, lld::DefinedAtom::ContentPermissions &value) {
     io.enumCase(value, "---",     lld::DefinedAtom::perm___);
     io.enumCase(value, "r--",     lld::DefinedAtom::permR__);

test/elf/ARM/mapping-code-model.test

+# Check that mapping symbols are treated as ARM or Thumb code properly.
+#
+# 1. ARM <=> Thumb generates both veneers.
+# RUN: yaml2obj -format=elf -docnum 1 %s > %t-a-arm.o
+# RUN: yaml2obj -format=elf -docnum 3 %s > %t-t-thm.o
+# RUN: lld -flavor gnu -target arm-linux-gnu --defsym=main=f_a \
+# RUN: -Bstatic --noinhibit-exec %t-a-arm.o %t-t-thm.o -o %t
+# RUN: llvm-objdump -t %t | FileCheck -check-prefix=INTER %s
+
+# INTER: SYMBOL TABLE:
+# INTER: {{[0-9a-f]+}} l     F .text  {{[0-9a-f]+}} __f_t_from_arm
+# INTER: {{[0-9a-f]+}} l     F .text  {{[0-9a-f]+}} __f_a_from_thumb
+
+# 2. Thumb <=> Thumb doesn't generate veneers.
+# RUN: yaml2obj -format=elf -docnum 2 %s > %t-a-thm.o
+# RUN: yaml2obj -format=elf -docnum 3 %s > %t-t-thm.o
+# RUN: lld -flavor gnu -target arm-linux-gnu --defsym=main=f_t \
+# RUN: -Bstatic --noinhibit-exec %t-t-thm.o %t-a-thm.o -o %t
+# RUN: llvm-objdump -t %t | FileCheck -check-prefix=THUMB %s
+
+# THUMB: SYMBOL TABLE:
+# THUMB-NOT: {{[0-9a-f]+}} l     F .text  {{[0-9a-f]+}} __f_t_from_thumb
+# THUMB-NOT: {{[0-9a-f]+}} l     F .text  {{[0-9a-f]+}} __f_a_from_thumb
+
+# f-a-arm.o
+---
+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:         00482DE904B08DE2FEFFFFEBFEFFFFEA0030A0E10300A0E10088BDE8
+  - Name:            .rel.text
+    Type:            SHT_REL
+    Link:            .symtab
+    AddressAlign:    0x0000000000000004
+    Info:            .text
+    Relocations:
+      - Offset:          0x0000000000000008
+        Symbol:          f_t
+        Type:            R_ARM_CALL
+      - Offset:          0x000000000000000C
+        Symbol:          f_t
+        Type:            R_ARM_JUMP24
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000001
+    Content:         ''
+  - Name:            .bss
+    Type:            SHT_NOBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000001
+    Content:         ''
+Symbols:
+  Local:
+    - Name:            '$a'
+      Section:         .text
+      Size:            0x0000000000000002
+    - Name:            '$a.f_a'
+      Section:         .text
+      Value:           0x0000000000000002
+  Global:
+    - Name:            f_a
+      Type:            STT_FUNC
+      Section:         .text
+    - Name:            f_t
+
+# f-a-thm.o
+---
+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:         80B400AF00231846BD465DF8047B7047
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000001
+    Content:         ''
+  - Name:            .bss
+    Type:            SHT_NOBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000001
+    Content:         ''
+Symbols:
+  Local:
+    - Name:            '$t'
+      Section:         .text
+      Size:            0x0000000000000002
+    - Name:            '$t.f_a'
+      Section:         .text
+      Value:           0x0000000000000002
+  Global:
+    - Name:            f_a
+      Type:            STT_FUNC
+      Section:         .text
+      Value:           0x0000000000000001
+
+# f-t-thm.o
+---
+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:         80B500AFFFF7FEFFFFF7FEBF0346184680BD00BF
+  - Name:            .rel.text
+    Type:            SHT_REL
+    Link:            .symtab
+    AddressAlign:    0x0000000000000004
+    Info:            .text
+    Relocations:
+      - Offset:          0x0000000000000004
+        Symbol:          f_a
+        Type:            R_ARM_THM_CALL
+      - Offset:          0x0000000000000008
+        Symbol:          f_a
+        Type:            R_ARM_THM_JUMP24
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000001
+    Content:         ''
+  - Name:            .bss
+    Type:            SHT_NOBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000001
+    Content:         ''
+Symbols:
+  Local:
+    - Name:            '$t'
+      Section:         .text
+      Size:            0x0000000000000002
+    - Name:            '$t.f_t'
+      Section:         .text
+      Value:           0x0000000000000002
+  Global:
+    - Name:            f_t
+      Type:            STT_FUNC
+      Section:         .text
+      Value:           0x0000000000000001
+    - Name:            f_a
+...

test/elf/ARM/mapping-symbols.test

+# Check that mapping symbols have zero size, local binding and none type.
+# RUN: yaml2obj -format=elf -docnum 1 %s > %t-a.o
+# RUN: yaml2obj -format=elf -docnum 2 %s > %t-t.o
+# RUN: lld -flavor gnu -target arm-linux-gnu \
+# RUN: -Bstatic --noinhibit-exec %t-a.o %t-t.o -o %t
+# RUN: llvm-readobj -symbols %t | FileCheck %s
+
+# CHECK:   Name: $a (1)
+# CHECK-NEXT:   Value: 0x{{[0-9a-f]+}}
+# CHECK-NEXT:   Size: 0
+# CHECK-NEXT:   Binding: Local (0x0)
+# CHECK-NEXT:   Type: None (0x0)
+# CHECK-NEXT:   Other: 0
+#
+# CHECK:   Name: $t (9)
+# CHECK-NEXT:   Value: 0x{{[0-9a-f]+}}
+# CHECK-NEXT:   Size: 0
+# CHECK-NEXT:   Binding: Local (0x0)
+# CHECK-NEXT:   Type: None (0x0)
+# CHECK-NEXT:   Other: 0
+#
+# CHECK:   Name: $d (24)
+# CHECK-NEXT:   Value: 0x{{[0-9a-f]+}}
+# CHECK-NEXT:   Size: 0
+# CHECK-NEXT:   Binding: Local (0x0)
+# CHECK-NEXT:   Type: None (0x0)
+# CHECK-NEXT:   Other: 0
+
+# arm.o
+---
+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:         00482DE904B08DE2FEFFFFEB0030A0E10300A0E10088BDE8
+  - Name:            .rel.text
+    Type:            SHT_REL
+    Link:            .symtab
+    AddressAlign:    0x0000000000000004
+    Info:            .text
+    Relocations:
+      - Offset:          0x0000000000000008
+        Symbol:          _Z1fv
+        Type:            R_ARM_CALL
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000001
+    Content:         ''
+  - Name:            .bss
+    Type:            SHT_NOBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000001
+    Content:         ''
+Symbols:
+  Local:
+    - Name:            '$a'
+      Section:         .text
+  Global:
+    - Name:            main
+      Type:            STT_FUNC
+      Section:         .text
+    - Name:            _Z1fv
+
+# thm.o
+---
+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:         80B400AF40F20003C0F200031B681846BD465DF8047B7047
+  - Name:            .rel.text
+    Type:            SHT_REL
+    Link:            .symtab
+    AddressAlign:    0x0000000000000004
+    Info:            .text
+    Relocations:
+      - Offset:          0x0000000000000004
+        Symbol:          _ZL1i
+        Type:            R_ARM_THM_MOVW_ABS_NC
+      - Offset:          0x0000000000000008
+        Symbol:          _ZL1i
+        Type:            R_ARM_THM_MOVT_ABS
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000001
+    Content:         ''
+  - Name:            .bss
+    Type:            SHT_NOBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000004
+    Content:         411C0000
+Symbols:
+  Local:
+    - Name:            _ZL1i
+      Type:            STT_OBJECT
+      Section:         .bss
+      Size:            0x0000000000000004
+    - Name:            '$d'
+      Section:         .bss
+    - Name:            '$t'
+      Section:         .text
+  Global:
+    - Name:            _Z1fv
+      Type:            STT_FUNC
+      Section:         .text
+      Value:           0x0000000000000001
+...