[WebAssembly] Add __start_/_stop_ symbols for data sections

[sbc100]

Summary

Fixes https://bugs.llvm.org/show_bug.cgi?id=41565

[sbc100]

• rebase

[ruiu]

LGTM

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: 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*
+@__stop_mysection = external global i8*
+
+define i8** @get_start() {
+  ret i8** @__start_mysection
+}
+
+define i8** @get_end() {
+  ret i8** @__stop_mysection
+}
+
+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:       - Index:           1
+; CHECK-NEXT:         Locals:          []
+; CHECK-NEXT:         Body:            4180888080000B
+; 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:   - 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/trunk/wasm/Driver.cpp

else if (!Config->AllowUndefined)
       error(Twine("symbol exported via --export not found: ") +
             Arg->getValue());
   }
 
   if (!Config->Relocatable) {
     // Add synthetic dummies for weak undefined functions.  Must happen
     // after LTO otherwise functions may not yet have signatures.
     Symtab->handleWeakUndefines();
-
-    // Make sure we have resolved all symbols.
-    if (!Config->AllowUndefined)
-      Symtab->reportRemainingUndefines();
   }
 
   if (EntrySym)
     EntrySym->setHidden(false);
 
   if (errorCount())
     return;
 
   // Do size optimizations: garbage collection
   markLive();
 
   // Write the result to the file.
   writeResult();
 }

lld/trunk/wasm/SymbolTable.h

public:
 
   bool addComdat(StringRef Name);
 
   DefinedData *addSyntheticDataSymbol(StringRef Name, uint32_t Flags);
   DefinedGlobal *addSyntheticGlobal(StringRef Name, uint32_t Flags,
                                     InputGlobal *Global);
   DefinedFunction *addSyntheticFunction(StringRef Name, uint32_t Flags,
                                         InputFunction *Function);
+  DefinedData *addOptionalDataSymbol(StringRef Name, uint32_t Value,
+                                     uint32_t Flags);
 
   void handleSymbolVariants();
   void handleWeakUndefines();
 
 private:
   std::pair<Symbol *, bool> insert(StringRef Name, const InputFile *File);
   std::pair<Symbol *, bool> insertName(StringRef Name);
 

lld/trunk/wasm/SymbolTable.cpp

DefinedFunction *SymbolTable::addSyntheticFunction(StringRef Name,
                                                    InputFunction *Function) {
   LLVM_DEBUG(dbgs() << "addSyntheticFunction: " << Name << "\n");
   assert(!find(Name));
   SyntheticFunctions.emplace_back(Function);
   return replaceSymbol<DefinedFunction>(insertName(Name).first, Name,
                                         Flags, nullptr, Function);
 }
 
+DefinedData *SymbolTable::addOptionalDataSymbol(StringRef Name, uint32_t Value,
+                                                uint32_t Flags) {
+  Symbol *S = find(Name);
+  if (!S || S->isDefined())
+    return nullptr;
+  LLVM_DEBUG(dbgs() << "addOptionalDataSymbol: " << Name << "\n");
+  auto *rtn = replaceSymbol<DefinedData>(S, Name, Flags);
+  rtn->setVirtualAddress(Value);
+  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);
 }
 
 DefinedGlobal *SymbolTable::addSyntheticGlobal(StringRef Name, uint32_t Flags,

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 writeHeader();

 void Writer::addSection(OutputSection *Sec) {
   if (!Sec->isNeeded())
     return;
   log("addSection: " + toString(*Sec));
   Sec->SectionIndex = OutputSections.size();
   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, 0);
+  Symtab->addOptionalDataSymbol(Saver.save("__stop_" + S), Stop, 0);
+}
+
 void Writer::addSections() {
   addSection(Out.DylinkSec);
   addSection(Out.TypeSec);
   addSection(Out.ImportSec);
   addSection(Out.FunctionSec);
   addSection(Out.TableSec);
   addSection(Out.MemorySec);
   addSection(Out.GlobalSec);
for (InputFunction *Func : Symtab->SyntheticFunctions)
     Out.FunctionSec->addFunction(Func);
 
   for (ObjFile *File : Symtab->ObjectFiles) {
     LLVM_DEBUG(dbgs() << "Functions: " << File->getName() << "\n");
     for (InputFunction *Func : File->Functions)
       Out.FunctionSec->addFunction(Func);
   }
 
-  scanRelocations();
-
   for (InputGlobal *Global : Symtab->SyntheticGlobals)
     Out.GlobalSec->addGlobal(Global);
 
   for (ObjFile *File : Symtab->ObjectFiles) {
     LLVM_DEBUG(dbgs() << "Globals: " << File->getName() << "\n");
     for (InputGlobal *Global : File->Globals)
       Out.GlobalSec->addGlobal(Global);
   }
void Writer::run() {
   log("-- createSyntheticSections");
   createSyntheticSections();
   log("-- populateProducers");
   populateProducers();
   log("-- populateTargetFeatures");
   populateTargetFeatures();
   log("-- calculateImports");
   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);
+  }
+
   log("-- assignIndexes");
   assignIndexes();
+  log("-- scanRelocations");
+  scanRelocations();
   log("-- calculateInitFunctions");
   calculateInitFunctions();
-  log("-- calculateTypes");
-  calculateTypes();
-  log("-- layoutMemory");
-  layoutMemory();
+
   if (!Config->Relocatable) {
+    // Create linker synthesized functions
     if (Config->Pic)
       createApplyRelocationsFunction();
     createCallCtorsFunction();
+
+    // Make sure we have resolved all symbols.
+    if (!Config->AllowUndefined)
+      Symtab->reportRemainingUndefines();
+
+    if (errorCount())
+      return;
   }
+
+  log("-- calculateTypes");
+  calculateTypes();
   log("-- calculateExports");
   calculateExports();
   log("-- calculateCustomSections");
   calculateCustomSections();
   log("-- populateSymtab");
   populateSymtab();
   log("-- addSections");
   addSections();