[ELF] Use llvm ADT's instead of std.

[shankarke]

Summary

This changes usage of std::map/std::unordered_map to use llvm ADT's. The llvm ADT's are more light weight, easy to use,
there are more error checks and easier to debug if there is an issue. Makes it consistent with rest of llvm too.

This change otherwise doesnot bring any new functionality.

[atanasyan]

lib/ReaderWriter/ELF/DefaultLayout.h

120

Why do you drop this comment?

[davide]

I skimmed over the patch quickly and it seems good to me. I'm curious to know if you made any A/B comparison, and if LLVM ADT results faster for this particular use case.

[rnk]

Rui mentioned that he had to change a DenseMap to a std::map / unordered_map to fix a crasher when linking Chrome. Unfortunately, I don't think he ever figured exactly what was wrong with the LLVM container.

Unfortunately, the Chrome link is currently broken, or I would tell you to watch the bot when you commit:
http://build.chromium.org/p/chromium.fyi/builders/CrWinClangLLD

[shankarke]

lib/ReaderWriter/ELF/DefaultLayout.h

120

Good catch, will put those comments back,

[shankarke]

davide: I havent measured. There are some low hanging fruits which I plan to do of resizing certain maps.

[shankarke]

rnk : I was able to self-host clang/lld and run without any issues, and I would think he was trying to link chromium with the lld windows flavor.

[shankarke]

Address comments from Simon.

[ruiu]

I usually don't apply someone else's patch to test Chromium build, but this should not affect the Windows port anyway, because this only changes the ELF port.

But this change may be riskier than you might think because of the subtle difference of semantics between std::map and llvm::DenseMap regarding references returned by operator[] and iterators. For std::map, it is guaranteed that inserting a new element does not invalidate existing references to a std::map. It doesn't invalidate iterators unless you remove an element and an iterator is pointing to the element.

These properties are not guaranteed by DenseMap. So, if you add a new item to a map while you are iterating over elements of the map, it may crash. It actually crashes only when the hash table is resized to add a new element for LHS, so it could produce a nasty flaky bug. For example the bug in the LayoutPass was there for more than 1 year until I fixed that.

Even

m[x] = m[y]

is not guaranteed to be safe for a DenseMap m, because a reference returned by m[y] can be invalidated by m[x]. This particular one is the bug in LayoutPass.cpp that Reid mentioned above (fix is r213969).

I checked the code quickly, and it looks safe to me, but please review your patch again with the above thing in your mind.

[shankarke]

Thanks for the info, Rui. Adding items to the map while you are iterating is bad in the first place, not sure why std::map didnt show the issue. I will double check the ELF Reader/Writer for any of these occurences.

[sanjoy]

These properties are not guaranteed by DenseMap. So, if you add a new item to a map while you are iterating over elements of the map, it may crash. It actually crashes only when the hash table is resized to add a new element for LHS, so it could produce a nasty flaky bug. For example the bug in the LayoutPass was there for more than 1 year until I fixed that.

A slight tangent: do you guys think it will be worth the effort to
turn such errors to deterministically fail an assert in debug mode?
For instance, I can imagine having an "epoch" counter in the DenseMap
and DenseMapIterator, with modifications to the DenseMap bumping the
counter and iterator accesses asserting "ParentDenseMap->epoch ==
this->epoch" on access.

Even

m[x] = m[y]

is not guaranteed to be safe for a DenseMap m, because a reference returned by m[y] can be invalidated by m[x]. This particular one is the bug in LayoutPass.cpp that Reid mentioned above (fix is r213969).

I checked the code quickly, and it looks safe to me, but please review your patch again with the above thing in your mind.

http://reviews.llvm.org/D7885

EMAIL PREFERENCES

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

---

llvm-commits mailing list
[e-mail]
http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits

lib/ReaderWriter/ELF/DefaultLayout.h

 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Format.h"
