[ELF] Add CodeModel attribute to the DefinedAtom class

[atanasyan]

Summary

MIPS ELF symbols might contain some additional MIPS-specific flags in the st_other field besides visibility ones. These flags indicate code properties like microMIPS / MIPS16 encoding, position independent code etc. We need to transfer the flags from input objects to the output linked file to write them into the symbol table, adjust symbols addresses etc.

I add new attribute CodeModel to the DefinedAtom class to hold target specific flag and to get over YAML/Native format conversion barrier. Other architectures/targets can extend CodeModel enumeration by their own flags.

MIPS specific part of this patch adds support for STO_MIPS_MICROMIPS flag. This flag marks microMIPS symbols. Such symbol should:

• Has STO_MIPS_MICROMIPS in the corresponding .symtab record.
• Has adjusted (odd) address in the corresponding .symtab and .dynsym records.

[kledzik]

The common code looks good to me.

I did notice that you parse the st_other to get all four MIPS code models, but when building a symbol table only two models are handled. Does that mean running ld -r on a .o file will lose model info?

[ruiu]

LGTM but please address Nick's comment before submitting.

lib/ReaderWriter/ELF/Mips/MipsDynamicLibraryWriter.h

82

nit: is this what clang-format formatted?

[atanasyan]

I plan to implement microMIPS (pic and non-pic) code model support soon. That is why I handle codeMipsMicro and codeMipsMicroPIC flags and postpone processing of codeMips16.

[atanasyan]

lib/ReaderWriter/ELF/Mips/MipsDynamicLibraryWriter.h

82

Yes, it looks strange a bit but it is result of the clang-format.

[atanasyan]

Thanks for review.

Closed by commit rL221864

include/lld/Core/DefinedAtom.h

