Use wasm-ld instead of "lld -flavor wasm".

[ruiu]

Summary

Invoking lld as ld.lld, ld.ld64, lld-link or wasm-ld are preferred
than invoking lld as lld and pass an -flavor option. We have "lld"
file mostly for historical reasons.

lld/trunk/test/wasm/alias.ll

 ; RUN: llc -filetype=obj -o %t.o %s
-; RUN: lld -flavor wasm --check-signatures %t.o -o %t.wasm
+; RUN: wasm-ld --check-signatures %t.o -o %t.wasm
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 @start_alias = alias void (), void ()* @_start
 
 ; Function Attrs: nounwind uwtable
 define void @_start() local_unnamed_addr #1 {

lld/trunk/test/wasm/archive.ll

 ; RUN: llc -filetype=obj %s -o %t.o
 ; RUN: llc -filetype=obj %S/Inputs/archive1.ll -o %t.a1.o
 ; RUN: llc -filetype=obj %S/Inputs/archive2.ll -o %t.a2.o
 ; RUN: llc -filetype=obj %S/Inputs/hello.ll -o %t.a3.o
 ; RUN: llvm-ar rcs %t.a %t.a1.o %t.a2.o %t.a3.o
 ; RUN: rm -f %t.imports
-; RUN: not lld -flavor wasm --check-signatures %t.a %t.o -o %t.wasm 2>&1 | FileCheck -check-prefix=CHECK-UNDEFINED %s
+; RUN: not wasm-ld --check-signatures %t.a %t.o -o %t.wasm 2>&1 | FileCheck -check-prefix=CHECK-UNDEFINED %s
 
 ; CHECK-UNDEFINED: undefined symbol: missing_func
 
 ; RUN: echo 'missing_func' > %t.imports
-; RUN: lld -flavor wasm --check-signatures %t.a %t.o -o %t.wasm
+; RUN: wasm-ld --check-signatures %t.a %t.o -o %t.wasm
 
 ; RUN: llvm-nm -a %t.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 declare i32 @foo() local_unnamed_addr #1
 declare i32 @missing_func() local_unnamed_addr #1
 

 ; CHECK:      00000003 T _start
 ; CHECK-NEXT: 00000001 T bar
 ; CHECK-NEXT: 00000002 T foo
 
 ; Verify that symbols from unused objects don't appear in the symbol table
 ; CHECK-NOT: hello
 
 ; Specifying the same archive twice is allowed.
-; RUN: lld -flavor wasm --check-signatures %t.a %t.a %t.o -o %t.wasm
+; RUN: wasm-ld --check-signatures %t.a %t.a %t.o -o %t.wasm

lld/trunk/test/wasm/call-indirect.ll

 ; RUN: llc -filetype=obj %p/Inputs/call-indirect.ll -o %t2.o
 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: lld -flavor wasm -no-gc-sections --check-signatures -o %t.wasm %t2.o %t.o
+; RUN: wasm-ld -no-gc-sections --check-signatures -o %t.wasm %t2.o %t.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 ; bitcode generated from the following C code:
 ; int foo(void) { return 1; }
 ; int (*indirect_func)(void) = &foo;
 ; void _start(void) { indirect_func(); }
 
 target triple = "wasm32-unknown-unknown-wasm"

lld/trunk/test/wasm/comdats.ll

 ; RUN: llc -filetype=obj -mtriple=wasm32-unknown-uknown-wasm %p/Inputs/comdat1.ll -o %t1.o
 ; RUN: llc -filetype=obj -mtriple=wasm32-unknown-uknown-wasm %p/Inputs/comdat2.ll -o %t2.o
 ; RUN: llc -filetype=obj -mtriple=wasm32-unknown-uknown-wasm %s -o %t.o
