[WebAssembly] Remove redundant code added in rL354538. NFC.

[sbc100]

Summary

The code for encoding the symbols signature into its name
was not actually being used in the final version of this change.

[ruiu]

LGTM

lld/trunk/wasm/SymbolTable.cpp

 using namespace llvm;
 using namespace llvm::wasm;
 using namespace llvm::object;
 using namespace lld;
 using namespace lld::wasm;
 
 SymbolTable *lld::wasm::Symtab;
 
-static char encodeValType(ValType Type) {
-  switch (Type) {
-  case ValType::I32:
-    return 'i';
-  case ValType::I64:
-    return 'j';
-  case ValType::F32:
-    return 'f';
-  case ValType::F64:
-    return 'd';
-  case ValType::V128:
-    return 'V';
-  case ValType::EXCEPT_REF:
-    return 'e';
-  }
-  llvm_unreachable("invalid wasm type");
-}
-
-static std::string encodeSignature(const WasmSignature &Sig) {
-  std::string S = ":";
-  for (ValType Type : Sig.Returns)
-    S += encodeValType(Type);
-  S += ':';
-  for (ValType Type : Sig.Params)
-    S += encodeValType(Type);
-  return S;
-}
-
-static StringRef getVariantName(StringRef BaseName, const WasmSignature &Sig) {
-  return Saver.save(BaseName + encodeSignature(Sig));
-}
-
 void SymbolTable::addFile(InputFile *File) {
   log("Processing: " + toString(File));
   if (Config->Trace)
     message(toString(File));
   File->parse();
 
   // LLVM bitcode file
   if (auto *F = dyn_cast<BitcodeFile>(File))

 }
 
 // The new signature doesn't match.  Create a variant to the symbol with the
 // signature encoded in the name and return that instead.  These symbols are
 // then unified later in handleSymbolVariants.
 bool SymbolTable::getFunctionVariant(Symbol* Sym, const WasmSignature *Sig,
                                      const InputFile *File, Symbol **Out) {
   LLVM_DEBUG(dbgs() << "getFunctionVariant: " << Sym->getName() << " -> "
-                    << getVariantName(Sym->getName(), *Sig)
                     << " " << toString(*Sig) << "\n");
   Symbol *Variant = nullptr;
 
   // Linear search through symbol variants.  Should never be more than two
   // or three entries here.
   auto &Variants = SymVariants[CachedHashStringRef(Sym->getName())];
   if (Variants.size() == 0)
     Variants.push_back(Sym);

 // mismatches.
 void SymbolTable::handleSymbolVariants() {
   for (auto Pair : SymVariants) {
     // Push the initial symbol onto the list of variants.
     StringRef SymName = Pair.first.val();
     std::vector<Symbol *> &Variants = Pair.second;
 
 #ifndef NDEBUG
-    dbgs() << "symbol with (" << Variants.size()
-                      << ") variants: " << SymName << "\n";
+    LLVM_DEBUG(dbgs() << "symbol with (" << Variants.size()
+                      << ") variants: " << SymName << "\n");
     for (auto *S: Variants) {
       auto *F = cast<FunctionSymbol>(S);
-      dbgs() << " variant: " + F->getName() << " " << toString(*F->Signature) << "\n";
+      LLVM_DEBUG(dbgs() << " variant: " + F->getName() << " "
+                        << toString(*F->Signature) << "\n");
     }
 #endif
 
     // Find the one definition.
     DefinedFunction *Defined = nullptr;
     for (auto *Symbol : Variants) {
       if (auto F = dyn_cast<DefinedFunction>(Symbol)) {
         Defined = F;