public:
   enum DynamicExport {
     /// \brief The linker may or may not export this atom dynamically depending
     ///   on the output type and other context of the link.
     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
+    codeMipsPIC,      // PIC function in a PIC / non-PIC mixed file
+    codeMipsMicro,    // microMIPS instruction encoding
+    codeMipsMicroPIC, // microMIPS instruction encoding + PIC
+    codeMips16,       // MIPS-16 instruction encoding
+  };
+
   struct Alignment {
     Alignment(int p2, int m = 0)
       : powerOf2(p2)
       , modulus(m) {}
 
     uint16_t powerOf2;
     uint16_t modulus;
 
public:
   /// \brief constraints on whether the linker may dead strip away this atom.
   virtual DeadStripKind deadStrip() const = 0;
 
   /// \brief Under which conditions should this atom be dynamically exported.
   virtual DynamicExport dynamicExport() const {
     return dynamicExportNormal;
   }
 
+  /// \brief Code model used by the atom.
+  virtual CodeModel codeModel() const { return codeNA; }
+
   /// \brief Returns the OS memory protections required for this atom's content
   /// at runtime.
   ///
   /// A function atom is R_X, a global variable is RW_, and a read-only constant
   /// is R__.
   virtual ContentPermissions permissions() const;
 
   /// \brief returns a reference to the raw (unrelocated) bytes of this Atom's

lib/ReaderWriter/ELF/Mips/MipsDynamicLibraryWriter.h

 #include "DynamicLibraryWriter.h"
 #include "MipsDynamicTable.h"
 #include "MipsELFWriters.h"
 #include "MipsLinkingContext.h"
 
 namespace lld {
 namespace elf {
 
+template <typename ELFT> class MipsSymbolTable;
 template <typename ELFT> class MipsDynamicSymbolTable;
 template <typename ELFT> class MipsTargetLayout;
 
 template <class ELFT>
 class MipsDynamicLibraryWriter : public DynamicLibraryWriter<ELFT> {
 public:
   MipsDynamicLibraryWriter(MipsLinkingContext &ctx,
                            MipsTargetLayout<ELFT> &layout,
                            MipsELFFlagsMerger &elfFlagsMerger);
 
 protected:
   // Add any runtime files and their atoms to the output
   bool createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
 
   void finalizeDefaultAtomValues() override;
 
   std::error_code setELFHeader() override {
     DynamicLibraryWriter<ELFT>::setELFHeader();
     _writeHelper.setELFHeader(*this->_elfHeader);
     return std::error_code();
   }
 
+  LLD_UNIQUE_BUMP_PTR(SymbolTable<ELFT>) createSymbolTable() override;
   LLD_UNIQUE_BUMP_PTR(DynamicTable<ELFT>) createDynamicTable() override;
 
   LLD_UNIQUE_BUMP_PTR(DynamicSymbolTable<ELFT>)
       createDynamicSymbolTable() override;
 
 private:
   MipsELFWriter<ELFT> _writeHelper;
   MipsLinkingContext &_mipsContext;

 
 template <class ELFT>
 void MipsDynamicLibraryWriter<ELFT>::finalizeDefaultAtomValues() {
   // Finalize the atom values that are part of the parent.
   DynamicLibraryWriter<ELFT>::finalizeDefaultAtomValues();
   _writeHelper.finalizeMipsRuntimeAtomValues();
 }
 
+template <class ELFT>
+LLD_UNIQUE_BUMP_PTR(SymbolTable<ELFT>)
+    MipsDynamicLibraryWriter<ELFT>::createSymbolTable() {
+  return LLD_UNIQUE_BUMP_PTR(SymbolTable<ELFT>)(new (
+      this->_alloc) MipsSymbolTable<ELFT>(_mipsContext));
+}
+
 /// \brief create dynamic table
 template <class ELFT>
 LLD_UNIQUE_BUMP_PTR(DynamicTable<ELFT>)
     MipsDynamicLibraryWriter<ELFT>::createDynamicTable() {
   return LLD_UNIQUE_BUMP_PTR(DynamicTable<ELFT>)(new (
       this->_alloc) MipsDynamicTable<ELFT>(_mipsContext, _mipsTargetLayout));
 }
 

lib/ReaderWriter/ELF/Mips/MipsELFFile.h

MipsELFDefinedAtom(const MipsELFFile<ELFT> &file, StringRef symbolName,
                      std::vector<ELFReference<ELFT> *> &referenceList)
       : ELFDefinedAtom<ELFT>(file, symbolName, sectionName, symbol, section,
                              contentData, referenceStart, referenceEnd,
                              referenceList) {}
 
   const MipsELFFile<ELFT>& file() const override {
     return static_cast<const MipsELFFile<ELFT> &>(this->_owningFile);
   }
+
+  DefinedAtom::CodeModel codeModel() const override {
+    switch (this->_symbol->st_other & llvm::ELF::STO_MIPS_MIPS16) {
+    case llvm::ELF::STO_MIPS_MIPS16:
+      return DefinedAtom::codeMips16;
+    case llvm::ELF::STO_MIPS_PIC:
+      return DefinedAtom::codeMipsPIC;
+    case llvm::ELF::STO_MIPS_MICROMIPS:
+      return DefinedAtom::codeMipsMicro;
+    case llvm::ELF::STO_MIPS_MICROMIPS | llvm::ELF::STO_MIPS_PIC:
+      return DefinedAtom::codeMipsMicroPIC;
+    default:
+      return DefinedAtom::codeNA;
+    }
+  }
 };
 
 template <class ELFT> class MipsELFFile : public ELFFile<ELFT> {
 public:
   MipsELFFile(StringRef name, bool atomizeStrings)
       : ELFFile<ELFT>(name, atomizeStrings) {}
 
   MipsELFFile(std::unique_ptr<MemoryBuffer> mb, bool atomizeStrings,

lib/ReaderWriter/ELF/Mips/MipsExecutableWriter.h

protected:
   void finalizeDefaultAtomValues() override;
 
   std::error_code setELFHeader() override {
     ExecutableWriter<ELFT>::setELFHeader();
     _writeHelper.setELFHeader(*this->_elfHeader);
     return std::error_code();
   }
 
+  LLD_UNIQUE_BUMP_PTR(SymbolTable<ELFT>) createSymbolTable() override;
   LLD_UNIQUE_BUMP_PTR(DynamicTable<ELFT>) createDynamicTable() override;
 
   LLD_UNIQUE_BUMP_PTR(DynamicSymbolTable<ELFT>)
       createDynamicSymbolTable() override;
 
 private:
   MipsELFWriter<ELFT> _writeHelper;
   MipsLinkingContext &_mipsContext;

 
 template <class ELFT>
 void MipsExecutableWriter<ELFT>::finalizeDefaultAtomValues() {
   // Finalize the atom values that are part of the parent.
   ExecutableWriter<ELFT>::finalizeDefaultAtomValues();
   _writeHelper.finalizeMipsRuntimeAtomValues();
 }
 
+template <class ELFT>
+LLD_UNIQUE_BUMP_PTR(SymbolTable<ELFT>)
+    MipsExecutableWriter<ELFT>::createSymbolTable() {
+  return LLD_UNIQUE_BUMP_PTR(SymbolTable<ELFT>)(new (
+      this->_alloc) MipsSymbolTable<ELFT>(_mipsContext));
+}
+
 /// \brief create dynamic table
 template <class ELFT>
 LLD_UNIQUE_BUMP_PTR(DynamicTable<ELFT>)
     MipsExecutableWriter<ELFT>::createDynamicTable() {
   return LLD_UNIQUE_BUMP_PTR(DynamicTable<ELFT>)(new (
       this->_alloc) MipsDynamicTable<ELFT>(_mipsContext, _mipsTargetLayout));
 }
 

lib/ReaderWriter/ELF/Mips/MipsTargetHandler.h

private:
   static const Registry::KindStrings kindStrings[];
   MipsLinkingContext &_ctx;
   MipsELFFlagsMerger _elfFlagsMerger;
   std::unique_ptr<MipsRuntimeFile<Mips32ElELFType>> _runtimeFile;
   std::unique_ptr<MipsTargetLayout<Mips32ElELFType>> _targetLayout;
   std::unique_ptr<MipsTargetRelocationHandler> _relocationHandler;
 };
 
+template <class ELFT> class MipsSymbolTable : public SymbolTable<ELFT> {
+public:
+  typedef llvm::object::Elf_Sym_Impl<ELFT> Elf_Sym;
+
+  MipsSymbolTable(const MipsLinkingContext &ctx)
+      : SymbolTable<ELFT>(ctx, ".symtab",
+                          DefaultLayout<ELFT>::ORDER_SYMBOL_TABLE) {}
+
+  void addDefinedAtom(Elf_Sym &sym, const DefinedAtom *da,
+                      int64_t addr) override {
+    SymbolTable<ELFT>::addDefinedAtom(sym, da, addr);
+
+    switch (da->codeModel()) {
+    case DefinedAtom::codeMipsMicro:
+      sym.st_other |= llvm::ELF::STO_MIPS_MICROMIPS;
+      break;
+    case DefinedAtom::codeMipsMicroPIC:
+      sym.st_other |= llvm::ELF::STO_MIPS_MICROMIPS | llvm::ELF::STO_MIPS_PIC;
+      break;
+    default:
+      break;
+    }
+  }
+
+  void finalize(bool sort = true) override {
+    SymbolTable<ELFT>::finalize(sort);
+
+    for (auto &ste : this->_symbolTable) {
+      if (!ste._atom)
+        continue;
+      if (const auto *da = dyn_cast<DefinedAtom>(ste._atom)) {
+        if (da->codeModel() == DefinedAtom::codeMipsMicro ||
+            da->codeModel() == DefinedAtom::codeMipsMicroPIC) {
+          // Adjust dynamic microMIPS symbol value. That allows a dynamic
+          // linker to recognize and handle this symbol correctly.
+          ste._symbol.st_value = ste._symbol.st_value | 1;
+        }
+      }
+    }
+  }
+};
+
 template <class ELFT>
 class MipsDynamicSymbolTable : public DynamicSymbolTable<ELFT> {
 public:
   MipsDynamicSymbolTable(const MipsLinkingContext &ctx,
                          MipsTargetLayout<ELFT> &layout)
       : DynamicSymbolTable<ELFT>(ctx, layout, ".dynsym",
                                  DefaultLayout<ELFT>::ORDER_DYNAMIC_SYMBOLS),
         _targetLayout(layout) {}
 
   void sortSymbols() override {
     typedef typename DynamicSymbolTable<ELFT>::SymbolEntry SymbolEntry;
     std::stable_sort(this->_symbolTable.begin(), this->_symbolTable.end(),
                      [this](const SymbolEntry &A, const SymbolEntry &B) {
       if (A._symbol.getBinding() != STB_GLOBAL &&
           B._symbol.getBinding() != STB_GLOBAL)
         return A._symbol.getBinding() < B._symbol.getBinding();
 
       return _targetLayout.getGOTSection().compare(A._atom, B._atom);
     });
   }
 
   void finalize() override {
+    DynamicSymbolTable<ELFT>::finalize();
+
     const auto &pltSection = _targetLayout.getPLTSection();
 
-    // Under some conditions a dynamic symbol table record should hold a symbol
-    // value of the corresponding PLT entry. For details look at the PLT entry
-    // creation code in the class MipsRelocationPass. Let's update atomLayout
-    // fields for such symbols.
     for (auto &ste : this->_symbolTable) {
       if (!ste._atom)
         continue;
       if (auto *layout = pltSection.findPLTLayout(ste._atom)) {
+        // Under some conditions a dynamic symbol table record should hold
+        // a symbol value of the corresponding PLT entry. For details look
+        // at the PLT entry creation code in the class MipsRelocationPass.
+        // Let's update atomLayout fields for such symbols.
         assert(!ste._atomLayout);
         ste._symbol.st_value = layout->_virtualAddr;
         ste._symbol.st_other |= ELF::STO_MIPS_PLT;
+      } else if (const auto *da = dyn_cast<DefinedAtom>(ste._atom)) {
+        if (da->codeModel() == DefinedAtom::codeMipsMicro ||
+            da->codeModel() == DefinedAtom::codeMipsMicroPIC) {
+          // Adjust dynamic microMIPS symbol value. That allows a dynamic
+          // linker to recognize and handle this symbol correctly.
+          ste._symbol.st_value = ste._symbol.st_value | 1;
+        }
       }
     }
-
-    DynamicSymbolTable<Mips32ElELFType>::finalize();
   }
 
 private:
   MipsTargetLayout<ELFT> &_targetLayout;
 };
 
 } // end namespace elf
 } // end namespace lld
 
 #endif

lib/ReaderWriter/ELF/OutputELFWriter.h

protected:
   uint64_t addressOfAtom(const Atom *atom) override {
     auto addr = _atomToAddressMap.find(atom);
     return addr == _atomToAddressMap.end() ? 0 : addr->second;
   }
 
   // This is a hook for creating default dynamic entries
   virtual void createDefaultDynamicEntries() {}
 
+  /// \brief Create symbol table.
+  virtual LLD_UNIQUE_BUMP_PTR(SymbolTable<ELFT>) createSymbolTable();
+
   /// \brief create dynamic table.
   virtual LLD_UNIQUE_BUMP_PTR(DynamicTable<ELFT>) createDynamicTable();
 
   /// \brief create dynamic symbol table.
   virtual LLD_UNIQUE_BUMP_PTR(DynamicSymbolTable<ELFT>)
       createDynamicSymbolTable();
 
   /// \brief Create entry in the dynamic symbols table for this atom.

 }
 
 template <class ELFT> void OutputELFWriter<ELFT>::createDefaultSections() {
   _elfHeader.reset(new (_alloc) ELFHeader<ELFT>(_context));
   _programHeader.reset(new (_alloc) ProgramHeader<ELFT>(_context));
   _layout.setHeader(_elfHeader.get());
   _layout.setProgramHeader(_programHeader.get());
 
-  _symtab.reset(new (_alloc) SymbolTable<ELFT>(
-      _context, ".symtab", DefaultLayout<ELFT>::ORDER_SYMBOL_TABLE));
+  _symtab = std::move(this->createSymbolTable());
   _strtab.reset(new (_alloc) StringTable<ELFT>(
       _context, ".strtab", DefaultLayout<ELFT>::ORDER_STRING_TABLE));
   _shstrtab.reset(new (_alloc) StringTable<ELFT>(
       _context, ".shstrtab", DefaultLayout<ELFT>::ORDER_SECTION_STRINGS));
   _shdrtab.reset(new (_alloc) SectionHeader<ELFT>(
       _context, DefaultLayout<ELFT>::ORDER_SECTION_HEADERS));
   _layout.addSection(_symtab.get());
   _layout.addSection(_strtab.get());
if (_layout.hasDynamicRelocationTable())
       _layout.getDynamicRelocationTable()->setSymbolTable(
           _dynamicSymbolTable.get());
     if (_layout.hasPLTRelocationTable())
       _layout.getPLTRelocationTable()->setSymbolTable(
           _dynamicSymbolTable.get());
   }
 }
 
