[WebAssembly] Improve invalid relocation error message

[sbc100]

Summary

This message now matches the equivalent message in the ELF linker.

[sbc100]

• clang-format

[sbc100]

• fix

[sbc100]

ping

[ruiu]

LGTM

lld/wasm/InputChunks.h

221

reloct -> reloc

lld/test/wasm/undefined-data.ll

 ; RUN: llc -filetype=obj %s -o %t.o
 ; RUN: not wasm-ld -o %t.wasm %t.o 2>&1 | FileCheck %s -check-prefix=UNDEF
 ; RUN: not wasm-ld --allow-undefined -o %t.wasm %t.o 2>&1 | FileCheck %s -check-prefix=BADRELOC
 
 target triple = "wasm32-unknown-unknown"
 
 @data_external = external global i32
 
 define i32 @_start() {
 entry:
     %0 = load i32, i32* @data_external, align 4
     ret i32 %0
 }
 
 ; UNDEF: undefined symbol: data_external
-; BADRELOC: undefined-data.ll.tmp.o: relocation of type R_WASM_MEMORY_ADDR_* against undefined data symbol: data_external
+; BADRELOC: relocation R_WASM_MEMORY_ADDR_LEB cannot be used againt symbol data_external; recompile with -fPIC

lld/wasm/InputChunks.h

protected:
   uint32_t getInputSectionOffset() const override { return 0; }
 
   const WasmSection &Section;
 };
 
 } // namespace wasm
 
 std::string toString(const wasm::InputChunk *);
+StringRef reloctTypeToString(uint8_t RelocType);
+
 } // namespace lld
 
 #endif // LLD_WASM_INPUT_CHUNKS_H

lld/wasm/InputChunks.cpp

 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace llvm::wasm;
 using namespace llvm::support::endian;
 using namespace lld;
 using namespace lld::wasm;
 
-static StringRef reloctTypeToString(uint8_t RelocType) {
+StringRef lld::reloctTypeToString(uint8_t RelocType) {
   switch (RelocType) {
 #define WASM_RELOC(NAME, REL)                                                  \
   case REL:                                                                    \
     return #NAME;
 #include "llvm/BinaryFormat/WasmRelocs.def"
 #undef WASM_RELOC
   }
   llvm_unreachable("unknown reloc type");

lld/wasm/Writer.cpp

void Writer::calculateTypes() {
   for (const InputEvent *E : InputEvents)
     registerType(E->Signature);
 }
 
 void Writer::processRelocations(InputChunk *Chunk) {
   if (!Chunk->Live)
     return;
   ObjFile *File = Chunk->File;
+
   ArrayRef<WasmSignature> Types = File->getWasmObj()->types();
   for (const WasmRelocation &Reloc : Chunk->getRelocations()) {
     switch (Reloc.Type) {
     case R_WASM_TABLE_INDEX_I32:
     case R_WASM_TABLE_INDEX_SLEB: {
       FunctionSymbol *Sym = File->getFunctionSymbol(Reloc.Index);
       if (Sym->hasTableIndex() || !Sym->hasFunctionIndex())
         continue;
       Sym->setTableIndex(TableBase + IndirectFunctions.size());
       IndirectFunctions.emplace_back(Sym);
       break;
     }
     case R_WASM_TYPE_INDEX_LEB:
       // Mark target type as live
       File->TypeMap[Reloc.Index] = registerType(Types[Reloc.Index]);
       File->TypeIsUsed[Reloc.Index] = true;
       break;
-    case R_WASM_MEMORY_ADDR_SLEB:
-    case R_WASM_MEMORY_ADDR_I32:
-    case R_WASM_MEMORY_ADDR_LEB: {
-      DataSymbol *DataSym = File->getDataSymbol(Reloc.Index);
-      if (!Config->Relocatable && !isa<DefinedData>(DataSym) &&
-          !DataSym->isWeak())
-        error(File->getName() +
-              ": relocation of type R_WASM_MEMORY_ADDR_* "
-              "against undefined data symbol: " +
-              DataSym->getName());
-      break;
-    }
     case R_WASM_GLOBAL_INDEX_LEB: {
       auto* Sym = File->getSymbols()[Reloc.Index];
       if (!isa<GlobalSymbol>(Sym) && !Sym->isInGOT()) {
         Sym->setGOTIndex(NumImportedGlobals++);
         GOTSymbols.push_back(Sym);
       }
     }
     }
+
+    if (!Config->Relocatable) {
+      switch (Reloc.Type) {
+      // These relocations types appear the code section.
+      // They should never appear in code compiled with -fPIC.
+      case R_WASM_TABLE_INDEX_SLEB:
+      case R_WASM_MEMORY_ADDR_SLEB:
+      case R_WASM_MEMORY_ADDR_LEB: {
+        auto *Sym = File->getSymbols()[Reloc.Index];
+        if (!Config->Relocatable && Sym->isUndefined() && !Sym->isWeak())
+          error(File->getName() + ": relocation " + reloctTypeToString(Reloc.Type) +
+                " cannot be used againt symbol " + Sym->getName() +
+              "; recompile with -fPIC");
+      }
       }
     }
+  }
+
+}
 
 void Writer::assignIndexes() {
   assert(InputFunctions.empty());
   uint32_t FunctionIndex = NumImportedFunctions;
   auto AddDefinedFunction = [&](InputFunction *Func) {
     if (!Func->Live)
       return;
     InputFunctions.emplace_back(Func);