Use error() instead of warn() to report undefined symbols.

[ruiu]

Summary

I believe the reason why we used warn() instead of error() to report
undefined symbols is because the older implementation of error() exitted
immediately. Here, we want to find as many undefined symbols as we can,
so I chose to use warn() instead of error().

Now error() does not exit immediately, so it doesn't make sense to keep
them as warnings.

[smeenai]

I'd been meaning to complain about lld-link outputting "warning" instead of "error" for undefined symbols. Thanks for fixing :)

[inglorion]

lgtm

lld/trunk/COFF/Driver.cpp

void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
 
   // Do LTO by compiling bitcode input files to a set of native COFF files then
   // link those files.
   Symtab->addCombinedLTOObjects();
   run();
 
   // Make sure we have resolved all symbols.
   Symtab->reportRemainingUndefines();
+  if (ErrorCount)
+    return;
 
   // Windows specific -- if no /subsystem is given, we need to infer
   // that from entry point name.
   if (Config->Subsystem == IMAGE_SUBSYSTEM_UNKNOWN) {
     Config->Subsystem = inferSubsystem();
     if (Config->Subsystem == IMAGE_SUBSYSTEM_UNKNOWN)
       fatal("subsystem must be defined");
   }

lld/trunk/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)
+    warn(S);
+  else
+    error(S);
+}
+
 void SymbolTable::reportRemainingUndefines() {
   SmallPtrSet<SymbolBody *, 8> Undefs;
+
   for (auto &I : Symtab) {
     Symbol *Sym = I.second;
     auto *Undef = dyn_cast<Undefined>(Sym->body());
     if (!Undef)
       continue;
     if (!Sym->IsUsedInRegularObj)
       continue;
+
     StringRef Name = Undef->getName();
+
     // A weak alias may have been resolved, so check for that.
     if (Defined *D = Undef->getWeakAlias()) {
       // We resolve weak aliases by replacing the alias's SymbolBody with the
       // target's SymbolBody. This causes all SymbolBody pointers referring to
       // the old symbol to instead refer to the new symbol. However, we can't
       // just blindly copy sizeof(Symbol::Body) bytes from D to Sym->Body
       // because D may be an internal symbol, and internal symbols are stored as
       // "unparented" SymbolBodies. For that reason we need to check which type
       // of symbol we are dealing with and copy the correct number of bytes.
       if (isa<DefinedRegular>(D))
         memcpy(Sym->Body.buffer, D, sizeof(DefinedRegular));
       else if (isa<DefinedAbsolute>(D))
         memcpy(Sym->Body.buffer, D, sizeof(DefinedAbsolute));
       else
         // No other internal symbols are possible.
         Sym->Body = D->symbol()->Body;
       continue;
     }
+
     // If we can resolve a symbol by removing __imp_ prefix, do that.
     // This odd rule is for compatibility with MSVC linker.
     if (Name.startswith("__imp_")) {
       Symbol *Imp = find(Name.substr(strlen("__imp_")));
       if (Imp && isa<Defined>(Imp->body())) {
         auto *D = cast<Defined>(Imp->body());
         replaceBody<DefinedLocalImport>(Sym, Name, D);
         LocalImportChunks.push_back(
             cast<DefinedLocalImport>(Sym->body())->getChunk());
         continue;
       }
     }
+
     // Remaining undefined symbols are not fatal if /force is specified.
     // They are replaced with dummy defined symbols.
     if (Config->Force)
       replaceBody<DefinedAbsolute>(Sym, Name, 0);
     Undefs.insert(Sym->body());
   }
+
   if (Undefs.empty())
     return;
+
   for (SymbolBody *B : Config->GCRoot)
     if (Undefs.count(B))
-      warn("<root>: undefined symbol: " + B->getName());
+      errorOrWarn("<root>: undefined symbol: " + B->getName());
+
   for (ObjFile *File : ObjFile::Instances)
     for (SymbolBody *Sym : File->getSymbols())
       if (Undefs.count(Sym))
-        warn(toString(File) + ": undefined symbol: " + Sym->getName());
-  if (!Config->Force)
-    fatal("link failed");
+        errorOrWarn(toString(File) + ": undefined symbol: " + Sym->getName());
 }
 
 std::pair<Symbol *, bool> SymbolTable::insert(StringRef Name) {
   Symbol *&Sym = Symtab[CachedHashStringRef(Name)];
   if (Sym)
     return {Sym, false};
   Sym = make<Symbol>();
   Sym->IsUsedInRegularObj = false;

lld/trunk/test/COFF/entry-inference.test

 # RUN: sed -e s/ENTRYNAME/main/ %s | yaml2obj > %t.obj
 # RUN: not lld-link /out:%t.exe %t.obj > %t.log 2>&1
 # RUN: FileCheck -check-prefix=MAIN %s < %t.log
 
 # RUN: sed s/ENTRYNAME/wmain/ %s | yaml2obj > %t.obj
 # RUN: not lld-link /out:%t.exe %t.obj > %t.log 2>&1
 # RUN: FileCheck -check-prefix=WMAIN %s < %t.log
 
 # RUN: sed s/ENTRYNAME/WinMain/ %s | yaml2obj > %t.obj
 # RUN: not lld-link /out:%t.exe %t.obj > %t.log 2>&1
 # RUN: FileCheck -check-prefix=WINMAIN %s < %t.log
 
 # RUN: sed s/ENTRYNAME/wWinMain/ %s | yaml2obj > %t.obj
 # RUN: not lld-link /out:%t.exe %t.obj > %t.log 2>&1
 # RUN: FileCheck -check-prefix=WWINMAIN %s < %t.log
 
-# MAIN:     <root>: undefined symbol: mainCRTStartup
-# WMAIN:    <root>: undefined symbol: wmainCRTStartup
-# WINMAIN:  <root>: undefined symbol: WinMainCRTStartup
-# WWINMAIN: <root>: undefined symbol: wWinMainCRTStartup
+# MAIN:     error: <root>: undefined symbol: mainCRTStartup
+# WMAIN:    error: <root>: undefined symbol: wmainCRTStartup
+# WINMAIN:  error: <root>: undefined symbol: WinMainCRTStartup
+# WWINMAIN: error: <root>: undefined symbol: wWinMainCRTStartup
 
 --- !COFF
 header:
   Machine:         IMAGE_FILE_MACHINE_AMD64
   Characteristics: []
 sections:
   - Name:            .text
     Characteristics: [ IMAGE_SCN_CNT_CODE, IMAGE_SCN_MEM_EXECUTE, IMAGE_SCN_MEM_READ ]

lld/trunk/test/COFF/force.test

 # RUN: yaml2obj < %s > %t.obj
 # RUN: not lld-link /out:%t.exe /entry:main %t.obj >& %t.log
-# RUN: FileCheck %s < %t.log
+# RUN: FileCheck -check-prefix=ERROR %s < %t.log
 # RUN: lld-link /out:%t.exe /entry:main %t.obj /force >& %t.log
-# RUN: FileCheck %s < %t.log
+# RUN: FileCheck -check-prefix=WARN %s < %t.log
 
-# CHECK: .obj: undefined symbol: foo
+# ERROR: error: {{.*}}.obj: undefined symbol: foo
+# WARN: warning: {{.*}}.obj: undefined symbol: foo
 
 --- !COFF
 header:
   Machine:         IMAGE_FILE_MACHINE_AMD64
   Characteristics: []
 sections:
   - Name:            .text
     Characteristics: [ IMAGE_SCN_CNT_CODE, IMAGE_SCN_MEM_EXECUTE, IMAGE_SCN_MEM_READ ]

lld/trunk/test/COFF/nodefaultlib.test

 # RUN:   /nodefaultlib:std64.lib >& %t.log || true
 # RUN: FileCheck -check-prefix=CHECK3 %s < %t.log
 
 # RUN: lld-link /libpath:%T /out:%t.exe /entry:main \
 # RUN:   /subsystem:console hello64.obj /defaultlib:std64 \
 # RUN:   /nodefaultlib:std64.lib >& %t.log || true
 # RUN: FileCheck -check-prefix=CHECK3 %s < %t.log
 
-CHECK1: hello64.obj: {{[Nn]}}o such file or directory
-CHECK2: hello64: {{[Nn]}}o such file or directory
-CHECK3: hello64.obj: undefined symbol: MessageBoxA
+CHECK1: error: could not open hello64.obj: {{[Nn]}}o such file or directory
+CHECK2: error: could not open hello64: {{[Nn]}}o such file or directory
+CHECK3: error: {{.*}}hello64.obj: undefined symbol: MessageBoxA
 
 # RUN: lld-link /libpath:%T /out:%t.exe /entry:main \
 # RUN:   /subsystem:console hello64.obj /defaultlib:std64.lib
 
 # RUN: env LIB=%T lld-link /out:%t.exe /entry:main \
 # RUN:   /subsystem:console hello64.obj /defaultlib:std64.lib