[lld] Correct forming of ARM/Thumb atoms

[denis-protivensky]

Summary

Symbols addressing Thumb code have zero bit set in st_value to distinguish them from ARM instructions.
This caused wrong atoms' forming because of offset of one byte brought in by that corrected st_value.

Fixed reading of st_value & st_value-related things in ARMELFFile while forming atoms.
Symbol table generation is also fixed for Thumb atoms.

[• shankar.easwaran]

lib/ReaderWriter/ELF/ARM/ARMELFFile.h

56

You are duplicating a lot of base class functionality

73

Why static?

128

Once you have the base function for getSymbolValue this function can be removed.

144

Add a base class function getSymbolValue and you can override that in ARM.

[denis-protivensky]

lib/ReaderWriter/ELF/ARM/ARMELFFile.h

56

Okay, I'll introduce getSymbolValue as for ELFFile.

73

This function is more like a helper which doesn't affect object's state and doesn't contain any logic connected directly with ELFFile. The same one is in ARMELFDefinedAtom and the only reason I couldn't move it out of classes is that it uses class-level Elf_Sym typedef. If you don't like that, I'll make it a class's member.

144

Agree.

[denis-protivensky]

Updated:

• Removed lots of overrides from ARMELFDefinedAtom and ARMELFFile by adding getSymbolValue method in both base classes and overriding it in the corresponding children
• Regrouped tests by putting all symbol-related test cases into ARM- and Thumb-specific bundles
• Added tests to check exact content generation for ARM and Thumb objects

[shankarke]

LGTM.

[ruiu]

LGTM

include/lld/Core/DefinedAtom.h

public:
 
   // Attributes describe a code model used by the atom.
   enum CodeModel {
     codeNA,           // no specific code model
     codeMipsPIC,      // PIC function in a PIC / non-PIC mixed file
     codeMipsMicro,    // microMIPS instruction encoding
     codeMipsMicroPIC, // microMIPS instruction encoding + PIC
     codeMips16,       // MIPS-16 instruction encoding
+    codeARMThumb,     // ARM Thumb instruction set
   };
 
   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> 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 {
+    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;
+  }
+
+  DefinedAtom::CodeModel codeModel() const override {
+    if (isThumbFunc(this->_symbol))
+      return DefinedAtom::codeARMThumb;
+    return DefinedAtom::codeNA;
+  }
+};
+
 template <class ELFT> class ARMELFFile : public ELFFile<ELFT> {
 public:
   ARMELFFile(std::unique_ptr<MemoryBuffer> mb, bool atomizeStrings)
       : ELFFile<ELFT>(std::move(mb), atomizeStrings) {}
 
   static ErrorOr<std::unique_ptr<ARMELFFile>>
   create(std::unique_ptr<MemoryBuffer> mb, bool atomizeStrings) {
     return std::unique_ptr<ARMELFFile<ELFT>>(
         new ARMELFFile<ELFT>(std::move(mb), atomizeStrings));
   }
+
+private:
+  typedef llvm::object::Elf_Sym_Impl<ELFT> Elf_Sym;
+  typedef llvm::object::Elf_Shdr_Impl<ELFT> Elf_Shdr;
+
+  /// 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 symbol->getType() == llvm::ELF::STT_FUNC ? value & ~0x1 : value;
+  }
+
+  /// 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 {
+    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/ARMExecutableWriter.h

 //===--------- lib/ReaderWriter/ELF/ARM/ARMExecutableWriter.h -------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 #ifndef LLD_READER_WRITER_ELF_ARM_ARM_EXECUTABLE_WRITER_H
 #define LLD_READER_WRITER_ELF_ARM_ARM_EXECUTABLE_WRITER_H
 
 #include "ExecutableWriter.h"
 #include "ARMLinkingContext.h"
 #include "ARMTargetHandler.h"
