[WebAssembly] Rename member DefinedFunctions -> InputFunctions. NFC.

[sbc100]

Summary

This avoids confusion with the DefinedFunction symbol
type.

[ruiu]

LGTM

lld/trunk/wasm/Writer.cpp

private:
   uint32_t NumMemoryPages = 0;
 
   std::vector<const WasmSignature *> Types;
   DenseMap<WasmSignature, int32_t, WasmSignatureDenseMapInfo> TypeIndices;
   std::vector<const FunctionSymbol *> ImportedFunctions;
   std::vector<const DataSymbol *> ImportedGlobals;
   std::vector<WasmExportEntry> ExportedSymbols;
   std::vector<const DefinedData *> DefinedDataSymbols;
-  std::vector<InputFunction *> DefinedFunctions;
+  std::vector<InputFunction *> InputFunctions;
   std::vector<const FunctionSymbol *> IndirectFunctions;
   std::vector<WasmInitFunc> InitFunctions;
 
   // Elements that are used to construct the final output
   std::string Header;
   std::vector<OutputSection *> OutputSections;
 
   std::unique_ptr<FileOutputBuffer> Buffer;
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 (DefinedFunctions.empty())
+  if (InputFunctions.empty())
     return;
 
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_FUNCTION);
   raw_ostream &OS = Section->getStream();
 
-  writeUleb128(OS, DefinedFunctions.size(), "function count");
-  for (const InputFunction *Func : DefinedFunctions)
+  writeUleb128(OS, InputFunctions.size(), "function count");
+  for (const InputFunction *Func : InputFunctions)
     writeUleb128(OS, lookupType(Func->Signature), "sig index");
 }
 
 void Writer::createMemorySection() {
   if (Config->ImportMemory)
     return;
 
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_MEMORY);
void Writer::createElemSection() {
   for (const FunctionSymbol *Sym : IndirectFunctions) {
     assert(Sym->getTableIndex() == TableIndex);
     writeUleb128(OS, Sym->getOutputIndex(), "function index");
     ++TableIndex;
   }
 }
 
 void Writer::createCodeSection() {
-  if (DefinedFunctions.empty())
+  if (InputFunctions.empty())
     return;
 
   log("createCodeSection");
 
-  auto Section = make<CodeSection>(DefinedFunctions);
+  auto Section = make<CodeSection>(InputFunctions);
   OutputSections.push_back(Section);
 }
 
 void Writer::createDataSection() {
   if (!Segments.size())
     return;
 
   log("createDataSection");
if (!InitFunctions.empty()) {
     }
     SubSection.finalizeContents();
     SubSection.writeToStream(OS);
   }
 
   struct ComdatEntry { unsigned Kind; uint32_t Index; };
   std::map<StringRef,std::vector<ComdatEntry>> Comdats;
 
