[WebAssembly] Fix bug handling hidden comdat symbols

[sbc100]

Summary

When hidden symbols are discarded by comdat rules we still want to
create a local defined symbol, otherwise Symbol::isDiscarded() relies on
begin able to check getChunk->discarded.

This is a follow up on rL362769. The comdat.ll test was previously
GC'ing the __wasm_call_ctors functions so the do_init function was
not actually being included in the link. Once hat function was
included in triggered that crash bug this change fixes.

Fixes: https://github.com/emscripten-core/emscripten/issues/8981

[kripken]

I'm not an expert on this but it looks right to me.

lld/test/wasm/Inputs/comdat1.ll

 target triple = "wasm32-unknown-unknown"
 
 $foo = comdat any
 
 @constantData = constant [3 x i8] c"abc", comdat($foo)
 
 define i32 @comdatFn() comdat($foo) {
   ret i32 ptrtoint ([3 x i8]* @constantData to i32)
 }
 
 define internal void @do_init() comdat($foo) {
   ret void
 }
 
[e-mail]_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void
-()*, i8* } { i32 65535, void ()* @do_init, i8* null }]
+%0 = type { i32, void ()*, i8* }
[e-mail]_ctors = appending global [1 x %0 ] [%0 { i32 65535, void ()* @do_init, i8* null }]
 
 ; Everything above this is part of the `foo` comdat group
 
 define i32 @callComdatFn1() {
     ret i32 ptrtoint (i32 ()* @comdatFn to i32)
 }

lld/test/wasm/Inputs/comdat2.ll

 target triple = "wasm32-unknown-unknown"
 
 $foo = comdat any
 
 @constantData = constant [3 x i8] c"abc", comdat($foo)
 
 define i32 @comdatFn() comdat($foo) {
   ret i32 ptrtoint ([3 x i8]* @constantData to i32)
 }
 
 define internal void @do_init() comdat($foo) {
   ret void
 }
 
[e-mail]_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void
-()*, i8* } { i32 65535, void ()* @do_init, i8* null }]
+%0 = type { i32, void ()*, i8* }
[e-mail]_ctors = appending global [1 x %0] [ %0 { i32 65535, void ()* @do_init, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @constantData, i32 0, i32 0) }]
 
 ; Everything above this is part of the `foo` comdat group
 
 define i32 @callComdatFn2() {
   ret i32 ptrtoint (i32 ()* @comdatFn to i32)
 }

lld/test/wasm/comdats.ll

 ; RUN: llc -filetype=obj -mtriple=wasm32-unknown-uknown-wasm %p/Inputs/comdat1.ll -o %t1.o
 ; RUN: llc -filetype=obj -mtriple=wasm32-unknown-uknown-wasm %p/Inputs/comdat2.ll -o %t2.o
 ; RUN: llc -filetype=obj -mtriple=wasm32-unknown-uknown-wasm %s -o %t.o
 ; RUN: wasm-ld --export-dynamic -o %t.wasm %t.o %t1.o %t2.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown"
 
+declare void @__wasm_call_ctors()
 declare i32 @comdatFn()
 
 define void @_start() {
 entry:
+  call void @__wasm_call_ctors()
   %call = call i32 @comdatFn()
   ret void
 }
 
 ; CHECK:       - Type:            GLOBAL
 ; CHECK-NEXT:    Globals:
 ; CHECK-NEXT:      - Index:           0
 ; CHECK-NEXT:        Type:            I32

 ; CHECK-NEXT:          Value:           1024
 ; CHECK-NEXT:  - Type:            EXPORT
 ; CHECK-NEXT:    Exports:
 ; CHECK-NEXT:      - Name:            memory
 ; CHECK-NEXT:        Kind:            MEMORY
 ; CHECK-NEXT:        Index:           0
 ; CHECK-NEXT:      - Name:            _start
 ; CHECK-NEXT:        Kind:            FUNCTION
-; CHECK-NEXT:        Index:           0
+; CHECK-NEXT:        Index:           1
 ; CHECK-NEXT:      - Name:            comdatFn
 ; CHECK-NEXT:        Kind:            FUNCTION
-; CHECK-NEXT:        Index:           1
+; CHECK-NEXT:        Index:           2
 ; CHECK-NEXT:      - Name:            constantData
 ; CHECK-NEXT:        Kind:            GLOBAL
 ; CHECK-NEXT:        Index:           1
 ; CHECK-NEXT:      - Name:            callComdatFn1
 ; CHECK-NEXT:        Kind:            FUNCTION
-; CHECK-NEXT:        Index:           2
+; CHECK-NEXT:        Index:           4
 ; CHECK-NEXT:      - Name:            callComdatFn2
 ; CHECK-NEXT:        Kind:            FUNCTION
