ELF: Don't use LayoutPass.

[ruiu]

Summary

Previously we applied the LayoutPass to order atoms and then
apply elf::ArrayOrderPass to sort them again. The first pass is
basically supposed to sort atoms in the normal fashion (which
is to sort symbols in the same order as the input files).
The second pass sorts atoms in {init,fini}_array.<priority> by
priority.

The problem is that the LayoutPass is overkill. It analysize
references between atoms to make a decision how to sort them.
It's slow, hard to understand, and above all, it doesn't seem
that we need its feature for ELF in the first place.

This patch remove the LayoutPass from ELF pass list. Now all
reordering is done in elf::OrderPass. That pass sorts atoms by
{init,fini}_array, and if they are not in the special section,
they are ordered as the same order as they appear in the command
line. The new code is far easier to understand, faster, and
still able to create valid executables.

I might have simplified things too much, because previously
we sorted atoms not only by position but by its permissions etc.
Because I didn't see any legitimate need to do so, I just decided
not to do that in this patch.

This patch changes the order of final output, although that's
benign. I didn't update affected tests yet as I'd like to get
feedback first.

[Bigcheese]

I believe this is correct. We do permission binning in the ELF writer.

[• shankar.easwaran]

You cannot move the array order pass outside the elf writer. You might have a linker script or an atom order file that selects aroms from .init_array and move it to to the ,text section after all the .text. The layout pass needs to make sure atoms are sorted by link order and leave everything else to the ELF writer.

[Bigcheese]

The array order pass is already outside of the elf writer.

[atanasyan]

I agree with Michael, the idea looks correct. By the way I have checked the patch using the LLVM test suite for MIPS target and found no regressions.

[shankarke]

This is a bug that apparently will be seen when using linker scripts.

Linker scripts control this behavior by using SORT_BY_INIT_PRIORITY. This is usually not present on targets that dont support init array by priority.

This is not safe to be done before the writer, and makes it hard to support with linker scripts IMO, and the pass should be moved inside the ELFWriter.

We might want to consider enabling this pass only for targets that need support of running initializers by priority (Example : X86_64)

[shankarke]

This is a great idea though, that sorting by file ordinals / atom ordinals should be enough for the general case. If an order file is used then it makes sense to use the complete layout pass.

[ruiu]

Thank you for reviewing!

As to {init,fini}_array, sorting by {init,fini}_array priority is already there for all architectures and this patch doesn't change that. Currently LLD doesn't interpret SORT_BY_INIT_PRIORITY linker script. I believe there's no bug there (because the feature doesn't exist yet).

Looks like this patch is in the right direction. I'll update the tests and upload a new patch to Phab.

[ruiu]

Updated test as this patch changes the order of output, although that change is benign.

[shankarke]

Can you run the llvm test suite and build lld with lld to make sure they are working properly.

[ruiu]

All tests that passed before applying this patch still pass.

[• shankar.easwaran]

Thanks for the info.

LGTM

include/lld/Core/DefinedAtom.h

public:
   /// Utility function to check if the atom belongs to a group section
   /// that represents section groups or .gnu.linkonce sections.
   bool isGroupParent() const {
     ContentType atomContentType = contentType();
     return (atomContentType == DefinedAtom::typeGroupComdat ||
             atomContentType == DefinedAtom::typeGnuLinkOnce);
   }
 
+  // Returns true if lhs should be placed before rhs in the final output.
+  static bool compareByPosition(const DefinedAtom *lhs,
+                                const DefinedAtom *rhs);
+
 protected:
   // DefinedAtom is an abstract base class. Only subclasses can access
   // constructor.
   DefinedAtom() : Atom(definitionRegular) { }
 
   // The memory for DefinedAtom objects is always managed by the owning File
   // object.  Therefore, no one but the owning File object should call delete on
   // an Atom.  In fact, some File objects may bulk allocate an array of Atoms,

lib/Core/DefinedAtom.cpp

 //===- DefinedAtom.cpp ------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/ErrorHandling.h"
 #include "lld/Core/DefinedAtom.h"