+template <class ELFT>
+LLD_UNIQUE_BUMP_PTR(SymbolTable<ELFT>)
+    OutputELFWriter<ELFT>::createSymbolTable() {
+  return LLD_UNIQUE_BUMP_PTR(SymbolTable<ELFT>)(new (_alloc) SymbolTable<ELFT>(
+      this->_context, ".symtab", DefaultLayout<ELFT>::ORDER_SYMBOL_TABLE));
+}
+
 /// \brief create dynamic table
 template <class ELFT>
 LLD_UNIQUE_BUMP_PTR(DynamicTable<ELFT>)
     OutputELFWriter<ELFT>::createDynamicTable() {
   return LLD_UNIQUE_BUMP_PTR(
       DynamicTable<ELFT>)(new (_alloc) DynamicTable<ELFT>(
       this->_context, _layout, ".dynamic", DefaultLayout<ELFT>::ORDER_DYNAMIC));
 }

lib/ReaderWriter/Native/NativeFileFormat.h

struct NativeAtomAttributesV1 {
   uint8_t   interposable;
   uint8_t   merge;
   uint8_t   contentType;
   uint8_t   sectionChoiceAndPosition; // high nibble is choice, low is position
   uint8_t   deadStrip;
   uint8_t   dynamicExport;
   uint8_t   permissions;
   uint8_t   alias;
+  uint8_t   codeModel;
 };
 
 
 
 //
 // The NCS_UndefinedAtomsV1 chunk contains an array of these structs
 //
 struct NativeUndefinedAtomIvarsV1 {

lib/ReaderWriter/Native/ReaderNative.cpp

public:
   DefinedAtom::DeadStripKind deadStrip() const override {
      return (DefinedAtom::DeadStripKind)(attributes().deadStrip);
   }
 
   DynamicExport dynamicExport() const override {
     return (DynamicExport)attributes().dynamicExport;
   }
 
+  DefinedAtom::CodeModel codeModel() const override {
+    return DefinedAtom::CodeModel(attributes().codeModel);
+  }
+
   DefinedAtom::ContentPermissions permissions() const override {
      return (DefinedAtom::ContentPermissions)(attributes().permissions);
   }
 
   ArrayRef<uint8_t> rawContent() const override;
 
   reference_iterator begin() const override;
 

lib/ReaderWriter/Native/WriterNative.cpp

NativeAtomAttributesV1 computeAttributesV1(const DefinedAtom& atom) {
     attrs.scope             = atom.scope();
     attrs.interposable      = atom.interposable();
     attrs.merge             = atom.merge();
     attrs.contentType       = atom.contentType();
     attrs.sectionChoiceAndPosition
                           = atom.sectionChoice() << 4 | atom.sectionPosition();
     attrs.deadStrip         = atom.deadStrip();
     attrs.dynamicExport     = atom.dynamicExport();
+    attrs.codeModel         = atom.codeModel();
     attrs.permissions       = atom.permissions();
     return attrs;
   }
 
   NativeAtomAttributesV1 computeAbsoluteAttributes(const AbsoluteAtom& atom) {
     NativeAtomAttributesV1 attrs;
     attrs.scope = atom.scope();
     return attrs;

lib/ReaderWriter/YAML/ReaderWriterYAML.cpp

 
 template <> struct ScalarEnumerationTraits<lld::DefinedAtom::DynamicExport> {
   static void enumeration(IO &io, lld::DefinedAtom::DynamicExport &value) {
     io.enumCase(value, "normal", lld::DefinedAtom::dynamicExportNormal);
     io.enumCase(value, "always", lld::DefinedAtom::dynamicExportAlways);
   }
 };
 
+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);
+  }
+};
+
 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__);
     io.enumCase(value, "r-x",     lld::DefinedAtom::permR_X);
     io.enumCase(value, "rw-",     lld::DefinedAtom::permRW_);
     io.enumCase(value, "rwx",     lld::DefinedAtom::permRWX);