-  for (const InputFunction *F : DefinedFunctions) {
+  for (const InputFunction *F : InputFunctions) {
     StringRef Comdat = F->getComdat();
     if (!Comdat.empty())
       Comdats[Comdat].emplace_back(
           ComdatEntry{WASM_COMDAT_FUNCTION, F->getOutputIndex()});
   }
   for (uint32_t I = 0; I < Segments.size(); ++I) {
     const auto &InputSegments = Segments[I]->InputSegments;
     if (InputSegments.empty())
if (!Comdats.empty()) {
     SubSection.finalizeContents();
     SubSection.writeToStream(OS);
   }
 }
 
 // Create the custom "name" section containing debug symbol names.
 void Writer::createNameSection() {
   unsigned NumNames = ImportedFunctions.size();
-  for (const InputFunction *F : DefinedFunctions)
+  for (const InputFunction *F : InputFunctions)
     if (!F->getName().empty())
       ++NumNames;
 
   if (NumNames == 0)
     return;
 
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_CUSTOM, "name");
 
   SubSection FunctionSubsection(WASM_NAMES_FUNCTION);
   raw_ostream &OS = FunctionSubsection.getStream();
   writeUleb128(OS, NumNames, "name count");
 
   // Names must appear in function index order.  As it happens ImportedFunctions
-  // and DefinedFunctions are numbers in order with imported functions coming
+  // and InputFunctions are numbers in order with imported functions coming
   // first.
   for (const Symbol *S : ImportedFunctions) {
     writeUleb128(OS, S->getOutputIndex(), "import index");
     writeStr(OS, S->getName(), "symbol name");
   }
-  for (const InputFunction *F : DefinedFunctions) {
+  for (const InputFunction *F : InputFunctions) {
     if (!F->getName().empty()) {
       writeUleb128(OS, F->getOutputIndex(), "func index");
       writeStr(OS, F->getName(), "symbol name");
     }
   }
 
   FunctionSubsection.finalizeContents();
   FunctionSubsection.writeToStream(Section->getStream());
for (ObjFile *File : Symtab->ObjectFiles) {
     for (uint32_t I = 0; I < Types.size(); I++)
       if (File->TypeIsUsed[I])
         File->TypeMap[I] = registerType(Types[I]);
   }
 
   for (const FunctionSymbol *Sym : ImportedFunctions)
     registerType(*Sym->getFunctionType());
 
-  for (const InputFunction *F : DefinedFunctions)
+  for (const InputFunction *F : InputFunctions)
     registerType(F->Signature);
 }
 
 void Writer::assignIndexes() {
   uint32_t GlobalIndex = ImportedGlobals.size() + DefinedDataSymbols.size();
-  uint32_t FunctionIndex = ImportedFunctions.size() + DefinedFunctions.size();
+  uint32_t FunctionIndex = ImportedFunctions.size() + InputFunctions.size();
 
   auto AddDefinedData = [&](DefinedData *Sym) {
     if (Sym) {
       DefinedDataSymbols.emplace_back(Sym);
       Sym->setOutputIndex(GlobalIndex++);
     }
   };
   AddDefinedData(WasmSym::StackPointer);
if (Config->Relocatable) {
     }
   }
 
   for (ObjFile *File : Symtab->ObjectFiles) {
     DEBUG(dbgs() << "Functions: " << File->getName() << "\n");
     for (InputFunction *Func : File->Functions) {
       if (!Func->Live)
         continue;
-      DefinedFunctions.emplace_back(Func);
+      InputFunctions.emplace_back(Func);
       Func->setOutputIndex(FunctionIndex++);
     }
   }
 
   for (ObjFile *File : Symtab->ObjectFiles) {
     DEBUG(dbgs() << "Handle relocs: " << File->getName() << "\n");
     auto HandleRelocs = [&](InputChunk *Chunk) {
       if (!Chunk->Live)

 }
 
 static const int OPCODE_CALL = 0x10;
 static const int OPCODE_END = 0xb;
 
 // Create synthetic "__wasm_call_ctors" function based on ctor functions
 // in input object.
 void Writer::createCtorFunction() {
-  uint32_t FunctionIndex = ImportedFunctions.size() + DefinedFunctions.size();
+  uint32_t FunctionIndex = ImportedFunctions.size() + InputFunctions.size();
   WasmSym::CallCtors->setOutputIndex(FunctionIndex);
 
   // First write the body bytes to a string.
   std::string FunctionBody;
   static WasmSignature Signature = {{}, WASM_TYPE_NORESULT};
   {
     raw_string_ostream OS(FunctionBody);
     writeUleb128(OS, 0, "num locals");
void Writer::createCtorFunction() {
   OS.flush();
   CtorFunctionBody += FunctionBody;
   ArrayRef<uint8_t> BodyArray(
       reinterpret_cast<const uint8_t *>(CtorFunctionBody.data()),
       CtorFunctionBody.size());
   CtorFunction = llvm::make_unique<SyntheticFunction>(
       Signature, BodyArray, WasmSym::CallCtors->getName());
   CtorFunction->setOutputIndex(FunctionIndex);
-  DefinedFunctions.emplace_back(CtorFunction.get());
+  InputFunctions.emplace_back(CtorFunction.get());
 }
 
 // Populate InitFunctions vector with init functions from all input objects.
 // This is then used either when creating the output linking section or to
 // synthesize the "__wasm_call_ctors" function.
 void Writer::calculateInitFunctions() {
   for (ObjFile *File : Symtab->ObjectFiles) {
     const WasmLinkingData &L = File->getWasmObj()->linkingData();
void Writer::run() {
   log("-- calculateInitFunctions");
   calculateInitFunctions();
   if (!Config->Relocatable)
     createCtorFunction();
   log("-- calculateTypes");
   calculateTypes();
 
   if (errorHandler().Verbose) {
-    log("Defined Functions: " + Twine(DefinedFunctions.size()));
+    log("Defined Functions: " + Twine(InputFunctions.size()));
     log("Defined Data Syms: " + Twine(DefinedDataSymbols.size()));
     log("Function Imports : " + Twine(ImportedFunctions.size()));
     log("Global Imports   : " + Twine(ImportedGlobals.size()));
     log("Total Imports    : " +
         Twine(ImportedFunctions.size() + ImportedGlobals.size()));
     for (ObjFile *File : Symtab->ObjectFiles)
       File->dumpInfo();
   }