-; CHECK-NEXT:        Index:           3
+; CHECK-NEXT:        Index:           5
 ; CHECK-NEXT:  - Type:            ELEM
 ; CHECK-NEXT:    Segments:
 ; CHECK-NEXT:      - Offset:
 ; CHECK-NEXT:          Opcode:          I32_CONST
 ; CHECK-NEXT:          Value:           1
-; CHECK-NEXT:        Functions:       [ 1 ]
+; CHECK-NEXT:        Functions:       [ 2 ]
 ; CHECK-NEXT:  - Type:            CODE
 ; CHECK-NEXT:    Functions:
 ; CHECK-NEXT:      - Index:           0
 ; CHECK-NEXT:        Locals:
-; CHECK-NEXT:        Body:            1081808080001A0B
+; CHECK-NEXT:        Body:            10030B
 ; CHECK-NEXT:      - Index:           1
 ; CHECK-NEXT:        Locals:
-; CHECK-NEXT:        Body:            4180888080000B
+; CHECK-NEXT:        Body:            1080808080001082808080001A0B
 ; CHECK-NEXT:      - Index:           2
 ; CHECK-NEXT:        Locals:
-; CHECK-NEXT:        Body:            4181808080000B
+; CHECK-NEXT:        Body:            4180888080000B
 ; CHECK-NEXT:      - Index:           3
 ; CHECK-NEXT:        Locals:
+; CHECK-NEXT:        Body:            0B
+; CHECK-NEXT:      - Index:           4
+; CHECK-NEXT:        Locals:
+; CHECK-NEXT:        Body:            4181808080000B
+; CHECK-NEXT:      - Index:           5
+; CHECK-NEXT:        Locals:
 ; CHECK-NEXT:        Body:            4181808080000B
 ; CHECK-NEXT:  - Type:            DATA
 ; CHECK-NEXT:    Segments:
 ; CHECK-NEXT:      - SectionOffset:   7
 ; CHECK-NEXT:        InitFlags:       0
 ; CHECK-NEXT:        Offset:
 ; CHECK-NEXT:          Opcode:          I32_CONST
 ; CHECK-NEXT:          Value:           1024
 ; CHECK-NEXT:        Content:         '616263'

lld/wasm/InputFiles.cpp

 Symbol *ObjFile::createDefined(const WasmSymbol &sym) {
   StringRef name = sym.Info.Name;
   uint32_t flags = sym.Info.Flags;
 
   switch (sym.Info.Kind) {
   case WASM_SYMBOL_TYPE_FUNCTION: {
     InputFunction *func =
         functions[sym.Info.ElementIndex - wasmObj->getNumImportedFunctions()];
-    if (func->discarded)
-      return nullptr;
     if (sym.isBindingLocal())
       return make<DefinedFunction>(name, flags, this, func);
+    if (func->discarded)
+      return nullptr;
     return symtab->addDefinedFunction(name, flags, this, func);
   }
   case WASM_SYMBOL_TYPE_DATA: {
     InputSegment *seg = segments[sym.Info.DataRef.Segment];
-    if (seg->discarded)
-      return nullptr;
-
     uint32_t offset = sym.Info.DataRef.Offset;
     uint32_t size = sym.Info.DataRef.Size;
-
     if (sym.isBindingLocal())
       return make<DefinedData>(name, flags, this, seg, offset, size);
+    if (seg->discarded)
+      return nullptr;
     return symtab->addDefinedData(name, flags, this, seg, offset, size);
   }
   case WASM_SYMBOL_TYPE_GLOBAL: {
     InputGlobal *global =
         globals[sym.Info.ElementIndex - wasmObj->getNumImportedGlobals()];
     if (sym.isBindingLocal())
       return make<DefinedGlobal>(name, flags, this, global);
     return symtab->addDefinedGlobal(name, flags, this, global);

lld/wasm/Writer.cpp

for (ObjFile *file : symtab->objectFiles) {
     for (const WasmInitFunc &f : l.InitFunctions) {
       FunctionSymbol *sym = file->getFunctionSymbol(f.Symbol);
       // comdat exclusions can cause init functions be discarded.
       if (sym->isDiscarded())
         continue;
       assert(sym->isLive());
       if (*sym->signature != WasmSignature{{}, {}})
         error("invalid signature for init func: " + toString(*sym));
+      LLVM_DEBUG(dbgs() << "initFunctions: " << toString(*sym) << "\n");
       initFunctions.emplace_back(WasmInitEntry{sym, f.Priority});
     }
   }
 
   // Sort in order of priority (lowest first) so that they are called
   // in the correct order.
   llvm::stable_sort(initFunctions,
                     [](const WasmInitEntry &l, const WasmInitEntry &r) {