Implements /force:multiple in lld-link

[ryan]

Summary

link.exe's /force:multiple is described here:
https://docs.microsoft.com/en-us/cpp/build/reference/force-force-file-output

lld-link with this /force:multiple implementation does not seem to do exactly
what link.exe is doing. But, the Microsoft documentation is fairly clear that
the behavior this option causes in the generated executables is undefined.

[ruiu]

Can you add a test?

COFF/SymbolTable.cpp

62

just_warn -> JustWarn

359

Do you have to change this

375

and this?

[ryan]

COFF/SymbolTable.cpp

359

I don't know. It just felt in the spirit of /force:multiple to use the existing symbol. (Doesn't impact me personally, I was just wanted /force for function symbols).

Do you think it's better to return null in this case? (There's other options here too, e.g. forcing the replaceSymbol case when /force:multiple is on.)

[ruiu]

COFF/SymbolTable.cpp

359

Yeah, it probably makes sense to use the first symbol rather than the last one. I just couldn't understand what this change is for. Could you add a testcase that covers this case?

COFF/Config.h

struct Configuration {
   Symbol *Entry = nullptr;
   bool NoEntry = false;
   std::string OutputFile;
   std::string ImportName;
   bool DoGC = true;
   bool DoICF = true;
   bool TailMerge;
   bool Relocatable = true;
-  bool Force = false;
+  bool ForceUnresolved = false;
+  bool ForceMultiple = false;
   bool Debug = false;
   bool DebugDwarf = false;
   bool DebugGHashes = false;
   bool DebugSymtab = false;
   bool ShowTiming = false;
   unsigned DebugTypes = static_cast<unsigned>(DebugType::None);
   std::vector<std::string> NatvisFiles;
   llvm::SmallString<128> PDBAltPath;

COFF/Driver.cpp

void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
   if (auto *Arg = Args.getLastArg(OPT_out))
     Config->OutputFile = Arg->getValue();
 
   // Handle /verbose
   if (Args.hasArg(OPT_verbose))
     Config->Verbose = true;
   errorHandler().Verbose = Config->Verbose;
 
-  // Handle /force or /force:unresolved
+  // Handle /force, /force:unresolved, and /force:multiple
   if (Args.hasArg(OPT_force, OPT_force_unresolved))
-    Config->Force = true;
+    Config->ForceUnresolved = true;
+  if (Args.hasArg(OPT_force, OPT_force_multiple))
+    Config->ForceMultiple = true;
 
