Remove kindInGroup reference

[ruiu]

Summary

That kind of reference was used only in ELFFile, and the use of
that reference there didn't seem to make sense. All test still
pass (after adjusting symbol names) without that code. LLD is
still be able to link LLD and Clang. Looks like we just don't
need this.

[kledzik]

From what I recall, ELF has the semantics that you cannot just remove an atom in the middle of a section, because there is not enough relocations in the section to fix up the remaining (e.g CALLs to static functions in the same section don't have relocations on them, so if the distance changed because some atom between the two was removed, the CALL now be to the new location). The group reference was a way to keep all atoms in a section together.

[ruiu]

All atoms in the same section already have kindAfter references, so that
all of them are added and removed as a group. So we don't need another
references to make them a group.

[• shankar.easwaran]

This is mainly relevant when you turn on garbage collection as Nick pointed out. You can refer to an atom in a section but to keep the section to be consistent w.r.t ELF you have to keep all the remaining atoms together.

[ruiu]

I think it's not for garbage collection. Because all atoms in the same
section are already connected with LayoutAfter references, they are treated
as a group by the garbage collector.
2015/01/26 19:25 "Shankar Easwaran" <[e-mail]>:

This is mainly relevant when you turn on garbage collection as Nick
pointed out. You can refer to an atom in a section but to keep the section
to be consistent w.r.t ELF you have to keep all the remaining atoms
together.

http://reviews.llvm.org/D7189

EMAIL PREFERENCES

http://reviews.llvm.org/settings/panel/emailpreferences/

[• shankar.easwaran]

Section groups(grouping multiple sections as part of a group) cannot be handled without ingroup references for garbage collection and correctness.

[ruiu]

That's not correct. As you may know (because you are the person who implemented section group support to LLD), kindInGroup is not used to implement section group. Please take a look at the code, this piece of code doesn't seem to do anything meaningful including section groups.

[shankarke]

Section groups is only implemented in lld/Core(does not test garbage collection with section groups though). Support is not in the ELF Reader as yet too.

[shankarke]

Sorry to club this in the current review thread, I think we are overloading the Layout references for garbage collection.

If you are creating a reference (kindLayoutAfter) from A to B, that may not mean that you cannot garbage collect B for the end user.

My thought on Layout references was that it only guarantees that atoms appear in Layout reference order.

Why are we overloading this for Garbage collection (aside from saving space/code) ?

We should create kindLive (or) some better name IMO for Garbage collection. With this the complex LayoutPass can be optional and would be meant only for users that need the LayoutReferences to specify layout of the image.

We could come up with a simpler pass for Layout(to sort atoms by file ordinal).

What do you think ?

[ruiu]

Sorry, Shankar, I don't get what you mean by "Section groups is only implemented in lld/Core". Can you please take a look at the diff? kindInGroup was used only in ELFFile.h, and that use didn't make sense. I'm just trying to delete dead code by this change. This change didn't change functionality, LLD is still able to link itself/Clang, nothing more than that.

[ruiu]

I'm going to submit this because Shankar approved on Phab.

Shankar, if you still want to bring up the point you mentioned in the last email, please start a new thread. Thanks!

[Eugene.Zelenko]

Committed in r227259.

include/lld/Core/Reference.h

public:
   /// setKindValue() is needed because during linking, some optimizations may
   /// change the codegen and hence the reference kind.
   void setKindValue(KindValue value) {
     _kindValue = value;
   }
 
   /// KindValues used with KindNamespace::all and KindArch::all.
   enum {
-    kindInGroup = 1,
     // kindLayoutAfter is treated as a bidirected edge by the dead-stripping
     // pass.
-    kindLayoutAfter = 2,
+    kindLayoutAfter = 1,
     // kindLayoutBefore is currently used only by PECOFF port, and will
     // be removed soon. To enforce layout, use kindLayoutAfter instead.
-    kindLayoutBefore = 3,
+    kindLayoutBefore,
     // kindGroupChild is treated as a bidirected edge too.
-    kindGroupChild = 4,
-    kindAssociate = 5,
+    kindGroupChild,
+    kindAssociate,
   };
 
   // A value to be added to the value of a target
   typedef int64_t Addend;
 
   /// If the reference is a fixup in the Atom, then this returns the
   /// byte offset into the Atom's content to do the fix up.
   virtual uint64_t offsetInAtom() const = 0;

include/lld/Passes/LayoutPass.h

public:
 
   virtual ~LayoutPass() {}
 
 private:
   // Build the followOn atoms chain as specified by the kindLayoutAfter
   // reference type
   void buildFollowOnTable(MutableFile::DefinedAtomRange &range);
 
-  // Build the followOn atoms chain as specified by the kindInGroup
-  // reference type
-  void buildInGroupTable(MutableFile::DefinedAtomRange &range);
-
   // Build a map of Atoms to ordinals for sorting the atoms
   void buildOrdinalOverrideMap(MutableFile::DefinedAtomRange &range);
 
   const Registry &_registry;
   SortOverride _customSorter;
 
   typedef llvm::DenseMap<const DefinedAtom *, const DefinedAtom *> AtomToAtomT;
   typedef llvm::DenseMap<const DefinedAtom *, uint64_t> AtomToOrdinalT;

lib/Core/Reader.cpp

for (const std::unique_ptr<Reader> &reader : _readers) {
     return std::error_code();
   }
 
   // No Reader could parse this file.
   return make_error_code(llvm::errc::executable_format_error);
 }
 
 static const Registry::KindStrings kindStrings[] = {
-    {Reference::kindInGroup, "in-group"},
     {Reference::kindLayoutAfter, "layout-after"},
     {Reference::kindLayoutBefore, "layout-before"},
     {Reference::kindGroupChild, "group-child"},
     {Reference::kindAssociate, "associate"},
     LLD_KIND_STRING_END};
 
 Registry::Registry() {
   addKindTable(Reference::KindNamespace::all, Reference::KindArch::all,

lib/Passes/LayoutPass.cpp

for (const Reference *r : *ai) {
       if (!checkAllPrevAtomsZeroSize(targetAtom))
         break;
       _followOnNexts[ai] = _followOnRoots[targetAtom];
       setChainRoot(_followOnRoots[targetAtom], _followOnRoots[ai]);
     }
   }
 }
 
