llvm-lto2: Simpler workaround for PR30396.

[pcc]

Summary

Maintain the command line resolutions as a map to a list of resolutions
rather than a single resolution, and apply the resolutions in the order
observed. This is not only simpler but allows us to test the scenario where
the two symbols have different resolutions.

[mehdi_amini]

LGTM.

[davide]

this looks good. thanks

llvm/trunk/test/ThinLTO/X86/module_asm_glob.ll

 ; RUN: opt -module-summary %s -o %t1.bc
 ; RUN: opt -module-summary %p/Inputs/module_asm.ll -o %t2.bc
 
 ; RUN: llvm-lto -thinlto-action=run -exported-symbol=main %t1.bc %t2.bc
 ; RUN: llvm-nm %t1.bc.thinlto.o | FileCheck  %s --check-prefix=NM0
 ; RUN: llvm-nm %t2.bc.thinlto.o | FileCheck  %s --check-prefix=NM1
 
 ; RUN: llvm-lto2 %t1.bc %t2.bc -o %t.o -save-temps \
+; RUN:     -r=%t1.bc,foo,lx \
 ; RUN:     -r=%t1.bc,foo,plx \
 ; RUN:     -r=%t1.bc,_simplefunction,pl \
 ; RUN:     -r=%t2.bc,main,plx \
 ; RUN:     -r=%t2.bc,_simplefunction,l
 ; RUN: llvm-nm %t.o.0 | FileCheck  %s --check-prefix=NM0
 ; RUN: llvm-nm %t.o.1 | FileCheck  %s --check-prefix=NM1
 
 ; NM0: T foo

llvm/trunk/tools/llvm-lto2/llvm-lto2.cpp

 int main(int argc, char **argv) {
   InitializeAllTargets();
   InitializeAllTargetMCs();
   InitializeAllAsmPrinters();
   InitializeAllAsmParsers();
 
   cl::ParseCommandLineOptions(argc, argv, "Resolution-based LTO test harness");
 
-  std::map<std::pair<std::string, std::string>, SymbolResolution>
+  // FIXME: Workaround PR30396 which means that a symbol can appear
+  // more than once if it is defined in module-level assembly and
+  // has a GV declaration. We allow (file, symbol) pairs to have multiple
+  // resolutions and apply them in the order observed.
+  std::map<std::pair<std::string, std::string>, std::list<SymbolResolution>>
       CommandLineResolutions;
   for (std::string R : SymbolResolutions) {
     StringRef Rest = R;
     StringRef FileName, SymbolName;
     std::tie(FileName, Rest) = Rest.split(',');
     if (Rest.empty()) {
       llvm::errs() << "invalid resolution: " << R << '\n';
       return 1;
     }
     std::tie(SymbolName, Rest) = Rest.split(',');
     SymbolResolution Res;
     for (char C : Rest) {
       if (C == 'p')
         Res.Prevailing = true;
       else if (C == 'l')
         Res.FinalDefinitionInLinkageUnit = true;
       else if (C == 'x')
         Res.VisibleToRegularObj = true;
       else
         llvm::errs() << "invalid character " << C << " in resolution: " << R
                      << '\n';
     }
-    CommandLineResolutions[{FileName, SymbolName}] = Res;
+    CommandLineResolutions[{FileName, SymbolName}].push_back(Res);
   }
 
   std::vector<std::unique_ptr<MemoryBuffer>> MBs;
 
   Config Conf;
   Conf.DiagHandler = [](const DiagnosticInfo &) {
     exit(1);
   };
int main(int argc, char **argv) {
 
   bool HasErrors = false;
   for (std::string F : InputFilenames) {
     std::unique_ptr<MemoryBuffer> MB = check(MemoryBuffer::getFile(F), F);
     std::unique_ptr<InputFile> Input =
         check(InputFile::create(MB->getMemBufferRef()), F);
 
     std::vector<SymbolResolution> Res;
-    // FIXME: Workaround PR30396 which means that a symbol can appear
-    // more than once if it is defined in module-level assembly and
-    // has a GV declaration. Keep track of the resolutions found in this
-    // file and remove them from the CommandLineResolutions map afterwards,
-    // so that we don't flag the second one as missing.
-    std::map<std::string, SymbolResolution> CurrentFileSymResolutions;
     for (const InputFile::Symbol &Sym : Input->symbols()) {
       auto I = CommandLineResolutions.find({F, Sym.getName()});
       if (I == CommandLineResolutions.end()) {
         llvm::errs() << argv[0] << ": missing symbol resolution for " << F
                      << ',' << Sym.getName() << '\n';
         HasErrors = true;
       } else {
-        Res.push_back(I->second);
-        CurrentFileSymResolutions[Sym.getName()] = I->second;
-      }
+        Res.push_back(I->second.front());
+        I->second.pop_front();
+        if (I->second.empty())
+          CommandLineResolutions.erase(I);
       }
-    for (auto I : CurrentFileSymResolutions) {
-#ifndef NDEBUG
-      auto NumErased =
-#endif
-          CommandLineResolutions.erase({F, I.first});
-      assert(NumErased > 0);
     }
 
     if (HasErrors)
       continue;
 
     MBs.push_back(std::move(MB));
     check(Lto.add(std::move(Input), Res), F);
   }