[WebAssembly] Rename function types to signatures

[aheejin]

Summary

Currently both of function signatures (WasmSignature objects) and
signature indices (unsigned ints) are often represented with variable
'FunctionTypes', which is confusing. I renamed some of them in D54096,
and this continues to rename other uses to signatures and signature
indices.

Should land with D54690.

[sbc100]

lgtm %nits

include/llvm/Object/Wasm.h

133–134

Its a little tricky because these corresponds exactly to the wasm "Types" section, which is how this terminology crept in. I suppose its ok for llvm to deviate from the wasm spec here.

134

Maybe just functionSignatures?

lib/MC/WasmObjectWriter.cpp

328

Looks like the return of these two is never uses, perhaps they should just return void.. not part of this CL though.

test/ObjectYAML/wasm/event_section.yaml

18

I think I prefer just "Signatures" or "FunctionSignatures"

tools/obj2yaml/wasm2yaml.cpp

165

Just "Signature" here since this could be an exception sig now right?

tools/yaml2obj/yaml2wasm.cpp

277

Hmm.. another place where diverging from the spec makes this is little less readable I think.

[dschuff]

lib/MC/WasmObjectWriter.cpp

234–235

One thing I started trying to do was remove WasmObjectWriter's version of WasmSignature (it now has a name that reflects what it is, which is good; but it's basically a duplicate of the one in BinaryFormat, which is bad). It's kind of annoying to find a good place to put it though, which is why I didn't finish.

[aheejin]

• Address comments

[aheejin]

So the main reason I started this is, we have signatures (WasmSignature objects), signature indices (uint32_t), and other custom types for other sections (GlobalType and EventType). And all these three are represented by variable names like 'Types' / '***Types`, and I wanted to use different variable and functions names for each of these to be more readable. But as you said, it's subtle because we can't change the name of 'Type Section', so ¯\_(ツ)_/¯

include/llvm/Object/Wasm.h

133–134

We also renamed it as Signatures here, which motivated me to rename these for the sake of consistency. We can change both (and possibly other places) back to types though.

134

Then we end up calling both WasmSignature objects and indices (uint32_t) as 'Signatures'. One of the main purpose of this patch is to distinguish them. If you think that makes things more confusing, I think I can drop this patch.

lib/MC/WasmObjectWriter.cpp

328

Done in D54734.

[dschuff]

include/llvm/Object/Wasm.h

134

In most parts of the compiler I think we want to be quite explicit about what kind of kind of type we are talking about because there are so many (e.g. MVT, wasm::ValueType, WasmSignature etc). Keeping those straight globally might be worth more than lining up exactly with the spec in the object file format. OTOH if this code is pretty well separated from e.g. MI (yes), and MC (maybe?) and every construct in here unambiguously lines up with something from the wasm object file format and not one of those other sets of abstractions, then we don't have to worry as much about that.

[aheejin]

include/llvm/Object/Wasm.h

134

I wanted to use the same terms with at least with MC, because they are the reader and writer for the same object file format. But anyway, if this direction does not look better, I can change the MC part to match this part to use 'type's.

[sbc100]

I general I think this is good change. I think there will always be point in the abstraction where we start prefering "spec" terms over "llvm" terms.

I certainly prefer the latest version WRT to the yaml output.

I'm ok with this change if @dschuff is

[aheejin]

• R_WEBASSEMBLY_TYPE_INDEX_LEB -> R_WEBASSEMBLY_SIGNATURE_INDEX_LEB

[aheejin]

In this comment, Rossberg said

Drive-by comment: the Wasm spec intentionally calls this type index, not signature index. The reason being that we expect additional forms of type definitions to appear in the type section in the future, see e.g. the GC proposal.

So I guess for the moment it's better to drop this CL to be cautious.

include/llvm/BinaryFormat/WasmRelocs.def

 #ifndef WASM_RELOC
 #error "WASM_RELOC must be defined"
 #endif
 
 WASM_RELOC(R_WEBASSEMBLY_FUNCTION_INDEX_LEB,   0)
 WASM_RELOC(R_WEBASSEMBLY_TABLE_INDEX_SLEB,     1)
 WASM_RELOC(R_WEBASSEMBLY_TABLE_INDEX_I32,      2)
 WASM_RELOC(R_WEBASSEMBLY_MEMORY_ADDR_LEB,      3)
 WASM_RELOC(R_WEBASSEMBLY_MEMORY_ADDR_SLEB,     4)
 WASM_RELOC(R_WEBASSEMBLY_MEMORY_ADDR_I32,      5)
-WASM_RELOC(R_WEBASSEMBLY_TYPE_INDEX_LEB,       6)
+WASM_RELOC(R_WEBASSEMBLY_SIGNATURE_INDEX_LEB,  6)
 WASM_RELOC(R_WEBASSEMBLY_GLOBAL_INDEX_LEB,     7)
 WASM_RELOC(R_WEBASSEMBLY_FUNCTION_OFFSET_I32,  8)
 WASM_RELOC(R_WEBASSEMBLY_SECTION_OFFSET_I32,   9)
 WASM_RELOC(R_WEBASSEMBLY_EVENT_INDEX_LEB,     10)

include/llvm/Object/RelocVisitor.h

