[WebAssembly] Add seperate Writer::lookupType and Writer::registerType. NFC

[sbc100]

• remove extra assert

[sbc100]

This is small change that was split out from D41893

[ruiu]

lld/trunk/wasm/Writer.cpp

574–576

auto It = TypeIndices.find(Sig);
if (It == TypeIndices.end()) {
  error(...);
  return 0;
}
return *It;

is faster because it looks up the hash table only once.

[sbc100]

lld/trunk/wasm/Writer.cpp

574–576

Fixed in followup CL: rL322219

lld/trunk/wasm/Writer.cpp

 // The writer writes a SymbolTable result to a file.
 class Writer {
 public:
   void run();
 
 private:
   void openFile();
 
-  uint32_t getTypeIndex(const WasmSignature &Sig);
+  uint32_t lookupType(const WasmSignature &Sig);
+  uint32_t registerType(const WasmSignature &Sig);
   void assignIndexes();
   void calculateImports();
   void calculateOffsets();
   void calculateTypes();
   void createOutputSegments();
   void layoutMemory();
   void createHeader();
   void createSections();
   SyntheticSection *createSyntheticSection(uint32_t Type,
-                                           std::string Name = "");
+                                           StringRef Name = "");
 
   // Builtin sections
   void createTypeSection();
   void createFunctionSection();
   void createTableSection();
   void createGlobalSection();
   void createExportSection();
   void createImportSection();
void Writer::createImportSection() {
 
   writeUleb128(OS, NumImports, "import count");
 
   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());
+    Import.SigIndex = lookupType(Sym->getFunctionType());
     writeImport(OS, Import);
   }
 
   if (Config->ImportMemory) {
     WasmImport Import;
     Import.Module = "env";
     Import.Field = "memory";
     Import.Kind = WASM_EXTERNAL_MEMORY;
void Writer::createFunctionSection() {
   if (DefinedFunctions.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, TypeIndices.lookup(Func->Signature), "sig index");
+    writeUleb128(OS, lookupType(Func->Signature), "sig index");
 }
 
 void Writer::createMemorySection() {
   if (Config->ImportMemory)
     return;
 
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_MEMORY);
   raw_ostream &OS = Section->getStream();
void Writer::layoutMemory() {
   }
 
   uint32_t MemSize = alignTo(MemoryPtr, WasmPageSize);
   NumMemoryPages = MemSize / WasmPageSize;
   debugPrint("mem: total pages = %d\n", NumMemoryPages);
 }
 
 SyntheticSection *Writer::createSyntheticSection(uint32_t Type,
-                                                 std::string Name) {
+                                                 StringRef Name) {
   auto Sec = make<SyntheticSection>(Type, Name);
   log("createSection: " + toString(*Sec));
   OutputSections.push_back(Sec);
   return Sec;
 }
 
 void Writer::createSections() {
   // Known sections
if (Sym->isFunction()) {
       ImportedFunctions.push_back(Sym);
     } else {
       Sym->setOutputIndex(ImportedGlobals.size());
       ImportedGlobals.push_back(Sym);
     }
   }
 }
 
-uint32_t Writer::getTypeIndex(const WasmSignature &Sig) {
+uint32_t Writer::lookupType(const WasmSignature &Sig) {
+  if (TypeIndices.count(Sig) == 0)
+    error("type not found: " + toString(Sig));
+  return TypeIndices.lookup(Sig);
+}
+
+uint32_t Writer::registerType(const WasmSignature &Sig) {
   auto Pair = TypeIndices.insert(std::make_pair(Sig, Types.size()));
-  if (Pair.second)
+  if (Pair.second) {
+    DEBUG(dbgs() << "type " << toString(Sig) << "\n");
     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));
+      File->TypeMap.push_back(registerType(Sig));
   }
 }
 
 void Writer::assignIndexes() {
   uint32_t GlobalIndex = ImportedGlobals.size();
   uint32_t FunctionIndex = ImportedFunctions.size();
 
   if (Config->StackPointerSymbol) {