Consistent use of <internal> when displaying internal symbol names

[sbc100]

Simplify wasm code

[ruiu]

LGTM

lld/trunk/COFF/InputFiles.cpp

static StringRef getBasename(StringRef Path) {
   if (Pos == StringRef::npos)
     return Path;
   return Path.substr(Pos + 1);
 }
 
 // Returns a string in the format of "foo.obj" or "foo.obj(bar.lib)".
 std::string lld::toString(coff::InputFile *File) {
   if (!File)
-    return "(internal)";
+    return "<internal>";
   if (File->ParentName.empty())
     return File->getName().lower();
 
   std::string Res =
       (getBasename(File->ParentName) + "(" + getBasename(File->getName()) + ")")
           .str();
   return StringRef(Res).lower();
 }

lld/trunk/COFF/SymbolTable.cpp

void SymbolTable::addLazy(ArchiveFile *F, const Archive::Symbol Sym) {
   if (!U || U->WeakAlias || S->PendingArchiveLoad)
     return;
   S->PendingArchiveLoad = true;
   F->addMember(&Sym);
 }
 
 void SymbolTable::reportDuplicate(Symbol *Existing, InputFile *NewFile) {
   error("duplicate symbol: " + toString(*Existing) + " in " +
-        toString(Existing->getFile()) + " and in " +
-        (NewFile ? toString(NewFile) : "(internal)"));
+        toString(Existing->getFile()) + " and in " + toString(NewFile));
 }
 
 Symbol *SymbolTable::addAbsolute(StringRef N, COFFSymbolRef Sym) {
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(N);
   S->IsUsedInRegularObj = true;
   if (WasInserted || isa<Undefined>(S) || isa<Lazy>(S))

lld/trunk/ELF/InputFiles.h

 }
 } // namespace llvm
 
 namespace lld {
 namespace elf {
 class InputFile;
 }
 
-// Returns "(internal)", "foo.a(bar.o)" or "baz.o".
+// Returns "<internal>", "foo.a(bar.o)" or "baz.o".
 std::string toString(const elf::InputFile *F);
 
 namespace elf {
 
 using llvm::object::Archive;
 
 class Lazy;
 class Symbol;

lld/trunk/ELF/InputSection.cpp

 //   path/to/foo.o:(function bar)
 //
 // or
 //
 //   path/to/foo.o:(function bar) in archive path/to/bar.a
 std::string InputSectionBase::getObjMsg(uint64_t Off) {
   // Synthetic sections don't have input files.
   if (!File)
-    return ("(internal):(" + Name + "+0x" + utohexstr(Off) + ")").str();
+    return ("<internal>:(" + Name + "+0x" + utohexstr(Off) + ")").str();
   std::string Filename = File->getName();
 
   std::string Archive;
   if (!File->ArchiveName.empty())
     Archive = (" in archive " + File->ArchiveName).str();
 
   // Find a symbol that encloses a given location.
   for (Symbol *B : File->getSymbols())

lld/trunk/test/ELF/duplicated-synthetic-sym.s

 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 // RUN: cd %S
 // RUN: not ld.lld %t.o --format=binary duplicated-synthetic-sym.s -o %t.elf 2>&1 | FileCheck %s
 // RUN: not ld.lld %t.o --format binary duplicated-synthetic-sym.s -o %t.elf 2>&1 | FileCheck %s
 
 // CHECK: duplicate symbol: _binary_duplicated_synthetic_sym_s_start
-// CHECK: defined at (internal):(.data+0x0)
+// CHECK: defined at <internal>:(.data+0x0)
 
     .globl  _binary_duplicated_synthetic_sym_s_start
 _binary_duplicated_synthetic_sym_s_start:
     .long   0

lld/trunk/wasm/SymbolTable.cpp

if (Sym)
     return {Sym, false};
   Sym = make<Symbol>(Name, false);
   return {Sym, true};
 }
 
 void SymbolTable::reportDuplicate(Symbol *Existing, InputFile *NewFile) {
   error("duplicate symbol: " + toString(*Existing) + "\n>>> defined in " +
         toString(Existing->getFile()) + "\n>>> defined in " +
-        (NewFile ? toString(NewFile) : "<internal>"));
+        toString(NewFile));
 }
 
 static void checkSymbolTypes(Symbol *Existing, InputFile *F,
                              const WasmSymbol *New) {
   if (Existing->isLazy())
     return;
 
   bool NewIsFunction = New->Type == WasmSymbol::SymbolType::FUNCTION_EXPORT ||
                        New->Type == WasmSymbol::SymbolType::FUNCTION_IMPORT;
   if (Existing->isFunction() == NewIsFunction)
     return;
 
-  std::string Filename = "<builtin>";
-  if (Existing->getFile())
-    Filename = toString(Existing->getFile());
   error("symbol type mismatch: " + New->Name + "\n>>> defined as " +
-        (Existing->isFunction() ? "Function" : "Global") + " in " + Filename +
-        "\n>>> defined as " + (NewIsFunction ? "Function" : "Global") + " in " +
-        F->getName());
+        (Existing->isFunction() ? "Function" : "Global") + " in " +
+        toString(Existing->getFile()) + "\n>>> defined as " +
+        (NewIsFunction ? "Function" : "Global") + " in " + F->getName());
 }
 
 Symbol *SymbolTable::addDefinedGlobal(StringRef Name) {
   DEBUG(dbgs() << "addDefinedGlobal: " << Name << "\n");
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name);
   if (WasInserted)