uint64_t visitWasm(uint32_t Rel, RelocationRef R, uint64_t Value) {
     if (ObjToVisit.getArch() == Triple::wasm32) {
       switch (Rel) {
       case wasm::R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
       case wasm::R_WEBASSEMBLY_TABLE_INDEX_SLEB:
       case wasm::R_WEBASSEMBLY_TABLE_INDEX_I32:
       case wasm::R_WEBASSEMBLY_MEMORY_ADDR_LEB:
       case wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
       case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
-      case wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB:
+      case wasm::R_WEBASSEMBLY_SIGNATURE_INDEX_LEB:
       case wasm::R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
       case wasm::R_WEBASSEMBLY_FUNCTION_OFFSET_I32:
       case wasm::R_WEBASSEMBLY_SECTION_OFFSET_I32:
       case wasm::R_WEBASSEMBLY_EVENT_INDEX_LEB:
         // For wasm section, its offset at 0 -- ignoring Value
         return 0;
       }
     }

include/llvm/Object/Wasm.h

 #include <vector>
 
 namespace llvm {
 namespace object {
 
 class WasmSymbol {
 public:
   WasmSymbol(const wasm::WasmSymbolInfo &Info,
-             const wasm::WasmSignature *FunctionType,
+             const wasm::WasmSignature *FunctionSig,
              const wasm::WasmGlobalType *GlobalType,
              const wasm::WasmEventType *EventType)
-      : Info(Info), FunctionType(FunctionType), GlobalType(GlobalType),
+      : Info(Info), FunctionSig(FunctionSig), GlobalType(GlobalType),
         EventType(EventType) {}
 
   const wasm::WasmSymbolInfo &Info;
-  const wasm::WasmSignature *FunctionType;
+  const wasm::WasmSignature *FunctionSig;
   const wasm::WasmGlobalType *GlobalType;
   const wasm::WasmEventType *EventType;
 
   bool isTypeFunction() const {
     return Info.Kind == wasm::WASM_SYMBOL_TYPE_FUNCTION;
   }
 
   bool isTypeData() const { return Info.Kind == wasm::WASM_SYMBOL_TYPE_DATA; }
public:
   const WasmSymbol &getWasmSymbol(const DataRefImpl &Symb) const;
   const WasmSymbol &getWasmSymbol(const SymbolRef &Symbol) const;
   const WasmSection &getWasmSection(const SectionRef &Section) const;
   const wasm::WasmRelocation &getWasmRelocation(const RelocationRef &Ref) const;
 
   static bool classof(const Binary *v) { return v->isWasm(); }
 
   const wasm::WasmDylinkInfo &dylinkInfo() const { return DylinkInfo; }
-  ArrayRef<wasm::WasmSignature> types() const { return Signatures; }
-  ArrayRef<uint32_t> functionTypes() const { return FunctionTypes; }
+  ArrayRef<wasm::WasmSignature> signatures() const { return Signatures; }
+  ArrayRef<uint32_t> functionSigIndices() const { return FunctionSigIndices; }
   ArrayRef<wasm::WasmImport> imports() const { return Imports; }
   ArrayRef<wasm::WasmTable> tables() const { return Tables; }
   ArrayRef<wasm::WasmLimits> memories() const { return Memories; }
   ArrayRef<wasm::WasmGlobal> globals() const { return Globals; }
   ArrayRef<wasm::WasmEvent> events() const { return Events; }
   ArrayRef<wasm::WasmExport> exports() const { return Exports; }
   ArrayRef<WasmSymbol> syms() const { return Symbols; }
   const wasm::WasmLinkingData &linkingData() const { return LinkingData; }
private:
   Error parseLinkingSectionSymtab(ReadContext &Ctx);
   Error parseLinkingSectionComdat(ReadContext &Ctx);
   Error parseRelocSection(StringRef Name, ReadContext &Ctx);
 
   wasm::WasmObjectHeader Header;
   std::vector<WasmSection> Sections;
   wasm::WasmDylinkInfo DylinkInfo;
   std::vector<wasm::WasmSignature> Signatures;
-  std::vector<uint32_t> FunctionTypes;
+  std::vector<uint32_t> FunctionSigIndices;
   std::vector<wasm::WasmTable> Tables;
   std::vector<wasm::WasmLimits> Memories;
   std::vector<wasm::WasmGlobal> Globals;
   std::vector<wasm::WasmEvent> Events;
   std::vector<wasm::WasmImport> Imports;
   std::vector<wasm::WasmExport> Exports;
   std::vector<wasm::WasmElemSegment> ElemSegments;
   std::vector<WasmSegment> DataSegments;

include/llvm/ObjectYAML/WasmYAML.h

 
 struct FunctionSection : Section {
   FunctionSection() : Section(wasm::WASM_SEC_FUNCTION) {}
 
   static bool classof(const Section *S) {
     return S->Type == wasm::WASM_SEC_FUNCTION;
   }
 
-  std::vector<uint32_t> FunctionTypes;
+  std::vector<uint32_t> FunctionSigIndices;
 };
 
 struct TableSection : Section {
   TableSection() : Section(wasm::WASM_SEC_TABLE) {}
 
   static bool classof(const Section *S) {
     return S->Type == wasm::WASM_SEC_TABLE;
   }

lib/MC/WasmObjectWriter.cpp

class WasmObjectWriter : public MCObjectWriter {
   // Relocations for fixing up references in the code section.
   std::vector<WasmRelocationEntry> CodeRelocations;
   uint32_t CodeSectionIndex;
 
   // Relocations for fixing up references in the data section.
   std::vector<WasmRelocationEntry> DataRelocations;
   uint32_t DataSectionIndex;
 
-  // Index values to use for fixing up call_indirect type indices.
-  // Maps function symbols to the index of the type of the function
-  DenseMap<const MCSymbolWasm *, uint32_t> TypeIndices;
+  // Index values to use for fixing up call_indirect signature indices.
+  // Maps function symbols to the index of the signature of the function
+  DenseMap<const MCSymbolWasm *, uint32_t> SignatureIndices;
   // Maps function symbols to the table element index space. Used
   // for TABLE_INDEX relocation types (i.e. address taken functions).
   DenseMap<const MCSymbolWasm *, uint32_t> TableIndices;
   // Maps function/global symbols to the function/global/event/section index
   // space.
   DenseMap<const MCSymbolWasm *, uint32_t> WasmIndices;
   // Maps data symbols to the Wasm segment and offset/size with the segment.
   DenseMap<const MCSymbolWasm *, wasm::WasmDataReference> DataLocations;
 
   // Stores output data (index, relocations, content offset) for custom
   // section.
   std::vector<WasmCustomSection> CustomSections;
   // Relocations for fixing up references in the custom sections.
   DenseMap<const MCSectionWasm *, std::vector<WasmRelocationEntry>>
       CustomSectionsRelocations;
 
   // Map from section to defining function symbol.
   DenseMap<const MCSection *, const MCSymbol *> SectionFunctions;
 
-  DenseMap<WasmSignature, uint32_t, WasmSignatureDenseMapInfo> SignatureIndices;
+  DenseMap<WasmSignature, uint32_t, WasmSignatureDenseMapInfo>
+      SignatureIndexMap;
   SmallVector<WasmSignature, 4> Signatures;
   SmallVector<WasmGlobal, 4> Globals;
   SmallVector<WasmDataSegment, 4> DataSegments;
   unsigned NumFunctionImports = 0;
   unsigned NumGlobalImports = 0;
   unsigned NumEventImports = 0;
   uint32_t SectionCount = 0;
 
WasmObjectWriter(std::unique_ptr<MCWasmObjectTargetWriter> MOTW,
       : W(OS, support::little), TargetObjectWriter(std::move(MOTW)) {}
 
   ~WasmObjectWriter() override;
 
 private:
   void reset() override {
     CodeRelocations.clear();
     DataRelocations.clear();
-    TypeIndices.clear();
+    SignatureIndices.clear();
     WasmIndices.clear();
     TableIndices.clear();
     DataLocations.clear();
     CustomSectionsRelocations.clear();
-    SignatureIndices.clear();
+    SignatureIndexMap.clear();
     Signatures.clear();
     Globals.clear();
     DataSegments.clear();
     SectionFunctions.clear();
     NumFunctionImports = 0;
     NumGlobalImports = 0;
     MCObjectWriter::reset();
   }
private:
   updateCustomSectionRelocations(const SmallVector<WasmFunction, 4> &Functions,
                                  const MCAsmLayout &Layout);
 
   uint32_t getProvisionalValue(const WasmRelocationEntry &RelEntry);
   void applyRelocations(ArrayRef<WasmRelocationEntry> Relocations,
                         uint64_t ContentsOffset);
 
   uint32_t getRelocationIndexValue(const WasmRelocationEntry &RelEntry);
-  uint32_t getFunctionType(const MCSymbolWasm &Symbol);
-  uint32_t getEventType(const MCSymbolWasm &Symbol);
-  void registerFunctionType(const MCSymbolWasm &Symbol);
-  void registerEventType(const MCSymbolWasm &Symbol);
+  uint32_t getFunctionSigIndex(const MCSymbolWasm &Symbol);
+  uint32_t getEventSigIndex(const MCSymbolWasm &Symbol);
+  void registerFunctionSignature(const MCSymbolWasm &Symbol);
+  void registerEventSignature(const MCSymbolWasm &Symbol);
 };
 
 } // end anonymous namespace
 
 WasmObjectWriter::~WasmObjectWriter() {}
 
 // Write out a section header and a patchable section size field.
 void WasmObjectWriter::startSection(SectionBookkeeping &Section,
else
       SectionSymbol = SecA.getBeginSymbol();
     if (!SectionSymbol)
       report_fatal_error("section symbol is required for relocation");
 
     C += Layout.getSymbolOffset(*SymA);
     SymA = cast<MCSymbolWasm>(SectionSymbol);
   }
 
-  // Relocation other than R_WEBASSEMBLY_TYPE_INDEX_LEB are required to be
+  // Relocation other than R_WEBASSEMBLY_SIGNATURE_INDEX_LEB are required to be
   // against a named symbol.
-  if (Type != wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB) {
+  if (Type != wasm::R_WEBASSEMBLY_SIGNATURE_INDEX_LEB) {
     if (SymA->getName().empty())
       report_fatal_error("relocations against un-named temporaries are not yet "
                          "supported by wasm");
 
     SymA->setUsedInReloc();
   }
 
   WasmRelocationEntry Rec(FixupOffset, SymA, C, Type, &FixupSection);
WasmObjectWriter::getProvisionalValue(const WasmRelocationEntry &RelEntry) {
   switch (RelEntry.Type) {
   case wasm::R_WEBASSEMBLY_TABLE_INDEX_SLEB:
   case wasm::R_WEBASSEMBLY_TABLE_INDEX_I32: {
     // Provisional value is table address of the resolved symbol itself
     const MCSymbolWasm *Sym = ResolveSymbol(*RelEntry.Symbol);
     assert(Sym->isFunction());
     return TableIndices[Sym];
   }
-  case wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB:
+  case wasm::R_WEBASSEMBLY_SIGNATURE_INDEX_LEB:
     // Provisional value is same as the index
     return getRelocationIndexValue(RelEntry);
   case wasm::R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
   case wasm::R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
   case wasm::R_WEBASSEMBLY_EVENT_INDEX_LEB:
     // Provisional value is function/global/event Wasm index
     if (!WasmIndices.count(RelEntry.Symbol))
       report_fatal_error("symbol not found in wasm index space: " +
for (const MCFragment &Frag : DataSection) {
     }
   }
 
   LLVM_DEBUG(dbgs() << "addData -> " << DataBytes.size() << "\n");
 }
 
 uint32_t
 WasmObjectWriter::getRelocationIndexValue(const WasmRelocationEntry &RelEntry) {
-  if (RelEntry.Type == wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB) {
-    if (!TypeIndices.count(RelEntry.Symbol))
+  if (RelEntry.Type == wasm::R_WEBASSEMBLY_SIGNATURE_INDEX_LEB) {
+    if (!SignatureIndices.count(RelEntry.Symbol))
       report_fatal_error("symbol not found in type index space: " +
                          RelEntry.Symbol->getName());
-    return TypeIndices[RelEntry.Symbol];
+    return SignatureIndices[RelEntry.Symbol];
   }
 
   return RelEntry.Symbol->getIndex();
 }
 
 // Apply the portions of the relocation records that we can handle ourselves
 // directly.
 void WasmObjectWriter::applyRelocations(
     ArrayRef<WasmRelocationEntry> Relocations, uint64_t ContentsOffset) {
   auto &Stream = static_cast<raw_pwrite_stream &>(W.OS);
   for (const WasmRelocationEntry &RelEntry : Relocations) {
     uint64_t Offset = ContentsOffset +
                       RelEntry.FixupSection->getSectionOffset() +
                       RelEntry.Offset;
 
     LLVM_DEBUG(dbgs() << "applyRelocation: " << RelEntry << "\n");
     uint32_t Value = getProvisionalValue(RelEntry);
 
     switch (RelEntry.Type) {
     case wasm::R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
-    case wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB:
+    case wasm::R_WEBASSEMBLY_SIGNATURE_INDEX_LEB:
     case wasm::R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
     case wasm::R_WEBASSEMBLY_MEMORY_ADDR_LEB:
     case wasm::R_WEBASSEMBLY_EVENT_INDEX_LEB:
       WritePatchableLEB(Stream, Value, Offset);
       break;
     case wasm::R_WEBASSEMBLY_TABLE_INDEX_I32:
     case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
     case wasm::R_WEBASSEMBLY_FUNCTION_OFFSET_I32:
for (auto &CustomSection : CustomSections) {
     endSection(Section);
 
     // Apply fixups.
     auto &Relocations = CustomSectionsRelocations[CustomSection.Section];
     applyRelocations(Relocations, CustomSection.OutputContentsOffset);
   }
 }
 
-uint32_t WasmObjectWriter::getFunctionType(const MCSymbolWasm &Symbol) {
+uint32_t WasmObjectWriter::getFunctionSigIndex(const MCSymbolWasm &Symbol) {
   assert(Symbol.isFunction());
-  assert(TypeIndices.count(&Symbol));
-  return TypeIndices[&Symbol];
+  assert(SignatureIndices.count(&Symbol));
+  return SignatureIndices[&Symbol];
 }
 
-uint32_t WasmObjectWriter::getEventType(const MCSymbolWasm &Symbol) {
+uint32_t WasmObjectWriter::getEventSigIndex(const MCSymbolWasm &Symbol) {
   assert(Symbol.isEvent());
-  assert(TypeIndices.count(&Symbol));
-  return TypeIndices[&Symbol];
+  assert(SignatureIndices.count(&Symbol));
+  return SignatureIndices[&Symbol];
 }
 
-void WasmObjectWriter::registerFunctionType(const MCSymbolWasm &Symbol) {
+void WasmObjectWriter::registerFunctionSignature(const MCSymbolWasm &Symbol) {
   assert(Symbol.isFunction());
 
   WasmSignature S;
   const MCSymbolWasm *ResolvedSym = ResolveSymbol(Symbol);
   if (auto *Sig = ResolvedSym->getSignature()) {
     S.Returns = Sig->Returns;
     S.Params = Sig->Params;
   }
 
-  auto Pair = SignatureIndices.insert(std::make_pair(S, Signatures.size()));
+  auto Pair = SignatureIndexMap.insert(std::make_pair(S, Signatures.size()));
   if (Pair.second)
     Signatures.push_back(S);
-  TypeIndices[&Symbol] = Pair.first->second;
+  SignatureIndices[&Symbol] = Pair.first->second;
 
-  LLVM_DEBUG(dbgs() << "registerFunctionType: " << Symbol
+  LLVM_DEBUG(dbgs() << "registerFunctionSignature: " << Symbol
                     << " new:" << Pair.second << "\n");
   LLVM_DEBUG(dbgs() << "  -> type index: " << Pair.first->second << "\n");
 }
 
-void WasmObjectWriter::registerEventType(const MCSymbolWasm &Symbol) {
+void WasmObjectWriter::registerEventSignature(const MCSymbolWasm &Symbol) {
   assert(Symbol.isEvent());
 
   // TODO Currently we don't generate imported exceptions, but if we do, we
   // should have a way of infering types of imported exceptions.
   WasmSignature S;
   if (auto *Sig = Symbol.getSignature()) {
     S.Returns = Sig->Returns;
     S.Params = Sig->Params;
   }
 
-  auto Pair = SignatureIndices.insert(std::make_pair(S, Signatures.size()));
+  auto Pair = SignatureIndexMap.insert(std::make_pair(S, Signatures.size()));
   if (Pair.second)
     Signatures.push_back(S);
-  TypeIndices[&Symbol] = Pair.first->second;
+  SignatureIndices[&Symbol] = Pair.first->second;
 
-  LLVM_DEBUG(dbgs() << "registerEventType: " << Symbol << " new:" << Pair.second
-                    << "\n");
+  LLVM_DEBUG(dbgs() << "registerEventSignature: " << Symbol
+                    << " new:" << Pair.second << "\n");
   LLVM_DEBUG(dbgs() << "  -> type index: " << Pair.first->second << "\n");
 }
 
 static bool isInSymtab(const MCSymbolWasm &Sym) {
   if (Sym.isUsedInReloc())
     return true;
 
   if (Sym.isComdat() && !Sym.isDefined())
MCSymbolWasm *TableSym =
       cast<MCSymbolWasm>(Ctx.getOrCreateSymbol("__indirect_function_table"));
   wasm::WasmImport TableImport;
   TableImport.Module = TableSym->getModuleName();
   TableImport.Field = TableSym->getName();
   TableImport.Kind = wasm::WASM_EXTERNAL_TABLE;
   TableImport.Table.ElemType = wasm::WASM_TYPE_ANYFUNC;
   Imports.push_back(TableImport);
 
-  // Populate SignatureIndices, and Imports and WasmIndices for undefined
+  // Populate SignatureIndexMap, and Imports and WasmIndices for undefined
   // symbols.  This must be done before populating WasmIndices for defined
   // symbols.
   for (const MCSymbol &S : Asm.symbols()) {
     const auto &WS = static_cast<const MCSymbolWasm &>(S);
 
     // Register types for all functions, including those with private linkage
     // (because wasm always needs a type signature).
     if (WS.isFunction())
-      registerFunctionType(WS);
+      registerFunctionSignature(WS);
 
     if (WS.isEvent())
-      registerEventType(WS);
+      registerEventSignature(WS);
 
     if (WS.isTemporary())
       continue;
 
     // If the symbol is not defined in this translation unit, import it.
     if (!WS.isDefined() && !WS.isComdat()) {
       if (WS.isFunction()) {
         wasm::WasmImport Import;
         Import.Module = WS.getModuleName();
         Import.Field = WS.getName();
         Import.Kind = wasm::WASM_EXTERNAL_FUNCTION;
-        Import.SigIndex = getFunctionType(WS);
+        Import.SigIndex = getFunctionSigIndex(WS);
         Imports.push_back(Import);
         WasmIndices[&WS] = NumFunctionImports++;
       } else if (WS.isGlobal()) {
         if (WS.isWeak())
           report_fatal_error("undefined global symbol cannot be weak");
 
         wasm::WasmImport Import;
         Import.Module = WS.getModuleName();
         Import.Field = WS.getName();
         Import.Kind = wasm::WASM_EXTERNAL_GLOBAL;
         Import.Global = WS.getGlobalType();
         Imports.push_back(Import);
         WasmIndices[&WS] = NumGlobalImports++;
       } else if (WS.isEvent()) {
         if (WS.isWeak())
           report_fatal_error("undefined event symbol cannot be weak");
 
         wasm::WasmImport Import;
         Import.Module = WS.getModuleName();
         Import.Field = WS.getName();
         Import.Kind = wasm::WASM_EXTERNAL_EVENT;
         Import.Event.Attribute = wasm::WASM_EVENT_ATTRIBUTE_EXCEPTION;
-        Import.Event.SigIndex = getEventType(WS);
+        Import.Event.SigIndex = getEventSigIndex(WS);
         Imports.push_back(Import);
         WasmIndices[&WS] = NumEventImports++;
       }
     }
   }
 
   // Populate DataSegments and CustomSections, which must be done before
   // populating DataLocations.
if (WS.isFunction()) {
 
         if (WS.getSize() == 0)
           report_fatal_error(
               "function symbols must have a size set with .size");
 
         // A definition. Write out the function body.
         Index = NumFunctionImports + Functions.size();
         WasmFunction Func;
-        Func.SigIndex = getFunctionType(WS);
+        Func.SigIndex = getFunctionSigIndex(WS);
         Func.Sym = &WS;
         WasmIndices[&WS] = Index;
         Functions.push_back(Func);
 
         auto &Section = static_cast<MCSectionWasm &>(WS.getSection());
         if (const MCSymbolWasm *C = Section.getGroup()) {
           Comdats[C->getName()].emplace_back(
               WasmComdatEntry{wasm::WASM_COMDAT_FUNCTION, Index});
if (WS.isFunction()) {
                         << WasmIndices.find(&WS)->second << "\n");
 
     } else if (WS.isEvent()) {
       // C++ exception symbol (__cpp_exception)
       unsigned Index;
       if (WS.isDefined()) {
         Index = NumEventImports + Events.size();
         wasm::WasmEventType Event;
-        Event.SigIndex = getEventType(WS);
+        Event.SigIndex = getEventSigIndex(WS);
         Event.Attribute = wasm::WASM_EVENT_ATTRIBUTE_EXCEPTION;
         WasmIndices[&WS] = Index;
         Events.push_back(Event);
       } else {
         // An import; the index was assigned above.
         Index = WasmIndices.find(&WS)->second;
       }
       LLVM_DEBUG(dbgs() << "  -> event index: " << WasmIndices.find(&WS)->second
auto HandleReloc = [&](const WasmRelocationEntry &Rel) {
       assert(Rel.Symbol->isFunction());
       const MCSymbolWasm &WS = *ResolveSymbol(*Rel.Symbol);
       uint32_t FunctionIndex = WasmIndices.find(&WS)->second;
       uint32_t TableIndex = TableElems.size() + kInitialTableOffset;
       if (TableIndices.try_emplace(&WS, TableIndex).second) {
         LLVM_DEBUG(dbgs() << "  -> adding " << WS.getName()
                           << " to table: " << TableIndex << "\n");
         TableElems.push_back(FunctionIndex);
-        registerFunctionType(WS);
+        registerFunctionSignature(WS);
       }
     };
 
     for (const WasmRelocationEntry &RelEntry : CodeRelocations)
       HandleReloc(RelEntry);
     for (const WasmRelocationEntry &RelEntry : DataRelocations)
       HandleReloc(RelEntry);
   }

lib/Object/WasmObjectFile.cpp

Error WasmObjectFile::parseDylinkSection(ReadContext &Ctx) {
   if (Ctx.Ptr != Ctx.End)
     return make_error<GenericBinaryError>("dylink section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseNameSection(ReadContext &Ctx) {
   llvm::DenseSet<uint64_t> Seen;
-  if (Functions.size() != FunctionTypes.size()) {
+  if (Functions.size() != FunctionSigIndices.size()) {
     return make_error<GenericBinaryError>("Names must come after code section",
                                           object_error::parse_failed);
   }
 
   while (Ctx.Ptr < Ctx.End) {
     uint8_t Type = readUint8(Ctx);
     uint32_t Size = readVaruint32(Ctx);
     const uint8_t *SubSectionEnd = Ctx.Ptr + Size;
Error WasmObjectFile::parseNameSection(ReadContext &Ctx) {
   if (Ctx.Ptr != Ctx.End)
     return make_error<GenericBinaryError>("Name section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseLinkingSection(ReadContext &Ctx) {
   HasLinkingSection = true;
-  if (Functions.size() != FunctionTypes.size()) {
+  if (Functions.size() != FunctionSigIndices.size()) {
     return make_error<GenericBinaryError>(
         "Linking data must come after code section",
         object_error::parse_failed);
   }
 
   LinkingData.Version = readVaruint32(Ctx);
   if (LinkingData.Version != wasm::WasmMetadataVersion) {
     return make_error<GenericBinaryError>(
for (auto &I : Imports) {
     else if (I.Kind == wasm::WASM_EXTERNAL_GLOBAL)
       ImportedGlobals.emplace_back(&I);
     else if (I.Kind == wasm::WASM_EXTERNAL_EVENT)
       ImportedEvents.emplace_back(&I);
   }
 
   while (Count--) {
     wasm::WasmSymbolInfo Info;
-    const wasm::WasmSignature *FunctionType = nullptr;
+    const wasm::WasmSignature *FunctionSig = nullptr;
     const wasm::WasmGlobalType *GlobalType = nullptr;
     const wasm::WasmEventType *EventType = nullptr;
 
     Info.Kind = readUint8(Ctx);
     Info.Flags = readVaruint32(Ctx);
     bool IsDefined = (Info.Flags & wasm::WASM_SYMBOL_UNDEFINED) == 0;
 
     switch (Info.Kind) {
     case wasm::WASM_SYMBOL_TYPE_FUNCTION:
       Info.ElementIndex = readVaruint32(Ctx);
       if (!isValidFunctionIndex(Info.ElementIndex) ||
           IsDefined != isDefinedFunctionIndex(Info.ElementIndex))
         return make_error<GenericBinaryError>("invalid function symbol index",
                                               object_error::parse_failed);
       if (IsDefined) {
         Info.Name = readString(Ctx);
         unsigned FuncIndex = Info.ElementIndex - NumImportedFunctions;
-        FunctionType = &Signatures[FunctionTypes[FuncIndex]];
+        FunctionSig = &Signatures[FunctionSigIndices[FuncIndex]];
         wasm::WasmFunction &Function = Functions[FuncIndex];
         if (Function.SymbolName.empty())
           Function.SymbolName = Info.Name;
       } else {
         wasm::WasmImport &Import = *ImportedFunctions[Info.ElementIndex];
-        FunctionType = &Signatures[Import.SigIndex];
+        FunctionSig = &Signatures[Import.SigIndex];
         Info.Name = Import.Field;
         Info.Module = Import.Module;
       }
       break;
 
     case wasm::WASM_SYMBOL_TYPE_GLOBAL:
       Info.ElementIndex = readVaruint32(Ctx);
       if (!isValidGlobalIndex(Info.ElementIndex) ||
while (Count--) {
 
     if ((Info.Flags & wasm::WASM_SYMBOL_BINDING_MASK) !=
             wasm::WASM_SYMBOL_BINDING_LOCAL &&
         !SymbolNames.insert(Info.Name).second)
       return make_error<GenericBinaryError>("Duplicate symbol name " +
                                                 Twine(Info.Name),
                                             object_error::parse_failed);
     LinkingData.SymbolTable.emplace_back(Info);
-    Symbols.emplace_back(LinkingData.SymbolTable.back(), FunctionType,
+    Symbols.emplace_back(LinkingData.SymbolTable.back(), FunctionSig,
                          GlobalType, EventType);
     LLVM_DEBUG(dbgs() << "Adding symbol: " << Symbols.back() << "\n");
   }
 
   return Error::success();
 }
 
 Error WasmObjectFile::parseLinkingSectionComdat(ReadContext &Ctx) {
while (RelocCount--) {
     switch (Reloc.Type) {
     case wasm::R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
     case wasm::R_WEBASSEMBLY_TABLE_INDEX_SLEB:
     case wasm::R_WEBASSEMBLY_TABLE_INDEX_I32:
       if (!isValidFunctionSymbol(Reloc.Index))
         return make_error<GenericBinaryError>("Bad relocation function index",
                                               object_error::parse_failed);
       break;
-    case wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB:
+    case wasm::R_WEBASSEMBLY_SIGNATURE_INDEX_LEB:
       if (Reloc.Index >= Signatures.size())
         return make_error<GenericBinaryError>("Bad relocation type index",
                                               object_error::parse_failed);
       break;
     case wasm::R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
       if (!isValidGlobalSymbol(Reloc.Index))
         return make_error<GenericBinaryError>("Bad relocation global index",
                                               object_error::parse_failed);
Error WasmObjectFile::parseImportSection(ReadContext &Ctx) {
   if (Ctx.Ptr != Ctx.End)
     return make_error<GenericBinaryError>("Import section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseFunctionSection(ReadContext &Ctx) {
   uint32_t Count = readVaruint32(Ctx);
-  FunctionTypes.reserve(Count);
-  uint32_t NumTypes = Signatures.size();
+  FunctionSigIndices.reserve(Count);
+  uint32_t NumSigs = Signatures.size();
   while (Count--) {
-    uint32_t Type = readVaruint32(Ctx);
-    if (Type >= NumTypes)
+    uint32_t SigIndex = readVaruint32(Ctx);
+    if (SigIndex >= NumSigs)
       return make_error<GenericBinaryError>("Invalid function type",
                                             object_error::parse_failed);
-    FunctionTypes.push_back(Type);
+    FunctionSigIndices.push_back(SigIndex);
   }
   if (Ctx.Ptr != Ctx.End)
     return make_error<GenericBinaryError>("Function section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseTableSection(ReadContext &Ctx) {
Error WasmObjectFile::parseExportSection(ReadContext &Ctx) {
   }
   if (Ctx.Ptr != Ctx.End)
     return make_error<GenericBinaryError>("Export section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 bool WasmObjectFile::isValidFunctionIndex(uint32_t Index) const {
-  return Index < NumImportedFunctions + FunctionTypes.size();
+  return Index < NumImportedFunctions + FunctionSigIndices.size();
 }
 
 bool WasmObjectFile::isDefinedFunctionIndex(uint32_t Index) const {
   return Index >= NumImportedFunctions && isValidFunctionIndex(Index);
 }
 
 bool WasmObjectFile::isValidGlobalIndex(uint32_t Index) const {
   return Index < NumImportedGlobals + Globals.size();
if (!isValidFunctionIndex(StartFunction))
     return make_error<GenericBinaryError>("Invalid start function",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseCodeSection(ReadContext &Ctx) {
   CodeSection = Sections.size();
   uint32_t FunctionCount = readVaruint32(Ctx);
-  if (FunctionCount != FunctionTypes.size()) {
+  if (FunctionCount != FunctionSigIndices.size()) {
     return make_error<GenericBinaryError>("Invalid function count",
                                           object_error::parse_failed);
   }
 
   while (FunctionCount--) {
     wasm::WasmFunction Function;
     const uint8_t *FunctionStart = Ctx.Ptr;
     uint32_t Size = readVaruint32(Ctx);

 
 uint64_t WasmObjectFile::getRelocationOffset(DataRefImpl Ref) const {
   const wasm::WasmRelocation &Rel = getWasmRelocation(Ref);
   return Rel.Offset;
 }
 
 symbol_iterator WasmObjectFile::getRelocationSymbol(DataRefImpl Ref) const {
   const wasm::WasmRelocation &Rel = getWasmRelocation(Ref);
-  if (Rel.Type == wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB)
+  if (Rel.Type == wasm::R_WEBASSEMBLY_SIGNATURE_INDEX_LEB)
     return symbol_end();
   DataRefImpl Sym;
   Sym.d.a = Rel.Index;
   Sym.d.b = 0;
   return symbol_iterator(SymbolRef(Sym, this));
 }
 
 uint64_t WasmObjectFile::getRelocationType(DataRefImpl Ref) const {

lib/ObjectYAML/WasmYAML.cpp

 
 static void sectionMapping(IO &IO, WasmYAML::ImportSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Imports", Section.Imports);
 }
 
 static void sectionMapping(IO &IO, WasmYAML::FunctionSection &Section) {
   commonSectionMapping(IO, Section);
-  IO.mapOptional("FunctionTypes", Section.FunctionTypes);
+  IO.mapOptional("FunctionSignatures", Section.FunctionSigIndices);
 }
 
 static void sectionMapping(IO &IO, WasmYAML::TableSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Tables", Section.Tables);
 }
 
 static void sectionMapping(IO &IO, WasmYAML::MemorySection &Section) {

lib/Target/WebAssembly/MCTargetDesc/WebAssemblyWasmObjectWriter.cpp

if (IsFunction)
       return wasm::R_WEBASSEMBLY_TABLE_INDEX_SLEB;
     return wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB;
   case WebAssembly::fixup_code_sleb128_i64:
     llvm_unreachable("fixup_sleb128_i64 not implemented yet");
   case WebAssembly::fixup_code_uleb128_i32:
     if (IsGlobalType(Target))
       return wasm::R_WEBASSEMBLY_GLOBAL_INDEX_LEB;
     if (IsFunctionType(Target))
-      return wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB;
+      return wasm::R_WEBASSEMBLY_SIGNATURE_INDEX_LEB;
     if (IsFunction)
       return wasm::R_WEBASSEMBLY_FUNCTION_INDEX_LEB;
     if (IsEventType(Target))
       return wasm::R_WEBASSEMBLY_EVENT_INDEX_LEB;
     return wasm::R_WEBASSEMBLY_MEMORY_ADDR_LEB;
   case FK_Data_4:
     if (IsFunction)
       return wasm::R_WEBASSEMBLY_TABLE_INDEX_I32;

test/MC/WebAssembly/comdat.ll

 ; CHECK-NEXT:           ElemType:        ANYFUNC
 ; CHECK-NEXT:           Limits:          
 ; CHECK-NEXT:             Initial:         0x00000000
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           funcImport
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         SigIndex:        0
 ; CHECK-NEXT:   - Type:            FUNCTION
-; CHECK-NEXT:     FunctionTypes:   [ 0, 0, 0 ]
+; CHECK-NEXT:     FunctionSignatures:   [ 0, 0, 0 ]
 ; CHECK-NEXT:  - Type:            CODE
 ; CHECK-NEXT:    Relocations:
 ; CHECK-NEXT:      - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
 ; CHECK-NEXT:        Index:           1
 ; CHECK-NEXT:        Offset:          0x00000004
 ; CHECK-NEXT:    Functions:
 ; CHECK-NEXT:      - Index:           1
 ; CHECK-NEXT:        Locals:

test/MC/WebAssembly/global-ctor-dtor.ll

 ; CHECK-NEXT:         Field:           func1
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         SigIndex:        1
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           func0
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         SigIndex:        1
 ; CHECK-NEXT:   - Type:            FUNCTION
-; CHECK-NEXT:     FunctionTypes:   [ 0, 1, 0, 1 ]
+; CHECK-NEXT:     FunctionSignatures:   [ 0, 1, 0, 1 ]
 ; CHECK-NEXT:   - Type:            ELEM
 ; CHECK-NEXT:     Segments:        
 ; CHECK-NEXT:       - Offset:          
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1
 ; CHECK-NEXT:         Functions:       [ 5, 7 ]
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Relocations:     

test/MC/WebAssembly/reloc-code.ll

 ; CHECK-NEXT:     }
 ; CHECK-NEXT:     Relocation {
 ; CHECK-NEXT:       Type: R_WEBASSEMBLY_MEMORY_ADDR_LEB (3)
 ; CHECK-NEXT:       Offset: 0x14
 ; CHECK-NEXT:       Symbol: a
 ; CHECK-NEXT:       Addend: 0
 ; CHECK-NEXT:     }
 ; CHECK-NEXT:     Relocation {
-; CHECK-NEXT:       Type: R_WEBASSEMBLY_TYPE_INDEX_LEB (6)
+; CHECK-NEXT:       Type: R_WEBASSEMBLY_SIGNATURE_INDEX_LEB (6)
 ; CHECK-NEXT:       Offset: 0x1A
 ; CHECK-NEXT:       Index: 0x1
 ; CHECK-NEXT:     }
 ; CHECK-NEXT:     Relocation {
-; CHECK-NEXT:       Type: R_WEBASSEMBLY_TYPE_INDEX_LEB (6)
+; CHECK-NEXT:       Type: R_WEBASSEMBLY_SIGNATURE_INDEX_LEB (6)
 ; CHECK-NEXT:       Offset: 0x24
 ; CHECK-NEXT:       Index: 0x0
 ; CHECK-NEXT:     }
 ; CHECK-NEXT:     Relocation {
 ; CHECK-NEXT:       Type: R_WEBASSEMBLY_FUNCTION_INDEX_LEB (0)
 ; CHECK-NEXT:       Offset: 0x2D
 ; CHECK-NEXT:       Symbol: c
 ; CHECK-NEXT:     }
 ; CHECK-NEXT:     Relocation {
 ; CHECK-NEXT:       Type: R_WEBASSEMBLY_FUNCTION_INDEX_LEB (0)
 ; CHECK-NEXT:       Offset: 0x34
 ; CHECK-NEXT:       Symbol: d
 ; CHECK-NEXT:     }
 ; CHECK-NEXT:   }
 ; CHECK-NEXT: ]

test/MC/WebAssembly/weak-alias.ll

 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           __indirect_function_table
 ; CHECK-NEXT:         Kind:            TABLE
 ; CHECK-NEXT:         Table:
 ; CHECK-NEXT:           ElemType:        ANYFUNC
 ; CHECK-NEXT:           Limits:
 ; CHECK-NEXT:             Initial:         0x00000001
 ; CHECK-NEXT:   - Type:            FUNCTION
-; CHECK-NEXT:     FunctionTypes:   [ 0, 0, 0, 0, 0 ]
+; CHECK-NEXT:     FunctionSignatures:   [ 0, 0, 0, 0, 0 ]
 ; CHECK-NEXT:   - Type:            ELEM
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1
 ; CHECK-NEXT:         Functions:       [ 0 ]
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Relocations:
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
 ; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:         Offset:          0x00000009
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
 ; CHECK-NEXT:         Index:           3
 ; CHECK-NEXT:         Offset:          0x00000012
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
 ; CHECK-NEXT:         Index:           5
 ; CHECK-NEXT:         Offset:          0x0000001E
-; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_TYPE_INDEX_LEB
+; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_SIGNATURE_INDEX_LEB
 ; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:         Offset:          0x00000024
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
 ; CHECK-NEXT:         Index:           7
 ; CHECK-NEXT:         Offset:          0x00000031
-; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_TYPE_INDEX_LEB
+; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_SIGNATURE_INDEX_LEB
 ; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:         Offset:          0x00000037
 ; CHECK-NEXT:     Functions:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            41000B
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Locals:

test/ObjectYAML/wasm/code_section.yaml

Signatures:
         ParamTypes:
           - I32
       - Index:           1
         ReturnType:      NORESULT
         ParamTypes:
           - I32
           - I64
   - Type:            FUNCTION
-    FunctionTypes:
+    FunctionSignatures:
       - 0
       - 1
   - Type:            CODE
     Relocations:
       - Type:            R_WEBASSEMBLY_TABLE_INDEX_SLEB
         Index:           0
         Offset:          0x00000006
       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB

test/ObjectYAML/wasm/event_section.yaml

Signatures:
         ReturnType:      I32
         ParamTypes:
           - I32
       - Index:           1
         ReturnType:      NORESULT
         ParamTypes:
           - I32
   - Type:            FUNCTION
-    FunctionTypes:   [ 0 ]
+    FunctionSignatures:   [ 0 ]
   - Type:            EVENT
     Events:
       - Index:           0
         Attribute:       0
         SigIndex:        1
   - Type:            CODE
     Relocations:
       - Type:            R_WEBASSEMBLY_EVENT_INDEX_LEB

 # CHECK-NEXT:         ReturnType:      I32
 # CHECK-NEXT:         ParamTypes:
 # CHECK-NEXT:           - I32
 # CHECK-NEXT:       - Index:           1
 # CHECK-NEXT:         ReturnType:      NORESULT
 # CHECK-NEXT:         ParamTypes:
 # CHECK-NEXT:           - I32
 # CHECK-NEXT:   - Type:            FUNCTION
-# CHECK-NEXT:     FunctionTypes:   [ 0 ]
+# CHECK-NEXT:     FunctionSignatures:   [ 0 ]
 # CHECK-NEXT:   - Type:            EVENT
 # CHECK-NEXT:     Events:
 # CHECK-NEXT:       - Index:           0
 # CHECK-NEXT:         Attribute:       0
 # CHECK-NEXT:         SigIndex:        1
 # CHECK-NEXT:   - Type:            CODE
 # CHECK-NEXT:     Relocations:
 # CHECK-NEXT:       - Type:            R_WEBASSEMBLY_EVENT_INDEX_LEB

test/ObjectYAML/wasm/export_section.yaml

 # RUN: yaml2obj %s | obj2yaml | FileCheck %s
 --- !WASM
 FileHeader:
   Version:         0x00000001
 Sections:
   - Type:            TYPE
     Signatures:
       - Index:           0
         ReturnType:      NORESULT
         ParamTypes:
   - Type:            FUNCTION
-    FunctionTypes: [ 0, 0 ]
+    FunctionSignatures: [ 0, 0 ]
   - Type:            GLOBAL
     Globals:
       - Index:       0
         Type:        I32
         Mutable:     false
         InitExpr:
           Opcode:          I64_CONST
           Value:           32

test/ObjectYAML/wasm/function_section.yaml

 # RUN: yaml2obj %s | obj2yaml | FileCheck %s
 --- !WASM
 FileHeader:
   Version:         0x00000001
 Sections:
   - Type:            TYPE
     Signatures:
       - Index:           0
         ReturnType:      NORESULT
         ParamTypes:
       - Index:           1
         ReturnType:      NORESULT
         ParamTypes:
           - I32
   - Type:            FUNCTION
-    FunctionTypes: [ 1, 0 ]
+    FunctionSignatures: [ 1, 0 ]
   - Type:            CODE
     Functions:
       - Index:           0
         Locals:
         Body:            0B
       - Index:           1
         Locals:
         Body:            0B
 ...
 # CHECK: --- !WASM
 # CHECK: FileHeader:
 # CHECK:   Version:           0x00000001
 # CHECK: Sections:
 # CHECK:   - Type:            FUNCTION
-# CHECK:     FunctionTypes: [ 1, 0 ]
+# CHECK:     FunctionSignatures: [ 1, 0 ]
 # CHECK: ...

test/ObjectYAML/wasm/start_section.yaml

 # RUN: yaml2obj %s | obj2yaml | FileCheck %s
 
 --- !WASM
 FileHeader:
   Version:         0x00000001
 Sections:
   - Type:            TYPE
     Signatures:
       - Index:           0
         ReturnType:      NORESULT
         ParamTypes:
   - Type:            FUNCTION
-    FunctionTypes: [ 0, 0, 0 ]
+    FunctionSignatures: [ 0, 0, 0 ]
   - Type:            START
     StartFunction:   1
   - Type:            CODE
     Functions:
       - Index:           0
         Locals:
         Body:            0B
       - Index:           1

test/ObjectYAML/wasm/weak_symbols.yaml

 # RUN: yaml2obj %s | obj2yaml | FileCheck %s
 --- !WASM
 FileHeader:
   Version:         0x00000001
 Sections:
   - Type:            TYPE
     Signatures:
       - Index:           0
         ReturnType:      I32
         ParamTypes:
   - Type:            FUNCTION
-    FunctionTypes:   [ 0, 0 ]
+    FunctionSignatures:   [ 0, 0 ]
   - Type:            GLOBAL
     Globals:         
       - Index:       0
         Type:        I32
         Mutable:     false
         InitExpr:
           Opcode:          I32_CONST
           Value:           1

test/tools/llvm-nm/wasm/exports.yaml

 # RUN: yaml2obj < %s | llvm-nm - | FileCheck -strict-whitespace %s
 
 # Check that wasm exports of functions/globals/data are displayed correctly
 
 --- !WASM
 FileHeader:
   Version:         0x00000001
 Sections:
   - Type:            TYPE
     Signatures:
       - Index:           0
         ReturnType:      I32
         ParamTypes:
           - I32
   - Type:            FUNCTION
-    FunctionTypes: [ 0 ]
+    FunctionSignatures: [ 0 ]
   - Type:            GLOBAL
     Globals:
       - Index:       0
         Type:        I32
         Mutable:     false
         InitExpr:
           Opcode:          I64_CONST
           Value:           32

test/tools/llvm-nm/wasm/weak-symbols.yaml

Signatures:
           - I32
   - Type:            IMPORT
     Imports:
       - Module:          env
         Field:           weak_import_func
         Kind:            FUNCTION
         SigIndex:        0
   - Type:            FUNCTION
-    FunctionTypes: [ 0 ]
+    FunctionSignatures: [ 0 ]
   - Type:            GLOBAL
     Globals:
       - Index:       0
         Type:        I32
         Mutable:     false
         InitExpr:
           Opcode:          I64_CONST
           Value:           32

test/tools/llvm-objdump/WebAssembly/relocations.test

 ; RUN: llc -mtriple=wasm32-unknown-unknown -filetype=obj %s -o - | llvm-objdump -r - | FileCheck %s
 
 @foo = external global i32, align 4
 @bar = global i32* @foo, align 4
 
 define void @make_call(void ()* nocapture %func) {
 entry:
   call void %func()
   ret void
 }
 
 ; CHECK:      RELOCATION RECORDS FOR [CODE]:
-; CHECK-NEXT: 00000006 R_WEBASSEMBLY_TYPE_INDEX_LEB 1+0
+; CHECK-NEXT: 00000006 R_WEBASSEMBLY_SIGNATURE_INDEX_LEB 1+0
 
 ; CHECK:      RELOCATION RECORDS FOR [DATA]:
 ; CHECK-NEXT: 00000006 R_WEBASSEMBLY_MEMORY_ADDR_I32 foo+0

tools/llvm-objdump/llvm-objdump.cpp

static std::error_code getRelocationValueString(const WasmObjectFile *Obj,
                                                 const RelocationRef &RelRef,
                                                 SmallVectorImpl<char> &Result) {
   const wasm::WasmRelocation& Rel = Obj->getWasmRelocation(RelRef);
   symbol_iterator SI = RelRef.getSymbol();
   std::string fmtbuf;
   raw_string_ostream fmt(fmtbuf);
   if (SI == Obj->symbol_end()) {
     // Not all wasm relocations have symbols associated with them.
-    // In particular R_WEBASSEMBLY_TYPE_INDEX_LEB.
+    // In particular R_WEBASSEMBLY_SIGNATURE_INDEX_LEB.
     fmt << Rel.Index;
   } else {
     Expected<StringRef> SymNameOrErr = SI->getName();
     if (!SymNameOrErr)
       return errorToErrorCode(SymNameOrErr.takeError());
     StringRef SymName = *SymNameOrErr;
     Result.append(SymName.begin(), SymName.end());
   }

tools/obj2yaml/wasm2yaml.cpp

case wasm::WASM_SEC_CUSTOM: {
         continue;
       }
       S = dumpCustomSection(WasmSec);
       break;
     }
     case wasm::WASM_SEC_TYPE: {
       auto TypeSec = make_unique<WasmYAML::TypeSection>();
       uint32_t Index = 0;
-      for (const auto &FunctionSig : Obj.types()) {
+      for (const auto &Signature : Obj.signatures()) {
         WasmYAML::Signature Sig;
         Sig.Index = Index++;
         Sig.ReturnType = wasm::WASM_TYPE_NORESULT;
-        assert(FunctionSig.Returns.size() <= 1 &&
+        assert(Signature.Returns.size() <= 1 &&
                "Functions with multiple returns are not supported");
-        if (FunctionSig.Returns.size())
-          Sig.ReturnType = static_cast<uint32_t>(FunctionSig.Returns[0]);
-        for (const auto &ParamType : FunctionSig.Params)
+        if (Signature.Returns.size())
+          Sig.ReturnType = static_cast<uint32_t>(Signature.Returns[0]);
+        for (const auto &ParamType : Signature.Params)
           Sig.ParamTypes.push_back(static_cast<uint32_t>(ParamType));
         TypeSec->Signatures.push_back(Sig);
       }
       S = std::move(TypeSec);
       break;
     }
     case wasm::WASM_SEC_IMPORT: {
       auto ImportSec = make_unique<WasmYAML::ImportSection>();
case wasm::WASM_SEC_IMPORT: {
         }
         ImportSec->Imports.push_back(Im);
       }
       S = std::move(ImportSec);
       break;
     }
     case wasm::WASM_SEC_FUNCTION: {
       auto FuncSec = make_unique<WasmYAML::FunctionSection>();
-      for (const auto &Func : Obj.functionTypes()) {
-        FuncSec->FunctionTypes.push_back(Func);
+      for (const auto &Func : Obj.functionSigIndices()) {
+        FuncSec->FunctionSigIndices.push_back(Func);
       }
       S = std::move(FuncSec);
       break;
     }
     case wasm::WASM_SEC_TABLE: {
       auto TableSec = make_unique<WasmYAML::TableSection>();
       for (const wasm::WasmTable &Table : Obj.tables()) {
         TableSec->Tables.push_back(make_table(Table));

tools/yaml2obj/yaml2wasm.cpp

 }
 
 int WasmWriter::writeSectionContent(raw_ostream &OS,
                                     WasmYAML::TypeSection &Section) {
   encodeULEB128(Section.Signatures.size(), OS);
   uint32_t ExpectedIndex = 0;
   for (const WasmYAML::Signature &Sig : Section.Signatures) {
     if (Sig.Index != ExpectedIndex) {
       errs() << "Unexpected type index: " << Sig.Index << "\n";
       return 1;
     }
     ++ExpectedIndex;
     writeUint8(OS, Sig.Form);
     encodeULEB128(Sig.ParamTypes.size(), OS);
     for (auto ParamType : Sig.ParamTypes)
       writeUint8(OS, ParamType);
     if (Sig.ReturnType == wasm::WASM_TYPE_NORESULT) {
default:
       return 1;
     }
   }
   return 0;
 }
 
 int WasmWriter::writeSectionContent(raw_ostream &OS,
                                     WasmYAML::FunctionSection &Section) {
-  encodeULEB128(Section.FunctionTypes.size(), OS);
-  for (uint32_t FuncType : Section.FunctionTypes) {
-    encodeULEB128(FuncType, OS);
+  encodeULEB128(Section.FunctionSigIndices.size(), OS);
+  for (uint32_t FuncSigIndex : Section.FunctionSigIndices) {
+    encodeULEB128(FuncSigIndex, OS);
   }
   return 0;
 }
 
 int WasmWriter::writeSectionContent(raw_ostream &OS,
                                     WasmYAML::ExportSection &Section) {
   encodeULEB128(Section.Exports.size(), OS);
   for (const WasmYAML::Export &Export : Section.Exports) {