   // Handle /debug
   if (Args.hasArg(OPT_debug, OPT_debug_dwarf, OPT_debug_ghash)) {
     Config->Debug = true;
     Config->Incremental = true;
     if (auto *Arg = Args.getLastArg(OPT_debugtype))
       Config->DebugTypes = parseDebugType(Arg->getValue());
     else

COFF/InputFiles.cpp

 /// Checks that Source is compatible with being a weak alias to Target.
 /// If Source is Undefined and has no weak alias set, makes it a weak
 /// alias to Target.
 static void checkAndSetWeakAlias(SymbolTable *Symtab, InputFile *F,
                                  Symbol *Source, Symbol *Target) {
   if (auto *U = dyn_cast<Undefined>(Source)) {
     if (U->WeakAlias && U->WeakAlias != Target)
       Symtab->reportDuplicate(Source, F);
+    else
       U->WeakAlias = Target;
   }
 }
 
 ArchiveFile::ArchiveFile(MemoryBufferRef M) : InputFile(ArchiveKind, M) {}
 
 void ArchiveFile::parse() {
   // Parse a MemoryBufferRef as an archive file.
   File = CHECK(Archive::create(MB), this);
void ImportFile::parse() {
   ImpSym = Symtab->addImportData(ImpName, this);
 
   if (Hdr->getType() == llvm::COFF::IMPORT_CONST)
     static_cast<void>(Symtab->addImportData(Name, this));
 
   // If type is function, we need to create a thunk which jump to an
   // address pointed by the __imp_ symbol. (This allows you to call
   // DLL functions just like regular non-DLL functions.)
-  if (Hdr->getType() == llvm::COFF::IMPORT_CODE)
+  if (Hdr->getType() == llvm::COFF::IMPORT_CODE && ImpSym)
     ThunkSym = Symtab->addImportThunk(Name, ImpSym, Hdr->Machine);
 }
 
 void BitcodeFile::parse() {
   Obj = check(lto::InputFile::create(MemoryBufferRef(
       MB.getBuffer(), Saver.save(ParentName + MB.getBufferIdentifier()))));
   std::vector<std::pair<Symbol *, bool>> Comdat(Obj->getComdatTable().size());
   for (size_t I = 0; I != Obj->getComdatTable().size(); ++I)

COFF/Options.td

 def profile : F<"profile">;
 def repro : F<"Brepro">, HelpText<"Use a hash of the executable as the PE header timestamp">;
 def swaprun_cd : F<"swaprun:cd">;
 def swaprun_net : F<"swaprun:net">;
 def verbose : F<"verbose">;
 def wholearchive_flag : F<"wholearchive">;
 
 def force : F<"force">,
-    HelpText<"Allow undefined symbols when creating executables">;
+    HelpText<"Allow undefined or duplicate symbols when creating executables">;
 def force_unresolved : F<"force:unresolved">;
+def force_multiple : F<"force:multiple">;
 defm WX : B<"WX", "Treat warnings as errors", "Don't treat warnings as errors">;
 
 defm allowbind : B<"allowbind", "Enable DLL binding (default)",
                    "Disable DLL binding">;
 defm allowisolation : B<"allowisolation", "Enable DLL isolation (default)",
                         "Disable DLL isolation">;
 defm appcontainer : B<"appcontainer",
                       "Image can only be run in an app container",

COFF/SymbolTable.cpp

void SymbolTable::addFile(InputFile *File) {
   StringRef S = File->getDirectives();
   if (S.empty())
     return;
 
   log("Directives: " + toString(File) + ": " + S);
   Driver->parseDirectives(S);
 }
 
-static void errorOrWarn(const Twine &S) {
-  if (Config->Force)
+static void errorOrWarn(bool just_warn, const Twine &S) {
+  if (just_warn)
     warn(S);
   else
     error(S);
 }
 
 // Returns the name of the symbol in SC whose value is <= Addr that is closest
 // to Addr. This is generally the name of the global variable or function whose
 // definition contains Addr.
if (Name.startswith("__imp_")) {
         LocalImportChunks.push_back(cast<DefinedLocalImport>(Sym)->getChunk());
         LocalImports[Sym] = D;
         continue;
       }
     }
 
     // Remaining undefined symbols are not fatal if /force is specified.
     // They are replaced with dummy defined symbols.
-    if (Config->Force)
+    if (Config->ForceUnresolved)
       replaceSymbol<DefinedAbsolute>(Sym, Name, 0);
     Undefs.insert(Sym);
   }
 
   if (Undefs.empty() && LocalImports.empty())
     return;
 
   for (Symbol *B : Config->GCRoot) {
     if (Undefs.count(B))
-      errorOrWarn("<root>: undefined symbol: " + B->getName());
+      errorOrWarn(Config->ForceUnresolved,
+                  "<root>: undefined symbol: " + B->getName());
     if (Config->WarnLocallyDefinedImported)
       if (Symbol *Imp = LocalImports.lookup(B))
         warn("<root>: locally defined symbol imported: " + Imp->getName() +
              " (defined in " + toString(Imp->getFile()) + ") [LNK4217]");
   }
 
   for (ObjFile *File : ObjFile::Instances) {
     size_t SymIndex = size_t{0} - 1;
     for (Symbol *Sym : File->getSymbols()) {
       ++SymIndex;
       if (!Sym)
         continue;
       if (Undefs.count(Sym))
-        errorOrWarn("undefined symbol: " + Sym->getName() +
+        errorOrWarn(Config->ForceUnresolved,
+                    "undefined symbol: " + Sym->getName() +
                     getSymbolLocations(File, SymIndex));
       if (Config->WarnLocallyDefinedImported)
         if (Symbol *Imp = LocalImports.lookup(Sym))
           warn(toString(File) + ": locally defined symbol imported: " +
                Imp->getName() + " (defined in " + toString(Imp->getFile()) +
                ") [LNK4217]");
     }
   }
void SymbolTable::addLazy(ArchiveFile *F, const Archive::Symbol Sym) {
   auto *U = dyn_cast<Undefined>(S);
   if (!U || U->WeakAlias || S->PendingArchiveLoad)
     return;
   S->PendingArchiveLoad = true;
   F->addMember(&Sym);
 }
 
 void SymbolTable::reportDuplicate(Symbol *Existing, InputFile *NewFile) {
-  error("duplicate symbol: " + toString(*Existing) + " in " +
+  errorOrWarn(Config->ForceMultiple,
+              "duplicate symbol: " + toString(*Existing) + " in " +
               toString(Existing->getFile()) + " and in " + toString(NewFile));
 }
 
 Symbol *SymbolTable::addAbsolute(StringRef N, COFFSymbolRef Sym) {
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(N);
   S->IsUsedInRegularObj = true;
   if (WasInserted || isa<Undefined>(S) || isa<Lazy>(S))
DefinedImportData *SymbolTable::addImportData(StringRef N, ImportFile *F) {
   std::tie(S, WasInserted) = insert(N);
   S->IsUsedInRegularObj = true;
   if (WasInserted || isa<Undefined>(S) || isa<Lazy>(S)) {
     replaceSymbol<DefinedImportData>(S, N, F);
     return cast<DefinedImportData>(S);
   }
 
   reportDuplicate(S, F);
-  return nullptr;
+  return dyn_cast<DefinedImportData>(S);
 }
 
 DefinedImportThunk *SymbolTable::addImportThunk(StringRef Name,
                                                DefinedImportData *ID,
                                                uint16_t Machine) {
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name);
   S->IsUsedInRegularObj = true;
   if (WasInserted || isa<Undefined>(S) || isa<Lazy>(S)) {
     replaceSymbol<DefinedImportThunk>(S, Name, ID, Machine);
     return cast<DefinedImportThunk>(S);
   }
 
   reportDuplicate(S, ID->File);
-  return nullptr;
+  return dyn_cast<DefinedImportThunk>(S);
 }
 
 std::vector<Chunk *> SymbolTable::getChunks() {
   std::vector<Chunk *> Res;
   for (ObjFile *File : ObjFile::Instances) {
     ArrayRef<Chunk *> V = File->getChunks();
     Res.insert(Res.end(), V.begin(), V.end());
   }