public:
     }
     NormalizedAtom(IO &io, const lld::DefinedAtom *atom)
         : _file(fileFromContext(io)), _name(atom->name()), _refName(),
           _scope(atom->scope()), _interpose(atom->interposable()),
           _merge(atom->merge()), _contentType(atom->contentType()),
           _alignment(atom->alignment()), _sectionChoice(atom->sectionChoice()),
           _sectionPosition(atom->sectionPosition()),
           _deadStrip(atom->deadStrip()), _dynamicExport(atom->dynamicExport()),
+          _codeModel(atom->codeModel()),
           _permissions(atom->permissions()), _size(atom->size()),
           _sectionName(atom->customSectionName()) {
       for (const lld::Reference *r : *atom)
         _references.push_back(r);
       if (!atom->occupiesDiskSpace())
         return;
       ArrayRef<uint8_t> cont = atom->rawContent();
       _content.reserve(cont.size());
public:
     Merge merge() const override { return _merge; }
     ContentType contentType() const override { return _contentType; }
     Alignment alignment() const override { return _alignment; }
     SectionChoice sectionChoice() const override { return _sectionChoice; }
     StringRef customSectionName() const override { return _sectionName; }
     SectionPosition sectionPosition() const override { return _sectionPosition; }
     DeadStripKind deadStrip() const override { return _deadStrip; }
     DynamicExport dynamicExport() const override { return _dynamicExport; }
+    CodeModel codeModel() const override { return _codeModel; }
     ContentPermissions permissions() const override { return _permissions; }
     void setGroupChild(bool val) { _isGroupChild = val; }
     bool isGroupChild() const { return _isGroupChild; }
     ArrayRef<uint8_t> rawContent() const override {
       if (!occupiesDiskSpace())
         return ArrayRef<uint8_t>();
       return ArrayRef<uint8_t>(
           reinterpret_cast<const uint8_t *>(_content.data()), _content.size());
public:
     Interposable                        _interpose;
     Merge                               _merge;
     ContentType                         _contentType;
     Alignment                           _alignment;
     SectionChoice                       _sectionChoice;
     SectionPosition                     _sectionPosition;
     DeadStripKind                       _deadStrip;
     DynamicExport                       _dynamicExport;
+    CodeModel                           _codeModel;
     ContentPermissions                  _permissions;
     uint32_t                            _ordinal;
     std::vector<ImplicitHex8>           _content;
     uint64_t                            _size;
     StringRef                           _sectionName;
     std::vector<const lld::Reference *> _references;
     bool _isGroupChild;
   };
io.mapOptional("section-choice",   keys->_sectionChoice,
                                          DefinedAtom::sectionBasedOnContent);
     io.mapOptional("section-name",     keys->_sectionName, StringRef());
     io.mapOptional("section-position", keys->_sectionPosition,
                                          DefinedAtom::sectionPositionAny);
     io.mapOptional("dead-strip",       keys->_deadStrip,
                                          DefinedAtom::deadStripNormal);
     io.mapOptional("dynamic-export",   keys->_dynamicExport,
                                          DefinedAtom::dynamicExportNormal);
+    io.mapOptional("code-model",       keys->_codeModel, DefinedAtom::codeNA);
     // default permissions based on content type
     io.mapOptional("permissions",      keys->_permissions,
                                          DefinedAtom::permissions(
                                                           keys->_contentType));
     io.mapOptional("references",       keys->_references);
   }
 };
 

