[lld][WebAssembly] Fix crash calling weakly undefined function in PIC code

lld/test/wasm/weak-undefined-pic.s

get_foo_addr:
   .functype get_foo_addr () -> (i32)
   global.get foo@GOT
   end_function
 
 .globl _start
 _start:
   .functype _start () -> ()
   call get_foo_addr
+  call foo
   end_function
 
 .weak foo
 .functype foo () -> (i32)
 
 # Verify that we do not generate dynamic relocations for the GOT entry.
 
 # CHECK-NOT: __wasm_apply_global_relocs

 
 # With `-pie` or `-shared` the resolution should be deferred to the dynamic
 # linker and the function address should be imported as GOT.func.foo.
 #
 # RUN: wasm-ld --experimental-pic -pie %t.o -o %t3.wasm
 # RUN: obj2yaml %t3.wasm | FileCheck %s --check-prefix=IMPORT
 
 #      IMPORT:  - Type:            IMPORT
-#      IMPORT:      - Module:          GOT.func
+#      IMPORT:        Field:           foo
+# IMPORT-NEXT:        Kind:            FUNCTION
+# IMPORT-NEXT:        SigIndex:        0
+# IMPORT-NEXT:      - Module:          GOT.func
 # IMPORT-NEXT:        Field:           foo
 # IMPORT-NEXT:        Kind:            GLOBAL
 # IMPORT-NEXT:        GlobalType:      I32
 # IMPORT-NEXT:        GlobalMutable:   true
 
 #      IMPORT:     GlobalNames:
 # IMPORT-NEXT:       - Index:           0
 # IMPORT-NEXT:         Name:            __memory_base
 # IMPORT-NEXT:       - Index:           1
 # IMPORT-NEXT:         Name:            __table_base
 # IMPORT-NEXT:       - Index:           2
 # IMPORT-NEXT:         Name:            foo

lld/wasm/InputChunks.cpp

void InputChunk::relocate(uint8_t *buf) const {
 
   LLVM_DEBUG(dbgs() << "applying relocations: " << toString(this)
                     << " count=" << relocations.size() << "\n");
   int32_t inputSectionOffset = getInputSectionOffset();
   uint64_t tombstone = getTombstone();
 
   for (const WasmRelocation &rel : relocations) {
     uint8_t *loc = buf + rel.Offset - inputSectionOffset;
-    auto value = file->calcNewValue(rel, tombstone, this);
     LLVM_DEBUG(dbgs() << "apply reloc: type=" << relocTypeToString(rel.Type));
     if (rel.Type != R_WASM_TYPE_INDEX_LEB)
       LLVM_DEBUG(dbgs() << " sym=" << file->getSymbols()[rel.Index]->getName());
     LLVM_DEBUG(dbgs() << " addend=" << rel.Addend << " index=" << rel.Index
-                      << " value=" << value << " offset=" << rel.Offset
-                      << "\n");
+                      << " offset=" << rel.Offset << "\n");
+    auto value = file->calcNewValue(rel, tombstone, this);
 
     switch (rel.Type) {
     case R_WASM_TYPE_INDEX_LEB:
     case R_WASM_FUNCTION_INDEX_LEB:
     case R_WASM_GLOBAL_INDEX_LEB:
     case R_WASM_EVENT_INDEX_LEB:
     case R_WASM_MEMORY_ADDR_LEB:
     case R_WASM_TABLE_NUMBER_LEB:

lld/wasm/Writer.cpp

for (auto &feature : required.keys()) {
               ". Use --no-check-features to suppress.");
     }
   }
 }
 
 static bool shouldImport(Symbol *sym) {
   if (!sym->isUndefined())
     return false;
-  if (sym->isWeak() && !config->relocatable)
+  if (sym->isWeak() && !config->relocatable && !config->isPic)
     return false;
   if (!sym->isLive())
     return false;
   if (!sym->isUsedInRegularObj)
     return false;
 
   // We don't generate imports for data symbols. They however can be imported
   // as GOT entries.