feedback

lld/test/wasm/weak-and-strong-undef.s

-# Test that when a symbol (foo) is both weakly and stronly undefined the
-# string undefined symbol alwaeys generates an error, whichever object
+# Test that when a symbol (foo) is both weakly and strongly referenced
+# the strong undefined symbol always generates an error, whichever object
 # file is seen first.
 
 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown %s -o %t1.o
 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown %S/Inputs/weak-undefined.s -o %t2.o
 # RUN: not wasm-ld %t1.o %t2.o -o /dev/null 2>&1 | FileCheck %s
 # RUN: not wasm-ld %t2.o %t1.o -o /dev/null 2>&1 | FileCheck %s
 
 # CHECK: undefined symbol: foo
 
 _start:
     .globl _start
     .functype _start () -> ()
     call foo
     end_function
 
 .functype foo () -> ()

lld/wasm/SymbolTable.cpp

if (!existing->importModule)
       existing->importModule = importModule;
     if (existing->importModule != importModule)
       error("import module mismatch for symbol: " + toString(*existing) +
             "\n>>> defined as " + *existing->importModule + " in " +
             toString(existing->getFile()) + "\n>>> defined as " +
             *importModule + " in " + toString(file));
   }
 
-  // Update symbol binding, if the existing symbols is weak
+  // Update symbol binding, if the existing symbol is weak
   uint32_t binding = flags & WASM_SYMBOL_BINDING_MASK;
   if (existing->isWeak() && binding != WASM_SYMBOL_BINDING_WEAK) {
     existing->flags = (existing->flags & ~WASM_SYMBOL_BINDING_MASK) | binding;
   }
 }
 
 Symbol *SymbolTable::addUndefinedFunction(StringRef name,
                                           Optional<StringRef> importName,
else {
     if (!existingFunction) {
       reportTypeError(s, file, WASM_SYMBOL_TYPE_FUNCTION);
       return s;
     }
     if (!existingFunction->signature && sig)
       existingFunction->signature = sig;
     auto *existingUndefined = dyn_cast<UndefinedFunction>(existingFunction);
     if (isCalledDirectly && !signatureMatches(existingFunction, sig)) {
-      // If the existing undefined functions is not called direcltly then let
+      // If the existing undefined functions is not called directly then let
       // this one take precedence.  Otherwise the existing function is either
-      // direclty called or defined, in which case we need a function variant.
+      // directly called or defined, in which case we need a function variant.
       if (existingUndefined && !existingUndefined->isCalledDirectly)
         replaceSym();
       else if (getFunctionVariant(s, sig, file, &s))
         replaceSym();
     }
     if (existingUndefined)
       setImportAttributes(existingUndefined, importName, importModule, flags,
                           file);