-; RUN: lld -flavor wasm -no-gc-sections --check-signatures -o %t.wasm %t.o %t1.o %t2.o
+; RUN: wasm-ld -no-gc-sections --check-signatures -o %t.wasm %t.o %t1.o %t2.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 declare i32 @inlineFn()
 
 define void @_start() local_unnamed_addr {
 entry:

lld/trunk/test/wasm/conflict.test

 # RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
-# RUN: not lld -flavor wasm --check-signatures -o %t.wasm %t.ret32.o %t.ret32.o 2>&1 | FileCheck %s
+# RUN: not wasm-ld --check-signatures -o %t.wasm %t.ret32.o %t.ret32.o 2>&1 | FileCheck %s
 
 # CHECK:      duplicate symbol: ret32
 # CHECK-NEXT: >>> defined in {{.*}}conflict.test.tmp.ret32.o
 # CHECK-NEXT: >>> defined in {{.*}}conflict.test.tmp.ret32.o

lld/trunk/test/wasm/data-layout.ll

 ; RUN: llc -filetype=obj %p/Inputs/hello.ll -o %t.hello.o
 ; RUN: llc -filetype=obj %s -o %t.o
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 @foo = hidden global i32 1, align 4
 @aligned_bar = hidden global i32 3, align 16
 
 @hello_str = external global i8*
 @external_ref = global i8** @hello_str, align 8
 
-; RUN: lld -flavor wasm -no-gc-sections --check-signatures --allow-undefined -o %t.wasm %t.o %t.hello.o
+; RUN: wasm-ld -no-gc-sections --check-signatures --allow-undefined -o %t.wasm %t.o %t.hello.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 ; CHECK:        - Type:            GLOBAL
 ; CHECK-NEXT:     Globals:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Type:            I32
 ; CHECK-NEXT:         Mutable:         true
 ; CHECK-NEXT:         InitExpr:

 ; CHECK-NEXT:       - SectionOffset:   41
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1052
 ; CHECK-NEXT:         Content:         68656C6C6F0A00
 
 
-; RUN: lld -flavor wasm --check-signatures --relocatable -o %t_reloc.wasm %t.o %t.hello.o
+; RUN: wasm-ld --check-signatures --relocatable -o %t_reloc.wasm %t.o %t.hello.o
 ; RUN: obj2yaml %t_reloc.wasm | FileCheck %s -check-prefix=RELOC
 
 ; RELOC:        - Type:            GLOBAL
 ; RELOC-NEXT:     Globals:
 ; RELOC-NEXT:       - Index:           0
 ; RELOC-NEXT:         Type:            I32
 ; RELOC-NEXT:         Mutable:         false
 ; RELOC-NEXT:         InitExpr:

lld/trunk/test/wasm/entry.ll

 ; RUN: llc -filetype=obj %s -o %t.o
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 define hidden void @entry() local_unnamed_addr #0 {
 entry:
   ret void
 }
 
-; RUN: lld -flavor wasm --check-signatures -e entry -o %t1.wasm %t.o
+; RUN: wasm-ld --check-signatures -e entry -o %t1.wasm %t.o
 ; RUN: obj2yaml %t1.wasm | FileCheck %s
-; RUN: lld -flavor wasm --check-signatures --entry=entry -o %t2.wasm %t.o
+; RUN: wasm-ld --check-signatures --entry=entry -o %t2.wasm %t.o
 ; RUN: obj2yaml %t2.wasm | FileCheck %s
 
 ; CHECK:        - Type:            EXPORT
 ; CHECK-NEXT:     Exports:
 ; CHECK-NEXT:       - Name:            memory
 ; CHECK-NEXT:         Kind:            MEMORY
 ; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:       - Name:            entry
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           0
 
 ; The __wasm_call_ctors is somewhat special.  Make sure we can use it
 ; as the entry point if we choose
