COFF: Fix the case where an object defines a weak external and its alias.

[pcc]

Summary

This worked before, but only by accident, and only with assertions disabled.
We ended up storing a DefinedRegular symbol in the WeakAlias field,
and never using it as an Undefined.

[ruiu]

LGTM

lld/trunk/COFF/InputFiles.cpp

Undefined *ObjectFile::createUndefined(COFFSymbolRef Sym) {
   return new (Alloc) Undefined(Name);
 }
 
 Undefined *ObjectFile::createWeakExternal(COFFSymbolRef Sym, const void *AuxP) {
   StringRef Name;
   COFFObj->getSymbolName(Sym, Name);
   auto *U = new (Alloc) Undefined(Name);
   auto *Aux = (const coff_aux_weak_external *)AuxP;
-  U->WeakAlias = cast<Undefined>(SparseSymbolBodies[Aux->TagIndex]);
+  U->WeakAlias = SparseSymbolBodies[Aux->TagIndex];
   return U;
 }
 
 Defined *ObjectFile::createDefined(COFFSymbolRef Sym, const void *AuxP,
                                    bool IsFirst) {
   StringRef Name;
   if (Sym.isCommon()) {
     auto *C = new (Alloc) CommonChunk(Sym);

lld/trunk/COFF/SymbolTable.cpp

 bool SymbolTable::reportRemainingUndefines() {
   bool Ret = false;
   for (auto &I : Symtab) {
     Symbol *Sym = I.second;
     auto *Undef = dyn_cast<Undefined>(Sym->Body);
     if (!Undef)
       continue;
     StringRef Name = Undef->getName();
-    // A weak alias may have been resovled, so check for that. A weak alias
-    // may be an weak alias to other symbol, so check recursively.
-    for (Undefined *U = Undef->WeakAlias; U; U = U->WeakAlias) {
-      if (auto *D = dyn_cast<Defined>(U->repl())) {
+    // A weak alias may have been resolved, so check for that. A weak alias
+    // may be a weak alias to another symbol, so check recursively.
+    for (SymbolBody *A = Undef->WeakAlias; A;
+         A = cast<Undefined>(A)->WeakAlias) {
+      if (auto *D = dyn_cast<Defined>(A->repl())) {
         Sym->Body = D;
         goto next;
       }
     }
     // 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_")));

lld/trunk/COFF/Symbols.h

public:
   static bool classof(const SymbolBody *S) {
     return S->kind() == UndefinedKind;
   }
 
   // An undefined symbol can have a fallback symbol which gives an
   // undefined symbol a second chance if it would remain undefined.
   // If it remains undefined, it'll be replaced with whatever the
   // Alias pointer points to.
-  Undefined *WeakAlias = nullptr;
+  SymbolBody *WeakAlias = nullptr;
 };
 
 // Windows-specific classes.
 
 // This class represents a symbol imported from a DLL. This has two
 // names for internal use and external use. The former is used for
 // name resolution, and the latter is used for the import descriptor
 // table in an output. The former has "__imp_" prefix.

lld/trunk/test/COFF/weak-external.test

+# RUN: yaml2obj %s > %t.obj
+# RUN: lld -flavor link2 /out:%t.exe /entry:g /subsystem:console %t.obj
+
+---
+header:          
+  Machine:         IMAGE_FILE_MACHINE_AMD64
+  Characteristics: [  ]
+sections:        
+  - Name:            '.text'
+    Characteristics: [ IMAGE_SCN_CNT_CODE, IMAGE_SCN_MEM_EXECUTE, IMAGE_SCN_MEM_READ ]
+    Alignment:       16
+    SectionData:     00
+symbols:         
+  - Name:            'f'
+    Value:           0
+    SectionNumber:   1
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_FUNCTION
+    StorageClass:    IMAGE_SYM_CLASS_EXTERNAL
+  - Name:            'g'
+    Value:           0
+    SectionNumber:   0
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_FUNCTION
+    StorageClass:    IMAGE_SYM_CLASS_WEAK_EXTERNAL
+    WeakExternal:    
+      TagIndex:        0
+      Characteristics: IMAGE_WEAK_EXTERN_SEARCH_LIBRARY
+...