test/core/code-model-attributes.objtxt

+# RUN: lld -core %s | FileCheck %s
+
+#
+# Test that code model attributes are preserved
+#
+
+---
+defined-atoms:
+    - name:         _def
+---
+defined-atoms:
+    - name:         _none
+      code-model:   none
+---
+defined-atoms:
+    - name:         _mips_pic
+      code-model:   mips-pic
+---
+defined-atoms:
+    - name:         _mips_micro
+      code-model:   mips-micro
+---
+defined-atoms:
+    - name:         _mips_micro_pic
+      code-model:   mips-micro-pic
+---
+defined-atoms:
+    - name:         _mips_16
+      code-model:   mips-16
+...
+
+# CHECK:       name: _def
+# CHECK-NOT:   code-model: mips-pic
+# CHECK-NOT:   code-model: mips-micro
+# CHECK-NOT:   code-model: mips-micro-pic
+# CHECK-NOT:   code-model: mips-16
+# CHECK:       name: _none
+# CHECK-NOT:   code-model: mips-pic
+# CHECK-NOT:   code-model: mips-micro
+# CHECK-NOT:   code-model: mips-micro-pic
+# CHECK-NOT:   code-model: mips-16
+# CHECK:       name: _mips_pic
+# CHECK:       code-model: mips-pic
+# CHECK:       name: _mips_micro
+# CHECK:       code-model: mips-micro
+# CHECK:       name: _mips_micro_pic
+# CHECK:       code-model: mips-micro-pic
+# CHECK:       name: _mips_16
+# CHECK:       code-model: mips-16
+# CHECK:       ...