-; RUN: lld -flavor wasm --check-signatures --entry=__wasm_call_ctors -o %t3.wasm %t.o
+; RUN: wasm-ld --check-signatures --entry=__wasm_call_ctors -o %t3.wasm %t.o
 ; RUN: obj2yaml %t3.wasm | FileCheck %s -check-prefix=CHECK-CTOR
 
 ; CHECK-CTOR:        - Type:            EXPORT
 ; CHECK-CTOR-NEXT:     Exports:
 ; CHECK-CTOR-NEXT:       - Name:            memory
 ; CHECK-CTOR-NEXT:         Kind:            MEMORY
 ; CHECK-CTOR-NEXT:         Index:           0
 ; CHECK-CTOR-NEXT:       - Name:            __wasm_call_ctors
 ; CHECK-CTOR-NEXT:         Kind:            FUNCTION
 ; CHECK-CTOR-NEXT:         Index:           0

lld/trunk/test/wasm/export.ll

 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: not lld -flavor wasm --check-signatures --export=missing -o %t.wasm %t.o 2>&1 | FileCheck -check-prefix=CHECK-ERROR %s
-; RUN: lld -flavor wasm --check-signatures --export=hidden_function -o %t.wasm %t.o
+; RUN: not wasm-ld --check-signatures --export=missing -o %t.wasm %t.o 2>&1 | FileCheck -check-prefix=CHECK-ERROR %s
+; RUN: wasm-ld --check-signatures --export=hidden_function -o %t.wasm %t.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 define hidden i32 @hidden_function() local_unnamed_addr {
 entry:
   ret i32 0
 }

lld/trunk/test/wasm/function-imports-first.ll

 ; RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: lld -flavor wasm --check-signatures -o %t.wasm %t.o %t.ret32.o
+; RUN: wasm-ld --check-signatures -o %t.wasm %t.o %t.ret32.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 ; Function Attrs: nounwind
 define hidden void @_start() local_unnamed_addr #0 {
 entry:
   %call = tail call i32 @ret32(float 0.000000e+00) #2

lld/trunk/test/wasm/function-imports.ll

 ; RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: lld -flavor wasm --check-signatures -o %t.wasm %t.ret32.o %t.o
+; RUN: wasm-ld --check-signatures -o %t.wasm %t.ret32.o %t.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 ; Function Attrs: nounwind
 define hidden void @_start() local_unnamed_addr #0 {
 entry:
   %call = tail call i32 @ret32(float 0.000000e+00) #2

lld/trunk/test/wasm/function-index.test

 # RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
 # RUN: llc -filetype=obj %p/Inputs/ret64.ll -o %t.ret64.o
-# RUN: lld -flavor wasm --check-signatures -r -o %t.wasm %t.ret32.o %t.ret64.o
+# RUN: wasm-ld --check-signatures -r -o %t.wasm %t.ret32.o %t.ret64.o
 # RUN: obj2yaml %t.wasm | FileCheck %s
 
 CHECK: Sections:
 CHECK:   - Type:            TYPE
 CHECK:     Signatures:
 CHECK:       - Index:           0
 CHECK:         ReturnType:      I32
 CHECK:         ParamTypes:
 CHECK:           - F32
 CHECK:       - Index:           1
 CHECK:         ReturnType:      I64
 CHECK:         ParamTypes:
 CHECK:           - F64
 CHECK: - Type:            FUNCTION
 CHECK:   FunctionTypes: [ 0, 1 ]

lld/trunk/test/wasm/gc-sections.ll

 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: lld -flavor wasm -print-gc-sections -o %t1.wasm %t.o | FileCheck %s -check-prefix=PRINT-GC
+; RUN: wasm-ld -print-gc-sections -o %t1.wasm %t.o | FileCheck %s -check-prefix=PRINT-GC
 ; PRINT-GC: removing unused section 'unused_function' in file '{{.*}}'
 ; PRINT-GC-NOT: removing unused section 'used_function' in file '{{.*}}'
 ; PRINT-GC: removing unused section '.data.unused_data' in file '{{.*}}'
 ; PRINT-GC-NOT: removing unused section '.data.used_data' in file '{{.*}}'
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 @unused_data = hidden global i64 1, align 4

 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            used_function
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            _start
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            __wasm_call_ctors
 ; CHECK-NEXT: ...
 
