[lld][WebAssembly] Fix __start/__stop symbols when combining input segments

[sbc100]

Summary

We should be generating one __start/__stop pair per output segment
not per input segment. The test wasn't catching this because it was
only linking a single object file.

Fixes PR41565

[carlokok]

With this patch, the symbols still seem to end up as 0:

target triple = "wasm32"

@__start_ELRTMLRR = external global i32
@__stop_ELRTMLRR = external global i32
@"ms_t7__1sTypee_GetMethodStart$MD" = constant { [16 x i8], i32* ()* } { [16 x i8] c"\CA\F0\D0\A07\CEi\B1\0F\BEkAqI\ED\BA", i32* ()* @ms_t7__1sTypee_GetMethodStart }, section "ELRTMLRR"
@"ms_t7__1sTyped_GetMethodsEnd$MD" = constant { [16 x i8], i32* ()* } { [16 x i8] c"\0E\BFR\1EJ+G\D7\F8B\96\9B3\E1\8D%", i32* ()* @ms_t7__1sTyped_GetMethodsEnd }, section "ELRTMLRR"
@"both" = constant { { [16 x i8], i32* ()* }*,  { [16 x i8], i32* ()* }* } {{ [16 x i8], i32* ()* }*@"ms_t7__1sTypee_GetMethodStart$MD", { [16 x i8], i32* ()* }*@"ms_t7__1sTyped_GetMethodsEnd$MD"}

define nonnull i32* @ms_t7__1sTypee_GetMethodStart() {
BasicBlock229:
  ret i32* @__start_ELRTMLRR
}

define nonnull i32* @ms_t7__1sTyped_GetMethodsEnd()  {
BasicBlock232:
  ret i32* @__stop_ELRTMLRR
}


define nonnull i32* @test() {
    %abba = load { { [16 x i8], i32* ()* }*,  { [16 x i8], i32* ()* }* }, { { [16 x i8], i32* ()* }*,  { [16 x i8], i32* ()* }* }* @"both"
    ret i32* null
}

llc -filetype=obj lltset.ll
lld -flavor wasm lltset.o -o lltest.wasm -no-entry --export-dynamic --undefined=test

C:\p\llvm\llvm-bin64\Debug\bin>llvm-objdump.exe lltest.wasm --disassemble

lltest.wasm: file format WASM

Disassembly of section CODE:

00000000 CODE:
        # 3 functions in section.
       1: 08 00                         throw           0
       3: 41 80 80 80 80 00             i32.const       0
       9: 0b                            end
       a: 08 00                         throw           0
       c: 41 80 80 80 80 00             i32.const       0
      12: 0b                            end
      13: 04 00                         if      invalid_type
      15: 41 00                         i32.const       0
      17: 0b                            end

Despite it being present at offset 1024:

- Type:            DATA
  Segments:
    - SectionOffset:   7
      InitFlags:       0
      Offset:
        Opcode:          I32_CONST
        Value:           1024
      Content:         CAF0D0A037CE69B10FBE6B417149EDBA010000000000000000000000000000000EBF521E4A2B47D7F842969B33E18D2502000000
    - SectionOffset:   65
      InitFlags:       0
      Offset:
        Opcode:          I32_CONST
        Value:           1080
      Content:         '0004000020040000'

[carlokok]

Update: it works if using --no-gc-sections (though obviously that's not a solution)

[sbc100]

Address feedback

[ruiu]

LGTM

lld/test/wasm/Inputs/explicit-section.ll

+target triple = "wasm32-unknown-unknown"
+
+@var1 = global i32 42, section "mysection", align 4
+@var2 = global i32 43, section "mysection", align 4

lld/test/wasm/startstop.ll

 ; RUN: llc -filetype=obj -o %t.o %s
-; RUN: wasm-ld --no-gc-sections %t.o -o %t.wasm
+; RUN: llc -filetype=obj %p/Inputs/explicit-section.ll -o %t2.o
+; RUN: wasm-ld --no-gc-sections --export=var1 %t.o %t2.o -o %t.wasm
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown"
 
 @foo = global i32 3, section "mysection", align 4
 @bar = global i32 4, section "mysection", align 4
 
 @__start_mysection = external global i8*

 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Locals:          []
 ; CHECK-NEXT:         Body:            0B
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Locals:          []
 ; CHECK-NEXT:         Body:            4180888080000B
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Locals:          []
-; CHECK-NEXT:         Body:            4188888080000B
+; CHECK-NEXT:         Body:            4190888080000B
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Locals:          []
 ; CHECK-NEXT:         Body:            0B
 ; 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:         '0300000004000000'
+; CHECK-NEXT:         Content:         03000000040000002A0000002B000000
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            __wasm_call_ctors
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            get_start
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            get_end
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Name:            _start

lld/wasm/Writer.cpp

private:
   void calculateTypes();
   void createOutputSegments();
   void layoutMemory();
   void createHeader();
 
   void addSection(OutputSection *Sec);
 
   void addSections();
-  void addStartStopSymbols(const InputSegment *Seg);
 
   void createCustomSections();
   void createSyntheticSections();
   void finalizeSections();
 
   // Custom sections
   void createRelocSections();
 
void Writer::addSection(OutputSection *Sec) {
   OutputSections.push_back(Sec);
 }
 
 // If a section name is valid as a C identifier (which is rare because of
 // the leading '.'), linkers are expected to define __start_<secname> and
 // __stop_<secname> symbols. They are at beginning and end of the section,
 // respectively. This is not requested by the ELF standard, but GNU ld and
 // gold provide the feature, and used by many programs.
-void Writer::addStartStopSymbols(const InputSegment *Seg) {
-  StringRef S = Seg->getName();
-  LLVM_DEBUG(dbgs() << "addStartStopSymbols: " << S << "\n");
-  if (!isValidCIdentifier(S))
-    return;
-  uint32_t Start = Seg->OutputSeg->StartVA + Seg->OutputSegmentOffset;
-  uint32_t Stop = Start + Seg->getSize();
-  Symtab->addOptionalDataSymbol(Saver.save("__start_" + S), Start);
-  Symtab->addOptionalDataSymbol(Saver.save("__stop_" + S), Stop);
+static void addStartStopSymbols(const OutputSegment *Seg) {
+  StringRef Name = Seg->Name;
+  LLVM_DEBUG(dbgs() << "addStartStopSymbols: " << Name << "\n");
+  if (!isValidCIdentifier(Name))
+    return;
+  uint32_t Start = Seg->StartVA;
+  uint32_t Stop = Start + Seg->Size;
+  Symtab->addOptionalDataSymbol(Saver.save("__start_" + Name), Start);
+  Symtab->addOptionalDataSymbol(Saver.save("__stop_" + Name), Stop);
 }
 
 void Writer::addSections() {
   addSection(Out.DylinkSec);
   addSection(Out.TypeSec);
   addSection(Out.ImportSec);
   addSection(Out.FunctionSec);
   addSection(Out.TableSec);
void Writer::run() {
   calculateImports();
   log("-- layoutMemory");
   layoutMemory();
 
   if (!Config->Relocatable) {
     // Create linker synthesized __start_SECNAME/__stop_SECNAME symbols
     // This has to be done after memory layout is performed.
     for (const OutputSegment *Seg : Segments)
-      for (const InputSegment *S : Seg->InputSegments)
-        addStartStopSymbols(S);
+      addStartStopSymbols(Seg);
   }
 
   log("-- scanRelocations");
   scanRelocations();
   log("-- assignIndexes");
   assignIndexes();
   log("-- calculateInitFunctions");
   calculateInitFunctions();