+#include "ARMSymbolTable.h"
 
 namespace lld {
 namespace elf {
 
 template <class ELFT>
 class ARMExecutableWriter : public ExecutableWriter<ELFT> {
 public:
   ARMExecutableWriter(ARMLinkingContext &context,
                       ARMTargetLayout<ELFT> &layout);
 
 protected:
   // Add any runtime files and their atoms to the output
   bool createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
 
   void finalizeDefaultAtomValues() override {
     // Finalize the atom values that are part of the parent.
     ExecutableWriter<ELFT>::finalizeDefaultAtomValues();
   }
 
   void addDefaultAtoms() override {
     ExecutableWriter<ELFT>::addDefaultAtoms();
   }
 
+  /// \brief Create symbol table.
+  LLD_UNIQUE_BUMP_PTR(SymbolTable<ELFT>) createSymbolTable() override;
+
 private:
   ARMLinkingContext &_context;
   ARMTargetLayout<ELFT> &_armLayout;
 };
 
 template <class ELFT>
 ARMExecutableWriter<ELFT>::ARMExecutableWriter(ARMLinkingContext &context,
                                                ARMTargetLayout<ELFT> &layout)
     : ExecutableWriter<ELFT>(context, layout), _context(context),
       _armLayout(layout) {}
 
 template <class ELFT>
 bool ARMExecutableWriter<ELFT>::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
   ExecutableWriter<ELFT>::createImplicitFiles(result);
   return true;
 }
 
+template <class ELFT>
+LLD_UNIQUE_BUMP_PTR(SymbolTable<ELFT>)
+    ARMExecutableWriter<ELFT>::createSymbolTable() {
+  return LLD_UNIQUE_BUMP_PTR(SymbolTable<ELFT>)(
+      new (this->_alloc) ARMSymbolTable<ELFT>(this->_context));
+}
+
 } // namespace elf
 } // namespace lld
 
 #endif // LLD_READER_WRITER_ELF_ARM_ARM_EXECUTABLE_WRITER_H

lib/ReaderWriter/ELF/ARM/ARMSymbolTable.h

+//===--------- lib/ReaderWriter/ELF/ARM/ARMSymbolTable.h ------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_READER_WRITER_ELF_ARM_ARM_SYMBOL_TABLE_H
+#define LLD_READER_WRITER_ELF_ARM_ARM_SYMBOL_TABLE_H
+
+namespace lld {
+namespace elf {
+
+/// \brief The SymbolTable class represents the symbol table in a ELF file
+template<class ELFT>
+class ARMSymbolTable : public SymbolTable<ELFT> {
+public:
+  typedef llvm::object::Elf_Sym_Impl<ELFT> Elf_Sym;
+
+  ARMSymbolTable(const ELFLinkingContext &context);
+
+  void addDefinedAtom(Elf_Sym &sym, const DefinedAtom *da,
+                      int64_t addr) override;
+};
+
+template <class ELFT>
+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
+  if (DefinedAtom::codeARMThumb == da->codeModel())
+    sym.st_value = static_cast<int64_t>(sym.st_value) | 0x1;
+}
+
+} // elf
+} // lld
+
+#endif // LLD_READER_WRITER_ELF_ARM_ARM_SYMBOL_TABLE_H

lib/ReaderWriter/ELF/Atoms.h

