COFF: Replace DLLNames maps with vectors.

[pcc]

Summary

The import lists are already binned by DLL name, so there's no need to
deduplicate here.

[ruiu]

You want to rebase first as I changed the types of the variables in this file as I used make<>.

[pcc]

Rebase

[ruiu]

LGTM

lld/COFF/DLL.cpp

429

auto *

466

auto *

lld/COFF/DLL.h

 private:
   void create();
 
   std::vector<DefinedImportData *> Imports;
   std::vector<Chunk *> Dirs;
   std::vector<Chunk *> Lookups;
   std::vector<Chunk *> Addresses;
   std::vector<Chunk *> Hints;
-  std::map<StringRef, Chunk *> DLLNames;
+  std::vector<Chunk *> DLLNames;
 };
 
 // Windows-specific.
 // DelayLoadContents creates all chunks for the delay-load DLL import table.
 class DelayLoadContents {
 public:
   void add(DefinedImportData *Sym) { Imports.push_back(Sym); }
   bool empty() { return Imports.empty(); }
private:
   Defined *Helper;
   std::vector<DefinedImportData *> Imports;
   std::vector<Chunk *> Dirs;
   std::vector<Chunk *> ModuleHandles;
   std::vector<Chunk *> Addresses;
   std::vector<Chunk *> Names;
   std::vector<Chunk *> HintNames;
   std::vector<Chunk *> Thunks;
-  std::map<StringRef, Chunk *> DLLNames;
+  std::vector<Chunk *> DLLNames;
 };
 
 // Windows-specific.
 // EdataContents creates all chunks for the DLL export table.
 class EdataContents {
 public:
   EdataContents();
   std::vector<Chunk *> Chunks;
 };
 
 } // namespace coff
 } // namespace lld
 
 #endif

lld/COFF/DLL.cpp

std::vector<Chunk *> IdataContents::getChunks() {
 
   // The loader assumes a specific order of data.
   // Add each type in the correct order.
   std::vector<Chunk *> V;
   V.insert(V.end(), Dirs.begin(), Dirs.end());
   V.insert(V.end(), Lookups.begin(), Lookups.end());
   V.insert(V.end(), Addresses.begin(), Addresses.end());
   V.insert(V.end(), Hints.begin(), Hints.end());
-  for (auto &KV : DLLNames)
-    V.push_back(KV.second);
+  V.insert(V.end(), DLLNames.begin(), DLLNames.end());
   return V;
 }
 
 void IdataContents::create() {
   std::vector<std::vector<DefinedImportData *>> V = binImports(Imports);
 
   // Create .idata contents for each DLL.
   for (std::vector<DefinedImportData *> &Syms : V) {
-    StringRef Name = Syms[0]->getDLLName();
-
     // Create lookup and address tables. If they have external names,
     // we need to create HintName chunks to store the names.
     // If they don't (if they are import-by-ordinals), we store only
     // ordinal values to the table.
     size_t Base = Lookups.size();
     for (DefinedImportData *S : Syms) {
       uint16_t Ord = S->getOrdinal();
       if (S->getExternalName().empty()) {
for (std::vector<DefinedImportData *> &Syms : V) {
     // Terminate with null values.
     Lookups.push_back(make<NullChunk>(ptrSize()));
     Addresses.push_back(make<NullChunk>(ptrSize()));
 
     for (int I = 0, E = Syms.size(); I < E; ++I)
       Syms[I]->setLocation(Addresses[Base + I]);
 
     // Create the import table header.
-    if (!DLLNames.count(Name))
-      DLLNames[Name] = make<StringChunk>(Name);
-    auto *Dir = make<ImportDirectoryChunk>(DLLNames[Name]);
+    DLLNames.push_back(make<StringChunk>(Syms[0]->getDLLName()));
+    auto Dir = make<ImportDirectoryChunk>(DLLNames.back());
     Dir->LookupTab = Lookups[Base];
     Dir->AddressTab = Addresses[Base];
     Dirs.push_back(Dir);
   }
   // Add null terminator.
   Dirs.push_back(make<NullChunk>(sizeof(ImportDirectoryTableEntry)));
 }
 
 std::vector<Chunk *> DelayLoadContents::getChunks() {
   std::vector<Chunk *> V;
   V.insert(V.end(), Dirs.begin(), Dirs.end());
   V.insert(V.end(), Names.begin(), Names.end());
   V.insert(V.end(), HintNames.begin(), HintNames.end());
-  for (auto &KV : DLLNames)
-    V.push_back(KV.second);
+  V.insert(V.end(), DLLNames.begin(), DLLNames.end());
   return V;
 }
 
 std::vector<Chunk *> DelayLoadContents::getDataChunks() {
   std::vector<Chunk *> V;
   V.insert(V.end(), ModuleHandles.begin(), ModuleHandles.end());
   V.insert(V.end(), Addresses.begin(), Addresses.end());
   return V;
 }
 
 uint64_t DelayLoadContents::getDirSize() {
   return Dirs.size() * sizeof(delay_import_directory_table_entry);
 }
 
 void DelayLoadContents::create(Defined *H) {
   Helper = H;
   std::vector<std::vector<DefinedImportData *>> V = binImports(Imports);
 
   // Create .didat contents for each DLL.
   for (std::vector<DefinedImportData *> &Syms : V) {
-    StringRef Name = Syms[0]->getDLLName();
-
     // Create the delay import table header.
-    if (!DLLNames.count(Name))
-      DLLNames[Name] = make<StringChunk>(Name);
-    auto *Dir = make<DelayDirectoryChunk>(DLLNames[Name]);
+    DLLNames.push_back(make<StringChunk>(Syms[0]->getDLLName()));
+    auto Dir = make<DelayDirectoryChunk>(DLLNames.back());
 
     size_t Base = Addresses.size();
     for (DefinedImportData *S : Syms) {
       Chunk *T = newThunkChunk(S, Dir);
       auto *A = make<DelayAddressChunk>(T);
       Addresses.push_back(A);
       Thunks.push_back(T);
       StringRef ExtName = S->getExternalName();