[WebAssembly] Output functions individually

[sbc100]

Summary

The code section is now written out one function
at a time rather than all the functions in a given
objects being serialized at once.

This change lays the groundwork for supporting
--gc-sections.

[sbc100]

remove debugging

[sbc100]

• remove debugging

[sbc100]

• add const

[sbc100]

• remove debugging

[sbc100]

• fix header

[ruiu]

wasm/InputFiles.cpp

147

This is not a review comment to lld, but why don't you emit one relocation section for each function? IIUC, this code scans an entire relocation section each time you instantiate a function, so that's O(n*m) where n and m are the number of relocations and functions.

203

i -> I

i++ -> ++I

207

CopyRelocationsRange -> copyRelocationsRange

wasm/InputFiles.h

119–123

What is a relation between Segment and Function? Is Function a type of Segment?

[ncw]

(This is towards https://bugs.llvm.org/show_bug.cgi?id=35534)

It looks like you're still emitting all functions, and the output hasn't actually changed? I haven't read it thoroughly yet, but from the fact that the tests haven't changed I deduce this patch doesn't do any pruning.

The next simple/logical thing to do is to handle weak symbols - when assigning the function indices, check for duplicates. Only functions that actually provide a Symbol should be kept, and the rest discarded (if the Symbol that they would have provided points to a different Function). That's a straightforward and quick check that's probably worth having, even if GC is later used to do even more vigorous pruning of unused code.

wasm/InputFiles.h

119–123

A "segment" is a data segment (a section containing data rather than text). When createDefined is used to make a function symbol, Function will not non-null and Segment null; and vice-versa when it's used for making symbols that refer to global variables, which have an associate segment containing the initial value.

[sbc100]

• feedback

[sbc100]

wasm/InputFiles.cpp

147

You are right we probably can/should do better here.

We tried to design the relocation system such that relocations would apply to the basic primitive of the object format: the wasm section.

However, the only two sections that contain relocations so far are the code and data sections, and we are not trying to split these up into GC'able chunks (a single segment for data and a single function for code). Going back to revist the relocations in the object file it would probably make a lot more sense at this point to one relocation section per function and per data segments. i.e. reloc.CODE.1 .. reloc.CODE.n rather than simply reloc.CODE. I've opened bug in our tool-conventions repo to discuss changing this: https://github.com/WebAssembly/tool-conventions/issues/32

wasm/InputFiles.h

119–123

In the wasm format the CODE section is made up of a sequence of functions (essentially blobs of wasm code). Whereas the DATA section is made up of a sequence of data segments. We could try to treat these to equally in the abstraction here, but unlike ELF they are represented in the same way.

[sbc100]

• feedback

[ncw]

Looks good, this definitely goes in the right direction and will be useful.

wasm/InputFiles.cpp

147

The linking tools convention shouldn't need to be changed - there's nothing stopping us just using a map when we read in the relocations in LLD. There's minimal advantage to storing the list of relocations per-section in the object file, which doesn't have to reflect whether LLD wants to use a map/vector for lookups.

Either way, I agree this commit doesn't need to be held up on that.

[ncw]

I've just been doing some testing, to evaluate the filesize from Wasm LLD.

I have here a binary that's part of our HTML5 product (the VNC Connect SDK, which includes an asm.js blob).

• In asm.js uncompressed, unminified, the output is 12684717 (13MB), gzips to 2138009 (2.1MB)
• LLD's current output is 1611558 (1.6MB)! Hooray.
• Of current output, 50695 (50KB) is duplicated string data. Tiny actually! Calculated as difference between strings and strings | sort -u output.
• Of current output, 87179 (85KB) is data from functions that are provided in multiple translation units (ie inline functions - where we can avoid outputting the duplicate copies). This was calculated with some hacky extra logging on my COMDAT branch.
• Current output gzips to 465671 (450KB)

So, we're actually pretty small already, at least compared to asm.js from Emscripten. Pruning some duplicate data would be nice, but (to me) it's lower-priority than essential functionality, considering the output is surprisingly competitive with asm.js already.

The next steps for me are to continue debugging the Comdat support to the point where our full app runs successfully.

[sbc100]

wasm/InputFiles.h

119–123

Sorry, I meant to say: they are *not* represented in the same way.

[ncw]

wasm/InputSegment.h

38

Would you mind reverting this change (pointer to ref) before merging? I'd like to add a member static InputSegment Discarded (see ELF InputSection) - but that's awkward if the members are forced to be non-null. Ditto for InputFunction.

[sbc100]

• rebase

[sbc100]

• rebase

[sbc100]

I have a followup change that will unify the InputFunction and InputSegment, but I'd like to land this change as-is to keep reasonably sizes. @ruiu WDYT?

[sbc100]

• remove two redundant methods

[sbc100]

• remove unused function

[sbc100]

ping @ruiu. I've got quick a few other pending changes stacked up on top of this one now. (sorry I know the holidays are coming up).

[sbc100]

• remove unused 'using'

[ncw]

wasm/InputSegment.h

38

Actually - if we're switching to isDiscarded rather than InputSegment::Discarded, then the change from pointer to ref is fine. Sorry! I'll change the Comdat review to match.

[sbc100]

@ruiu PTAL. This change is needed before I can land https://reviews.llvm.org/D41426

wasm/InputFiles.h

119–123

I have a followup change that unifies these two with single base class

[sbc100]

• check condition outside loop

[sbc100]

@ruiu: ping

(sorry for repeated ping, just that this change is blocking others)

[ruiu]

wasm/InputFunction.h

36

IIUC, since wasm functions don't exist in the regular virtual address space, it is always considered zero in size. Defining this function seems a bit pointless to me because functions don't have the notion of "size" at all in webassembly. Can you remove this function?

47

Not sure if I understand this, but is Offset a correct term for wasm functions? I think functions have indices, but they don't have output offsets in a normal sense (because they do not exist in the regular address space).

[sbc100]

• rebase

[sbc100]

• - feedback

[sbc100]

wasm/InputFunction.h

36

removed getSize()

47

This is the offset of the bytes for this function withing the output CODE section.

[ruiu]

LGTM

wasm/InputFiles.cpp

29–33

You are using namespace llvm::wasm just above this line.

wasm/InputFiles.h

 
 #include <vector>
 
 using llvm::object::Archive;
 using llvm::object::WasmObjectFile;
 using llvm::object::WasmSection;
 using llvm::object::WasmSymbol;
 using llvm::wasm::WasmImport;
+using llvm::wasm::WasmSignature;
+using llvm::wasm::WasmFunction;
 
 namespace lld {
 namespace wasm {
 
 class Symbol;
+class InputFunction;
 class InputSegment;
 
 class InputFile {
 public:
   enum Kind {
     ObjectKind,
     ArchiveKind,
   };
public:
   void dumpInfo() const;
 
   uint32_t relocateTypeIndex(uint32_t Original) const;
   uint32_t relocateFunctionIndex(uint32_t Original) const;
   uint32_t relocateGlobalIndex(uint32_t Original) const;
   uint32_t relocateTableIndex(uint32_t Original) const;
   uint32_t getRelocatedAddress(uint32_t Index) const;
 
-  // Returns true if the given function index is an imported function,
-  // as opposed to the locally defined function.
-  bool isImportedFunction(uint32_t Index) const;
+  size_t getNumFunctionImports() const { return NumFunctionImports; }
+  size_t getNumGlobalImports() const { return NumGlobalImports; }
 
-  size_t NumFunctionImports() const { return FunctionImports; }
-  size_t NumGlobalImports() const { return GlobalImports; }
-
-  int32_t FunctionIndexOffset = 0;
   const WasmSection *CodeSection = nullptr;
-  std::vector<OutputRelocation> CodeRelocations;
-  int32_t CodeOffset = 0;
-  const WasmSection *DataSection = nullptr;
 
   std::vector<uint32_t> TypeMap;
   std::vector<InputSegment *> Segments;
+  std::vector<InputFunction *> Functions;
 
   ArrayRef<Symbol *> getSymbols() { return Symbols; }
   ArrayRef<Symbol *> getTableSymbols() { return TableSymbols; }
 
 private:
+  // Returns true if the given function index is an imported function,
+  // as opposed to the locally defined function.
+  bool isImportedFunction(uint32_t Index) const;
+
   Symbol *createDefined(const WasmSymbol &Sym,
-                        const InputSegment *Segment = nullptr);
-  Symbol *createUndefined(const WasmSymbol &Sym);
+                        const InputSegment *Segment = nullptr,
+                        InputFunction *Function = nullptr);
+  Symbol *createUndefined(const WasmSymbol &Sym,
+                          const WasmSignature *Signature = nullptr);
   void initializeSymbols();
-  InputSegment *getSegment(const WasmSymbol &WasmSym);
+  InputSegment *getSegment(const WasmSymbol &WasmSym) const;
+  const WasmSignature *getFunctionSig(const WasmSymbol &Sym) const;
+  InputFunction *getFunction(const WasmSymbol &Sym) const;
   Symbol *getFunctionSymbol(uint32_t FunctionIndex) const;
   Symbol *getTableSymbol(uint32_t TableIndex) const;
   Symbol *getGlobalSymbol(uint32_t GlobalIndex) const;
 
   // List of all symbols referenced or defined by this file.
   std::vector<Symbol *> Symbols;
 
   // List of all function symbols indexed by the function index space
   std::vector<Symbol *> FunctionSymbols;
 
   // List of all global symbols indexed by the global index space
   std::vector<Symbol *> GlobalSymbols;
 
   // List of all indirect symbols indexed by table index space.
   std::vector<Symbol *> TableSymbols;
 
-  uint32_t GlobalImports = 0;
-  uint32_t FunctionImports = 0;
+  const WasmSection *DataSection = nullptr;
+  uint32_t NumGlobalImports = 0;
+  uint32_t NumFunctionImports = 0;
   std::unique_ptr<WasmObjectFile> WasmObj;
 };
 
 // Opens a given file.
 llvm::Optional<MemoryBufferRef> readFile(StringRef Path);
 
 } // namespace wasm
 
 std::string toString(const wasm::InputFile *File);
 
 } // namespace lld
 
 #endif

