[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/trunk/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/trunk/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 --export=get_start --export=get_end --export=foo --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*

 define void @_start()  {
 entry:
   ret void
 }
 ; CHECK:        - Type:            CODE
 ; CHECK-NEXT:     Functions:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Locals:          []
-; CHECK-NEXT:         Body:            0B
+; CHECK-NEXT:         Body:            4180888080000B
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Locals:          []
-; CHECK-NEXT:         Body:            4180888080000B
+; CHECK-NEXT:         Body:            4190888080000B
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Locals:          []
-; CHECK-NEXT:         Body:            4188888080000B
-; 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:       - Index:           1
 ; CHECK-NEXT:         Name:            get_end
-; CHECK-NEXT:       - Index:           3
+; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            _start

lld/trunk/wasm/InputChunks.cpp

#endif
 
   LLVM_DEBUG(dbgs() << "applying relocations: " << getName()
                     << " count=" << Relocations.size() << "\n");
   int32_t Off = OutputOffset - getInputSectionOffset();
 
   for (const WasmRelocation &Rel : Relocations) {
     uint8_t *Loc = Buf + Rel.Offset + Off;
     uint32_t Value = File->calcNewValue(Rel);
-    LLVM_DEBUG(dbgs() << "apply reloc: type=" << relocTypeToString(Rel.Type)
-                      << " addend=" << Rel.Addend << " index=" << Rel.Index
+    LLVM_DEBUG(dbgs() << "apply reloc: type=" << relocTypeToString(Rel.Type));
+    if (Rel.Type != R_WASM_TYPE_INDEX_LEB)
+      LLVM_DEBUG(dbgs() << " sym=" << File->getSymbols()[Rel.Index]->getName());
+    LLVM_DEBUG(dbgs() << " addend=" << Rel.Addend << " index=" << Rel.Index
                       << " value=" << Value << " offset=" << Rel.Offset
                       << "\n");
 
     switch (Rel.Type) {
     case R_WASM_TYPE_INDEX_LEB:
     case R_WASM_FUNCTION_INDEX_LEB:
     case R_WASM_GLOBAL_INDEX_LEB:
     case R_WASM_EVENT_INDEX_LEB:

lld/trunk/wasm/SymbolTable.cpp

DefinedData *SymbolTable::addOptionalDataSymbol(StringRef Name, uint32_t Value,
   Symbol *S = find(Name);
   if (!S && (Config->ExportAll || Config->ExportedSymbols.count(Name) != 0))
     S = insertName(Name).first;
   else if (!S || S->isDefined())
     return nullptr;
   LLVM_DEBUG(dbgs() << "addOptionalDataSymbol: " << Name << "\n");
   auto *rtn = replaceSymbol<DefinedData>(S, Name, Flags);
   rtn->setVirtualAddress(Value);
+  rtn->Referenced = true;
   return rtn;
 }
 
 DefinedData *SymbolTable::addSyntheticDataSymbol(StringRef Name,
                                                  uint32_t Flags) {
   LLVM_DEBUG(dbgs() << "addSyntheticDataSymbol: " << Name << "\n");
   assert(!find(Name));
   return replaceSymbol<DefinedData>(insertName(Name).first, Name, Flags);

lld/trunk/wasm/Symbols.h

Symbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F)
         ForceExport(false), CanInline(false), Traced(false) {}
 
   StringRef Name;
   InputFile *File;
   uint32_t Flags;
   uint32_t OutputSymbolIndex = INVALID_INDEX;
   uint32_t GOTIndex = INVALID_INDEX;
   Kind SymbolKind;
-  bool Referenced : 1;
 
 public:
+  bool Referenced : 1;
+
   // True if the symbol was used for linking and thus need to be added to the
   // output file's symbol table. This is true for all symbols except for
   // unreferenced DSO symbols, lazy (archive) symbols, and bitcode symbols that
   // are unreferenced except by other bitcode objects.
   bool IsUsedInRegularObj : 1;
 
   // True if ths symbol is explicity marked for export (i.e. via the -e/--export
   // command line flag)

lld/trunk/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();