[WebAssembly] Add support for writing out init functions in linking section

[sbc100]

Summary

This change adds support for init functions in the linking
section, but only in -r/--relocatable mode.

[sbc100]

• shink test

[sbc100]

• clang format

[sbc100]

• test with -r and without -r

[ncw]

It's a start! (I guess this can be merged quickly, since it doesn't "do" much yet.)

For full support, I guess we're going to change things as follows?

1. Scrap the --entry and --no-entry arguments, entrypoints are now specified via llvm global ctors instead.
2. When not relocatable, synthesise a function that calls the InitFuncs
3. Add a new argument --start-entry / --export-entry=NAME which determines whether the synthesised function is added as the start func or exported by name. (These are exclusive choices, the last-specified of --start-entry and --export-entry wins). The default could be either --start-entry or --export-entry=_start, I don't particularly mind.

Alternatively for (1), we could retain --entry / --no-entry, and simply have them specify a function that will be added to the very end of the InitFuncs. I suppose the use-case would be to maybe specify some sort of void _start_main() { exit(main()); } function? We can certainly provide a _start_main symbol like that in Musl, and allow users to choose whether or not main will be invoked by passing --entry=_start_main if they want it (not by default). Or we could be "clever" and see if the user has actually provided a function called "main", and change the default accordingly!

I've updated my Musl fork to expect these semantics, by changing it to do libc initialisation using a ctor function at highest priority:
https://github.com/NWilson/musl/pull/1/files#diff-ee27602452b4de86f218293f457baa93

[sbc100]

I like the idea of keeping the generated function (i.e. __wasm_call_ctors, or whatever we call it) separate from main(). Then its up the c library, or runtime to decide if they want to call those two things in the same call stack, or separately. For the emscripten use case I think we want to be able to fist call ctors().. then later on call main(). But with a more stand alone toolchain (such as one based your musl port), it could happen in the same call if we decide that makes sense.

[ruiu]

wasm/OutputSections.cpp

184

Can't you omit std::string?

test/wasm/Inputs/global-ctor-dtor.ll

+define hidden void @myctor() {
+entry:
+  ret void
+}
+
+define hidden void @mydtor() {
+entry:
+  %ptr = alloca i32
+  ret void
+}
+
[e-mail]_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @myctor, i8* null }]
+
[e-mail]_dtors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @mydtor, i8* null }]

test/wasm/init-fini.ll

+; RUN: llc -mtriple=wasm32-unknown-unknown-wasm -filetype=obj -o %t.o %s
+; RUN: llc -mtriple=wasm32-unknown-unknown-wasm -filetype=obj %S/Inputs/global-ctor-dtor.ll -o %t.global-ctor-dtor.o
+
+define hidden void @func1() {
+entry:
+  ret void
+}
+
+define hidden void @func2() {
+entry:
+  ret void
+}
+
+define void @__cxa_atexit() {
+  ret void
+}
+
+define hidden void @_start() {
+entry:
+  ret void
+}
+
[e-mail]_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @func1, i8* null }]
+
[e-mail]_dtors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @func2, i8* null }]
+
+; RUN: lld -flavor wasm %t.o %t.global-ctor-dtor.o -o %t.wasm
+; RUN: obj2yaml %t.wasm | FileCheck %s
+
+; CHECK:          Name:            linking
+; CHECK-NEXT:     DataSize:        0
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Name:            name
+; CHECK-NEXT:     FunctionNames:   
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Name:            func1
+; CHECK-NEXT:       - Index:           1
+; CHECK-NEXT:         Name:            func2
+; CHECK-NEXT:       - Index:           2
+; CHECK-NEXT:         Name:            __cxa_atexit
+; CHECK-NEXT:       - Index:           3
+; CHECK-NEXT:         Name:            _start
+; CHECK-NEXT:       - Index:           4
+; CHECK-NEXT:         Name:            .Lcall_dtors
+; CHECK-NEXT:       - Index:           5
+; CHECK-NEXT:         Name:            .Lregister_call_dtors
+; CHECK-NEXT:       - Index:           6
+; CHECK-NEXT:         Name:            .Lbitcast
+; CHECK-NEXT:       - Index:           7
+; CHECK-NEXT:         Name:            myctor
+; CHECK-NEXT:       - Index:           8
+; CHECK-NEXT:         Name:            mydtor
+; CHECK-NEXT:       - Index:           9
+; CHECK-NEXT:         Name:            .Lcall_dtors
+; CHECK-NEXT:       - Index:           10
+; CHECK-NEXT:         Name:            .Lregister_call_dtors
+; CHECK-NEXT: ...
+
+
+; RUN: lld -flavor wasm -r %t.o %t.global-ctor-dtor.o -o %t.reloc.wasm
+; RUN: obj2yaml %t.reloc.wasm | FileCheck -check-prefix=RELOC %s
+
+; RELOC:          Name:            linking
+; RELOC-NEXT:     DataSize:        0
+; RELOC-NEXT:     InitFunctions:   
+; RELOC-NEXT:       - Priority:        65535
+; RELOC-NEXT:         FunctionIndex:   0
+; RELOC-NEXT:       - Priority:        65535
+; RELOC-NEXT:         FunctionIndex:   5
+; RELOC-NEXT:       - Priority:        65535
+; RELOC-NEXT:         FunctionIndex:   7
+; RELOC-NEXT:       - Priority:        65535
+; RELOC-NEXT:         FunctionIndex:   10
+; RELOC-NEXT:   - Type:            CUSTOM
+; RELOC-NEXT:     Name:            name
+; RELOC-NEXT:     FunctionNames:   
+; RELOC-NEXT:       - Index:           0
+; RELOC-NEXT:         Name:            func1
+; RELOC-NEXT:       - Index:           1
+; RELOC-NEXT:         Name:            func2
+; RELOC-NEXT:       - Index:           2
+; RELOC-NEXT:         Name:            __cxa_atexit
+; RELOC-NEXT:       - Index:           3
+; RELOC-NEXT:         Name:            _start
+; RELOC-NEXT:       - Index:           4
+; RELOC-NEXT:         Name:            .Lcall_dtors
+; RELOC-NEXT:       - Index:           5
+; RELOC-NEXT:         Name:            .Lregister_call_dtors
+; RELOC-NEXT:       - Index:           6
+; RELOC-NEXT:         Name:            .Lbitcast
+; RELOC-NEXT:       - Index:           7
+; RELOC-NEXT:         Name:            myctor
+; RELOC-NEXT:       - Index:           8
+; RELOC-NEXT:         Name:            mydtor
+; RELOC-NEXT:       - Index:           9
+; RELOC-NEXT:         Name:            .Lcall_dtors
+; RELOC-NEXT:       - Index:           10
+; RELOC-NEXT:         Name:            .Lregister_call_dtors
+; RELOC-NEXT: ...