wasm/InputFiles.cpp

 //===- InputFiles.cpp -----------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "InputFiles.h"
 
 #include "Config.h"
+#include "InputFunction.h"
 #include "InputSegment.h"
 #include "SymbolTable.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/Wasm.h"
 #include "llvm/Support/raw_ostream.h"
 
 #define DEBUG_TYPE "lld"
 
 using namespace lld;
 using namespace lld::wasm;
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::wasm;
 
+using llvm::wasm::WasmFunction;
+
 Optional<MemoryBufferRef> lld::wasm::readFile(StringRef Path) {
   log("Loading: " + Path);
 
   auto MBOrErr = MemoryBuffer::getFile(Path);
   if (auto EC = MBOrErr.getError()) {
     error("cannot open " + Path + ": " + EC.message());
     return None;
   }
   std::unique_ptr<MemoryBuffer> &MB = *MBOrErr;
   MemoryBufferRef MBRef = MB->getMemBufferRef();
   make<std::unique_ptr<MemoryBuffer>>(std::move(MB)); // take MB ownership
 
   return MBRef;
 }
 
 void ObjFile::dumpInfo() const {
-  log("reloc info for: " + getName() + "\n" +
-      "        FunctionIndexOffset : " + Twine(FunctionIndexOffset) + "\n" +
-      "         NumFunctionImports : " + Twine(NumFunctionImports()) + "\n" +
-      "           NumGlobalImports : " + Twine(NumGlobalImports()) + "\n");
+  log("info for: " + getName() + "\n" +
+      "      Total Functions : " + Twine(FunctionSymbols.size()) + "\n" +
+      "        Total Globals : " + Twine(GlobalSymbols.size()) + "\n" +
+      "     Function Imports : " + Twine(NumFunctionImports) + "\n" +
+      "       Global Imports : " + Twine(NumGlobalImports) + "\n" +
+      "        Table Entries : " + Twine(TableSymbols.size()) + "\n");
 }
 
 bool ObjFile::isImportedFunction(uint32_t Index) const {
-  return Index < NumFunctionImports();
+  return Index < NumFunctionImports;
 }
 
 Symbol *ObjFile::getFunctionSymbol(uint32_t Index) const {
   return FunctionSymbols[Index];
 }
 
 Symbol *ObjFile::getTableSymbol(uint32_t Index) const {
   return TableSymbols[Index];
for (const SectionRef &Sec : WasmObj->sections()) {
     else if (Section.Type == WASM_SEC_DATA)
       DataSection = &Section;
   }
 
   initializeSymbols();
 }
 
 // Return the InputSegment in which a given symbol is defined.
