[ELF][X86_64][Hexagon] order plt/got entries properly and fix test

[shankarke]

Summary

The atoms in the map are not ordered in the same way as we create plt / got entries. This is to make the result consistent across continuous runs so that the ordinals are properly assigned.

[Bigcheese]

lgtm

[Eugene.Zelenko]

Committed in rL176970.

lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.cpp

for (const auto &atom : mf.defined())
         handleReference(*atom, *ref);
 
     // Add all created atoms to the link.
     uint64_t ordinal = 0;
     if (_PLT0) {
       _PLT0->setOrdinal(ordinal++);
       mf.addAtom(*_PLT0);
     }
-    for (const auto &plt : _pltMap) {
-      plt.second->setOrdinal(ordinal++);
-      mf.addAtom(*plt.second);
+    for (auto &plt : _pltVector) {
+      plt->setOrdinal(ordinal++);
+      mf.addAtom(*plt);
     }
     if (_null) {
       _null->setOrdinal(ordinal++);
       mf.addAtom(*_null);
     }
-    if (_PLT0) {
+    if (_got0) {
       _got0->setOrdinal(ordinal++);
       mf.addAtom(*_got0);
     }
-    for (const auto &got : _gotMap) {
-      got.second->setOrdinal(ordinal++);
-      mf.addAtom(*got.second);
+    for (auto &got : _gotVector) {
+      got->setOrdinal(ordinal++);
+      mf.addAtom(*got);
     }
   }
 
 protected:
   /// \brief Owner of all the Atoms created by this pass.
   ELFPassFile _file;
   
   /// \brief Map Atoms to their GOT entries.
   llvm::DenseMap<const Atom *, GOTAtom *> _gotMap;
 
   /// \brief Map Atoms to their PLT entries.
   llvm::DenseMap<const Atom *, PLTAtom *> _pltMap;
 
+  /// \brief the list of GOT/PLT atoms
+  std::vector<GOTAtom *> _gotVector;
+  std::vector<PLTAtom *> _pltVector;
+
   /// \brief GOT entry that is always 0. Used for undefined weaks.
   GOTAtom *_null;
 
   /// \brief The got and plt entries for .PLT0. This is used to call into the
   /// dynamic linker for symbol resolution.
   /// @{
   PLT0Atom *_PLT0;
   GOTAtom *_got0;
const PLT0Atom *getPLT0() {
     getNullGOT();
     _PLT0 = new (_file._alloc) HexagonPLT0Atom(_file);
     _got0 = new (_file._alloc) HexagonGOTAtom(_file, ".got.plt");
     _PLT0->addReference(R_HEX_B32_PCREL_X, 0, _got0, 0);
     _PLT0->addReference(R_HEX_6_PCREL_X, 4, _got0, 0);
 #ifndef NDEBUG
     _got0->_name = "__got0";
 #endif
+    DEBUG_WITH_TYPE("PLT", llvm::dbgs() << "[ PLT0/GOT0 ] "
+                                        << "Adding plt0/got0 \n");
     return _PLT0;
   }
 
   const PLTAtom *getPLTEntry(const Atom *a) {
     auto plt = _pltMap.find(a);
     if (plt != _pltMap.end())
       return plt->second;
     auto ga = new (_file._alloc) HexagonGOTAtom(_file, ".got.plt");
     ga->addReference(R_HEX_JMP_SLOT, 0, a, 0);
     auto pa = new (_file._alloc) HexagonPLTAtom(_file, ".plt");
     pa->addReference(R_HEX_B32_PCREL_X, 0, ga, 0);
     pa->addReference(R_HEX_6_PCREL_X, 4, ga, 4);
 
     // Point the got entry to the PLT0 atom initially
     ga->addReference(R_HEX_32, 0, getPLT0(), 0);
 #ifndef NDEBUG
     ga->_name = "__got_";
     ga->_name += a->name();
     pa->_name = "__plt_";
     pa->_name += a->name();
+    DEBUG_WITH_TYPE("PLT", llvm::dbgs() << "[" << a->name() << "] "
+                                        << "Adding plt/got: " << pa->_name
+                                        << "/" << ga->_name << "\n");
 #endif
     _gotMap[a] = ga;
     _pltMap[a] = pa;
+    _gotVector.push_back(ga);
+    _pltVector.push_back(pa);
     return pa;
   }
 
   ErrorOr<void> handlePLT32(const Reference &ref) {
     // Turn this into a PC32 to the PLT entry.
     const_cast<Reference &>(ref).setKind(R_HEX_B22_PCREL);
     const_cast<Reference &>(ref).setTarget(getPLTEntry(ref.target()));
     return error_code::success();

lib/ReaderWriter/ELF/X86_64/X86_64TargetInfo.cpp

 #ifndef NDEBUG
     ga->_name = "__got_ifunc_";
     ga->_name += da->name();
     pa->_name = "__plt_ifunc_";
     pa->_name += da->name();
 #endif
     _gotMap[da] = ga;
     _pltMap[da] = pa;
+    _gotVector.push_back(ga);
+    _pltVector.push_back(pa);
     return pa;
   }
 
   /// \brief Redirect the call to the PLT stub for the target IFUNC.
   ///
   /// This create a PLT and GOT entry for the IFUNC if one does not exist. The
   /// GOT entry and a IRELATIVE relocation to the original target resolver.
   ErrorOr<void> handleIFUNC(const Reference &ref) {
const GOTAtom *getGOTTPOFF(const DefinedAtom *atom) {
     if (got == _gotMap.end()) {
       auto g = new (_file._alloc) X86_64GOTAtom(_file, ".got");
       g->addReference(R_X86_64_TPOFF64, 0, atom, 0);
 #ifndef NDEBUG
       g->_name = "__got_tls_";
       g->_name += atom->name();
 #endif
       _gotMap[atom] = g;
+      _gotVector.push_back(g);
       return g;
     }
     return got->second;
   }
 
   /// \brief Create a TPOFF64 GOT entry and change the relocation to a PC32 to
   /// the GOT.
   void handleGOTTPOFF(const Reference &ref) {
const GOTAtom *getGOT(const DefinedAtom *da) {
     if (got == _gotMap.end()) {
       auto g = new (_file._alloc) X86_64GOTAtom(_file, ".got");
       g->addReference(R_X86_64_64, 0, da, 0);
 #ifndef NDEBUG
       g->_name = "__got_";
       g->_name += da->name();
 #endif
       _gotMap[da] = g;
+      _gotVector.push_back(g);
       return g;
     }
     return got->second;
   }
 
   /// \brief Handle a GOTPCREL relocation to an undefined weak atom by using a
   /// null GOT entry.
   void handleGOTPCREL(const Reference &ref) {
for (const auto &atom : mf.defined())
         handleReference(*atom, *ref);
 
     // Add all created atoms to the link.
     uint64_t ordinal = 0;
     if (_PLT0) {
       _PLT0->setOrdinal(ordinal++);
       mf.addAtom(*_PLT0);
     }
-    for (const auto &plt : _pltMap) {
-      plt.second->setOrdinal(ordinal++);
-      mf.addAtom(*plt.second);
+    for (auto &plt : _pltVector) {
+      plt->setOrdinal(ordinal++);
+      mf.addAtom(*plt);
     }
     if (_null) {
       _null->setOrdinal(ordinal++);
       mf.addAtom(*_null);
     }
     if (_PLT0) {
       _got0->setOrdinal(ordinal++);
       _got1->setOrdinal(ordinal++);
       mf.addAtom(*_got0);
       mf.addAtom(*_got1);
     }
-    for (const auto &got : _gotMap) {
-      got.second->setOrdinal(ordinal++);
-      mf.addAtom(*got.second);
+    for (auto &got : _gotVector) {
+      got->setOrdinal(ordinal++);
+      mf.addAtom(*got);
     }
   }
 
 protected:
   /// \brief Owner of all the Atoms created by this pass.
   ELFPassFile _file;
   
   /// \brief Map Atoms to their GOT entries.
   llvm::DenseMap<const Atom *, GOTAtom *> _gotMap;
 
   /// \brief Map Atoms to their PLT entries.
   llvm::DenseMap<const Atom *, PLTAtom *> _pltMap;
 
+  /// \brief the list of GOT/PLT atoms
+  std::vector<GOTAtom *> _gotVector;
+  std::vector<PLTAtom *> _pltVector;
+
   /// \brief GOT entry that is always 0. Used for undefined weaks.
   GOTAtom *_null;
 
   /// \brief The got and plt entries for .PLT0. This is used to call into the
   /// dynamic linker for symbol resolution.
   /// @{
   PLT0Atom *_PLT0;
   GOTAtom *_got0;

 #ifndef NDEBUG
     ga->_name = "__got_";
     ga->_name += a->name();
     pa->_name = "__plt_";
     pa->_name += a->name();
 #endif
     _gotMap[a] = ga;
     _pltMap[a] = pa;
+    _gotVector.push_back(ga);
+    _pltVector.push_back(pa);
     return pa;
   }
 
   ErrorOr<void> handlePLT32(const Reference &ref) {
     // Turn this into a PC32 to the PLT entry.
     const_cast<Reference &>(ref).setKind(R_X86_64_PC32);
     // Handle IFUNC.
     if (const DefinedAtom *da = dyn_cast_or_null<const DefinedAtom>(ref.target()))
const GOTAtom *getSharedGOT(const SharedLibraryAtom *sla) {
     if (got == _gotMap.end()) {
       auto g = new (_file._alloc) X86_64GOTAtom(_file, ".got.dyn");
       g->addReference(R_X86_64_GLOB_DAT, 0, sla, 0);
 #ifndef NDEBUG
       g->_name = "__got_";
       g->_name += sla->name();
 #endif
       _gotMap[sla] = g;
+      _gotVector.push_back(g);
       return g;
     }
     return got->second;
   }
 
   void handleGOTPCREL(const Reference &ref) {
     const_cast<Reference &>(ref).setKind(R_X86_64_PC32);
     if (isa<UndefinedAtom>(ref.target()))

test/elf/x86-64-dynamic.test

 CHECK:    permissions:     rw-
         - name:            __got1
 CHECK:    type:            got
 CHECK:    content:         [ 00, 00, 00, 00, 00, 00, 00, 00 ]
 CHECK:    alignment:       2^3
 CHECK:    section-choice:  custom-required
 CHECK:    section-name:    .got.plt
 CHECK:    permissions:     rw-
-        - name:            __got_i
-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
         - name:            __got_foo
 CHECK:    type:            got
 CHECK:    content:         [ 00, 00, 00, 00, 00, 00, 00, 00 ]
 CHECK:    alignment:       2^3
 CHECK:    section-choice:  custom-required
 CHECK:    section-name:    .got.plt
 CHECK:    permissions:     rw-
 CHECK:    references:
 CHECK:      - kind:            R_X86_64_JUMP_SLOT
 CHECK:        offset:          0
 CHECK:        target:          foo
 CHECK:      - kind:            R_X86_64_64
 CHECK:        offset:          0
               target:          __plt_foo
 CHECK:        addend:          6
+        - name:            __got_i
+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
               target:          __plt_foo
 CHECK:        addend:          -4