-/// This pass builds the followon tables using InGroup relationships
-/// The algorithm follows a very simple approach
-/// a) If the rootAtom is not part of any root, create a new root with the
-///    as the head
-/// b) If the current Atom root is not found, then make the current atoms root
-///    point to the rootAtom
-/// c) If the root of the current Atom is itself a root of some other tree
-///    make all the atoms in the chain point to the ingroup reference
-/// d) Check to see if the current atom is part of the chain from the rootAtom
-///    if not add the atom to the chain, so that the current atom is part of the
-///    the chain where the rootAtom is in
-void LayoutPass::buildInGroupTable(MutableFile::DefinedAtomRange &range) {
-  ScopedTask task(getDefaultDomain(), "LayoutPass::buildInGroupTable");
-  // This table would convert precededby references to follow on
-  // references so that we have only one table
-  for (const DefinedAtom *ai : range) {
-    for (const Reference *r : *ai) {
-      if (r->kindNamespace() != lld::Reference::KindNamespace::all ||
-          r->kindValue() != lld::Reference::kindInGroup)
-        continue;
-      const DefinedAtom *rootAtom = dyn_cast<DefinedAtom>(r->target());
-      // If the root atom is not part of any root
-      // create a new root
-      if (_followOnRoots.count(rootAtom) == 0) {
-        _followOnRoots[rootAtom] = rootAtom;
-      }
-      // If the current Atom has not been seen yet and there is no root
-      // that has been set, set the root of the atom to the targetAtom
-      // as the targetAtom points to the ingroup root
-      auto iter = _followOnRoots.find(ai);
-      if (iter == _followOnRoots.end()) {
-        _followOnRoots[ai] = rootAtom;
-      } else if (iter->second == ai) {
-        if (iter->second != rootAtom)
-          setChainRoot(iter->second, rootAtom);
-      } else {
-        // TODO : Flag an error that the root of the tree
-        // is different, Here is an example
-        // Say there are atoms
-        // chain 1 : a->b->c
-        // chain 2 : d->e->f
-        // and e,f have their ingroup reference as a
-        // this could happen only if the root of e,f that is d
-        // has root as 'a'
-        continue;
-      }
-
-      // Check if the current atom is part of the chain
-      bool isAtomInChain = false;
-      const DefinedAtom *lastAtom = rootAtom;
-      for (;;) {
-        AtomToAtomT::iterator followOnAtomsIter =
-            _followOnNexts.find(lastAtom);
-        if (followOnAtomsIter != _followOnNexts.end()) {
-          lastAtom = followOnAtomsIter->second;
-          if (lastAtom != ai)
-            continue;
-          isAtomInChain = true;
-        }
-        break;
-      }
-
-      if (!isAtomInChain)
-        _followOnNexts[lastAtom] = ai;
-    }
-  }
-}
-
 /// Build an ordinal override map by traversing the followon chain, and
 /// assigning ordinals to each atom, if the atoms have their ordinals
 /// already assigned skip the atom and move to the next. This is the
 /// main map thats used to sort the atoms while comparing two atoms together
 void LayoutPass::buildOrdinalOverrideMap(MutableFile::DefinedAtomRange &range) {
   ScopedTask task(getDefaultDomain(), "LayoutPass::buildOrdinalOverrideMap");
   uint64_t index = 0;
   for (const DefinedAtom *ai : range) {

 void LayoutPass::perform(std::unique_ptr<MutableFile> &mergedFile) {
   // sort the atoms
   ScopedTask task(getDefaultDomain(), "LayoutPass");
   MutableFile::DefinedAtomRange atomRange = mergedFile->definedAtoms();
 
   // Build follow on tables
   buildFollowOnTable(atomRange);
 
-  // Build Ingroup reference table
-  buildInGroupTable(atomRange);
-
   // Check the structure of followon graph if running in debug mode.
   DEBUG(checkFollowonChain(atomRange));
 
   // Build override maps
   buildOrdinalOverrideMap(atomRange);
 
   DEBUG({
     llvm::dbgs() << "unsorted atoms:\n";

lib/ReaderWriter/ELF/ELFFile.h

if (handleSectionWithNoSymbols(section, symbols)) {
       ELFDefinedAtom<ELFT> *newAtom =
           createSectionAtom(section, *sectionName, *sectionContents);
       _definedAtoms._atoms.push_back(newAtom);
       newAtom->setOrdinal(++_ordinal);
       continue;
     }
 
     ELFDefinedAtom<ELFT> *previousAtom = nullptr;
-    ELFDefinedAtom<ELFT> *inGroupAtom = nullptr;
     ELFReference<ELFT> *anonFollowedBy = nullptr;
 
     for (auto si = symbols.begin(), se = symbols.end(); si != se; ++si) {
       auto symbol = *si;
       StringRef symbolName = "";
       if (symbol->getType() != llvm::ELF::STT_SECTION) {
         auto symName = _objFile->getSymbolName(symbol);
         if (std::error_code ec = symName.getError())
for (auto si = symbols.begin(), se = symbols.end(); si != se; ++si) {
       // the anonymous atom that we created.
       if (anonAtom)
         createEdge(newAtom, anonAtom, Reference::kindLayoutAfter);
 
       if (previousAtom) {
         // Set the followon atom to the weak atom that we have created, so
         // that they would alias when the file gets written.
         followOn->setTarget(anonAtom ? anonAtom : newAtom);
-
-        // Add a preceded-by reference only if the current atom is not a weak
-        // atom.
-        if (symbol->getBinding() != llvm::ELF::STB_WEAK)
-          createEdge(newAtom, inGroupAtom, lld::Reference::kindInGroup);
       }
 
       // The previous atom is always the atom created before unless the atom
       // is a weak atom.
       previousAtom = anonAtom ? anonAtom : newAtom;
 
-      if (!inGroupAtom)
-        inGroupAtom = previousAtom;
-
       _definedAtoms._atoms.push_back(newAtom);
       _symbolToAtomMapping.insert(std::make_pair(&*symbol, newAtom));
       if (anonAtom)
         _definedAtoms._atoms.push_back(anonAtom);
     }
   }
 
   updateReferences();

test/core/ingroup-test-big.objtxt

-# RUN: lld -core --add-pass layout %s | FileCheck %s -check-prefix=CHKORDER
-
----
-defined-atoms:
-  - name:            A
-    scope:           global
-    references:
-      - kind:            layout-after
-        offset:          0
-        target:          B
-  - name:            B
-    scope:           global
-    references:
-      - kind:            in-group
-        offset:          0
-        target:          A
-      - kind:            layout-after
-        offset:          0
-        target:          C
-  - name:            C
-    scope:           global
-    references:
-      - kind:            in-group
-        offset:          0
-        target:          A
-  - name:            E
-    scope:           global
-    references:
-      - kind:            in-group
-        offset:          0
-        target:          E
-      - kind:            layout-after
-        offset:          0
-        target:          F
-  - name:            F
-    scope:           global
-    references:
-      - kind:            in-group
-        offset:          0
-        target:          E
-  - name:            D
-    scope:           global
-    references:
-      - kind:            in-group
-        offset:          0
-        target:          A
-      - kind:            layout-after
-        offset:          0
-        target:          E
-...
-
-# CHKORDER:   - name:            A
-# CHKORDER:   - name:            B
-# CHKORDER:   - name:            C
-# CHKORDER:   - name:            D
-# CHKORDER:   - name:            E
-# CHKORDER:   - name:            F

test/core/ingroup-test-loop.objtxt

-# RUN: lld -core --add-pass layout %s | FileCheck %s -check-prefix=CHKORDER
-
----
-defined-atoms:
-  - name:            A
-    scope:           global
-    references:
-      - kind:            layout-after
-        offset:          0
-        target:          E
-  - name:            E
-    scope:           global
-    references:
-      - kind:            in-group
-        offset:          0
-        target:          A
-...
-
-# CHKORDER:   - name:            A
-# CHKORDER:   - name:            E

test/core/ingroup-test-with-layout-after.objtxt

-# RUN: lld -core --add-pass layout %s | FileCheck %s -check-prefix=CHKORDER
-
----
-defined-atoms:
-  - name:            A
-    scope:           global
-    references:
-      - kind:            layout-after
-        offset:          0
-        target:          B
-  - name:            B
-    scope:           global
-    references:
-      - kind:            in-group
-        offset:          0
-        target:          A
-      - kind:            layout-after
-        offset:          0
-        target:          E
-  - name:            F
-    scope:           global
-    references:
-      - kind:            in-group
-        offset:          0
-        target:          E
-      - kind:            layout-after
-        offset:          0
-        target:          G
-  - name:            G
-    scope:           global
-    references:
-      - kind:            in-group
-        offset:          0
-        target:          E
-  - name:            E
-    scope:           global
-    references:
-      - kind:            in-group
-        offset:          0
-        target:          A
-      - kind:            layout-after
-        offset:          0
-        target:          F
-...
-
-# CHKORDER:   - name:            A
-# CHKORDER:   - name:            B
-# CHKORDER:   - name:            E
-# CHKORDER:   - name:            F
-# CHKORDER:   - name:            G

test/core/ingroup-test.objtxt

-# RUN: lld -core --add-pass layout %s | FileCheck %s -check-prefix=CHKORDER
-
----
-defined-atoms:
-  - name:            A
-    scope:           global
-
-  - name:            B
-    scope:           global
-    references:
-      - kind:            in-group
-        offset:          0
-        target:          A
-  - name:            F
-    scope:           global
-    references:
-      - kind:            in-group
-        offset:          0
-        target:          E
-  - name:            G
-    scope:           global
-    references:
-      - kind:            in-group
-        offset:          0
-        target:          E
-  - name:            E
-    scope:           global
-    references:
-      - kind:            in-group
-        offset:          0
-        target:          A
-...
-
-# CHKORDER:   - name:            A
-# CHKORDER:   - name:            B
-# CHKORDER:   - name:            E
-# CHKORDER:   - name:            F
-# CHKORDER:   - name:            G

test/elf/Mips/ctors-order.test

 # Check ordering of .ctors.* sections.
 
 # RUN: yaml2obj -format=elf -docnum 1 %s > %t-crtbeginS.o
 # RUN: yaml2obj -format=elf -docnum 2 %s > %t-crtendS.o
 # RUN: yaml2obj -format=elf -docnum 3 %s > %t-obj.o
 # RUN: lld -flavor gnu -target mipsel -shared --output-filetype=yaml \
 # RUN:     %t-crtbeginS.o %t-obj.o %t-crtendS.o | FileCheck %s
 # RUN: lld -flavor gnu -target mipsel -shared -o %t.so \
 # RUN:     %t-crtbeginS.o %t-obj.o %t-crtendS.o
 # RUN: llvm-objdump -s %t.so | FileCheck -check-prefix=RAW %s
 
 # CHECK:      defined-atoms:
-# CHECK-NEXT:   - ref-name:        L000
-# CHECK-NEXT:     type:            data
+# CHECK-NEXT:   - type:            data
 # CHECK-NEXT:     alignment:       2^2
 # CHECK-NEXT:     section-choice:  custom-required
 # CHECK-NEXT:     section-name:    .ctors
 # CHECK-NEXT:     references:
 # CHECK-NEXT:       - kind:            layout-after
 # CHECK-NEXT:         offset:          0
 # CHECK-NEXT:         target:          __CTOR_LIST__
 # CHECK-NEXT:   - name:            __CTOR_LIST__
 # CHECK-NEXT:     type:            data
 # CHECK-NEXT:     content:         [ FF, FF, FF, FF ]
 # CHECK-NEXT:     alignment:       2^2
 # CHECK-NEXT:     section-choice:  custom-required
 # CHECK-NEXT:     section-name:    .ctors
-# CHECK-NEXT:     references:
-# CHECK-NEXT:       - kind:            in-group
-# CHECK-NEXT:         offset:          0
-# CHECK-NEXT:         target:          L000
 # CHECK-NEXT:   - type:            data
 # CHECK-NEXT:     content:         [ 11, 11, 11, 11 ]
 # CHECK-NEXT:     alignment:       2^2
 # CHECK-NEXT:     section-choice:  custom-required
 # CHECK-NEXT:     section-name:    .ctors.1
 # CHECK-NEXT:   - type:            data
 # CHECK-NEXT:     content:         [ 22, 22, 22, 22 ]
 # CHECK-NEXT:     alignment:       2^2
 # CHECK-NEXT:     section-choice:  custom-required
 # CHECK-NEXT:     section-name:    .ctors.2
-# CHECK-NEXT:   - ref-name:        L005
+# CHECK-NEXT:   - ref-name:        L003
 # CHECK-NEXT:     type:            data
 # CHECK-NEXT:     alignment:       2^2
 # CHECK-NEXT:     section-choice:  custom-required
 # CHECK-NEXT:     section-name:    .ctors
 # CHECK-NEXT:     references:
 # CHECK-NEXT:       - kind:            layout-after
 # CHECK-NEXT:         offset:          0
 # CHECK-NEXT:         target:          __CTOR_END__

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

 # 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:        L009
+# CHECK-GOT:   - ref-name:        L008
 # 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:     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:        L009
+# CHECK-GOT:   - ref-name:        L008
 # 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
 
 # Local GOT entries:
-# YAML:       - ref-name:        L002
+# YAML:       - 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_1
-# 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:            LLD_R_MIPS_32_HI16
 # YAML-NEXT:        offset:          0
 # YAML-NEXT:        target:          data_2
-# 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:            R_MIPS_32
 # YAML-NEXT:        offset:          0
 # YAML-NEXT:        target:          data_h
 
 # Global GOT entries:
-# 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:          bar
 # YAML-NEXT:      - kind:            R_MIPS_32
 # YAML-NEXT:        offset:          0
 # YAML-NEXT:        target:          bar
-# YAML-NEXT:  - ref-name:        L006
+# 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:          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:       L002
+# 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:       L003
+# 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:       L004
+# YAML-NEXT:       target:       L003
 # YAML-NEXT:     - kind:         R_MICROMIPS_CALL16
 # YAML-NEXT:       offset:       20
-# YAML-NEXT:       target:       L005
+# YAML-NEXT:       target:       L004
 # YAML-NEXT:     - kind:         R_MICROMIPS_CALL16
 # YAML-NEXT:       offset:       24
-# YAML-NEXT:       target:       L006
+# 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)