-InputSegment *ObjFile::getSegment(const WasmSymbol &WasmSym) {
+InputSegment *ObjFile::getSegment(const WasmSymbol &WasmSym) const {
   uint32_t Address = WasmObj->getWasmSymbolValue(WasmSym);
   for (InputSegment *Segment : Segments) {
     if (Address >= Segment->startVA() && Address < Segment->endVA()) {
       DEBUG(dbgs() << "Found symbol in segment: " << WasmSym.Name << " -> "
                    << Segment->getName() << "\n");
 
       return Segment;
     }
   }
   error("symbol not found in any segment: " + WasmSym.Name);
   return nullptr;
 }
 
-static void CopyRelocationsRange(std::vector<WasmRelocation> &To,
+static void copyRelocationsRange(std::vector<WasmRelocation> &To,
                                  ArrayRef<WasmRelocation> From, size_t Start,
-                                 size_t End) {
+                                 size_t Size) {
   for (const WasmRelocation &R : From)
-    if (R.Offset >= Start && R.Offset < End)
+    if (R.Offset >= Start && R.Offset < Start + Size)
       To.push_back(R);
 }
 
+// Get the signature for a given function symbol, either by looking
+// it up in function sections (for defined functions), of the imports section
+// (for imported functions).
+const WasmSignature *ObjFile::getFunctionSig(const WasmSymbol &Sym) const {
+  DEBUG(dbgs() << "getFunctionSig: " << Sym.Name << "\n");
+  uint32_t FunctionType;
+  if (isImportedFunction(Sym.ElementIndex)) {
+    const WasmImport &Import = WasmObj->imports()[Sym.ImportIndex];
+    FunctionType = Import.SigIndex;
+  } else {
+    uint32_t FuntionIndex = Sym.ElementIndex - NumFunctionImports;
+    FunctionType = WasmObj->functionTypes()[FuntionIndex];
+  }
+  return &WasmObj->types()[FunctionType];
+}
+
+InputFunction *ObjFile::getFunction(const WasmSymbol &Sym) const {
+  uint32_t FuntionIndex = Sym.ElementIndex - NumFunctionImports;
+  return Functions[FuntionIndex];
+}
+
 void ObjFile::initializeSymbols() {
   Symbols.reserve(WasmObj->getNumberOfSymbols());
 
   for (const WasmImport &Import : WasmObj->imports()) {
     switch (Import.Kind) {
     case WASM_EXTERNAL_FUNCTION:
-      ++FunctionImports;
+      ++NumFunctionImports;
       break;
     case WASM_EXTERNAL_GLOBAL:
-      ++GlobalImports;
+      ++NumGlobalImports;
       break;
     }
   }
 
-  FunctionSymbols.resize(FunctionImports + WasmObj->functions().size());
-  GlobalSymbols.resize(GlobalImports + WasmObj->globals().size());
+  FunctionSymbols.resize(NumFunctionImports + WasmObj->functions().size());
+  GlobalSymbols.resize(NumGlobalImports + WasmObj->globals().size());
 
   for (const WasmSegment &S : WasmObj->dataSegments()) {
-    InputSegment *Seg = make<InputSegment>(&S, this);
-    CopyRelocationsRange(Seg->Relocations, DataSection->Relocations,
-                         Seg->getInputSectionOffset(),
-                         Seg->getInputSectionOffset() + Seg->getSize());
+    InputSegment *Seg = make<InputSegment>(S, *this);
+    copyRelocationsRange(Seg->Relocations, DataSection->Relocations,
+                         Seg->getInputSectionOffset(), Seg->getSize());
     Segments.emplace_back(Seg);
   }
 
+  ArrayRef<WasmFunction> Funcs = WasmObj->functions();
+  ArrayRef<uint32_t> FuncTypes = WasmObj->functionTypes();
+  ArrayRef<WasmSignature> Types = WasmObj->types();
+  for (size_t I = 0; I < Funcs.size(); ++I) {
+    const WasmFunction &Func = Funcs[I];
+    const WasmSignature &Sig = Types[FuncTypes[I]];
+    InputFunction *Function = make<InputFunction>(Sig, Func, *this);
+    copyRelocationsRange(Function->Relocations, CodeSection->Relocations,
+                         Func.CodeSectionOffset, Func.Size);
+    Functions.emplace_back(Function);
+  }
+
   // Populate `FunctionSymbols` and `GlobalSymbols` based on the WasmSymbols
   // in the object
   for (const SymbolRef &Sym : WasmObj->symbols()) {
     const WasmSymbol &WasmSym = WasmObj->getWasmSymbol(Sym.getRawDataRefImpl());
     Symbol *S;
     switch (WasmSym.Type) {
     case WasmSymbol::SymbolType::FUNCTION_IMPORT:
+      S = createUndefined(WasmSym, getFunctionSig(WasmSym));
+      break;
     case WasmSymbol::SymbolType::GLOBAL_IMPORT:
       S = createUndefined(WasmSym);
       break;
     case WasmSymbol::SymbolType::GLOBAL_EXPORT:
-      S = createDefined(WasmSym, getSegment(WasmSym));
+      S = createDefined(WasmSym, getSegment(WasmSym), nullptr);
       break;
     case WasmSymbol::SymbolType::FUNCTION_EXPORT:
-      S = createDefined(WasmSym);
+      S = createDefined(WasmSym, nullptr, getFunction(WasmSym));
       break;
     case WasmSymbol::SymbolType::DEBUG_FUNCTION_NAME:
       // These are for debugging only, no need to create linker symbols for them
       continue;
     }
 
     Symbols.push_back(S);
     if (WasmSym.isFunction()) {
for (uint64_t FunctionIndex : Segment.Functions)
       TableSymbols.push_back(getFunctionSymbol(FunctionIndex));
   }
 
   DEBUG(dbgs() << "TableSymbols: " << TableSymbols.size() << "\n");
   DEBUG(dbgs() << "Functions   : " << FunctionSymbols.size() << "\n");
   DEBUG(dbgs() << "Globals     : " << GlobalSymbols.size() << "\n");
 }
 
-Symbol *ObjFile::createUndefined(const WasmSymbol &Sym) {
-  return Symtab->addUndefined(this, &Sym);
+Symbol *ObjFile::createUndefined(const WasmSymbol &Sym,
+                                 const WasmSignature *Signature) {
+  return Symtab->addUndefined(this, &Sym, Signature);
 }
 
 Symbol *ObjFile::createDefined(const WasmSymbol &Sym,
-                               const InputSegment *Segment) {
+                               const InputSegment *Segment,
+                               InputFunction *Function) {
   Symbol *S;
   if (Sym.isLocal()) {
     S = make<Symbol>(Sym.Name, true);
     Symbol::Kind Kind;
     if (Sym.Type == WasmSymbol::SymbolType::FUNCTION_EXPORT)
       Kind = Symbol::Kind::DefinedFunctionKind;
     else if (Sym.Type == WasmSymbol::SymbolType::GLOBAL_EXPORT)
       Kind = Symbol::Kind::DefinedGlobalKind;
     else
       llvm_unreachable("invalid local symbol type");
-    S->update(Kind, this, &Sym, Segment);
+    S->update(Kind, this, &Sym, Segment, Function);
     return S;
   }
-  return Symtab->addDefined(this, &Sym, Segment);
+  return Symtab->addDefined(this, &Sym, Segment, Function);
 }
 
 void ArchiveFile::parse() {
   // Parse a MemoryBufferRef as an archive file.
   DEBUG(dbgs() << "Parsing library: " << toString(this) << "\n");
   File = CHECK(Archive::create(MB), toString(this));
 
   // Read the symbol table to construct Lazy symbols.

wasm/InputFunction.h

+//===- InpuFunction.h -------------------------------------------*- C++ -*-===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Represents a WebAssembly function in an input file which could also be
+// assigned a function index in the output.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_WASM_INPUT_FUNCTION_H
+#define LLD_WASM_INPUT_FUNCTION_H
+
+#include "WriterUtils.h"
+#include "llvm/Object/Wasm.h"
+
+using llvm::wasm::WasmRelocation;
+using llvm::wasm::WasmFunction;
+
+namespace lld {
+namespace wasm {
+
+class ObjFile;
+
+class InputFunction {
+public:
+  InputFunction(const WasmSignature &S, const WasmFunction &Func,
+                const ObjFile &F)
+      : Signature(S), Function(Func), File(F) {}
+
+  uint32_t getSize() const { return 0; }
+  uint32_t getOutputIndex() const { return OutputIndex.getValue(); };
+  bool hasOutputIndex() const { return OutputIndex.hasValue(); };
+
+  void setOutputIndex(uint32_t Index) {
+    assert(!hasOutputIndex());
+    OutputIndex = Index;
+  };
+
+  const WasmSignature &Signature;
+  const WasmFunction &Function;
+  int32_t OutputOffset = 0;
+  std::vector<WasmRelocation> Relocations;
+  std::vector<OutputRelocation> OutRelocations;
+  const ObjFile &File;
+
+protected:
+  llvm::Optional<uint32_t> OutputIndex;
+};
+
+} // namespace wasm
+} // namespace lld
+
+#endif // LLD_WASM_INPUT_FUNCTION_H

wasm/InputSegment.h

 namespace lld {
 namespace wasm {
 
 class ObjFile;
 class OutputSegment;
 
 class InputSegment {
 public:
-  InputSegment(const WasmSegment *Seg, const ObjFile *F)
+  InputSegment(const WasmSegment &Seg, const ObjFile &F)
       : Segment(Seg), File(F) {}
 
   // Translate an offset in the input segment to an offset in the output
   // segment.
   uint32_t translateVA(uint32_t Address) const;
 
   const OutputSegment *getOutputSegment() const { return OutputSeg; }
 
   uint32_t getOutputSegmentOffset() const { return OutputSegmentOffset; }
 
-  uint32_t getInputSectionOffset() const { return Segment->SectionOffset; }
+  uint32_t getInputSectionOffset() const { return Segment.SectionOffset; }
 
   void setOutputSegment(const OutputSegment *Segment, uint32_t Offset) {
     OutputSeg = Segment;
     OutputSegmentOffset = Offset;
   }
 
-  uint32_t getSize() const { return Segment->Data.Content.size(); }
-  uint32_t getAlignment() const { return Segment->Data.Alignment; }
-  uint32_t startVA() const { return Segment->Data.Offset.Value.Int32; }
+  uint32_t getSize() const { return Segment.Data.Content.size(); }
+  uint32_t getAlignment() const { return Segment.Data.Alignment; }
+  uint32_t startVA() const { return Segment.Data.Offset.Value.Int32; }
   uint32_t endVA() const { return startVA() + getSize(); }
-  StringRef getName() const { return Segment->Data.Name; }
+  StringRef getName() const { return Segment.Data.Name; }
 
-  const WasmSegment *Segment;
-  const ObjFile *File;
+  const WasmSegment &Segment;
+  const ObjFile &File;
   std::vector<WasmRelocation> Relocations;
 
 protected:
   const OutputSegment *OutputSeg = nullptr;
   uint32_t OutputSegmentOffset = 0;
 };
 
 } // namespace wasm
 } // namespace lld
 
 #endif // LLD_WASM_INPUT_SEGMENT_H

wasm/OutputSections.h

 namespace wasm {
 class OutputSection;
 }
 std::string toString(wasm::OutputSection *Section);
 
 namespace wasm {
 
 class OutputSegment;
-class ObjFile;
+class InputFunction;
 
 class OutputSection {
 public:
   OutputSection(uint32_t Type, std::string Name = "")
       : Type(Type), Name(Name) {}
 
   virtual ~OutputSection() = default;
 
   void setOffset(size_t NewOffset) {
-    log("setOffset: " + toString(this) + " -> " + Twine(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;
   virtual void finalizeContents() {}
 
public:
   void writeToStream(raw_ostream &OS) {
     writeBytes(OS, Header.data(), Header.size());
     writeBytes(OS, Body.data(), Body.size());
   }
 };
 
 class CodeSection : public OutputSection {
 public:
-  explicit CodeSection(uint32_t NumFunctions, ArrayRef<ObjFile *> Objs);
+  explicit CodeSection(ArrayRef<InputFunction *> Functions);
   size_t getSize() const override { return Header.size() + BodySize; }
   void writeTo(uint8_t *Buf) override;
   uint32_t numRelocations() const override;
   void writeRelocations(raw_ostream &OS) const override;
 
 protected:
-  ArrayRef<ObjFile *> InputObjects;
+  ArrayRef<InputFunction *> Functions;
   std::string CodeSectionHeader;
   size_t BodySize = 0;
 };
 
 class DataSection : public OutputSection {
 public:
   explicit DataSection(ArrayRef<OutputSegment *> Segments);
   size_t getSize() const override { return Header.size() + BodySize; }

wasm/OutputSections.cpp

 //===- OutputSections.cpp -------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "OutputSections.h"
 
 #include "Config.h"
 #include "InputFiles.h"
+#include "InputFunction.h"
 #include "OutputSegment.h"
 #include "SymbolTable.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Threads.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/LEB128.h"
 

 static void calcRelocations(const ObjFile &File,
                             ArrayRef<WasmRelocation> Relocs,
                             std::vector<OutputRelocation> &OutputRelocs,
                             int32_t OutputOffset) {
   log("calcRelocations: " + File.getName() + " offset=" + Twine(OutputOffset));
   for (const WasmRelocation &Reloc : Relocs) {
     OutputRelocation NewReloc;
     NewReloc.Reloc = Reloc;
+    assert(Reloc.Offset + OutputOffset > 0);
     NewReloc.Reloc.Offset += OutputOffset;
     DEBUG(dbgs() << "reloc: type=" << Reloc.Type << " index=" << Reloc.Index
                  << " offset=" << Reloc.Offset
                  << " newOffset=" << NewReloc.Reloc.Offset << "\n");
 
     if (Config->EmitRelocs)
       NewReloc.NewIndex = calcNewIndex(File, Reloc);
     else
debugWrite(OS.tell(),
              "section type [" + Twine(sectionTypeToString(Type)) + "]");
   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)
-    : OutputSection(WASM_SEC_CODE), InputObjects(Objs) {
+CodeSection::CodeSection(ArrayRef<InputFunction *> Functions)
+    : OutputSection(WASM_SEC_CODE), Functions(Functions) {
+  assert(Functions.size() > 0);
+
   raw_string_ostream OS(CodeSectionHeader);
-  writeUleb128(OS, NumFunctions, "function count");
+  writeUleb128(OS, Functions.size(), "function count");
   OS.flush();
   BodySize = CodeSectionHeader.size();
 
-  for (ObjFile *File : InputObjects) {
-    if (!File->CodeSection)
-      continue;
-
-    File->CodeOffset = BodySize;
-    ArrayRef<uint8_t> Content = File->CodeSection->Content;
-    unsigned HeaderSize = 0;
-    decodeULEB128(Content.data(), &HeaderSize);
-
-    calcRelocations(*File, File->CodeSection->Relocations,
-                    File->CodeRelocations, BodySize - HeaderSize);
-
-    size_t PayloadSize = Content.size() - HeaderSize;
-    BodySize += PayloadSize;
+  for (InputFunction *Func : Functions) {
+    Func->OutputOffset = BodySize;
+    calcRelocations(Func->File, Func->Relocations, Func->OutRelocations,
+                    Func->OutputOffset - Func->Function.CodeSectionOffset);
+    BodySize += Func->Function.Size;
   }
 
   createHeader(BodySize);
 }
 
 void CodeSection::writeTo(uint8_t *Buf) {
   log("writing " + toString(this));
   log(" size=" + Twine(getSize()));
+  log(" headersize=" + Twine(Header.size()));
+  log(" codeheadersize=" + Twine(CodeSectionHeader.size()));
   Buf += Offset;
 
   // Write section header
   memcpy(Buf, Header.data(), Header.size());
   Buf += Header.size();
 
   uint8_t *ContentsStart = Buf;
 
   // Write code section headers
   memcpy(Buf, CodeSectionHeader.data(), CodeSectionHeader.size());
   Buf += CodeSectionHeader.size();
 
   // Write code section bodies
-  parallelForEach(InputObjects, [ContentsStart](ObjFile *File) {
-    if (!File->CodeSection)
-      return;
-
-    ArrayRef<uint8_t> Content(File->CodeSection->Content);
-
-    // Payload doesn't include the initial header (function count)
-    unsigned HeaderSize = 0;
-    decodeULEB128(Content.data(), &HeaderSize);
-
-    size_t PayloadSize = Content.size() - HeaderSize;
-    memcpy(ContentsStart + File->CodeOffset, Content.data() + HeaderSize,
-           PayloadSize);
-
-    log("applying relocations for: " + File->getName());
-    if (File->CodeRelocations.size())
-      applyRelocations(ContentsStart, File->CodeRelocations);
+  parallelForEach(Functions, [ContentsStart](InputFunction *Func) {
+    ArrayRef<uint8_t> Content(Func->File.CodeSection->Content);
+    memcpy(ContentsStart + Func->OutputOffset,
+           Content.data() + Func->Function.CodeSectionOffset,
+           Func->Function.Size);
+    if (Func->OutRelocations.size())
+      applyRelocations(ContentsStart, Func->OutRelocations);
   });
 }
 
 uint32_t CodeSection::numRelocations() const {
   uint32_t Count = 0;
-  for (ObjFile *File : InputObjects)
-    Count += File->CodeRelocations.size();
+  for (const InputFunction *Func : Functions)
+    Count += Func->OutRelocations.size();
   return Count;
 }
 
 void CodeSection::writeRelocations(raw_ostream &OS) const {
-  for (ObjFile *File : InputObjects)
-    for (const OutputRelocation &Reloc : File->CodeRelocations)
+  for (const InputFunction *Func : Functions)
+    for (const OutputRelocation &Reloc : Func->OutRelocations)
       writeReloc(OS, Reloc);
 }
 
 DataSection::DataSection(ArrayRef<OutputSegment *> Segments)
     : OutputSection(WASM_SEC_DATA), Segments(Segments) {
   raw_string_ostream OS(DataSectionHeader);
 
   writeUleb128(OS, Segments.size(), "data segment count");
for (OutputSegment *Segment : Segments) {
     Segment->setSectionOffset(BodySize);
     BodySize += Segment->Header.size();
     log("Data segment: size=" + Twine(Segment->Size));
     for (const InputSegment *InputSeg : Segment->InputSegments) {
       uint32_t InputOffset = InputSeg->getInputSectionOffset();
       uint32_t OutputOffset = Segment->getSectionOffset() +
                               Segment->Header.size() +
                               InputSeg->getOutputSegmentOffset();
-      calcRelocations(*InputSeg->File, InputSeg->Relocations, Relocations,
+      calcRelocations(InputSeg->File, InputSeg->Relocations, Relocations,
                       OutputOffset - InputOffset);
     }
     BodySize += Segment->Size;
   }
 
   createHeader(BodySize);
 }
 
void DataSection::writeTo(uint8_t *Buf) {
 
   parallelForEach(Segments, [ContentsStart](const OutputSegment *Segment) {
     // Write data segment header
     uint8_t *SegStart = ContentsStart + Segment->getSectionOffset();
     memcpy(SegStart, Segment->Header.data(), Segment->Header.size());
 
     // Write segment data payload
     for (const InputSegment *Input : Segment->InputSegments) {
-      ArrayRef<uint8_t> Content(Input->Segment->Data.Content);
+      ArrayRef<uint8_t> Content(Input->Segment.Data.Content);
       memcpy(SegStart + Segment->Header.size() +
                  Input->getOutputSegmentOffset(),
              Content.data(), Content.size());
     }
   });
 
   applyRelocations(ContentsStart, Relocations);
 }
 
 void DataSection::writeRelocations(raw_ostream &OS) const {
   for (const OutputRelocation &Reloc : Relocations)
     writeReloc(OS, Reloc);
 }

wasm/SymbolTable.h

public:
 
   void reportDuplicate(Symbol *Existing, InputFile *NewFile);
   void reportRemainingUndefines();
 
   ArrayRef<Symbol *> getSymbols() const { return SymVector; }
   Symbol *find(StringRef Name);
 
   Symbol *addDefined(InputFile *F, const WasmSymbol *Sym,
-                     const InputSegment *Segment = nullptr);
-  Symbol *addUndefined(InputFile *F, const WasmSymbol *Sym);
+                     const InputSegment *Segment = nullptr,
+                     InputFunction *Function = nullptr);
+  Symbol *addUndefined(InputFile *F, const WasmSymbol *Sym,
+                       const WasmSignature *Signature = nullptr);
   Symbol *addUndefinedFunction(StringRef Name, const WasmSignature *Type);
   Symbol *addDefinedGlobal(StringRef Name);
   void addLazy(ArchiveFile *F, const Archive::Symbol *Sym);
 
 private:
   std::pair<Symbol *, bool> insert(StringRef Name);
 
   llvm::DenseMap<llvm::CachedHashStringRef, Symbol *> SymMap;

wasm/SymbolTable.cpp

 //===- SymbolTable.cpp ----------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "SymbolTable.h"
 
 #include "Config.h"
+#include "InputFunction.h"
 #include "WriterUtils.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 
 #include <unordered_set>
 
 #define DEBUG_TYPE "lld"
 

 }
 
 void SymbolTable::reportDuplicate(Symbol *Existing, InputFile *NewFile) {
   error("duplicate symbol: " + toString(*Existing) + "\n>>> defined in " +
         toString(Existing->getFile()) + "\n>>> defined in " +
         toString(NewFile));
 }
 
-// Get the signature for a given function symbol, either by looking
-// it up in function sections (for defined functions), of the imports section
-// (for imported functions).
-static const WasmSignature *getFunctionSig(const ObjFile &Obj,
-                                           const WasmSymbol &Sym) {
-  DEBUG(dbgs() << "getFunctionSig: " << Sym.Name << "\n");
-  const WasmObjectFile *WasmObj = Obj.getWasmObj();
-  uint32_t FunctionType;
-  if (Obj.isImportedFunction(Sym.ElementIndex)) {
-    const WasmImport &Import = WasmObj->imports()[Sym.ImportIndex];
-    FunctionType = Import.SigIndex;
-  } else {
-    uint32_t FuntionIndex = Sym.ElementIndex - Obj.NumFunctionImports();
-    FunctionType = WasmObj->functionTypes()[FuntionIndex];
-  }
-  return &WasmObj->types()[FunctionType];
-}
-
 // Check the type of new symbol matches that of the symbol is replacing.
 // For functions this can also involve verifying that the signatures match.
 static void checkSymbolTypes(const Symbol &Existing, const InputFile &F,
                              const WasmSymbol &New,
                              const WasmSignature *NewSig) {
   if (Existing.isLazy())
     return;
 
Symbol *SymbolTable::addDefinedGlobal(StringRef Name) {
   if (WasInserted)
     S->update(Symbol::DefinedGlobalKind);
   else if (!S->isGlobal())
     error("symbol type mismatch: " + Name);
   return S;
 }
 
 Symbol *SymbolTable::addDefined(InputFile *F, const WasmSymbol *Sym,
-                                const InputSegment *Segment) {
+                                const InputSegment *Segment,
+                                InputFunction *Function) {
   DEBUG(dbgs() << "addDefined: " << Sym->Name << "\n");
   Symbol *S;
   bool WasInserted;
   Symbol::Kind Kind = Symbol::DefinedFunctionKind;
-  const WasmSignature *NewSig = nullptr;
   if (Sym->Type == WasmSymbol::SymbolType::GLOBAL_EXPORT)
     Kind = Symbol::DefinedGlobalKind;
-  else
-    NewSig = getFunctionSig(*cast<ObjFile>(F), *Sym);
 
   std::tie(S, WasInserted) = insert(Sym->Name);
   if (WasInserted) {
-    S->update(Kind, F, Sym, Segment, NewSig);
+    S->update(Kind, F, Sym, Segment, Function);
   } else if (S->isLazy()) {
     // The existing symbol is lazy. Replace it without checking types since
     // lazy symbols don't have any type information.
     DEBUG(dbgs() << "replacing existing lazy symbol: " << Sym->Name << "\n");
-    S->update(Kind, F, Sym, Segment, NewSig);
+    S->update(Kind, F, Sym, Segment, Function);
   } else if (!S->isDefined()) {
     // The existing symbol table entry is undefined. The new symbol replaces
     // it, after checking the type matches
     DEBUG(dbgs() << "resolving existing undefined symbol: " << Sym->Name
                  << "\n");
-    checkSymbolTypes(*S, *F, *Sym, NewSig);
-    S->update(Kind, F, Sym, Segment, NewSig);
+    checkSymbolTypes(*S, *F, *Sym, Function ? &Function->Signature : nullptr);
+    S->update(Kind, F, Sym, Segment, Function);
   } else if (Sym->isWeak()) {
     // the new symbol is weak we can ignore it
     DEBUG(dbgs() << "existing symbol takes precedence\n");
   } else if (S->isWeak()) {
     // the new symbol is not weak and the existing symbol is, so we replace
     // it
     DEBUG(dbgs() << "replacing existing weak symbol\n");
-    checkSymbolTypes(*S, *F, *Sym, NewSig);
-    S->update(Kind, F, Sym, Segment, NewSig);
+    checkSymbolTypes(*S, *F, *Sym, Function ? &Function->Signature : nullptr);
+    S->update(Kind, F, Sym, Segment, Function);
   } else {
     // neither symbol is week. They conflict.
     reportDuplicate(S, F);
   }
   return S;
 }
 
 Symbol *SymbolTable::addUndefinedFunction(StringRef Name,
                                           const WasmSignature *Type) {
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name);
   if (WasInserted) {
-    S->update(Symbol::UndefinedFunctionKind, nullptr, nullptr, nullptr, Type);
+    S->update(Symbol::UndefinedFunctionKind);
+    S->setFunctionType(Type);
   } else if (!S->isFunction()) {
     error("symbol type mismatch: " + Name);
   }
   return S;
 }
 
-Symbol *SymbolTable::addUndefined(InputFile *F, const WasmSymbol *Sym) {
+Symbol *SymbolTable::addUndefined(InputFile *F, const WasmSymbol *Sym,
+                                  const WasmSignature *Type) {
   DEBUG(dbgs() << "addUndefined: " << Sym->Name << "\n");
   Symbol *S;
   bool WasInserted;
   Symbol::Kind Kind = Symbol::UndefinedFunctionKind;
-  const WasmSignature *NewSig = nullptr;
   if (Sym->Type == WasmSymbol::SymbolType::GLOBAL_IMPORT)
     Kind = Symbol::UndefinedGlobalKind;
-  else
-    NewSig = getFunctionSig(*cast<ObjFile>(F), *Sym);
   std::tie(S, WasInserted) = insert(Sym->Name);
   if (WasInserted) {
-    S->update(Kind, F, Sym, nullptr, NewSig);
+    S->update(Kind, F, Sym);
+    if (Type)
+      S->setFunctionType(Type);
   } else if (S->isLazy()) {
     DEBUG(dbgs() << "resolved by existing lazy\n");
     auto *AF = cast<ArchiveFile>(S->getFile());
     AF->addMember(&S->getArchiveSymbol());
   } else if (S->isDefined()) {
     DEBUG(dbgs() << "resolved by existing\n");
-    checkSymbolTypes(*S, *F, *Sym, NewSig);
+    checkSymbolTypes(*S, *F, *Sym, Type);
   }
   return S;
 }
 
 void SymbolTable::addLazy(ArchiveFile *F, const Archive::Symbol *Sym) {
   DEBUG(dbgs() << "addLazy: " << Sym->getName() << "\n");
   StringRef Name = Sym->getName();
   Symbol *S;

wasm/Symbols.h

 using llvm::wasm::WasmImport;
 using llvm::wasm::WasmSignature;
 
 namespace lld {
 namespace wasm {
 
 class InputFile;
 class InputSegment;
+class InputFunction;
 
 class Symbol {
 public:
   enum Kind {
     DefinedFunctionKind,
     DefinedGlobalKind,
 
     LazyKind,
public:
   // Returns the file from which this symbol was created.
   InputFile *getFile() const { return File; }
 
   uint32_t getGlobalIndex() const;
   uint32_t getFunctionIndex() const;
 
   bool hasFunctionType() const { return FunctionType != nullptr; }
   const WasmSignature &getFunctionType() const;
+  void setFunctionType(const WasmSignature *Type);
   uint32_t getOutputIndex() const;
   uint32_t getTableIndex() const { return TableIndex.getValue(); }
 
   // Returns the virtual address of a defined global.
   // Only works for globals, not functions.
   uint32_t getVirtualAddress() const;
 
   // Set the output index of the symbol (in the function or global index
   // space of the output object.
   void setOutputIndex(uint32_t Index);
 
   // Returns true if a table index has been set for this symbol
   bool hasTableIndex() const { return TableIndex.hasValue(); }
 
   // Set the table index of the symbol
   void setTableIndex(uint32_t Index);
 
   void setVirtualAddress(uint32_t VA);
 
   void update(Kind K, InputFile *F = nullptr, const WasmSymbol *Sym = nullptr,
               const InputSegment *Segment = nullptr,
-              const WasmSignature *Sig = nullptr);
+              const InputFunction *Function = nullptr);
 
   void setArchiveSymbol(const Archive::Symbol &Sym) { ArchiveSymbol = Sym; }
   const Archive::Symbol &getArchiveSymbol() { return ArchiveSymbol; }
 
   // This bit is used by Writer::writeNameSection() to prevent
   // symbols from being written to the symbol table more than once.
   unsigned WrittenToSymtab : 1;
   unsigned WrittenToNameSec : 1;
 
 protected:
   unsigned IsLocal : 1;
 
   StringRef Name;
   Archive::Symbol ArchiveSymbol = {nullptr, 0, 0};
   Kind SymbolKind = InvalidKind;
   InputFile *File = nullptr;
   const WasmSymbol *Sym = nullptr;
   const InputSegment *Segment = nullptr;
+  const InputFunction *Function = nullptr;
   llvm::Optional<uint32_t> OutputIndex;
   llvm::Optional<uint32_t> TableIndex;
   llvm::Optional<uint32_t> VirtualAddress;
-  const WasmSignature *FunctionType;
+  const WasmSignature *FunctionType = nullptr;
 };
 
 } // namespace wasm
 
 // Returns a symbol name for an error message.
 std::string toString(const wasm::Symbol &Sym);
 std::string toString(wasm::Symbol::Kind Kind);
 
 } // namespace lld
 
 #endif

wasm/Symbols.cpp

 //===- Symbols.cpp --------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Symbols.h"
 
 #include "Config.h"
 #include "InputFiles.h"
+#include "InputFunction.h"
 #include "InputSegment.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Strings.h"
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace lld;
 using namespace lld::wasm;
 
 uint32_t Symbol::getGlobalIndex() const {
   assert(!Sym->isFunction());
   return Sym->ElementIndex;
 }
 
 uint32_t Symbol::getFunctionIndex() const {
   assert(Sym->isFunction());
   return Sym->ElementIndex;
 }
 
 const WasmSignature &Symbol::getFunctionType() const {
+  if (Function != nullptr)
+    return Function->Signature;
+
   assert(FunctionType != nullptr);
   return *FunctionType;
 }
 
+void Symbol::setFunctionType(const WasmSignature *Type) {
+  assert(FunctionType == nullptr);
+  assert(Function == nullptr);
+  FunctionType = Type;
+}
+
 uint32_t Symbol::getVirtualAddress() const {
   assert(isGlobal());
   DEBUG(dbgs() << "getVirtualAddress: " << getName() << "\n");
   if (isUndefined())
     return UINT32_MAX;
   if (VirtualAddress.hasValue())
     return VirtualAddress.getValue();
 
   assert(Sym != nullptr);
   ObjFile *Obj = cast<ObjFile>(File);
   const WasmGlobal &Global =
-      Obj->getWasmObj()->globals()[getGlobalIndex() - Obj->NumGlobalImports()];
+      Obj->getWasmObj()
+          ->globals()[getGlobalIndex() - Obj->getNumGlobalImports()];
   assert(Global.Type == llvm::wasm::WASM_TYPE_I32);
   assert(Segment);
   return Segment->translateVA(Global.InitExpr.Value.Int32);
 }
 
 uint32_t Symbol::getOutputIndex() const {
   if (isUndefined() && isWeak())
     return 0;
+  if (Function)
+    return Function->getOutputIndex();
   return OutputIndex.getValue();
 }
 
 void Symbol::setVirtualAddress(uint32_t Value) {
   DEBUG(dbgs() << "setVirtualAddress " << Name << " -> " << Value << "\n");
   assert(!VirtualAddress.hasValue());
   VirtualAddress = Value;
 }
 
 void Symbol::setOutputIndex(uint32_t Index) {
   DEBUG(dbgs() << "setOutputIndex " << Name << " -> " << Index << "\n");
+  assert(!Function);
   assert(!OutputIndex.hasValue());
   OutputIndex = Index;
 }
 
 void Symbol::setTableIndex(uint32_t Index) {
   DEBUG(dbgs() << "setTableIndex " << Name << " -> " << Index << "\n");
   assert(!TableIndex.hasValue());
   TableIndex = Index;
 }
 
 void Symbol::update(Kind K, InputFile *F, const WasmSymbol *WasmSym,
-                    const InputSegment *Seg, const WasmSignature *Sig) {
+                    const InputSegment *Seg, const InputFunction *Func) {
   SymbolKind = K;
   File = F;
   Sym = WasmSym;
   Segment = Seg;
-  FunctionType = Sig;
+  Function = Func;
 }
 
 bool Symbol::isWeak() const { return Sym && Sym->isWeak(); }
 
 bool Symbol::isHidden() const { return Sym && Sym->isHidden(); }
 
 std::string lld::toString(const wasm::Symbol &Sym) {
   if (Config->Demangle)

wasm/Writer.cpp

 //===- Writer.cpp ---------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Writer.h"
 
 #include "Config.h"
+#include "InputFunction.h"
 #include "OutputSections.h"
 #include "OutputSegment.h"
 #include "SymbolTable.h"
 #include "WriterUtils.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Threads.h"
 #include "llvm/Support/FileOutputBuffer.h"

 class Writer {
 public:
   void run();
 
 private:
   void openFile();
 
   uint32_t getTypeIndex(const WasmSignature &Sig);
-  void assignSymbolIndexes();
+  void assignIndexes();
   void calculateImports();
   void calculateOffsets();
   void calculateTypes();
   void createOutputSegments();
   void layoutMemory();
   void createHeader();
   void createSections();
   SyntheticSection *createSyntheticSection(uint32_t Type,
private:
   void createLinkingSection();
   void createNameSection();
 
   void writeHeader();
   void writeSections();
 
   uint64_t FileSize = 0;
   uint32_t DataSize = 0;
-  uint32_t NumFunctions = 0;
   uint32_t NumMemoryPages = 0;
   uint32_t InitialTableOffset = 0;
 
   std::vector<const WasmSignature *> Types;
   DenseMap<WasmSignature, int32_t, WasmSignatureDenseMapInfo> TypeIndices;
-  std::vector<const Symbol *> FunctionImports;
-  std::vector<const Symbol *> GlobalImports;
+  std::vector<const Symbol *> ImportedFunctions;
+  std::vector<const Symbol *> ImportedGlobals;
   std::vector<const Symbol *> DefinedGlobals;
+  std::vector<InputFunction *> DefinedFunctions;
   std::vector<const Symbol *> IndirectFunctions;
 
   // Elements that are used to construct the final output
   std::string Header;
   std::vector<OutputSection *> OutputSections;
 
   std::unique_ptr<FileOutputBuffer> Buffer;
 
static void debugPrint(const char *fmt, ...) {
   fprintf(stderr, "lld: ");
   va_list ap;
   va_start(ap, fmt);
   vfprintf(stderr, fmt, ap);
   va_end(ap);
 }
 
 void Writer::createImportSection() {
-  uint32_t NumImports = FunctionImports.size() + GlobalImports.size();
+  uint32_t NumImports = ImportedFunctions.size() + ImportedGlobals.size();
   if (Config->ImportMemory)
     ++NumImports;
 
   if (NumImports == 0)
     return;
 
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_IMPORT);
   raw_ostream &OS = Section->getStream();
 
   writeUleb128(OS, NumImports, "import count");
 
-  for (const Symbol *Sym : FunctionImports) {
+  for (const Symbol *Sym : ImportedFunctions) {
     WasmImport Import;
     Import.Module = "env";
     Import.Field = Sym->getName();
     Import.Kind = WASM_EXTERNAL_FUNCTION;
     assert(TypeIndices.count(Sym->getFunctionType()) > 0);
     Import.SigIndex = TypeIndices.lookup(Sym->getFunctionType());
     writeImport(OS, Import);
   }
 
   if (Config->ImportMemory) {
     WasmImport Import;
     Import.Module = "env";
     Import.Field = "memory";
     Import.Kind = WASM_EXTERNAL_MEMORY;
     Import.Memory.Flags = 0;
     Import.Memory.Initial = NumMemoryPages;
     writeImport(OS, Import);
   }
 
-  for (const Symbol *Sym : GlobalImports) {
+  for (const Symbol *Sym : ImportedGlobals) {
     WasmImport Import;
     Import.Module = "env";
     Import.Field = Sym->getName();
     Import.Kind = WASM_EXTERNAL_GLOBAL;
     Import.Global.Mutable = false;
     Import.Global.Type = WASM_TYPE_I32; // Sym->getGlobalType();
     writeImport(OS, Import);
   }
 }
 
 void Writer::createTypeSection() {
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_TYPE);
   raw_ostream &OS = Section->getStream();
   writeUleb128(OS, Types.size(), "type count");
   for (const WasmSignature *Sig : Types) {
     writeSig(OS, *Sig);
   }
 }
 
 void Writer::createFunctionSection() {
-  if (!NumFunctions)
+  if (DefinedFunctions.empty())
     return;
 
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_FUNCTION);
   raw_ostream &OS = Section->getStream();
 
-  writeUleb128(OS, NumFunctions, "function count");
-  for (ObjFile *File : Symtab->ObjectFiles) {
-    for (uint32_t Sig : File->getWasmObj()->functionTypes()) {
-      writeUleb128(OS, File->relocateTypeIndex(Sig), "sig index");
-    }
+  writeUleb128(OS, DefinedFunctions.size(), "function count");
+  for (const InputFunction *Func : DefinedFunctions) {
+    writeUleb128(OS, TypeIndices.lookup(Func->Signature), "sig index");
   }
 }
 
 void Writer::createMemorySection() {
   if (Config->ImportMemory)
     return;
 
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_MEMORY);
void Writer::createElemSection() {
   for (const Symbol *Sym : IndirectFunctions) {
     assert(Sym->getTableIndex() == TableIndex);
     writeUleb128(OS, Sym->getOutputIndex(), "function index");
     ++TableIndex;
   }
 }
 
 void Writer::createCodeSection() {
-  if (!NumFunctions)
+  if (DefinedFunctions.empty())
     return;
 
   log("createCodeSection");
 
-  auto Section = make<CodeSection>(NumFunctions, Symtab->ObjectFiles);
+  auto Section = make<CodeSection>(DefinedFunctions);
   OutputSections.push_back(Section);
 }
 
 void Writer::createDataSection() {
   if (!Segments.size())
     return;
 
   log("createDataSection");
void Writer::createSections() {
 
   for (OutputSection *S : OutputSections) {
     S->setOffset(FileSize);
     S->finalizeContents();
     FileSize += S->getSize();
   }
 }
 
-void Writer::calculateOffsets() {
-  for (ObjFile *File : Symtab->ObjectFiles) {
-    const WasmObjectFile *WasmFile = File->getWasmObj();
-
-    // Function Index
-    File->FunctionIndexOffset =
-        FunctionImports.size() - File->NumFunctionImports() + NumFunctions;
-    NumFunctions += WasmFile->functions().size();
-
-    // Memory
-    if (WasmFile->memories().size() > 1)
-      fatal(File->getName() + ": contains more than one memory");
-  }
-}
-
 void Writer::calculateImports() {
   for (Symbol *Sym : Symtab->getSymbols()) {
     if (!Sym->isUndefined() || Sym->isWeak())
       continue;
 
     if (Sym->isFunction()) {
-      Sym->setOutputIndex(FunctionImports.size());
-      FunctionImports.push_back(Sym);
+      Sym->setOutputIndex(ImportedFunctions.size());
+      ImportedFunctions.push_back(Sym);
     } else {
-      Sym->setOutputIndex(GlobalImports.size());
-      GlobalImports.push_back(Sym);
+      Sym->setOutputIndex(ImportedGlobals.size());
+      ImportedGlobals.push_back(Sym);
     }
   }
 }
 
 uint32_t Writer::getTypeIndex(const WasmSignature &Sig) {
   auto Pair = TypeIndices.insert(std::make_pair(Sig, Types.size()));
   if (Pair.second)
     Types.push_back(&Sig);
   return Pair.first->second;
 }
 
 void Writer::calculateTypes() {
   for (ObjFile *File : Symtab->ObjectFiles) {
     File->TypeMap.reserve(File->getWasmObj()->types().size());
     for (const WasmSignature &Sig : File->getWasmObj()->types())
       File->TypeMap.push_back(getTypeIndex(Sig));
   }
 }
 
-void Writer::assignSymbolIndexes() {
-  uint32_t GlobalIndex = GlobalImports.size();
+void Writer::assignIndexes() {
+  uint32_t GlobalIndex = ImportedGlobals.size();
+  uint32_t FunctionIndex = ImportedFunctions.size();
 
   if (Config->StackPointerSymbol) {
     DefinedGlobals.emplace_back(Config->StackPointerSymbol);
     Config->StackPointerSymbol->setOutputIndex(GlobalIndex++);
   }
 
   if (Config->EmitRelocs)
     DefinedGlobals.reserve(Symtab->getSymbols().size());
 
   uint32_t TableIndex = InitialTableOffset;
 
   for (ObjFile *File : Symtab->ObjectFiles) {
-    DEBUG(dbgs() << "assignSymbolIndexes: " << File->getName() << "\n");
+    DEBUG(dbgs() << "Globals: " << File->getName() << "\n");
 
     for (Symbol *Sym : File->getSymbols()) {
       // Assign indexes for symbols defined with this file.
       if (!Sym->isDefined() || File != Sym->getFile())
         continue;
-      if (Sym->isFunction()) {
-        auto *Obj = cast<ObjFile>(Sym->getFile());
-        Sym->setOutputIndex(Obj->FunctionIndexOffset +
-                            Sym->getFunctionIndex());
-      } else if (Config->EmitRelocs) {
-        DefinedGlobals.emplace_back(Sym);
-        Sym->setOutputIndex(GlobalIndex++);
-      }
+      if (Sym->isFunction() || !Config->EmitRelocs)
+        continue;
+
+
+    DEBUG(dbgs() << "Functions: " << File->getName() << "\n");
+    for (InputFunction *Func : File->Functions) {
+      DefinedFunctions.emplace_back(Func);
+      Func->setOutputIndex(FunctionIndex++);
     }
 
+    DEBUG(dbgs() << "Table Indexes: " << File->getName() << "\n");
     for (Symbol *Sym : File->getTableSymbols()) {
       if (!Sym->hasTableIndex()) {
         Sym->setTableIndex(TableIndex++);
         IndirectFunctions.emplace_back(Sym);
       }
     }
   }
 }

 void Writer::run() {
   if (!Config->Relocatable)
     InitialTableOffset = 1;
 
   log("-- calculateTypes");
   calculateTypes();
   log("-- calculateImports");
   calculateImports();
-  log("-- calculateOffsets");
-  calculateOffsets();
+  log("-- assignIndexes");
+  assignIndexes();
 
   if (errorHandler().Verbose) {
-    log("Defined Functions: " + Twine(NumFunctions));
+    log("Defined Functions: " + Twine(DefinedFunctions.size()));
     log("Defined Globals  : " + Twine(DefinedGlobals.size()));
-    log("Function Imports : " + Twine(FunctionImports.size()));
-    log("Global Imports   : " + Twine(GlobalImports.size()));
+    log("Function Imports : " + Twine(ImportedFunctions.size()));
+    log("Global Imports   : " + Twine(ImportedGlobals.size()));
     log("Total Imports    : " +
-        Twine(FunctionImports.size() + GlobalImports.size()));
+        Twine(ImportedFunctions.size() + ImportedGlobals.size()));
     for (ObjFile *File : Symtab->ObjectFiles)
       File->dumpInfo();
   }
 
-  log("-- assignSymbolIndexes");
-  assignSymbolIndexes();
   log("-- layoutMemory");
   layoutMemory();
 
   createHeader();
   log("-- createSections");
   createSections();
 
   log("-- openFile");