-
+#include "lld/Core/File.h"
 
 namespace lld {
 
-
 DefinedAtom::ContentPermissions DefinedAtom::permissions() const {
   // By default base permissions on content type.
   return permissions(this->contentType());
 }
 
 // Utility function for deriving permissions from content type
 DefinedAtom::ContentPermissions DefinedAtom::permissions(ContentType type) {
   switch (type) {
DefinedAtom::ContentPermissions DefinedAtom::permissions(ContentType type) {
   case typeGnuLinkOnce:
   case typeUnknown:
   case typeTempLTO:
     return permUnknown;
   }
   llvm_unreachable("unknown content type");
 }
 
+bool DefinedAtom::compareByPosition(const DefinedAtom *lhs,
+                                    const DefinedAtom *rhs) {
+  const File *lhsFile = &lhs->file();
+  const File *rhsFile = &rhs->file();
+  if (lhsFile->ordinal() != rhsFile->ordinal())
+    return lhsFile->ordinal() < rhsFile->ordinal();
+  assert(lhs->ordinal() != rhs->ordinal());
+  return lhs->ordinal() < rhs->ordinal();
+}
 
 } // namespace
-

lib/ReaderWriter/ELF/ArrayOrderPass.h

-//===- lib/ReaderWriter/ELF/ArrayOrderPass.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_ARRAY_ORDER_PASS_H
-#define LLD_READER_WRITER_ELF_ARRAY_ORDER_PASS_H
-
-#include "lld/Core/Pass.h"
-
-namespace lld {
-namespace elf {
-/// \brief This pass sorts atoms in .{init,fini}_array.<priority> sections.
-class ArrayOrderPass : public Pass {
-public:
-  ArrayOrderPass() : Pass() {}
-  void perform(std::unique_ptr<MutableFile> &mergedFile) override;
-};
-}
-}
-
-#endif

lib/ReaderWriter/ELF/ArrayOrderPass.cpp

-//===- lib/ReaderWriter/ELF/ArrayOrderPass.cpp ----------------------------===//
-//
-//                             The LLVM Linker
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "ArrayOrderPass.h"
-#include <algorithm>
-#include <limits>
-
-namespace lld {
-namespace elf {
-void ArrayOrderPass::perform(std::unique_ptr<MutableFile> &f) {
-  auto definedAtoms = f->definedAtoms();
-
-  // Move sections need to be sorted into the separate continious group.
-  // That reduces a number of sorting elements and simplifies conditions
-  // in the sorting predicate.
-  auto last = std::stable_partition(definedAtoms.begin(), definedAtoms.end(),
-                                    [](const DefinedAtom *atom) {
-    if (atom->sectionChoice() != DefinedAtom::sectionCustomRequired)
-      return false;
-
-    StringRef name = atom->customSectionName();
-    return name.startswith(".init_array") || name.startswith(".fini_array");
-  });
-
-  std::stable_sort(definedAtoms.begin(), last,
-                   [](const DefinedAtom *left, const DefinedAtom *right) {
-    StringRef leftSec = left->customSectionName();
-    StringRef rightSec = right->customSectionName();
-
-    // Drop the front dot from the section name and get
-    // an optional section's number starting after the second dot.
-    StringRef leftNum = leftSec.drop_front().rsplit('.').second;
-    StringRef rightNum = rightSec.drop_front().rsplit('.').second;
-
-    // Sort {.init_array, .fini_array}[.<num>] sections
-    // according to their number. Sections without optional
-    // numer suffix should go last.
-
-    uint32_t leftPriority;
-    uint32_t rightPriority;
-    if (leftNum.getAsInteger(10, leftPriority))
-      leftPriority = std::numeric_limits<uint32_t>::max();
-    if (rightNum.getAsInteger(10, rightPriority))
-      rightPriority = std::numeric_limits<uint32_t>::max();
-
-    return leftPriority < rightPriority;
-  });
-}
-} // end namespace elf
-} // end namespace lld

lib/ReaderWriter/ELF/CMakeLists.txt

 add_llvm_library(lldELF
-  ArrayOrderPass.cpp
   ELFLinkingContext.cpp
   Reader.cpp
   Writer.cpp
   LINK_LIBS
     lldCore
     lldPasses
     lldYAML
     LLVMSupport

lib/ReaderWriter/ELF/ELFLinkingContext.cpp

 //===- lib/ReaderWriter/ELF/ELFLinkingContext.cpp -------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lld/ReaderWriter/ELFLinkingContext.h"
-#include "ArrayOrderPass.h"
 #include "ELFFile.h"
+#include "OrderPass.h"
 #include "TargetHandler.h"
 #include "lld/Core/Instrumentation.h"
 #include "lld/Core/SharedLibraryFile.h"
-#include "lld/Passes/LayoutPass.h"
 #include "lld/Passes/RoundTripYAMLPass.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Config/config.h"
 #include "llvm/Support/ELF.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 
: _outputELFType(llvm::ELF::ET_EXEC), _triple(triple),
       _isStaticExecutable(false), _noInhibitExec(false), _exportDynamic(false),
       _mergeCommonStrings(false), _useShlibUndefines(true),
       _dynamicLinkerArg(false), _noAllowDynamicLibraries(false),
       _mergeRODataToTextSegment(true), _demangle(true), _alignSegments(true),
       _outputMagic(OutputMagic::DEFAULT), _initFunction("_init"),
       _finiFunction("_fini"), _sysrootPath("") {}
 
 void ELFLinkingContext::addPasses(PassManager &pm) {
-  pm.add(std::unique_ptr<Pass>(new LayoutPass(registry())));
-  pm.add(std::unique_ptr<Pass>(new elf::ArrayOrderPass()));
+  pm.add(std::unique_ptr<Pass>(new elf::OrderPass()));
 }
 
 uint16_t ELFLinkingContext::getOutputMachine() const {
   switch (getTriple().getArch()) {
   case llvm::Triple::x86:
     return llvm::ELF::EM_386;
   case llvm::Triple::x86_64:
     return llvm::ELF::EM_X86_64;

lib/ReaderWriter/ELF/OrderPass.h

+//===- lib/ReaderWriter/ELF/OrderPass.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_ORDER_PASS_H
+#define LLD_READER_WRITER_ELF_ORDER_PASS_H
+
+#include "lld/Core/Parallel.h"
+#include <algorithm>
+#include <limits>
+
+namespace lld {
+namespace elf {
+
+/// \brief This pass sorts atoms by file and atom ordinals.
+/// .{init,fini}_array.<priority> sections are handled specially.
+class OrderPass : public Pass {
+public:
+  void perform(std::unique_ptr<MutableFile> &file) override {
+    MutableFile::DefinedAtomRange defined = file->definedAtoms();
+    auto last = std::partition(defined.begin(), defined.end(), isInitFini);
+    parallel_sort(defined.begin(), last, compareInitFini);
+    parallel_sort(last, defined.end(), DefinedAtom::compareByPosition);
+  }
+
+private:
+  static bool isInitFini(const DefinedAtom *atom) {
+    if (atom->sectionChoice() != DefinedAtom::sectionCustomRequired)
+      return false;
+    StringRef name = atom->customSectionName();
+    return name.startswith(".init_array") || name.startswith(".fini_array");
+  }
+
+  static bool compareInitFini(const DefinedAtom *lhs, const DefinedAtom *rhs) {
+    StringRef lhsSec = lhs->customSectionName();
+    StringRef rhsSec = rhs->customSectionName();
+
+    // Drop the front dot from the section name and get
+    // an optional section's number starting after the second dot.
+    StringRef lhsNum = lhsSec.drop_front().rsplit('.').second;
+    StringRef rhsNum = rhsSec.drop_front().rsplit('.').second;
+
+    // Sort {.init_array, .fini_array}[.<num>] sections
+    // according to their number. Sections without optional
+    // numer suffix should go last.
+
+    uint32_t lhsPriority;
+    uint32_t rhsPriority;
+    if (lhsNum.getAsInteger(10, lhsPriority))
+      lhsPriority = std::numeric_limits<uint32_t>::max();
+    if (rhsNum.getAsInteger(10, rhsPriority))
+      rhsPriority = std::numeric_limits<uint32_t>::max();
+
+    if (lhsPriority != rhsPriority)
+      return lhsPriority < rhsPriority;
+
+    // If both atoms have the same priority, fall back to default.
+    return DefinedAtom::compareByPosition(lhs, rhs);
+  }
+};
+
+}
+}
+
+#endif

lib/ReaderWriter/PECOFF/OrderPass.h

 #include "Atoms.h"
 #include "lld/Core/Parallel.h"
 #include "lld/Core/Pass.h"
 #include <algorithm>
 
 namespace lld {
 namespace pecoff {
 
-static bool compareByPosition(const DefinedAtom *lhs, const DefinedAtom *rhs) {
-  const File *lhsFile = &lhs->file();
-  const File *rhsFile = &rhs->file();
-  if (lhsFile->ordinal() != rhsFile->ordinal())
-    return lhsFile->ordinal() < rhsFile->ordinal();
-  assert(lhs->ordinal() != rhs->ordinal());
-  return lhs->ordinal() < rhs->ordinal();
-}
-
 static bool compare(const DefinedAtom *lhs, const DefinedAtom *rhs) {
   bool lhsCustom = (lhs->sectionChoice() == DefinedAtom::sectionCustomRequired);
   bool rhsCustom = (rhs->sectionChoice() == DefinedAtom::sectionCustomRequired);
   if (lhsCustom && rhsCustom) {
     int cmp = lhs->customSectionName().compare(rhs->customSectionName());
     if (cmp != 0)
       return cmp < 0;
-    return compareByPosition(lhs, rhs);
+    return DefinedAtom::compareByPosition(lhs, rhs);
   }
   if (lhsCustom && !rhsCustom)
     return true;
   if (!lhsCustom && rhsCustom)
     return false;
-  return compareByPosition(lhs, rhs);
+  return DefinedAtom::compareByPosition(lhs, rhs);
 }
 
 class OrderPass : public lld::Pass {
 public:
   void perform(std::unique_ptr<MutableFile> &file) override {
     MutableFile::DefinedAtomRange defined = file->definedAtoms();
     parallel_sort(defined.begin(), defined.end(), compare);
   }
 };
 
 } // namespace pecoff
 } // namespace lld
 
 #endif

test/elf/AArch64/defsym.test

 RUN: lld -flavor gnu -target aarch64--linux-gnu --defsym=main=fn \
 RUN: --noinhibit-exec %p/Inputs/fn.o -o %t
 RUN: llvm-readobj -symbols %t | FileCheck %s
 
 CHECK: Symbol {
 CHECK:   Name: main (1)
 CHECK:   Value: 0x4001A4
 CHECK:   Size: 0
 CHECK:   Binding: Global (0x1)
 CHECK:   Type: Function (0x2)
 CHECK:   Other: 0
 CHECK:   Section: .text (0x5)
 CHECK: }
 CHECK: Symbol {
-CHECK:   Name: fn (6)
+CHECK:   Name: fn (11)
 CHECK:   Value: 0x4001A4
 CHECK:   Size: 8
 CHECK:   Binding: Global (0x1)
 CHECK:   Type: Function (0x2)
 CHECK:   Other: 0
 CHECK:   Section: .text (0x5)
 CHECK: }

test/elf/Hexagon/dynlib-gotoff.test

 # This tests GOT's and PLT's for dynamic libraries for Hexagon
 RUN: lld -flavor gnu -target hexagon %p/Inputs/dynobj.o \
 RUN:   -o %t --output-filetype=yaml -shared --noinhibit-exec
 RUN: FileCheck -check-prefix=CHECKGOTPLT %s < %t
 
+              - name:            .PLT0
+CHECKGOTPLT:    type:            stub
+CHECKGOTPLT:    content:         [ 00, 40, 00, 00, 1C, C0, 49, 6A, 0E, 42, 9C, E2,
+CHECKGOTPLT:                       4F, 40, 9C, 91, 3C, C0, 9C, 91, 0E, 42, 0E, 8C,
+CHECKGOTPLT:                       00, C0, 9C, 52 ]
+CHECKGOTPLT:    alignment:       2^4
+CHECKGOTPLT:    section-name:    .plt
+CHECKGOTPLT:    references:
+CHECKGOTPLT:      - kind:            R_HEX_B32_PCREL_X
+CHECKGOTPLT:        offset:          0
+                    target:          __got0
+CHECKGOTPLT:      - kind:            R_HEX_6_PCREL_X
+CHECKGOTPLT:        offset:          4
+                    target:          __got0
+CHECKGOTPLT:        addend:          4
+              - name:            __plt_fn
+CHECKGOTPLT:    type:            stub
+CHECKGOTPLT:    content:         [ 00, 40, 00, 00, 0E, C0, 49, 6A, 1C, C0, 8E, 91,
+CHECKGOTPLT:                       00, C0, 9C, 52 ]
+CHECKGOTPLT:    alignment:       2^4
+CHECKGOTPLT:    section-name:    .plt
+CHECKGOTPLT:    references:
+CHECKGOTPLT:      - kind:            R_HEX_B32_PCREL_X
+CHECKGOTPLT:        offset:          0
+                    target:          __got_fn
+CHECKGOTPLT:      - kind:            R_HEX_6_PCREL_X
+CHECKGOTPLT:        offset:          4
+                    target:          __got_fn
+CHECKGOTPLT:        addend:          4
+              - name:            __plt_fn1
+CHECKGOTPLT:    type:            stub
+CHECKGOTPLT:    content:         [ 00, 40, 00, 00, 0E, C0, 49, 6A, 1C, C0, 8E, 91,
+CHECKGOTPLT:                       00, C0, 9C, 52 ]
+CHECKGOTPLT:    alignment:       2^4
+CHECKGOTPLT:    section-name:    .plt
+CHECKGOTPLT:    references:
+CHECKGOTPLT:      - kind:            R_HEX_B32_PCREL_X
+CHECKGOTPLT:        offset:          0
+                    target:          __got_fn1
+CHECKGOTPLT:      - kind:            R_HEX_6_PCREL_X
+CHECKGOTPLT:        offset:          4
+                    target:          __got_fn1
+CHECKGOTPLT:        addend:          4
+              - name:            __plt_fn2
+CHECKGOTPLT:    type:            stub
+CHECKGOTPLT:    content:         [ 00, 40, 00, 00, 0E, C0, 49, 6A, 1C, C0, 8E, 91,
+CHECKGOTPLT:                       00, C0, 9C, 52 ]
+CHECKGOTPLT:    alignment:       2^4
+CHECKGOTPLT:    section-name:    .plt
+CHECKGOTPLT:    references:
+CHECKGOTPLT:      - kind:            R_HEX_B32_PCREL_X
+CHECKGOTPLT:        offset:          0
+                    target:          __got_fn2
+CHECKGOTPLT:      - kind:            R_HEX_6_PCREL_X
+CHECKGOTPLT:        offset:          4
+                    target:          __got_fn2
+CHECKGOTPLT:        addend:          4
               - name:            __got0
 CHECKGOTPLT:    type:            got
 CHECKGOTPLT:    content:         [ 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00,
 CHECKGOTPLT:                       00, 00, 00, 00 ]
 CHECKGOTPLT:    alignment:       2^3
 CHECKGOTPLT:    section-name:    .got.plt
 CHECKGOTPLT:    permissions:     rw-
               - name:            __got_c

 CHECKGOTPLT:    permissions:     rw-
 CHECKGOTPLT:    references:
 CHECKGOTPLT:      - kind:            R_HEX_JMP_SLOT
 CHECKGOTPLT:        offset:          0
 CHECKGOTPLT:        target:          fn2
 CHECKGOTPLT:      - kind:            R_HEX_32
 CHECKGOTPLT:        offset:          0
                     target:          .PLT0
-              - name:            .PLT0
-CHECKGOTPLT:    type:            stub
-CHECKGOTPLT:    content:         [ 00, 40, 00, 00, 1C, C0, 49, 6A, 0E, 42, 9C, E2,
-CHECKGOTPLT:                       4F, 40, 9C, 91, 3C, C0, 9C, 91, 0E, 42, 0E, 8C,
-CHECKGOTPLT:                       00, C0, 9C, 52 ]
-CHECKGOTPLT:    alignment:       2^4
-CHECKGOTPLT:    section-name:    .plt
-CHECKGOTPLT:    references:
-CHECKGOTPLT:      - kind:            R_HEX_B32_PCREL_X
-CHECKGOTPLT:        offset:          0
-                    target:          __got0
-CHECKGOTPLT:      - kind:            R_HEX_6_PCREL_X
-CHECKGOTPLT:        offset:          4
-                    target:          __got0
-CHECKGOTPLT:        addend:          4
-              - name:            __plt_fn
-CHECKGOTPLT:    type:            stub
-CHECKGOTPLT:    content:         [ 00, 40, 00, 00, 0E, C0, 49, 6A, 1C, C0, 8E, 91,
-CHECKGOTPLT:                       00, C0, 9C, 52 ]
-CHECKGOTPLT:    alignment:       2^4
-CHECKGOTPLT:    section-name:    .plt
-CHECKGOTPLT:    references:
-CHECKGOTPLT:      - kind:            R_HEX_B32_PCREL_X
-CHECKGOTPLT:        offset:          0
-                    target:          __got_fn
-CHECKGOTPLT:      - kind:            R_HEX_6_PCREL_X
-CHECKGOTPLT:        offset:          4
-                    target:          __got_fn
-CHECKGOTPLT:        addend:          4
-              - name:            __plt_fn1
-CHECKGOTPLT:    type:            stub
-CHECKGOTPLT:    content:         [ 00, 40, 00, 00, 0E, C0, 49, 6A, 1C, C0, 8E, 91,
-CHECKGOTPLT:                       00, C0, 9C, 52 ]
-CHECKGOTPLT:    alignment:       2^4
-CHECKGOTPLT:    section-name:    .plt
-CHECKGOTPLT:    references:
-CHECKGOTPLT:      - kind:            R_HEX_B32_PCREL_X
-CHECKGOTPLT:        offset:          0
-                    target:          __got_fn1
-CHECKGOTPLT:      - kind:            R_HEX_6_PCREL_X
-CHECKGOTPLT:        offset:          4
-                    target:          __got_fn1
-CHECKGOTPLT:        addend:          4
-              - name:            __plt_fn2
-CHECKGOTPLT:    type:            stub
-CHECKGOTPLT:    content:         [ 00, 40, 00, 00, 0E, C0, 49, 6A, 1C, C0, 8E, 91,
-CHECKGOTPLT:                       00, C0, 9C, 52 ]
-CHECKGOTPLT:    alignment:       2^4
-CHECKGOTPLT:    section-name:    .plt
-CHECKGOTPLT:    references:
-CHECKGOTPLT:      - kind:            R_HEX_B32_PCREL_X
-CHECKGOTPLT:        offset:          0
-                    target:          __got_fn2
-CHECKGOTPLT:      - kind:            R_HEX_6_PCREL_X
-CHECKGOTPLT:        offset:          4
-                    target:          __got_fn2
-CHECKGOTPLT:        addend:          4

test/elf/Hexagon/zerofillquick-sdata.test

 # This tests that a typeZeroFillFast atom is associated with a section that has
 # the correct memory size.
 
 RUN: lld -flavor gnu -target hexagon %p/Inputs/sdata1.o %p/Inputs/sdata2.o \
 RUN:    -o %t --noinhibit-exec -static
 RUN: llvm-readobj -sections %t | FileCheck -check-prefix=CHECKSECTIONSANDSIZE %s
 
 CHECKSECTIONSANDSIZE:  Section {
 CHECKSECTIONSANDSIZE:    Name: .sdata (13)
 CHECKSECTIONSANDSIZE:    Address: 0x1000
 CHECKSECTIONSANDSIZE:    Offset: 0x1000
-CHECKSECTIONSANDSIZE:    Size: 20
+CHECKSECTIONSANDSIZE:    Size: 24
 CHECKSECTIONSANDSIZE:  }
 CHECKSECTIONSANDSIZE:  Section {
 CHECKSECTIONSANDSIZE:    Name: .bss (20)
 CHECKSECTIONSANDSIZE:    Address: 0x1018
 CHECKSECTIONSANDSIZE:    Offset: 0x1018
 CHECKSECTIONSANDSIZE:  }

test/elf/Mips/dynlib-dynsym-micro.test

 # CHECK-GOT:     section-name:    .got
 # CHECK-GOT:     permissions:     rw-
 # CHECK-GOT:   - type:            got
 # CHECK-GOT:     content:         [ 00, 00, 00, 80 ]
 # CHECK-GOT:     alignment:       2^2
 # CHECK-GOT:     section-choice:  custom-required
 # CHECK-GOT:     section-name:    .got
 # CHECK-GOT:     permissions:     rw-
-# CHECK-GOT:   - ref-name:        L002
+# CHECK-GOT:   - ref-name:        L000
 # CHECK-GOT:     type:            got
 # CHECK-GOT:     content:         [ 00, 00, 00, 00 ]
 # CHECK-GOT:     alignment:       2^2
 # CHECK-GOT:     section-choice:  custom-required
 # CHECK-GOT:     section-name:    .got
 # CHECK-GOT:     permissions:     rw-
 # CHECK-GOT:     references:
 # CHECK-GOT:       - kind:            LLD_R_MIPS_32_HI16
 # CHECK-GOT:         offset:          0
-# CHECK-GOT:         target:          L003
-# CHECK-GOT:   - ref-name:        L004
+# CHECK-GOT:         target:          L007
+# CHECK-GOT:   - ref-name:        L002
 # CHECK-GOT:     type:            got
 # CHECK-GOT:     content:         [ 00, 00, 00, 00 ]
 # CHECK-GOT:     alignment:       2^2
 # CHECK-GOT:     section-choice:  custom-required
 # CHECK-GOT:     section-name:    .got
 # CHECK-GOT:     permissions:     rw-
 # CHECK-GOT:     references:
 # CHECK-GOT:       - kind:            LLD_R_MIPS_32_HI16
 # CHECK-GOT:         offset:          0
-# CHECK-GOT:         target:          L005
-# CHECK-GOT:   - ref-name:        L006
+# CHECK-GOT:         target:          L008
+# CHECK-GOT:   - ref-name:        L004
 # CHECK-GOT:     type:            got
 # CHECK-GOT:     content:         [ 00, 00, 00, 00 ]
 # CHECK-GOT:     alignment:       2^2
 # CHECK-GOT:     section-choice:  custom-required
 # CHECK-GOT:     section-name:    .got
 # CHECK-GOT:     permissions:     rw-
 # CHECK-GOT:     references:
 # CHECK-GOT:       - kind:            LLD_R_MIPS_GLOBAL_GOT
 # CHECK-GOT:         offset:          0
 # CHECK-GOT:         target:          foo
-# CHECK-GOT:   - ref-name:        L007
+# CHECK-GOT:   - ref-name:        L005
 # CHECK-GOT:     type:            got
 # CHECK-GOT:     content:         [ 00, 00, 00, 00 ]
 # CHECK-GOT:     alignment:       2^2
 # CHECK-GOT:     section-choice:  custom-required
 # CHECK-GOT:     section-name:    .got
 # CHECK-GOT:     permissions:     rw-
 # CHECK-GOT:     references:
 # CHECK-GOT:       - kind:            LLD_R_MIPS_GLOBAL_GOT
 # CHECK-GOT:         offset:          0
 # CHECK-GOT:         target:          ext1
-# CHECK-GOT:   - ref-name:        L008
+# CHECK-GOT:   - ref-name:        L006
 # CHECK-GOT:     type:            got
 # CHECK-GOT:     content:         [ 00, 00, 00, 00 ]
 # CHECK-GOT:     alignment:       2^2
 # CHECK-GOT:     section-choice:  custom-required
 # CHECK-GOT:     section-name:    .got
 # CHECK-GOT:     permissions:     rw-
 # CHECK-GOT:     references:
 # CHECK-GOT:       - kind:            LLD_R_MIPS_GLOBAL_GOT

test/elf/Mips/dynlib-dynsym.test

 # CHECK-GOT:     section-name:    .got
 # CHECK-GOT:     permissions:     rw-
 # CHECK-GOT:   - type:            got
 # CHECK-GOT:     content:         [ 00, 00, 00, 80 ]
 # CHECK-GOT:     alignment:       2^2
 # CHECK-GOT:     section-choice:  custom-required
 # CHECK-GOT:     section-name:    .got
 # CHECK-GOT:     permissions:     rw-
-# CHECK-GOT:   - ref-name:        L002
+# CHECK-GOT:   - ref-name:        L000
 # CHECK-GOT:     type:            got
 # CHECK-GOT:     content:         [ 00, 00, 00, 00 ]
 # CHECK-GOT:     alignment:       2^2
 # CHECK-GOT:     section-choice:  custom-required
 # CHECK-GOT:     section-name:    .got
 # CHECK-GOT:     permissions:     rw-
 # CHECK-GOT:     references:
 # CHECK-GOT:       - kind:            LLD_R_MIPS_32_HI16
 # CHECK-GOT:         offset:          0
-# CHECK-GOT:         target:          L003
-# CHECK-GOT:   - ref-name:        L004
+# CHECK-GOT:         target:          L007
+# CHECK-GOT:   - ref-name:        L002
 # CHECK-GOT:     type:            got
 # CHECK-GOT:     content:         [ 00, 00, 00, 00 ]
 # CHECK-GOT:     alignment:       2^2
 # CHECK-GOT:     section-choice:  custom-required
 # CHECK-GOT:     section-name:    .got
 # CHECK-GOT:     permissions:     rw-
 # CHECK-GOT:     references:
 # CHECK-GOT:       - kind:            LLD_R_MIPS_32_HI16
 # CHECK-GOT:         offset:          0
-# CHECK-GOT:         target:          L005
-# CHECK-GOT:   - ref-name:        L006
+# CHECK-GOT:         target:          L008
+# CHECK-GOT:   - ref-name:        L004
 # CHECK-GOT:     type:            got
 # CHECK-GOT:     content:         [ 00, 00, 00, 00 ]
 # CHECK-GOT:     alignment:       2^2
 # CHECK-GOT:     section-choice:  custom-required
 # CHECK-GOT:     section-name:    .got
 # CHECK-GOT:     permissions:     rw-
 # CHECK-GOT:     references:
 # CHECK-GOT:       - kind:            LLD_R_MIPS_GLOBAL_GOT
 # CHECK-GOT:         offset:          0
 # CHECK-GOT:         target:          foo
-# CHECK-GOT:   - ref-name:        L007
+# CHECK-GOT:   - ref-name:        L005
 # CHECK-GOT:     type:            got
 # CHECK-GOT:     content:         [ 00, 00, 00, 00 ]
 # CHECK-GOT:     alignment:       2^2
 # CHECK-GOT:     section-choice:  custom-required
 # CHECK-GOT:     section-name:    .got
 # CHECK-GOT:     permissions:     rw-
 # CHECK-GOT:     references:
 # CHECK-GOT:       - kind:            LLD_R_MIPS_GLOBAL_GOT
 # CHECK-GOT:         offset:          0
 # CHECK-GOT:         target:          ext1
-# CHECK-GOT:   - ref-name:        L008
+# CHECK-GOT:   - ref-name:        L006
 # CHECK-GOT:     type:            got
 # CHECK-GOT:     content:         [ 00, 00, 00, 00 ]
 # CHECK-GOT:     alignment:       2^2
 # CHECK-GOT:     section-choice:  custom-required
 # CHECK-GOT:     section-name:    .got
 # CHECK-GOT:     permissions:     rw-
 # CHECK-GOT:     references:
 # CHECK-GOT:       - kind:            LLD_R_MIPS_GLOBAL_GOT

test/elf/Mips/got16-micro.test

 # REQUIRES: mips
 
 # Check handling of global/local R_MICROMIPS_GOT16 relocations.
 # RUN: llvm-mc -triple=mipsel -mattr=micromips -relocation-model=pic \
 # RUN:     -filetype=obj -o=%t.o %s
 # RUN: lld -flavor gnu -target mipsel -shared --noinhibit-exec \
 # RUN:     --output-filetype=yaml %t.o \
 # RUN:     | FileCheck -check-prefix YAML %s
 # RUN: lld -flavor gnu -target mipsel -shared --noinhibit-exec -o %t2 %t.o
 # RUN: llvm-objdump -t -disassemble -mattr=micromips %t2 \
 # RUN:   | FileCheck -check-prefix RAW %s
 
+# Function glob
+# YAML:      - name:         main
+# YAML:        scope:        global
+# YAML:        content:      [ 5C, FC, 00, 00, 42, 30, 00, 00, 5C, FC, 00, 00,
+# YAML:                        42, 30, 00, 00, 5C, FC, 00, 00, 5C, FC, 00, 00,
+# YAML:                        5C, FC, 00, 00 ]
+# YAML:        alignment:    4 mod 2^4
+# YAML:        code-model:   mips-micro
+# YAML:        references:
+# YAML-NEXT:     - kind:         R_MICROMIPS_GOT16
+# YAML-NEXT:       offset:       0
+# YAML-NEXT:       target:       L000
+# YAML-NEXT:     - kind:         R_MICROMIPS_LO16
+# YAML-NEXT:       offset:       4
+# YAML-NEXT:       target:       data_1
+# YAML-NEXT:     - kind:         R_MICROMIPS_GOT16
+# YAML-NEXT:       offset:       8
+# YAML-NEXT:       target:       L001
+# YAML-NEXT:     - kind:         R_MICROMIPS_LO16
+# YAML-NEXT:       offset:       12
+# YAML-NEXT:       target:       data_2
+# YAML-NEXT:     - kind:         R_MICROMIPS_GOT16
+# YAML-NEXT:       offset:       16
+# YAML-NEXT:       target:       L002
+# YAML-NEXT:     - kind:         R_MICROMIPS_CALL16
+# YAML-NEXT:       offset:       20
+# YAML-NEXT:       target:       L003
+# YAML-NEXT:     - kind:         R_MICROMIPS_CALL16
+# YAML-NEXT:       offset:       24
+# YAML-NEXT:       target:       L004
+
 # Local GOT entries:
-# YAML:       - ref-name:        L001
+# YAML:       - ref-name:        L000
 # YAML-NEXT:    type:            got
 # YAML-NEXT:    content:         [ 00, 00, 00, 00 ]
 # YAML-NEXT:    alignment:       2^2
 # YAML-NEXT:    section-choice:  custom-required
 # YAML-NEXT:    section-name:    .got
 # YAML-NEXT:    permissions:     rw-
 # YAML-NEXT:    references:
 # YAML-NEXT:      - kind:            LLD_R_MIPS_32_HI16
 # YAML-NEXT:        offset:          0
 # YAML-NEXT:        target:          data_1
-# YAML-NEXT:  - ref-name:        L002
+# YAML-NEXT:  - ref-name:        L001
 # YAML-NEXT:    type:            got
 # YAML-NEXT:    content:         [ 00, 00, 00, 00 ]
 # YAML-NEXT:    alignment:       2^2
 # YAML-NEXT:    section-choice:  custom-required
 # YAML-NEXT:    section-name:    .got
 # YAML-NEXT:    permissions:     rw-
 # YAML-NEXT:    references:
 # YAML-NEXT:      - kind:            LLD_R_MIPS_32_HI16
 # YAML-NEXT:        offset:          0
 # YAML-NEXT:        target:          data_2
-# YAML-NEXT:  - ref-name:        L003
+# YAML-NEXT:  - ref-name:        L002
 # YAML-NEXT:    type:            got
 # YAML-NEXT:    content:         [ 00, 00, 00, 00 ]
 # YAML-NEXT:    alignment:       2^2
 # YAML-NEXT:    section-choice:  custom-required
 # YAML-NEXT:    section-name:    .got
 # YAML-NEXT:    permissions:     rw-
 # YAML-NEXT:    references:
 # YAML-NEXT:      - kind:            R_MIPS_32
 # YAML-NEXT:        offset:          0
 # YAML-NEXT:        target:          data_h
 
 # Global GOT entries:
-# YAML-NEXT:  - ref-name:        L004
+# YAML-NEXT:  - ref-name:        L003
 # YAML-NEXT:    type:            got
 # YAML-NEXT:    content:         [ 00, 00, 00, 00 ]
 # YAML-NEXT:    alignment:       2^2
 # YAML-NEXT:    section-choice:  custom-required
 # YAML-NEXT:    section-name:    .got
 # YAML-NEXT:    permissions:     rw-
 # YAML-NEXT:    references:
 # YAML-NEXT:      - kind:            LLD_R_MIPS_GLOBAL_GOT
 # YAML-NEXT:        offset:          0
 # YAML-NEXT:        target:          bar
 # YAML-NEXT:      - kind:            R_MIPS_32
 # YAML-NEXT:        offset:          0
 # YAML-NEXT:        target:          bar
-# YAML-NEXT:  - ref-name:        L005
+# YAML-NEXT:  - ref-name:        L004
 # YAML-NEXT:    type:            got
 # YAML-NEXT:    content:         [ 00, 00, 00, 00 ]
 # YAML-NEXT:    alignment:       2^2
 # YAML-NEXT:    section-choice:  custom-required
 # YAML-NEXT:    section-name:    .got
 # YAML-NEXT:    permissions:     rw-
 # YAML-NEXT:    references:
 # YAML-NEXT:      - kind:            LLD_R_MIPS_GLOBAL_GOT
 # YAML-NEXT:        offset:          0
 # YAML-NEXT:        target:          foo
 
-# Function glob
-# YAML:      - name:         main
-# YAML:        scope:        global
-# YAML:        content:      [ 5C, FC, 00, 00, 42, 30, 00, 00, 5C, FC, 00, 00,
-# YAML:                        42, 30, 00, 00, 5C, FC, 00, 00, 5C, FC, 00, 00,
-# YAML:                        5C, FC, 00, 00 ]
-# YAML:        alignment:    4 mod 2^4
-# YAML:        code-model:   mips-micro
-# YAML:        references:
-# YAML-NEXT:     - kind:         R_MICROMIPS_GOT16
-# YAML-NEXT:       offset:       0
-# YAML-NEXT:       target:       L001
-# YAML-NEXT:     - kind:         R_MICROMIPS_LO16
-# YAML-NEXT:       offset:       4
-# YAML-NEXT:       target:       data_1
-# YAML-NEXT:     - kind:         R_MICROMIPS_GOT16
-# YAML-NEXT:       offset:       8
-# YAML-NEXT:       target:       L002
-# YAML-NEXT:     - kind:         R_MICROMIPS_LO16
-# YAML-NEXT:       offset:       12
-# YAML-NEXT:       target:       data_2
-# YAML-NEXT:     - kind:         R_MICROMIPS_GOT16
-# YAML-NEXT:       offset:       16
-# YAML-NEXT:       target:       L003
-# YAML-NEXT:     - kind:         R_MICROMIPS_CALL16
-# YAML-NEXT:       offset:       20
-# YAML-NEXT:       target:       L004
-# YAML-NEXT:     - kind:         R_MICROMIPS_CALL16
-# YAML-NEXT:       offset:       24
-# YAML-NEXT:       target:       L005
-
 # RAW: Disassembly of section .text:
 # RAW: main:
 # RAW-NEXT:   164:  5c fc 18 80   lw      $2, -32744($gp)
 # RAW-NEXT:   168:  42 30 40 10   addiu   $2, $2, 4160
 # RAW-NEXT:   16c:  5c fc 1c 80   lw      $2, -32740($gp)
 # RAW-NEXT:   170:  42 30 60 20   addiu   $2, $2, 8288
 # RAW-NEXT:   174:  5c fc 20 80   lw      $2, -32736($gp)
 # RAW-NEXT:   178:  5c fc 24 80   lw      $2, -32732($gp)

test/elf/Mips/got16.test

 # REQUIRES: mips
 
 # Check handling of global/local GOT16 relocations.
 # RUN: yaml2obj -format=elf %s > %t.o
 # RUN: lld -flavor gnu -target mipsel -shared --noinhibit-exec \
 # RUN:     --output-filetype=yaml %t.o \
 # RUN:     | FileCheck -check-prefix YAML %s
 # RUN: lld -flavor gnu -target mipsel -shared --noinhibit-exec -o %t2 %t.o
 # RUN: llvm-objdump -t -disassemble %t2 | FileCheck -check-prefix RAW %s
 
+# Function glob
+# YAML:  - name:            glob
+# YAML:    scope:           global
+# YAML:    content:         [ 00, 00, 84, 8F, 00, 00, 84, 24, 01, 00, 84, 8F,
+# YAML:                       00, 02, 84, 24, 00, 00, 84, 8F, 00, 00, 84, 8F,
+# YAML:                       00, 00, 84, 8F ]
+# YAML:    alignment:       2^2
+# YAML:    references:
+# YAML:      - kind:            R_MIPS_GOT16
+# YAML:        offset:          0
+# YAML:        target:          L000
+# YAML:      - kind:            R_MIPS_LO16
+# YAML:        offset:          4
+# YAML:        target:          L009
+# YAML:      - kind:            R_MIPS_GOT16
+# YAML:        offset:          8
+# YAML:        target:          L002
+# YAML:        addend:          66048
+# YAML:      - kind:            R_MIPS_LO16
+# YAML:        offset:          12
+# YAML:        target:          L009
+# YAML:        addend:          512
+# YAML:      - kind:            R_MIPS_GOT16
+# YAML:        offset:          16
+# YAML:        target:          L004
+# YAML:      - kind:            R_MIPS_CALL16
+# YAML:        offset:          20
+# YAML:        target:          L005
+# YAML:      - kind:            R_MIPS_CALL16
+# YAML:        offset:          24
+# YAML:        target:          L006
+
 # Local GOT entries:
-# YAML:       - ref-name:        L003
+# YAML:       - ref-name:        L000
 # YAML-NEXT:    type:            got
 # YAML-NEXT:    content:         [ 00, 00, 00, 00 ]
 # YAML-NEXT:    alignment:       2^2
 # YAML-NEXT:    section-choice:  custom-required
 # YAML-NEXT:    section-name:    .got
 # YAML-NEXT:    permissions:     rw-
 # YAML-NEXT:    references:
 # YAML-NEXT:      - kind:            LLD_R_MIPS_32_HI16
 # YAML-NEXT:        offset:          0
-# YAML-NEXT:        target:          L006
-# YAML-NEXT:  - ref-name:        L005
+# YAML-NEXT:        target:          L009
+# YAML-NEXT:  - ref-name:        L002
 # YAML-NEXT:    type:            got
 # YAML-NEXT:    content:         [ 00, 00, 00, 00 ]
 # YAML-NEXT:    alignment:       2^2
 # YAML-NEXT:    section-choice:  custom-required
 # YAML-NEXT:    section-name:    .got
 # YAML-NEXT:    permissions:     rw-
 # YAML-NEXT:    references:
 # YAML-NEXT:      - kind:            LLD_R_MIPS_32_HI16
 # YAML-NEXT:        offset:          0
-# YAML-NEXT:        target:          L006
+# YAML-NEXT:        target:          L009
 # YAML-NEXT:        addend:          66048
-# YAML-NEXT:  - ref-name:        L007
+# YAML-NEXT:  - ref-name:        L004
 # YAML-NEXT:    type:            got
 # YAML-NEXT:    content:         [ 00, 00, 00, 00 ]
 # YAML-NEXT:    alignment:       2^2
 # YAML-NEXT:    section-choice:  custom-required
 # YAML-NEXT:    section-name:    .got
 # YAML-NEXT:    permissions:     rw-
 # YAML-NEXT:    references:
 # YAML-NEXT:      - kind:            R_MIPS_32
 # YAML-NEXT:        offset:          0
 # YAML-NEXT:        target:          hidden
 
 # Global GOT entries:
-# YAML-NEXT:  - ref-name:        L008
+# YAML-NEXT:  - ref-name:        L005
 # YAML-NEXT:    type:            got
 # YAML-NEXT:    content:         [ 00, 00, 00, 00 ]
 # YAML-NEXT:    alignment:       2^2
 # YAML-NEXT:    section-choice:  custom-required
 # YAML-NEXT:    section-name:    .got
 # YAML-NEXT:    permissions:     rw-
 # YAML-NEXT:    references:
 # YAML-NEXT:      - kind:            LLD_R_MIPS_GLOBAL_GOT
 # YAML-NEXT:        offset:          0
 # YAML-NEXT:        target:          glob
 # YAML-NEXT:      - kind:            R_MIPS_32
 # YAML-NEXT:        offset:          0
 # YAML-NEXT:        target:          glob
-# YAML-NEXT:  - ref-name:        L009
+# YAML-NEXT:  - ref-name:        L006
 # YAML-NEXT:    type:            got
 # YAML-NEXT:    content:         [ 00, 00, 00, 00 ]
 # YAML-NEXT:    alignment:       2^2
 # YAML-NEXT:    section-choice:  custom-required
 # YAML-NEXT:    section-name:    .got
 # YAML-NEXT:    permissions:     rw-
 # YAML-NEXT:    references:
 # YAML-NEXT:      - kind:            LLD_R_MIPS_GLOBAL_GOT
 # YAML-NEXT:        offset:          0
 # YAML-NEXT:        target:          extern
 
-# Function glob
-# YAML:  - name:            glob
-# YAML:    scope:           global
-# YAML:    content:         [ 00, 00, 84, 8F, 00, 00, 84, 24, 01, 00, 84, 8F,
-# YAML:                       00, 02, 84, 24, 00, 00, 84, 8F, 00, 00, 84, 8F,
-# YAML:                       00, 00, 84, 8F ]
-# YAML:    alignment:       2^2
-# YAML:    references:
-# YAML:      - kind:            R_MIPS_GOT16
-# YAML:        offset:          0
-# YAML:        target:          L003
-# YAML:      - kind:            R_MIPS_LO16
-# YAML:        offset:          4
-# YAML:        target:          L006
-# YAML:      - kind:            R_MIPS_GOT16
-# YAML:        offset:          8
-# YAML:        target:          L005
-# YAML:        addend:          66048
-# YAML:      - kind:            R_MIPS_LO16
-# YAML:        offset:          12
-# YAML:        target:          L006
-# YAML:        addend:          512
-# YAML:      - kind:            R_MIPS_GOT16
-# YAML:        offset:          16
-# YAML:        target:          L007
-# YAML:      - kind:            R_MIPS_CALL16
-# YAML:        offset:          20
-# YAML:        target:          L008
-# YAML:      - kind:            R_MIPS_CALL16
-# YAML:        offset:          24
-# YAML:        target:          L009
-
 # RAW: Disassembly of section .text:
 # RAW: glob:
 # RAW-NEXT:   12c:  18 80 84 8f  lw      $4, -32744($gp)
 # RAW-NEXT:   130:  00 20 84 24  addiu   $4, $4, 8192
 # RAW-NEXT:   134:  1c 80 84 8f  lw      $4, -32740($gp)
 # RAW-NEXT:   138:  00 22 84 24  addiu   $4, $4, 8704
 # RAW-NEXT:   13c:  20 80 84 8f  lw      $4, -32736($gp)
 # RAW-NEXT:   140:  24 80 84 8f  lw      $4, -32732($gp)

test/elf/Mips/rel-dynamic-02.test

 # RUN: llvm-readobj -dt -r -s %t1-so | FileCheck -check-prefix=PLT-SYM %s
 
 # PLT-SYM:     Sections [
 # PLT-SYM:       Section {
 # PLT-SYM-NOT:     Name: .plt ({{[0-9]+}})
 #
 # PLT-SYM:      Relocations [
 # PLT-SYM-NEXT:   Section (4) .rel.dyn {
-# PLT-SYM-NEXT:     0x2000 R_MIPS_REL32 T1 0x0
 # PLT-SYM-NEXT:     0x140 R_MIPS_REL32 T1 0x0
+# PLT-SYM-NEXT:     0x2000 R_MIPS_REL32 T1 0x0
 # PLT-SYM-NEXT:   }
 # PLT-SYM-NEXT: ]
 #
 # PLT-SYM:      Name: T1@ (7)
 # PLT-SYM-NEXT: Value: 0x0
 # PLT-SYM-NEXT: Size: 0
 # PLT-SYM-NEXT: Binding: Global (0x1)
 # PLT-SYM-NEXT: Type: None (0x0)

test/elf/Mips/rel-dynamic-11.test

 # RUN: llvm-readobj -dt -r -s %t2.so | FileCheck -check-prefix=PLT-SYM %s
 
 # PLT-SYM:     Sections [
 # PLT-SYM:       Section {
 # PLT-SYM-NOT:     Name: .plt ({{[0-9]+}})
 #
 # PLT-SYM:      Relocations [
 # PLT-SYM-NEXT:   Section (4) .rel.dyn {
-# PLT-SYM-NEXT:     0x2000 R_MIPS_REL32 T1 0x0
 # PLT-SYM-NEXT:     0x150 R_MIPS_REL32 T1 0x0
+# PLT-SYM-NEXT:     0x2000 R_MIPS_REL32 T1 0x0
 # PLT-SYM-NEXT:   }
 # PLT-SYM-NEXT: ]
 #
 # PLT-SYM:      Name: T1@ (7)
 # PLT-SYM-NEXT: Value: 0x0
 # PLT-SYM-NEXT: Size: 0
 # PLT-SYM-NEXT: Binding: Global (0x1)
 # PLT-SYM-NEXT: Type: Function (0x2)

test/elf/X86_64/orderatoms-by-override.test

-# This testcase tests the behaviour of the layoutpass so that the atoms that
-# appear by their override take preference before proceeding to default behaviour
-RUN: lld -flavor gnu -target x86_64 %p/Inputs/rwint.o \
-RUN:     %p/Inputs/constint.o --output-filetype=yaml -o %t --noinhibit-exec
-RUN: FileCheck %s -check-prefix=CHECKORDER < %t
-
-CHECKORDER:  - name:            b
-CHECKORDER:  - name:            a

test/elf/check.test

 # This tests the basic functionality of ordering data and functions as they
 # appear in the inputs
 RUN: lld -flavor gnu -target i386 -e global_func --noinhibit-exec --output-filetype=yaml \
 RUN:    %p/Inputs/object-test.elf-i386  -o %t
 RUN: FileCheck %s -check-prefix ELF-i386 < %t
 RUN: lld -flavor gnu -target hexagon -e global_func --noinhibit-exec --output-filetype=yaml \
 RUN:    %p/Inputs/object-test.elf-hexagon -o %t1
 RUN: FileCheck %s -check-prefix ELF-hexagon < %t1
 
 ELF-i386: defined-atoms:
-ELF-i386:   - name:            global_variable
-ELF-i386:   - name:            uninitialized_static_variable
 ELF-i386:   - name:            global_func
 ELF-i386:   - name:            static_func
 ELF-i386:   - name:            weak_func
 ELF-i386:   - name:            hidden_func
 ELF-i386:   - name:            no_dead_strip
 ELF-i386:   - name:            no_special_section_func
+ELF-i386:   - name:            global_variable
+ELF-i386:   - name:            uninitialized_static_variable
 ELF-i386:   - name:            special_section_func
 ELF-i386: undefined-atoms:
 ELF-i386:   - name:            puts
 ELF-i386: absolute-atoms:
 ELF-i386:   - name:            sample.c
 
-ELF-hexagon:   - name:            global_variable
-ELF-hexagon:   - name:            uninitialized_static_variable
 ELF-hexagon:   - name:            global_func
 ELF-hexagon:   - name:            static_func
 ELF-hexagon:   - name:            weak_func
 ELF-hexagon:   - name:            hidden_func
 ELF-hexagon:   - name:            no_dead_strip
 ELF-hexagon:   - name:            no_special_section_func
+ELF-hexagon:   - name:            global_variable
+ELF-hexagon:   - name:            uninitialized_static_variable
 ELF-hexagon:   - name:            special_section_func
 ELF-hexagon: undefined-atoms:
 ELF-hexagon:   - name:            puts
 ELF-hexagon: absolute-atoms:
 ELF-hexagon:   - name:            sample.c
 ELF-hexagon:     scope:           static
 ELF-hexagon:     value:           0x0000000000000000

test/elf/dynamic.test

 # Checks functionality of dynamic executables
 RUN: lld -flavor gnu -target x86_64-linux %p/Inputs/use-shared.x86-64 \
 RUN:   %p/Inputs/shared.so-x86-64 -o %t -e main --allow-shlib-undefined \
 RUN:   -rpath /l1:/l2 -rpath /l3
 RUN: lld -flavor gnu -target x86_64-linux %p/Inputs/use-shared.x86-64 \
 RUN:   %p/Inputs/shared.so-x86-64 --output-filetype=yaml -o %t2 --allow-shlib-undefined \
 RUN: --noinhibit-exec
 RUN: llvm-objdump -p %t >> %t2
 RUN: llvm-readobj -s -dyn-symbols -dynamic-table %t >> %t2
 RUN: FileCheck %s < %t2
 
-CHECK: type: got
-CHECK: references:
-CHECK:   kind: R_X86_64_JUMP_SLOT
-
 CHECK: name: main
 CHECK: kind: R_X86_64_PC32
 CHECK:  offset: 18
 CHECK:  target: [[PLTNAME:[-a-zA-Z0-9_]+]]
 
 CHECK: name: [[PLTNAME]]
 CHECK: type: stub
 
+CHECK: type: got
+CHECK: references:
+CHECK:   kind: R_X86_64_JUMP_SLOT
+
 CHECK: shared-library-atoms:
 CHECK:  name: foo
 CHECK:  load-name: shared.so-x86-64
 
 CHECK: PHDR off 0x{{0+}}40
 CHECK: INTERP
 CHECK: flags r--
 

test/elf/gotpcrel.test

 # This test checks that GOTPCREL entries are being handled properly
 RUN: lld -flavor gnu -target x86_64-linux -static -e main --output-filetype=yaml  \
 RUN:   --noinhibit-exec %p/Inputs/gotpcrel.x86-64  \
 RUN:   | FileCheck %s -check-prefix=YAML
 
-YAML: name: [[NULLGOT:[a-zA-Z0-9_]+]]
-YAML: content: [ 00, 00, 00, 00, 00, 00, 00, 00 ]
-YAML-NOT: references:
-
-YAML: name: [[MAINGOT:[a-zA-Z0-9_]+]]
-YAML: kind: R_X86_64_64
-YAML: target: main
-
 YAML: name: main
 YAML: references:
 YAML:   kind:    R_X86_64_GOTPCREL
 YAML:   offset:  3
-YAML:   target:  [[NULLGOT]]
+YAML:   target:  [[NULLGOT:[a-zA-Z0-9_]+]]
 YAML:   kind:    R_X86_64_GOTPCREL
 YAML:   offset:  10
-YAML:   target:  [[MAINGOT]]
+YAML:   target:  [[MAINGOT:[a-zA-Z0-9_]+]]
 
+YAML: name: [[NULLGOT]]
+YAML: content: [ 00, 00, 00, 00, 00, 00, 00, 00 ]
+YAML-NOT: references:
+
+YAML: name: [[MAINGOT]]
+YAML: kind: R_X86_64_64
+YAML: target: main

test/elf/hexagon-quickdata-sort.test

 RUN: lld -flavor gnu -target hexagon %p/Inputs/quickdata-sort-test.o.elf-hexagon -o %t1 --noinhibit-exec
 RUN: llvm-nm -n %t1 | FileCheck %s -check-prefix=quickdataSort
 
-quickdataSort: 00002000 D AA1
-quickdataSort: 00002001 D A1
-quickdataSort: 00002002 D BB1
-quickdataSort: 00002004 D B1
-quickdataSort: 00002008 D CC1
-quickdataSort: 0000200c D C1
-quickdataSort: 00002010 D DD1
-quickdataSort: 00002018 D D1
+quickdataSort: 00002000 D A1
+quickdataSort: 00002001 D AA1
+quickdataSort: 00002002 D B1
+quickdataSort: 00002004 D BB1
+quickdataSort: 00002008 D C1
+quickdataSort: 0000200c D CC1
+quickdataSort: 00002010 D D1
+quickdataSort: 00002018 D DD1
 

test/elf/hexagon-quickdata-sortcommon.test

 RUN: lld -flavor gnu -target hexagon -o %t1 --noinhibit-exec \
 RUN:     %p/Inputs/quickdata-sortcommon-test.o.elf-hexagon
 RUN: llvm-nm -n %t1 | FileCheck %s -check-prefix=quickdataSortCommon
 
-quickdataSortCommon: 00002000 D AA1
-quickdataSortCommon: 00002001 D A1
+quickdataSortCommon: 00002000 D A1
+quickdataSortCommon: 00002001 D AA1
 quickdataSortCommon: 00002002 D AAA1
-quickdataSortCommon: 00002004 D BB1
-quickdataSortCommon: 00002006 D B1
+quickdataSortCommon: 00002004 D B1
+quickdataSortCommon: 00002006 D BB1
 quickdataSortCommon: 00002008 D BBB1
-quickdataSortCommon: 0000200c D CC1
-quickdataSortCommon: 00002010 D C1
+quickdataSortCommon: 0000200c D C1
+quickdataSortCommon: 00002010 D CC1
 quickdataSortCommon: 00002014 D CCC1
-quickdataSortCommon: 00002018 D DD1
-quickdataSortCommon: 00002020 D D1
+quickdataSortCommon: 00002018 D D1
+quickdataSortCommon: 00002020 D DD1
 quickdataSortCommon: 00002028 D DDD1

test/elf/ifunc.test

 
 # Test that STT_GNU_IFUNC symbols have type Code in SharedLibraryAtom.
 RUN: lld -flavor gnu -target x86_64-linux --output-filetype=yaml \
 RUN:   --noinhibit-exec %p/Inputs/ifunc.cpp.x86-64 -L%p/Inputs -lifunc.x86-64 \
 RUN: | FileCheck %s --check-prefix=SHARED
 
 PLT: defined-atoms:
 
-// Make sure there's a got entry with a IRELATIVE relocation.
-PLT: type: got
-PLT: references:
-PLT:  kind: R_X86_64_IRELATIVE
-PLT:  target: hey
-
 PLT: name:  plt
 PLT: scope: global
 PLT: references:
 PLT:   kind:   R_X86_64_PC32
 PLT:   target: [[PLTNAME:[-a-zA-Z0-9_]+]]
 
 PLT: name: main
 PLT: scope: global
 PLT: references:
 PLT:   kind: R_X86_64_PC32
 PLT:   target: [[PLTNAME]]
 
 // Make sure the target of main's relocation is a stub with a PC32 relocation.
 // This relocation is to the got atom, but you can't really write that check in
 // FileCheck.
 PLT: name:
 PLT: type: stub
 PLT: references
 PLT:   kind: R_X86_64_PC32
 
+// Make sure there's a got entry with a IRELATIVE relocation.
+PLT: type: got
+PLT: references:
+PLT:  kind: R_X86_64_IRELATIVE
+PLT:  target: hey
+
 CHECK: name: hey
 CHECK: scope: global
 CHECK: type: resolver
 
 
 // This is a horribly brittle test. We need a way to do arithmetic on captured
 // variables.
 BIN: {{[0-9a-f]+}}: ff 25 {{[0-9a-f]+}} {{[0-9a-f]+}} 00 00 jmpq *{{[0-9]+}}(%rip)

test/elf/quickdata.test

 RUN: lld -flavor gnu -target hexagon --output-filetype=yaml %p/Inputs/quickdata-test.elf-hexagon \
 RUN: --noinhibit-exec | FileCheck %s -check-prefix hexagon
 
-hexagon:  - name:            init
-hexagon:    scope:           global
-hexagon:    type:            quick-data
 hexagon:  - name:            ac1
 hexagon:    scope:           global
 hexagon:    type:            zero-fill-quick
 hexagon:    size:            1
 hexagon:    merge:           as-tentative
+hexagon:  - name:            init
+hexagon:    scope:           global
+hexagon:    type:            quick-data
 hexagon:  - name:            bss1
 hexagon:    scope:           global
 hexagon:    type:            zero-fill-quick
 

test/elf/tls.test

 # REQUIRES: x86
 
 # This tests verifies that TLS variables have correct offsets
 RUN: lld -flavor gnu -target x86_64-linux %p/Inputs/tls.x86-64 -static  \
 RUN: --output-filetype=yaml --noinhibit-exec | FileCheck %s -check-prefix=YAML
 
 RUN: lld -flavor gnu -target x86_64-linux %p/Inputs/tls.x86-64 -o %t \
 RUN:   --noinhibit-exec -e main -static && llvm-objdump -d %t | FileCheck %s
 
 // Verify that the TLS accesses have the correct offsets.
 
-YAML:  type: got
-YAML:  references:
-YAML:   kind: R_X86_64_TPOFF64
-YAML:   target: tls2
-
 YAML:  name: main
 YAML:  references:
 YAML:    kind: R_X86_64_TPOFF32
 YAML:    offset: 9
 YAML:    target: tls1
 YAML:    kind: R_X86_64_TPOFF32
 YAML:    offset: 17
 YAML:    target: tls0
 YAML:    kind: R_X86_64_TPOFF32
 YAML:    offset: 25
 YAML:    target: tls2
 
 YAML:  name: GOTTPOFF
 YAML:  kind: R_X86_64_PC32
 YAML:  target: [[GOTNAME:[a-zA-Z0-9_]+]]
 
+YAML:  type: got
+YAML:  references:
+YAML:   kind: R_X86_64_TPOFF64
+YAML:   target: tls2
 
 // main
 CHECK: addl %fs:-4
 CHECK: addl %fs:-8
 CHECK: addl %fs:-12
 
 // GOTTPOFF
 CHECK: movq {{[0-9]+}}(%rip)
 
 // TLSLD
 CHECK: movq %fs:0, %rax
 CHECK: leaq -8(%rax), %rax

test/elf/x86-64-dynamic.test

 # Checks that linking an object file with a shared object creates the necessary
 # PLT/GOT Entries
 RUN: lld -flavor gnu -target x86_64-linux %p/Inputs/use-shared.x86-64 \
 RUN:   %p/Inputs/shared.so-x86-64 --output-filetype=yaml -o %t1 --noinhibit-exec
 RUN: FileCheck %s < %t1
 
 RUN: lld -flavor gnu -target x86_64-linux %p/Inputs/use-shared-32s.x86-64 \
 RUN:   %p/Inputs/shared.so-x86-64 --output-filetype=yaml --noinhibit-exec \
 RUN: | FileCheck %s --check-prefix=32S
 
-// Don't check the GOT and PLT names as they are only present in assert builds.
-CHECK:    type:            got
-CHECK:    content:         [ 00, 00, 00, 00, 00, 00, 00, 00 ]
-CHECK:    section-choice:  custom-required
-CHECK:    section-name:    .got.dyn
-CHECK:    permissions:     rw-
-CHECK:    references:
-CHECK:      - kind:            R_X86_64_GLOB_DAT
-CHECK:        offset:          0
-CHECK:        target:          i
-
 CHECK:  - name:            main
 CHECK:    scope:           global
 CHECK:    references:
 CHECK:      - kind:            R_X86_64_PC32
 CHECK:        offset:          18
 CHECK:        target:          [[PLTNAME:[-a-zA-Z0-9_]+]]
 CHECK:        addend:          -4
 CHECK:      - kind:            R_X86_64_GOTPCREL

 CHECK:      - kind:            LLD_R_X86_64_GOTRELINDEX
 CHECK:        offset:          7
               target:          __got_foo
 CHECK:      - kind:            R_X86_64_PC32
 CHECK:        offset:          12
               target:          .PLT0
 CHECK:        addend:          -4
 
-
+// Don't check the GOT and PLT names as they are only present in assert builds.
+CHECK:    type:            got
+CHECK:    content:         [ 00, 00, 00, 00, 00, 00, 00, 00 ]
+CHECK:    section-choice:  custom-required
+CHECK:    section-name:    .got.dyn
+CHECK:    permissions:     rw-
+CHECK:    references:
+CHECK:      - kind:            R_X86_64_GLOB_DAT
+CHECK:        offset:          0
+CHECK:        target:          i
 
 CHECK:shared-library-atoms:
 CHECK:  - name:            foo
 CHECK:    load-name:       shared.so-x86-64
 
 32S: name: main
 32S: kind: R_X86_64_PC32
 32S: target: func
 32S: kind: R_X86_64_32S
 32S: kind: R_X86_64_PC32
 32S: type: stub