-#include <map>
-#include <unordered_map>
 
 namespace lld {
 namespace elf {
 /// \brief The DefaultLayout class is used by the Writer to arrange
 ///        sections and segments in the order determined by the target ELF
 ///        format. The writer creates a single instance of the DefaultLayout
 ///        class
 template<class ELFT>
enum DefaultSectionOrder {
     ORDER_STRING_TABLE = 250,
     ORDER_SECTION_HEADERS = 260
   };
 
 public:
 
   // The Key used for creating Sections
   // The sections are created using
-  // SectionName, contentPermissions
+  // SectionName, contentPermissions,path
   struct SectionKey {
+    SectionKey() : _name(""), _perm(DefinedAtom::perm___), _path("") {}
+
     SectionKey(StringRef name, DefinedAtom::ContentPermissions perm,
                StringRef path)
         : _name(name), _perm(perm), _path(path) {}
 
     // Data members
     StringRef _name;
     DefinedAtom::ContentPermissions _perm;
     StringRef _path;
   };
 
-  struct SectionKeyHash {
-    int64_t operator()(const SectionKey &k) const {
+  struct SectionKeyInfo {
+    static SectionKey getEmptyKey() { return SectionKey(); }
+    static SectionKey getTombstoneKey() { return SectionKey(); }
+    static unsigned getHashValue(const SectionKey &k) {
       return llvm::hash_combine(k._name, k._perm, k._path);
     }
-  };
-
-  struct SectionKeyEq {
-    bool operator()(const SectionKey &lhs, const SectionKey &rhs) const {
+    static bool isEqual(const SectionKey &lhs, const SectionKey &rhs) {
       return ((lhs._name == rhs._name) && (lhs._perm == rhs._perm) &&
               (lhs._path == rhs._path));
     }
   };
 
   typedef typename std::vector<Chunk<ELFT> *>::iterator ChunkIter;
   typedef typename std::vector<Segment<ELFT> *>::iterator SegmentIter;
 
-  // The additional segments are used to figure out
-  // if there is a segment by that type already created
-  // For example : PT_TLS, we have two sections .tdata/.tbss
-  // that are part of PT_TLS, we need to create this additional
-  // segment only once
-  typedef std::pair<int64_t, int64_t> AdditionalSegmentKey;
-  // The segments are created using
-  // SegmentName, Segment flags
-  typedef std::pair<StringRef, int64_t> SegmentKey;
+  struct SegmentKey {
+    SegmentKey() : _name(""), _perm(-1) {}
+    SegmentKey(StringRef name, int64_t perm) : _name(name), _perm(perm) {}
+    // Data members
+    StringRef _name;
+    int64_t _perm;
+  };
 
-  // HashKey for the Segment
-  class SegmentHashKey {
-  public:
-    int64_t operator() (const SegmentKey &k) const {
-      // k.first = SegmentName
-      // k.second = SegmentFlags
-      return llvm::hash_combine(k.first, k.second);
+  struct SegmentKeyInfo {
+    static SegmentKey getEmptyKey() { return SegmentKey(); }
+    static SegmentKey getTombstoneKey() { return SegmentKey(); }
+    static unsigned getHashValue(const SegmentKey &k) {
+      return llvm::hash_combine(k._name, k._perm);
+    }
+    static bool isEqual(const SegmentKey &lhs, const SegmentKey &rhs) {
+      return ((lhs._name == rhs._name) && (lhs._perm == rhs._perm));
     }
   };
 
-  class AdditionalSegmentHashKey {
-  public:
-    int64_t operator() (int64_t segmentType, int64_t segmentFlag) const {
-      // k.first = SegmentName
-      // k.second = SegmentFlags
-      return llvm::hash_combine(segmentType, segmentFlag);
+  // The additional segments are used to figure out if there is a segment by
+  // that type already created For example : PT_TLS, we have two sections
+  // .tdata/.tbss that are part of PT_TLS, we need to create this additional
+  // segment only once.
+  struct AdditionalSegmentKey {
+    AdditionalSegmentKey() : _segmentType(-1), _perm(-1) {}
+    AdditionalSegmentKey(int64_t segmentType, int64_t perm)
+        : _segmentType(segmentType), _perm(perm) {}
+    // Data members
+    int64_t _segmentType;
+    int64_t _perm;
+  };
+
+  struct AdditionalSegmentKeyInfo {
+    static AdditionalSegmentKey getEmptyKey() { return AdditionalSegmentKey(); }
+    static AdditionalSegmentKey getTombstoneKey() {
+      return AdditionalSegmentKey();
+    }
+    static unsigned getHashValue(const AdditionalSegmentKey &k) {
+      return llvm::hash_combine(k._segmentType, k._perm);
+    }
+    static bool isEqual(const AdditionalSegmentKey &lhs,
+                        const AdditionalSegmentKey &rhs) {
+      return ((lhs._segmentType == rhs._segmentType) &&
+              (lhs._perm == rhs._perm));
     }
   };
 
   // Output Sections contain the map of Sectionnames to a vector of sections,
   // that have been merged to form a single section
-  typedef llvm::StringMap<OutputSection<ELFT> *> OutputSectionMapT;
+  typedef llvm::DenseMap<StringRef, OutputSection<ELFT> *, StringRefMappingInfo>
+      OutputSectionMapT;
   typedef
       typename std::vector<OutputSection<ELFT> *>::iterator OutputSectionIter;
 
-  typedef std::unordered_map<SectionKey, AtomSection<ELFT> *, SectionKeyHash,
-                             SectionKeyEq> SectionMapT;
-  typedef std::map<AdditionalSegmentKey, Segment<ELFT> *> AdditionalSegmentMapT;
-  typedef std::unordered_map<SegmentKey, Segment<ELFT> *, SegmentHashKey>
+  typedef llvm::DenseMap<SectionKey, AtomSection<ELFT> *, SectionKeyInfo>
+      SectionMapT;
+  typedef llvm::DenseMap<AdditionalSegmentKey, Segment<ELFT> *,
+                         AdditionalSegmentKeyInfo> AdditionalSegmentMapT;
+  typedef llvm::DenseMap<SegmentKey, Segment<ELFT> *, SegmentKeyInfo>
       SegmentMapT;
 
   /// \brief find a absolute atom pair given a absolute atom name
   struct FindByName {
     const std::string _name;
     FindByName(StringRef name) : _name(name) {}
     bool operator()(const lld::AtomLayout *j) { return j->_atom->name() == _name; }
   };
 

lib/ReaderWriter/ELF/DynamicFile.h

 #ifndef LLD_READER_WRITER_ELF_DYNAMIC_FILE_H
 #define LLD_READER_WRITER_ELF_DYNAMIC_FILE_H
 
 #include "Atoms.h"
 #include "lld/Core/SharedLibraryFile.h"
 #include "lld/ReaderWriter/ELFLinkingContext.h"
 #include "llvm/Object/ELF.h"
 #include "llvm/Support/Path.h"
-#include <unordered_map>
 
 namespace lld {
 namespace elf {
 template <class ELFT> class DynamicFile : public SharedLibraryFile {
 public:
   static ErrorOr<std::unique_ptr<DynamicFile>>
   create(std::unique_ptr<llvm::MemoryBuffer> mb, ELFLinkingContext &ctx);
 
struct SymAtomPair {
     SymAtomPair() : _symbol(nullptr), _atom(nullptr) {}
     const typename llvm::object::ELFFile<ELFT>::Elf_Sym *_symbol;
     const SharedLibraryAtom *_atom;
   };
 
   std::unique_ptr<MemoryBuffer> _mb;
   ELFLinkingContext &_ctx;
   bool _useShlibUndefines;
-  mutable std::unordered_map<StringRef, SymAtomPair> _nameToSym;
+  mutable llvm::StringMap<SymAtomPair> _nameToSym;
 };
 
 template <class ELFT>
 ErrorOr<std::unique_ptr<DynamicFile<ELFT>>>
 DynamicFile<ELFT>::create(std::unique_ptr<llvm::MemoryBuffer> mb,
                           ELFLinkingContext &ctx) {
   return std::unique_ptr<DynamicFile>(new DynamicFile(std::move(mb), ctx));
 }
 
 } // end namespace elf
 } // end namespace lld
 
 #endif

lib/ReaderWriter/ELF/ELFFile.h

 //===- lib/ReaderWriter/ELF/ELFFile.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_FILE_H
 #define LLD_READER_WRITER_ELF_FILE_H
 
 #include "Atoms.h"
+#include "ReaderWriterUtils.h"
 #include "lld/Core/File.h"
 #include "lld/Core/Reference.h"
 #include "lld/ReaderWriter/ELFLinkingContext.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Object/ELF.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ELF.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/Memory.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
-#include <map>
 #include <system_error>
-#include <unordered_map>
 
 namespace lld {
 
 namespace elf {
 /// \brief Read a binary, find out based on the symbol table contents what kind
 /// of symbol it is and create corresponding atoms for it
 template <class ELFT> class ELFFile : public File {
 
   typedef llvm::object::Elf_Sym_Impl<ELFT> Elf_Sym;
   typedef llvm::object::Elf_Shdr_Impl<ELFT> Elf_Shdr;
   typedef llvm::object::Elf_Rel_Impl<ELFT, false> Elf_Rel;
   typedef llvm::object::Elf_Rel_Impl<ELFT, true> Elf_Rela;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym_Iter Elf_Sym_Iter;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Rela_Iter Elf_Rela_Iter;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Rel_Iter Elf_Rel_Iter;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Word Elf_Word;
 
-  // A Map is used to hold the atoms that have been divided up
-  // after reading the section that contains Merge String attributes
-  struct MergeSectionKey {
-    MergeSectionKey(const Elf_Shdr *shdr, int64_t offset)
-        : _shdr(shdr), _offset(offset) {}
-    // Data members
-    const Elf_Shdr *_shdr;
-    int64_t _offset;
-  };
-  struct MergeSectionEq {
-    int64_t operator()(const MergeSectionKey &k) const {
-      return llvm::hash_combine((int64_t)(k._shdr->sh_name),
-                                (int64_t)k._offset);
-    }
-    bool operator()(const MergeSectionKey &lhs,
-                    const MergeSectionKey &rhs) const {
-      return ((lhs._shdr->sh_name == rhs._shdr->sh_name) &&
-              (lhs._offset == rhs._offset));
-    }
-  };
-
   struct MergeString {
     MergeString(int64_t offset, StringRef str, const Elf_Shdr *shdr,
                 StringRef sectionName)
         : _offset(offset), _string(str), _shdr(shdr),
           _sectionName(sectionName) {}
     // the offset of this atom
     int64_t _offset;
     // The content
template <class ELFT> class ELFFile : public File {
   /// \brief find a merge atom given a offset
   ELFMergeAtom<ELFT> *findMergeAtom(const Elf_Shdr *shdr, uint64_t offset) {
     auto it = std::find_if(_mergeAtoms.begin(), _mergeAtoms.end(),
                            FindByOffset(shdr, offset));
     assert(it != _mergeAtoms.end());
     return *it;
   }
 
-  typedef std::unordered_map<MergeSectionKey, DefinedAtom *, MergeSectionEq,
-                             MergeSectionEq> MergedSectionMapT;
+  // A Map is used to hold the atoms that have been divided up
+  // after reading the section that contains Merge String attributes
+  struct MergeSectionKey {
+    MergeSectionKey() : _shdr(nullptr), _offset(0) {}
+    MergeSectionKey(const Elf_Shdr *shdr, int64_t offset)
+        : _shdr(shdr), _offset(offset) {}
+    // Data members
+    const Elf_Shdr *_shdr;
+    int64_t _offset;
+  };
+
+  struct MergeSectionKeyInfo {
+    static MergeSectionKey getEmptyKey() { return MergeSectionKey(); }
+    static MergeSectionKey getTombstoneKey() { return MergeSectionKey(); }
+    static unsigned getHashValue(const MergeSectionKey &k) {
+      return llvm::hash_combine((int64_t)(k._shdr->sh_name),
+                                (int64_t)k._offset);
+    }
+    static bool isEqual(const MergeSectionKey &lhs,
+                        const MergeSectionKey &rhs) {
+      if (!lhs._shdr && !rhs._shdr)
+        return true;
+      return (lhs._shdr && rhs._shdr &&
+              (lhs._shdr->sh_name == rhs._shdr->sh_name) &&
+              (lhs._offset == rhs._offset));
+    }
+  };
+
+  typedef llvm::DenseMap<MergeSectionKey, DefinedAtom *, MergeSectionKeyInfo>
+      MergedSectionMapT;
   typedef typename MergedSectionMapT::iterator MergedSectionMapIterT;
 
 public:
   ELFFile(StringRef name, ELFLinkingContext &ctx)
       : File(name, kindObject), _ordinal(0),
         _doStringsMerge(ctx.mergeCommonStrings()), _useWrap(false), _ctx(ctx) {
     setLastError(std::error_code());
   }
protected:
   atom_collection_vector<UndefinedAtom> _undefinedAtoms;
   atom_collection_vector<SharedLibraryAtom> _sharedLibraryAtoms;
   atom_collection_vector<AbsoluteAtom> _absoluteAtoms;
 
   /// \brief _relocationAddendReferences and _relocationReferences contain the
   /// list of relocations references.  In ELF, if a section named, ".text" has
   /// relocations will also have a section named ".rel.text" or ".rela.text"
   /// which will hold the entries.
-  std::unordered_map<StringRef, range<Elf_Rela_Iter>>
+  llvm::DenseMap<StringRef, range<Elf_Rela_Iter>, StringRefMappingInfo>
       _relocationAddendReferences;
   MergedSectionMapT _mergedSectionMap;
-  std::unordered_map<StringRef, range<Elf_Rel_Iter>> _relocationReferences;
+  llvm::DenseMap<StringRef, range<Elf_Rel_Iter>, StringRefMappingInfo>
+      _relocationReferences;
   std::vector<ELFReference<ELFT> *> _references;
   llvm::DenseMap<const Elf_Sym *, Atom *> _symbolToAtomMapping;
   llvm::DenseMap<const ELFReference<ELFT> *, const Elf_Sym *>
   _referenceToSymbol;
   // Group child atoms have a pair corresponding to the signature and the
   // section header of the section that was used for generating the signature.
   llvm::DenseMap<const Elf_Sym *, std::pair<StringRef, const Elf_Shdr *>>
       _groupChild;
   llvm::StringMap<Atom *> _undefAtomsForGroupChild;
 
   /// \brief Atoms that are created for a section that has the merge property
   /// set
   MergeAtomsT _mergeAtoms;
 
   /// \brief the section and the symbols that are contained within it to create
   /// used to create atoms
-  std::map<const Elf_Shdr *, std::vector<Elf_Sym_Iter>> _sectionSymbols;
+  llvm::MapVector<const Elf_Shdr *, std::vector<Elf_Sym_Iter>> _sectionSymbols;
 
   /// \brief Sections that have merge string property
   std::vector<const Elf_Shdr *> _mergeStringSections;
 
   std::unique_ptr<MemoryBuffer> _mb;
   int64_t _ordinal;
 
   /// \brief the cached options relevant while reading the ELF File

lib/ReaderWriter/ELF/Mips/MipsSectionChunks.h

for (const auto &r : *da) {
       }
     }
 
     return layout;
   }
 
 private:
   /// \brief Map PLT Atoms to their layouts.
-  std::unordered_map<const Atom *, const AtomLayout *> _pltLayoutMap;
+  llvm::DenseMap<const Atom *, const AtomLayout *> _pltLayoutMap;
 };
 
 } // elf
 } // lld
 
 #endif

lib/ReaderWriter/ELF/Reader.cpp

 //===- lib/ReaderWriter/ELF/Reader.cpp ------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// \brief Defines the ELF Reader and all helper sub classes to consume an ELF
 /// file and produces atoms out of it.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "ELFReader.h"
-#include <map>
 #include <vector>
 
 using llvm::support::endianness;
 using namespace llvm::object;
 
 namespace lld {
 
 // This dynamic registration of a handler causes support for all ELF

lib/ReaderWriter/ELF/ReaderWriterUtils.h

+//===- lib/ReaderWriter/ELF/ReaderWriterUtils.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_READER_WRITER_UTILS_H
+#define LLD_READER_WRITER_ELF_READER_WRITER_UTILS_H
+
+#include "llvm/ADT/StringExtras.h"
+
+namespace lld {
+namespace elf {
+// Helper for creating a llvm DenseMap of StringRef's.
+struct StringRefMappingInfo {
+  static StringRef getEmptyKey() { return StringRef(); }
+  static StringRef getTombstoneKey() { return StringRef(" ", 0); }
+  static unsigned getHashValue(StringRef const val) {
+    return llvm::HashString(val);
+  }
+  static bool isEqual(StringRef const lhs, StringRef const rhs) {
+    return lhs.equals(rhs);
+  }
+};
+}
+}
+
+#endif

lib/ReaderWriter/ELF/SectionChunks.h

 //===- lib/ReaderWriter/ELF/SectionChunks.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_SECTION_CHUNKS_H
 #define LLD_READER_WRITER_ELF_SECTION_CHUNKS_H
 
 #include "Chunk.h"
 #include "Layout.h"
+#include "ReaderWriterUtils.h"
 #include "TargetHandler.h"
 #include "Writer.h"
 #include "lld/Core/DefinedAtom.h"
 #include "lld/Core/Parallel.h"
 #include "lld/Core/range.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/StringExtras.h"
 #include "llvm/Object/ELF.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Dwarf.h"
 #include "llvm/Support/ELF.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileOutputBuffer.h"
 #include <memory>
public:
 
   inline void setNumEntries(int64_t numEntries) {
     _stringMap.resize(numEntries);
   }
 
 private:
   std::vector<StringRef> _strings;
 
-  struct StringRefMappingInfo {
-    static StringRef getEmptyKey() { return StringRef(); }
-    static StringRef getTombstoneKey() { return StringRef(" ", 0); }
-    static unsigned getHashValue(StringRef const val) {
-      return llvm::HashString(val);
-    }
-    static bool isEqual(StringRef const lhs, StringRef const rhs) {
-      return lhs.equals(rhs);
-    }
-  };
   typedef typename llvm::DenseMap<StringRef, uint64_t,
                                   StringRefMappingInfo> StringMapT;
   typedef typename StringMapT::iterator StringMapTIter;
   StringMapT _stringMap;
 };
 
 template <class ELFT>
 StringTable<ELFT>::StringTable(const ELFLinkingContext &context,