-; RUN: lld -flavor wasm -print-gc-sections --no-gc-sections -o %t1.no-gc.wasm %t.o
+; RUN: wasm-ld -print-gc-sections --no-gc-sections -o %t1.no-gc.wasm %t.o
 ; RUN: obj2yaml %t1.no-gc.wasm | FileCheck %s -check-prefix=NO-GC
 
 ; NO-GC:        - Type:            TYPE
 ; NO-GC-NEXT:     Signatures:      
 ; NO-GC-NEXT:       - Index:           0
 ; NO-GC-NEXT:         ReturnType:      I64
 ; NO-GC-NEXT:         ParamTypes:      
 ; NO-GC-NEXT:       - Index:           1

 ; NO-GC-NEXT:       - Index:           1
 ; NO-GC-NEXT:         Name:            used_function
 ; NO-GC-NEXT:       - Index:           2
 ; NO-GC-NEXT:         Name:            _start
 ; NO-GC-NEXT:       - Index:           3
 ; NO-GC-NEXT:         Name:            __wasm_call_ctors
 ; NO-GC-NEXT: ...
 
-; RUN: not lld -flavor wasm --gc-sections --relocatable -o %t1.no-gc.wasm %t.o 2>&1 | FileCheck %s -check-prefix=CHECK-ERROR
-; CHECK-ERROR: lld{{.*}}: error: -r and --gc-sections may not be used together
+; RUN: not wasm-ld --gc-sections --relocatable -o %t1.no-gc.wasm %t.o 2>&1 | FileCheck %s -check-prefix=CHECK-ERROR
+; CHECK-ERROR: wasm-ld: error: -r and --gc-sections may not be used together

lld/trunk/test/wasm/import-memory.test

 # RUN: llc -filetype=obj %p/Inputs/start.ll -o %t.start.o
-# RUN: lld -flavor wasm --check-signatures --import-memory -o %t.wasm %t.start.o
+# RUN: wasm-ld --check-signatures --import-memory -o %t.wasm %t.start.o
 # RUN: obj2yaml %t.wasm | FileCheck %s
 
 # Verify the --import-memory flag creates a memory import
 
 # CHECK:       - Type:            IMPORT
 # CHECK-NEXT:    Imports:
 # CHECK-NEXT:      - Module:          env
 # CHECK-NEXT:        Field:           memory
 # CHECK-NEXT:        Kind:            MEMORY
 # CHECK-NEXT:        Memory:
 # CHECK-NEXT:          Initial:         0x00000002

lld/trunk/test/wasm/init-fini.ll

 ]
 
 @llvm.global_dtors = appending global [3 x { i32, void ()*, i8* }] [
   { i32, void ()*, i8* } { i32 1001, void ()* @func3, i8* null },
   { i32, void ()*, i8* } { i32 101, void ()* @func3, i8* null },
   { i32, void ()*, i8* } { i32 101, void ()* @func4, i8* null }
 ]
 
-; RUN: lld -flavor wasm --check-signatures %t.o %t.global-ctor-dtor.o -o %t.wasm
+; RUN: wasm-ld --check-signatures %t.o %t.global-ctor-dtor.o -o %t.wasm
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 ; CHECK:        - Type:            ELEM
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1
 ; CHECK-NEXT:         Functions:       [ 6, 8, 12, 14, 16 ]

 ; CHECK-NEXT:         Name:            .Lcall_dtors.2002
 ; CHECK-NEXT:       - Index:           17
 ; CHECK-NEXT:         Name:            .Lregister_call_dtors.2002
 ; CHECK-NEXT:       - Index:           18
 ; CHECK-NEXT:         Name:            __wasm_call_ctors
 ; CHECK-NEXT: ...
 
 
-; RUN: lld -flavor wasm --check-signatures -r %t.o %t.global-ctor-dtor.o -o %t.reloc.wasm
+; RUN: wasm-ld --check-signatures -r %t.o %t.global-ctor-dtor.o -o %t.reloc.wasm
 ; RUN: obj2yaml %t.reloc.wasm | FileCheck -check-prefix=RELOC %s
 
 ; RELOC:          Name:            linking
 ; RELOC-NEXT:     DataSize:        0
 ; RELOC-NEXT:     SymbolInfo:
 ; RELOC-NEXT:       - Name:            __dso_handle
 ; RELOC-NEXT:         Flags:           [ BINDING_WEAK, VISIBILITY_HIDDEN ]
 ; RELOC-NEXT:       - Name:            func1