case llvm::ELF::SHT_FINI_ARRAY:
       ret = typeData;
       break;
     }
 
     return _contentType = ret;
   }
 
   Alignment alignment() const override {
+    // Obtain proper value of st_value field.
+    const auto symValue = getSymbolValue(_symbol);
+
     // 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(_symbol->st_value));
+      return Alignment(llvm::Log2_64(symValue));
     } else if (_section->sh_addralign == 0) {
       // sh_addralign of 0 means no alignment
-      return Alignment(0, _symbol->st_value);
+      return Alignment(0, symValue);
     }
     return Alignment(llvm::Log2_64(_section->sh_addralign),
-                     _symbol->st_value % _section->sh_addralign);
+                     symValue % _section->sh_addralign);
   }
 
   // Do we have a choice for ELF?  All symbols live in explicit sections.
   SectionChoice sectionChoice() const override {
     switch (contentType()) {
     case typeCode:
     case typeData:
     case typeZeroFill:
public:
   void addReference(ELFReference<ELFT> *reference) {
     _referenceList.push_back(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;
+  }
+
+protected:
   const ELFFile<ELFT> &_owningFile;
   StringRef _symbolName;
   StringRef _sectionName;
   const Elf_Sym *_symbol;
   const Elf_Shdr *_section;
   /// \brief Holds the bits that make up the atom.
   ArrayRef<uint8_t> _contentData;
 

lib/ReaderWriter/ELF/ELFFile.h

protected:
   /// actual storage has not yet been allocated. (The linker will allocate
   /// storage for them in the later pass after coalescing tentative symbols by
   /// name.)
   virtual bool isCommonSymbol(const Elf_Sym *symbol) const {
     return symbol->getType() == llvm::ELF::STT_COMMON ||
            symbol->st_shndx == llvm::ELF::SHN_COMMON;
   }
 
+  /// 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;
+  }
+
   /// Process the common symbol and create an atom for it.
   virtual ErrorOr<ELFCommonAtom<ELFT> *>
   handleCommonSymbol(StringRef symName, const Elf_Sym *sym) {
     return new (_readerStorage) ELFCommonAtom<ELFT>(*this, symName, sym);
   }
 
   /// Returns true if the symbol is a defined symbol.
   virtual bool isDefinedSymbol(const Elf_Sym *sym) const {
for (; SymI != SymE; ++SymI) {
     const Elf_Shdr *section = _objFile->getSection(&*SymI);
 
     auto symbolName = _objFile->getSymbolName(SymI);
     if (std::error_code ec = symbolName.getError())
       return ec;
 
     if (isAbsoluteSymbol(&*SymI)) {
       ErrorOr<ELFAbsoluteAtom<ELFT> *> absAtom =
-          handleAbsoluteSymbol(*symbolName, &*SymI, SymI->st_value);
+          handleAbsoluteSymbol(*symbolName, &*SymI, (int64_t)getSymbolValue(&*SymI));
       _absoluteAtoms._atoms.push_back(*absAtom);
       _symbolToAtomMapping.insert(std::make_pair(&*SymI, *absAtom));
     } else if (isUndefinedSymbol(&*SymI)) {
       ErrorOr<ELFUndefinedAtom<ELFT> *> undefAtom =
           handleUndefinedSymbol(*symbolName, &*SymI);
       _undefinedAtoms._atoms.push_back(*undefAtom);
       _symbolToAtomMapping.insert(std::make_pair(&*SymI, *undefAtom));
     } else if (isCommonSymbol(&*SymI)) {

 
 template <class ELFT> std::error_code ELFFile<ELFT>::createAtoms() {
   for (auto &i : _sectionSymbols) {
     const Elf_Shdr *section = i.first;
     std::vector<Elf_Sym_Iter> &symbols = i.second;
 
     // Sort symbols by position.
     std::stable_sort(symbols.begin(), symbols.end(),
-                     [](Elf_Sym_Iter A,
-                        Elf_Sym_Iter B) { return A->st_value < B->st_value; });
+                     [this](Elf_Sym_Iter A, Elf_Sym_Iter B)
+                         { return getSymbolValue(&*A) < getSymbolValue(&*B); });
 
     ErrorOr<StringRef> sectionName = this->getSectionName(section);
     if (std::error_code ec = sectionName.getError())
       return ec;
 
     auto sectionContents = getSectionContents(section);
     if (std::error_code ec = sectionContents.getError())
       return ec;
for (auto si = symbols.begin(), se = symbols.end(); si != se; ++si) {
         } else {
           followOn = new (_readerStorage)
               ELFReference<ELFT>(lld::Reference::kindLayoutAfter);
           previousAtom->addReference(followOn);
         }
       }
 
       ArrayRef<uint8_t> symbolData((const uint8_t *)sectionContents->data() +
-                                       symbol->st_value,
+                                       getSymbolValue(&*symbol),
                                    contentSize);
 
       // If the linker finds that a section has global atoms that are in a
       // mergeable section, treat them as defined atoms as they shouldn't be
       // merged away as well as these symbols have to be part of symbol
       // resolution
       if (isMergeableStringSection(section)) {
         if (symbol->getBinding() == llvm::ELF::STB_GLOBAL) {
return *handleDefinedSymbol(symbolName, sectionName, symbol, section,
                               _references);
 }
 
 template <class ELFT>
 void ELFFile<ELFT>::createRelocationReferences(const Elf_Sym &symbol,
                                                ArrayRef<uint8_t> content,
                                                range<Elf_Rela_Iter> rels) {
   bool isMips64EL = _objFile->isMips64EL();
+  const auto symValue = getSymbolValue(&symbol);
   for (const auto &rel : rels) {
-    if (rel.r_offset < symbol.st_value ||
-        symbol.st_value + content.size() <= rel.r_offset)
+    if (rel.r_offset < symValue ||
+        symValue + content.size() <= rel.r_offset)
       continue;
     _references.push_back(new (_readerStorage) ELFReference<ELFT>(
-        &rel, rel.r_offset - symbol.st_value, kindArch(),
+        &rel, rel.r_offset - symValue, kindArch(),
         rel.getType(isMips64EL), rel.getSymbol(isMips64EL)));
   }
 }
 
 template <class ELFT>
 void ELFFile<ELFT>::createRelocationReferences(const Elf_Sym &symbol,
                                                ArrayRef<uint8_t> symContent,
                                                ArrayRef<uint8_t> secContent,
                                                range<Elf_Rel_Iter> rels) {
   bool isMips64EL = _objFile->isMips64EL();
+  const auto symValue = getSymbolValue(&symbol);
   for (const auto &rel : rels) {
-    if (rel.r_offset < symbol.st_value ||
-        symbol.st_value + symContent.size() <= rel.r_offset)
+    if (rel.r_offset < symValue ||
+        symValue + symContent.size() <= rel.r_offset)
       continue;
     _references.push_back(new (_readerStorage) ELFReference<ELFT>(
-        &rel, rel.r_offset - symbol.st_value, kindArch(),
+        &rel, rel.r_offset - symValue, kindArch(),
         rel.getType(isMips64EL), rel.getSymbol(isMips64EL)));
-    int32_t addend = *(symContent.data() + rel.r_offset - symbol.st_value);
+    int32_t addend = *(symContent.data() + rel.r_offset - symValue);
     _references.back()->setAddend(addend);
   }
 }
 
 template <class ELFT>
 void ELFFile<ELFT>::updateReferenceForMergeStringAccess(ELFReference<ELFT> *ref,
                                                         const Elf_Sym *symbol,
                                                         const Elf_Shdr *shdr) {
if (msec != _mergedSectionMap.end()) {
     ref->setTarget(msec->second);
     return;
   }
 
   // The target atom was not merged. Mergeable atoms are not in
   // _symbolToAtomMapping, so we cannot find it by calling findAtom(). We
   // instead call findMergeAtom().
   if (symbol->getType() != llvm::ELF::STT_SECTION)
-    addend = symbol->st_value + addend;
+    addend = getSymbolValue(symbol) + addend;
   ELFMergeAtom<ELFT> *mergedAtom = findMergeAtom(shdr, addend);
   ref->setOffset(addend - mergedAtom->offset());
   ref->setAddend(0);
   ref->setTarget(mergedAtom);
 }
 
 template <class ELFT> void ELFFile<ELFT>::updateReferences() {
   for (auto &ri : _references) {
ELFFile<ELFT>::createSectionAtom(const Elf_Shdr *section, StringRef sectionName,
   newAtom->setOrdinal(++_ordinal);
   return newAtom;
 }
 
 template <class ELFT>
 uint64_t ELFFile<ELFT>::symbolContentSize(const Elf_Shdr *section,
                                           const Elf_Sym *symbol,
                                           const Elf_Sym *nextSymbol) {
+  const auto symValue = getSymbolValue(symbol);
   // if this is the last symbol, take up the remaining data.
-  return nextSymbol ? nextSymbol->st_value - symbol->st_value
-                    : section->sh_size - symbol->st_value;
+  return nextSymbol ? getSymbolValue(nextSymbol) - symValue
+                    : section->sh_size - symValue;
 }
 
 template <class ELFT>
 void ELFFile<ELFT>::createEdge(ELFDefinedAtom<ELFT> *from,
                                ELFDefinedAtom<ELFT> *to, uint32_t edgeKind) {
   auto reference = new (_readerStorage) ELFReference<ELFT>(edgeKind);
   reference->setTarget(to);
   from->addReference(reference);
 }
 
 } // end namespace elf
 } // end namespace lld
 
 #endif // LLD_READER_WRITER_ELF_FILE_H

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);
   }
 };
 
 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/arm-symbols.test

+# Check that symbols formed from ARM instructions are valid:
+# 1. Symbol address.
+# 2. Symbol content size.
+# 3. Symbol content.
+
+# RUN: yaml2obj -format=elf %s > %t-a.o
+# RUN: lld -flavor gnu -target arm-linux-gnu \
+# RUN: -Bstatic --noinhibit-exec %t-a.o -o %t-a
+# RUN: llvm-readobj -symbols %t-a | FileCheck -check-prefix=SYM-ADDR %s
+# RUN: llvm-readobj -symbols %t-a | FileCheck -check-prefix=SYM-SIZE %s
+# RUN: llvm-objdump -s -t %t-a | FileCheck -check-prefix=SYM-CONTENT %s
+
+# SYM-ADDR:   Name: main (1)
+# SYM-ADDR-NEXT:   Value: 0x400074
+
+# SYM-SIZE:   Name: main (1)
+# SYM-SIZE-NEXT:   Value: 0x{{[0-9a-f]+}}
+# SYM-SIZE-NEXT:   Size: 28
+
+# SYM-CONTENT: Contents of section .text:
+# SYM-CONTENT-NEXT: 400074 04b02de5 00b08de2 0030a0e3 0300a0e1  ..-......0......
+# SYM-CONTENT-NEXT: 400084 00d04be2 04b09de4 1eff2fe1           ..K......./.
+
+---
+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:         04B02DE500B08DE20030A0E30300A0E100D04BE204B09DE41EFF2FE1
+  - 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:
+  Global:
+    - Name:            main
+      Type:            STT_FUNC
+      Section:         .text
+...

test/elf/ARM/defsym.test

 # Check that defined symbols are present in the generated executable
 
 # RUN: yaml2obj -format=elf %s > %t-o.o
-# RUN: lld -flavor gnu -target arm-linux-gnu --defsym=main=fn -e=fn \
-# RUN: -static --noinhibit-exec %t-o.o -o %t
+# RUN: lld -flavor gnu -target arm-linux-gnu --defsym=main=fn \
+# RUN: -Bstatic --noinhibit-exec %t-o.o -o %t
 # RUN: llvm-readobj -symbols %t | FileCheck %s
 
-# CHECK: Symbol {
 # CHECK:   Name: main (1)
-# CHECK:   Value: 0x400075
-# CHECK:   Size: 0
-# CHECK:   Binding: Global (0x1)
-# CHECK:   Type: Function (0x2)
-# CHECK:   Other: 0
-# CHECK:   Section: .text (0x1)
-# CHECK: }
-# CHECK: Symbol {
+# CHECK-NEXT:   Value: 0x400074
+# CHECK-NEXT:   Size: 0
+# CHECK-NEXT:   Binding: Global (0x1)
+# CHECK-NEXT:   Type: Function (0x2)
+# CHECK-NEXT:   Other: 0
+# CHECK-NEXT:   Section: .text (0x1)
 # CHECK:   Name: fn (6)
-# CHECK:   Value: 0x400075
-# CHECK:   Size: 15
-# CHECK:   Binding: Global (0x1)
-# CHECK:   Type: Function (0x2)
-# CHECK:   Other: 0
-# CHECK:   Section: .text (0x1)
-# CHECK: }
+# CHECK-NEXT:   Value: 0x400074
+# CHECK-NEXT:   Size: {{[0-9]+}}
+# CHECK-NEXT:   Binding: Global (0x1)
+# CHECK-NEXT:   Type: Function (0x2)
+# CHECK-NEXT:   Other: 0
+# CHECK-NEXT:   Section: .text (0x1)
 
 ---
 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
+    Content:         04B02DE500B08DE20030A0E30300A0E100D04BE204B09DE41EFF2FE1
   - 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:         ''
-  - Name:            .note.GNU-stack
-    Type:            SHT_PROGBITS
-    AddressAlign:    0x0000000000000001
-    Content:         ''
 Symbols:
-  Local:
-    - Name:            .text
-      Type:            STT_SECTION
-      Section:         .text
-    - Name:            .data
-      Type:            STT_SECTION
-      Section:         .data
-    - Name:            .bss
-      Type:            STT_SECTION
-      Section:         .bss
-    - Name:            .note.GNU-stack
-      Type:            STT_SECTION
-      Section:         .note.GNU-stack
   Global:
     - Name:            fn
       Type:            STT_FUNC
       Section:         .text
-      Value:           0x0000000000000001
-      Size:            0x0000000000000010
 ...

test/elf/ARM/thm-symbols.test

+# Check that symbols formed from Thumb instructions are valid:
+# 1. Symbol address.
+# 2. Symbol content size.
+# 3. Symbol content.
+
+# RUN: yaml2obj -format=elf %s > %t-t.o
+# RUN: lld -flavor gnu -target arm-linux-gnu \
+# RUN: -Bstatic --noinhibit-exec %t-t.o -o %t-t
+# RUN: llvm-readobj -symbols %t-t | FileCheck -check-prefix=SYM-ADDR %s
+# RUN: llvm-readobj -symbols %t-t | FileCheck -check-prefix=SYM-SIZE %s
+# RUN: llvm-objdump -s -t %t-t | FileCheck -check-prefix=SYM-CONTENT %s
+
+# SYM-ADDR:   Name: main (1)
+# SYM-ADDR-NEXT:   Value: 0x400075
+
+# SYM-SIZE:   Name: main (1)
+# SYM-SIZE-NEXT:   Value: 0x{{[0-9a-f]+}}
+# SYM-SIZE-NEXT:   Size: 16
+
+# SYM-CONTENT: Contents of section .text:
+# SYM-CONTENT-NEXT: 400074 80b400af 00231846 bd465df8 047b7047  .....#.F.F]..{pG
+
+---
+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:
+  Global:
+    - Name:            main
+      Type:            STT_FUNC
+      Section:         .text
+      Value:           0x0000000000000001
+...