wasm/OutputSections.h

 
 class OutputSection {
 public:
   OutputSection(uint32_t Type, std::string Name = "")
       : Type(Type), Name(Name) {}
 
   virtual ~OutputSection() = default;
 
+  std::string getSectionName();
+
   void setOffset(size_t NewOffset) {
     log("setOffset: " + toString(this) + " -> " + Twine(NewOffset));
     Offset = NewOffset;
   }
 
   void createHeader(size_t BodySize);
   virtual size_t getSize() const = 0;
   virtual void writeTo(uint8_t *Buf) = 0;

 // Just like the synthetic sections themselves these need to be created before
 // they can be written out (since they are preceded by their length). This
 // class is used to create subsections and then write them into the stream
 // of the parent section.
 class SubSection : public SyntheticSection {
 public:
   explicit SubSection(uint32_t Type) : SyntheticSection(Type) {}
 
+  std::string getSectionName();
+
   void writeToStream(raw_ostream &OS) {
     writeBytes(OS, Header.data(), Header.size());
     writeBytes(OS, Body.data(), Body.size());
   }
 };
 
 class CodeSection : public OutputSection {
 public:

wasm/OutputSections.cpp

default:
       NewReloc.Value = calcNewIndex(File, Reloc);
       break;
     }
 
     OutputRelocs.emplace_back(NewReloc);
   }
 }
 
+std::string OutputSection::getSectionName() {
+  return sectionTypeToString(Type);
+}
+
+std::string SubSection::getSectionName() {
+  return std::string("subsection <type=") + std::to_string(Type) + ">";
+}
+
 void OutputSection::createHeader(size_t BodySize) {
   raw_string_ostream OS(Header);
-  debugWrite(OS.tell(),
-             "section type [" + Twine(sectionTypeToString(Type)) + "]");
+  debugWrite(OS.tell(), "section type [" + Twine(getSectionName()) + "]");
   writeUleb128(OS, Type, nullptr);
   writeUleb128(OS, BodySize, "section size");
   OS.flush();
   log("createHeader: " + toString(this) + " body=" + Twine(BodySize) +
       " total=" + Twine(getSize()));
 }
 
 CodeSection::CodeSection(uint32_t NumFunctions, ArrayRef<ObjFile *> Objs)

wasm/Writer.cpp

SyntheticSection *Section =
       createSyntheticSection(WASM_SEC_CUSTOM, "linking");
   raw_ostream &OS = Section->getStream();
 
   SubSection DataSizeSubSection(WASM_DATA_SIZE);
   writeUleb128(DataSizeSubSection.getStream(), DataSize, "data size");
   DataSizeSubSection.finalizeContents();
   DataSizeSubSection.writeToStream(OS);
 
-  if (Segments.size() && Config->Relocatable) {
+  if (!Config->Relocatable)
+    return;
+
+  if (Segments.size()) {
     SubSection SubSection(WASM_SEGMENT_INFO);
     writeUleb128(SubSection.getStream(), Segments.size(), "num data segments");
     for (const OutputSegment *S : Segments) {
       writeStr(SubSection.getStream(), S->Name, "segment name");
       writeUleb128(SubSection.getStream(), S->Alignment, "alignment");
       writeUleb128(SubSection.getStream(), 0, "flags");
     }
     SubSection.finalizeContents();
     SubSection.writeToStream(OS);
   }
+
+  std::vector<WasmInitFunc> InitFunctions;
+  for (ObjFile *File : Symtab->ObjectFiles) {
+    const WasmLinkingData &L = File->getWasmObj()->linkingData();
+    InitFunctions.reserve(InitFunctions.size() + L.InitFunctions.size());
+    for (const WasmInitFunc &F : L.InitFunctions) {
+      InitFunctions.emplace_back(WasmInitFunc{
+          F.Priority, File->relocateFunctionIndex(F.FunctionIndex)});
+    }
+  }
+
+  if (!InitFunctions.empty()) {
+    SubSection SubSection(WASM_INIT_FUNCS);
+    writeUleb128(SubSection.getStream(), InitFunctions.size(),
+                 "num init functionsw");
+    for (const WasmInitFunc &F : InitFunctions) {
+      writeUleb128(SubSection.getStream(), F.Priority, "priority");
+      writeUleb128(SubSection.getStream(), F.FunctionIndex, "function index");
+    }
+    SubSection.finalizeContents();
+    SubSection.writeToStream(OS);
+  }
 }
 
 // Create the custom "name" section containing debug symbol names.
 void Writer::createNameSection() {
   // Create an array of all function sorted by function index space
   std::vector<const Symbol *> Names;
 
   for (ObjFile *File : Symtab->ObjectFiles) {