lld/trunk/test/wasm/invalid-stack-size.test

 ; RUN: llc -filetype=obj %p/Inputs/start.ll -o %t.o
-; RUN: not lld -flavor wasm --check-signatures -o %t.wasm -z stack-size=1 %t.o 2>&1 | FileCheck %s
+; RUN: not wasm-ld --check-signatures -o %t.wasm -z stack-size=1 %t.o 2>&1 | FileCheck %s
 
 ; CHECK: error: stack size must be 16-byte aligned

lld/trunk/test/wasm/load-undefined.test

 ; Verify that the -u / --undefined option is able to pull in symbols from
 ; an archive, and doesn't error when uses to pull in a symbol already loaded.
 ;
 ; RUN: llc -filetype=obj %S/Inputs/ret64.ll -o %t.o
 ; RUN: llc -filetype=obj %S/Inputs/ret32.ll -o %t2.o
 ; RUN: llc -filetype=obj %S/Inputs/start.ll -o %t.start.o
 ; RUN: llvm-ar rcs %t2.a %t2.o
-; RUN: lld -flavor wasm --check-signatures %t.start.o %t2.a %t.o -o %t.wasm -u ret32 --undefined ret64
+; RUN: wasm-ld --check-signatures %t.start.o %t2.a %t.o -o %t.wasm -u ret32 --undefined ret64
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 ; CHECK:        - Type:            EXPORT
 ; CHECK-NEXT:     Exports:
 ; CHECK-NEXT:       - Name:            memory
 ; CHECK-NEXT:         Kind:            MEMORY
 ; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:       - Name:            _start

 ; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:       - Name:            __data_end
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         Index:           2
 ; CHECK-NEXT:   - Type:
 
 
 ; Verify that referencing a symbol that doesn't exist won't work
-; RUN: not lld -flavor wasm --check-signatures %t.start.o -o %t.wasm -u symboldoesnotexist 2>&1 | FileCheck -check-prefix=CHECK-UNDEFINED1 %s
+; RUN: not wasm-ld --check-signatures %t.start.o -o %t.wasm -u symboldoesnotexist 2>&1 | FileCheck -check-prefix=CHECK-UNDEFINED1 %s
 ; CHECK-UNDEFINED1: error: undefined symbol: symboldoesnotexist
 
-; RUN: not lld -flavor wasm --check-signatures %t.start.o -o %t.wasm --undefined symboldoesnotexist --allow-undefined 2>&1 | FileCheck -check-prefix=CHECK-UNDEFINED2 %s
+; RUN: not wasm-ld --check-signatures %t.start.o -o %t.wasm --undefined symboldoesnotexist --allow-undefined 2>&1 | FileCheck -check-prefix=CHECK-UNDEFINED2 %s
 ; CHECK-UNDEFINED2: function forced with --undefined not found: symboldoesnotexist

lld/trunk/test/wasm/local-symbols.ll

 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: lld -flavor wasm --check-signatures -o %t.wasm %t.o