test/elf/Mips/st-other.test

+# Check STO_MICROMIPS flag handling. microMIPS symbol records in a dynamic
+# symbol table should not have STO_MICROMIPS flag but their value field
+# must be odd. microMIPS symbol records in a regular symbol table should
+# have the STO_MICROMIPS flag.
+
+# RUN: yaml2obj -format=elf %s > %t-micro.o
+
+# RUN: lld -flavor gnu -target mipsel -shared -o %t.so %t-micro.o
+# RUN: llvm-readobj -dyn-symbols %t.so | FileCheck -check-prefix=SO %s
+
+# RUN: lld -flavor gnu -target mipsel -e S0 -o %t.exe %t-micro.o
+# RUN: llvm-readobj -symbols %t.exe | FileCheck -check-prefix=EXE-SYM %s
+# RUN: llvm-readobj -dyn-symbols %t.exe | FileCheck -check-prefix=EXE-DSYM %s
+
+# SO:      Symbol {
+# SO:        Name: S0@ (1)
+# SO-NEXT:   Value: 0xEC
+# SO-NEXT:   Size: 4
+# SO-NEXT:   Binding: Global (0x1)
+# SO-NEXT:   Type: Function (0x2)
+# SO-NEXT:   Other: 0
+# SO-NEXT:   Section: .text (0x4)
+# SO-NEXT: }
+
+# SO:      Symbol {
+# SO:        Name: S1@ (4)
+# SO-NEXT:   Value: 0xF1
+# SO-NEXT:   Size: 4
+# SO-NEXT:   Binding: Global (0x1)
+# SO-NEXT:   Type: Function (0x2)
+# SO-NEXT:   Other: 0
+# SO-NEXT:   Section: .text (0x4)
+# SO-NEXT: }
+
+# EXE-SYM:      Symbol {
+# EXE-SYM:        Name: S0 (1)
+# EXE-SYM-NEXT:   Value: 0x400108
+# EXE-SYM-NEXT:   Size: 4
+# EXE-SYM-NEXT:   Binding: Global (0x1)
+# EXE-SYM-NEXT:   Type: Function (0x2)
+# EXE-SYM-NEXT:   Other: 0
+# EXE-SYM-NEXT:   Section: .text (0x5)
+# EXE-SYM-NEXT: }
+
+# EXE-SYM:      Symbol {
+# EXE-SYM:        Name: S1 (4)
+# EXE-SYM-NEXT:   Value: 0x40010D
+# EXE-SYM-NEXT:   Size: 4
+# EXE-SYM-NEXT:   Binding: Global (0x1)
+# EXE-SYM-NEXT:   Type: Function (0x2)
+# EXE-SYM-NEXT:   Other: 128
+# EXE-SYM-NEXT:   Section: .text (0x5)
+# EXE-SYM-NEXT: }
+
+# EXE-DSYM-NOT: Name: S1 (4)
+
+# micro.o
+---
+FileHeader:
+  Class:           ELFCLASS32
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_MIPS
+  Flags:           [EF_MIPS_ABI_O32, EF_MIPS_ARCH_32R2, EF_MIPS_MICROMIPS]
+
+Sections:
+  - Name:          .text
+    Type:          SHT_PROGBITS
+    Flags:         [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:  0x04
+    Size:          0x08
+
+Symbols:
+  Global:
+    - Name:       S0
+      Type:       STT_FUNC
+      Section:    .text
+      Size:       0x04
+      Value:      0x00
+      Visibility: STV_DEFAULT
+      Other:      [ ]
+
+    - Name:       S1
+      Type:       STT_FUNC
+      Section:    .text
+      Size:       0x04
+      Value:      0x04
+      Visibility: STV_DEFAULT
+      Other:      [ STO_MIPS_MICROMIPS ]
+...