+; RUN: wasm-ld --check-signatures -o %t.wasm %t.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 @foo = default global i32 1, align 4
 @bar = internal default global i32 3, align 4
 
 define internal i32 @baz() local_unnamed_addr {

lld/trunk/test/wasm/locals-duplicate.test

 ; RUN: llc -filetype=obj %p/Inputs/locals-duplicate1.ll -o %t1.o
 ; RUN: llc -filetype=obj %p/Inputs/locals-duplicate2.ll -o %t2.o
-; RUN: lld -flavor wasm --check-signatures --no-entry -o %t.wasm %t1.o %t2.o
+; RUN: wasm-ld --check-signatures --no-entry -o %t.wasm %t1.o %t2.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 ; CHECK:      --- !WASM
 ; CHECK-NEXT: FileHeader:
 ; CHECK-NEXT:   Version:         0x00000001
 ; CHECK-NEXT: Sections:
 ; CHECK-NEXT:   - Type:            TYPE
 ; CHECK-NEXT:     Signatures:

 ; CHECK-NEXT:         Name:            get_func2B
 ; CHECK-NEXT:       - Index:           17
 ; CHECK-NEXT:         Name:            get_func3B
 ; CHECK-NEXT:       - Index:           18
 ; CHECK-NEXT:         Name:            __wasm_call_ctors
 ; CHECK-NEXT: ...
 
 
-; RUN: lld -flavor wasm --check-signatures -r --no-entry -o %t.reloc.wasm %t1.o %t2.o
+; RUN: wasm-ld --check-signatures -r --no-entry -o %t.reloc.wasm %t1.o %t2.o
 ; RUN: obj2yaml %t.reloc.wasm | FileCheck -check-prefix=RELOC %s
 
 ; RELOC:      --- !WASM
 ; RELOC-NEXT: FileHeader:
 ; RELOC-NEXT:   Version:         0x00000001
 ; RELOC-NEXT: Sections:
 ; RELOC-NEXT:   - Type:            TYPE
 ; RELOC-NEXT:     Signatures:

lld/trunk/test/wasm/many-functions.ll

 ; RUN: llc -filetype=obj %p/Inputs/many-funcs.ll -o %t.many.o
 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: lld -flavor wasm --check-signatures -r -o %t.wasm %t.many.o %t.o
+; RUN: wasm-ld --check-signatures -r -o %t.wasm %t.many.o %t.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 ; Test that relocations within the CODE section correctly handle
 ; linking object with different header sizes.  many-funcs.ll has
 ; 128 function and so the final output requires a 2-byte LEB in
 ; the CODE section header to store the function count.
 
 target triple = "wasm32-unknown-unknown-wasm"

lld/trunk/test/wasm/relocatable.ll

 ; RUN: llc -filetype=obj %p/Inputs/hello.ll -o %t.hello.o
 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: lld -flavor wasm --check-signatures -r -o %t.wasm %t.hello.o %t.o
+; RUN: wasm-ld --check-signatures -r -o %t.wasm %t.hello.o %t.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 ; Function Attrs: nounwind
 define hidden i32 @my_func() local_unnamed_addr {
 entry:
   %call = tail call i32 @foo_import()

lld/trunk/test/wasm/signature-mismatch.ll

 ; RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
 ; RUN: llc -filetype=obj %s -o %t.main.o
-; RUN: not lld -flavor wasm --check-signatures -o %t.wasm %t.main.o %t.ret32.o 2>&1 | FileCheck %s
+; RUN: not wasm-ld --check-signatures -o %t.wasm %t.main.o %t.ret32.o 2>&1 | FileCheck %s
 ; Run the test again by with the object files in the other order to verify
 ; the check works when the undefined symbol is resolved by an existing defined
 ; one.
-; RUN: not lld -flavor wasm --check-signatures -o %t.wasm %t.ret32.o %t.main.o 2>&1 | FileCheck %s -check-prefix=REVERSE
+; RUN: not wasm-ld --check-signatures -o %t.wasm %t.ret32.o %t.main.o 2>&1 | FileCheck %s -check-prefix=REVERSE
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 ; Function Attrs: nounwind
 define hidden void @_start() local_unnamed_addr #0 {
 entry:
   %call = tail call i32 @ret32(i32 1, i64 2, i32 3) #2
   ret void

lld/trunk/test/wasm/stack-pointer.ll

 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: lld -flavor wasm --check-signatures --relocatable -o %t.wasm %t.o
+; RUN: wasm-ld --check-signatures --relocatable -o %t.wasm %t.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 ; Function Attrs: nounwind
 define i32 @_start() local_unnamed_addr {
 entry:
   %retval = alloca i32, align 4

lld/trunk/test/wasm/strip-debug.test

 RUN: llc -filetype=obj %p/Inputs/start.ll -o %t.start.o
-RUN: lld -flavor wasm --check-signatures --strip-debug -o %t.wasm %t.start.o
+RUN: wasm-ld --check-signatures --strip-debug -o %t.wasm %t.start.o
 RUN: obj2yaml %t.wasm | FileCheck %s
 
 # Check that there is no name section
 CHECK-NOT:   Name:    name

lld/trunk/test/wasm/symbol-type-mismatch.ll

 ; RUN: llc -filetype=obj %s -o %t.o
 ; RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
-; RUN: not lld -flavor wasm --check-signatures -o %t.wasm %t.o %t.ret32.o 2>&1 | FileCheck %s
+; RUN: not wasm-ld --check-signatures -o %t.wasm %t.o %t.ret32.o 2>&1 | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 @ret32 = extern_weak global i32, align 4
 
 ; CHECK: error: symbol type mismatch: ret32
 ; CHECK: >>> defined as Global in {{.*}}symbol-type-mismatch.ll.tmp.o
 ; CHECK: >>> defined as Function in {{.*}}.ret32.o

lld/trunk/test/wasm/undefined-entry.test

 RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
-RUN: not lld -flavor wasm --check-signatures -o %t.wasm %t.ret32.o 2>&1 | FileCheck %s
+RUN: not wasm-ld --check-signatures -o %t.wasm %t.ret32.o 2>&1 | FileCheck %s
 
 CHECK: error: undefined symbol: _start
 
-RUN: not lld -flavor wasm --check-signatures -entry=foo -o %t.wasm %t.ret32.o 2>&1 | FileCheck %s -check-prefix=CHECK-CUSTOM
+RUN: not wasm-ld --check-signatures -entry=foo -o %t.wasm %t.ret32.o 2>&1 | FileCheck %s -check-prefix=CHECK-CUSTOM
 
 CHECK-CUSTOM: error: undefined symbol: foo
 
-RUN: lld -flavor wasm --check-signatures -entry=foo --allow-undefined -o %t.wasm %t.ret32.o
+RUN: wasm-ld --check-signatures -entry=foo --allow-undefined -o %t.wasm %t.ret32.o

lld/trunk/test/wasm/undefined.ll

 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: lld -flavor wasm --check-signatures --allow-undefined -o %t.wasm %t.o
+; RUN: wasm-ld --check-signatures --allow-undefined -o %t.wasm %t.o
 
 ; Fails due to undefined 'foo'
-; RUN: not lld -flavor wasm --check-signatures -o %t.wasm %t.o 2>&1 | FileCheck %s
+; RUN: not wasm-ld --check-signatures -o %t.wasm %t.o 2>&1 | FileCheck %s
 ; CHECK: error: {{.*}}.o: undefined symbol: foo
 
 ; But succeeds if we pass a file containing 'foo' as --allow-undefined-file.
 ; RUN: echo 'foo' > %t.txt
-; RUN: lld -flavor wasm --check-signatures --allow-undefined-file=%t.txt -o %t.wasm %t.o
+; RUN: wasm-ld --check-signatures --allow-undefined-file=%t.txt -o %t.wasm %t.o
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 ; Takes the address of the external foo() resulting in undefined external
 @bar = hidden local_unnamed_addr global i8* bitcast (i32 ()* @foo to i8*), align 4
 
 declare i32 @foo() #0
 
 define hidden void @_start() local_unnamed_addr #0 {
 entry:
     ret void
 }

lld/trunk/test/wasm/version.ll

 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: lld -flavor wasm --check-signatures -o %t.wasm %t.o
+; RUN: wasm-ld --check-signatures -o %t.wasm %t.o
 ; RUN: llvm-readobj -file-headers %t.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 define hidden void @_start() local_unnamed_addr #0 {
 entry:
     ret void
 }
 
 ; CHECK: Format: WASM
 ; CHECK: Arch: wasm32
 ; CHECK: AddressSize: 32bit
 ; CHECK: Version: 0x1

lld/trunk/test/wasm/visibility-hidden.ll

 ; RUN: llc -filetype=obj -o %t.o %s
 ; RUN: llc -filetype=obj %S/Inputs/hidden.ll -o %t2.o
 ; RUN: llvm-ar rcs %t2.a %t2.o
-; RUN: lld -flavor wasm --check-signatures %t.o %t2.a -o %t.wasm
+; RUN: wasm-ld --check-signatures %t.o %t2.a -o %t.wasm
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 ; Test that hidden symbols are not exported, whether pulled in from an archive
 ; or directly.
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 define hidden i32 @objectHidden() {

lld/trunk/test/wasm/weak-alias-overide.ll

 ; RUN: llc -filetype=obj -o %t.o %s
 ; RUN: llc -filetype=obj %S/Inputs/weak-alias.ll -o %t2.o
-; RUN: lld -flavor wasm --check-signatures %t.o %t2.o -o %t.wasm
+; RUN: wasm-ld --check-signatures %t.o %t2.o -o %t.wasm
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 ; Test that the strongly defined alias_fn from this file is used both here
 ; and in call_alias.
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 define i32 @alias_fn() local_unnamed_addr #1 {

lld/trunk/test/wasm/weak-alias.ll

 ; RUN: llc -filetype=obj -o %t.o %s
 ; RUN: llc -filetype=obj %S/Inputs/weak-alias.ll -o %t2.o
-; RUN: lld -flavor wasm --check-signatures %t.o %t2.o -o %t.wasm
+; RUN: wasm-ld --check-signatures %t.o %t2.o -o %t.wasm
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 ; Test that weak aliases (alias_fn is a weak alias of direct_fn) are linked correctly
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 declare i32 @alias_fn() local_unnamed_addr #1
 

 ; CHECK-NEXT:       - Index:           4
 ; CHECK-NEXT:         Name:            call_alias_ptr
 ; CHECK-NEXT:       - Index:           5
 ; CHECK-NEXT:         Name:            call_direct_ptr
 ; CHECK-NEXT:       - Index:           6
 ; CHECK-NEXT:         Name:            __wasm_call_ctors
 ; CHECK-NEXT: ...
 
-; RUN: lld -flavor wasm --check-signatures --relocatable %t.o %t2.o -o %t.reloc.o
+; RUN: wasm-ld --check-signatures --relocatable %t.o %t2.o -o %t.reloc.o
 ; RUN: obj2yaml %t.reloc.o | FileCheck %s -check-prefix=RELOC
 
 ; RELOC:      --- !WASM
 ; RELOC-NEXT: FileHeader:
 ; RELOC-NEXT:   Version:         0x00000001
 ; RELOC-NEXT: Sections:
 ; RELOC-NEXT:   - Type:            TYPE
 ; RELOC-NEXT:     Signatures:

lld/trunk/test/wasm/weak-symbols.ll

 ; RUN: llc -filetype=obj %p/Inputs/weak-symbol1.ll -o %t1.o
 ; RUN: llc -filetype=obj %p/Inputs/weak-symbol2.ll -o %t2.o
 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: lld -flavor wasm -no-gc-sections --check-signatures -o %t.wasm %t.o %t1.o %t2.o
+; RUN: wasm-ld -no-gc-sections --check-signatures -o %t.wasm %t.o %t1.o %t2.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 declare i32 @weakFn() local_unnamed_addr
 @weakGlobal = external global i32
 
 define void @_start() local_unnamed_addr {

lld/trunk/test/wasm/weak-undefined.ll

 ; RUN: llc -filetype=obj -o %t.o %s
-; RUN: lld -flavor wasm --check-signatures -strip-debug %t.o -o %t.wasm
+; RUN: wasm-ld --check-signatures -strip-debug %t.o -o %t.wasm
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 ; Test that undefined weak externals (global_var) and (foo) don't cause
 ; link failures and resolve to zero.
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 @global_var = extern_weak global i32, align 4