[WebAssembly] Use inline target triple in test cases

[sbc100]

Summary

This is somewhat preferable since (in many cases) it allows llc
to be run directly on the .ll files without having to pass the
-mtriple argument.

[sbc100]

• revert docs change

docs/WebAssembly.rst

 Object file format
 ------------------
 
 The format the input object files that lld expects is specified as part of the
 the WebAssembly tool conventions
 https://github.com/WebAssembly/tool-conventions/blob/master/Linking.md.
 
 This is object format that the llvm will produce when run with the
-``wasm32-unknown-unknown-wasm`` target.  To build llvm with WebAssembly support
-currently requires enabling the experimental backed using
+``wasm32-unknown-unknown`` target triple.  To build llvm with WebAssembly
+support currently requires enabling the experimental backed using
 ``-DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD=WebAssembly``.
 
 
 Missing features
 ----------------
 
 There are several key features that are not yet implement in the WebAssembly
 ports:
 
 - COMDAT support.  This means that support for C++ is still very limited.
 - Function stripping.  Currently there is no support for ``--gc-sections`` so
   functions and data from a given object will linked as a unit.
 - Section start/end symbols.  The synthetic symbols that mark the start and
   of data regions are not yet created in the output file.

test/wasm/Inputs/archive1.ll

+target triple = "wasm32-unknown-unknown-wasm"
+
 declare i32 @bar() local_unnamed_addr #1
 
 define i32 @foo() local_unnamed_addr #0 {
 entry:
   %call = tail call i32 @bar() #2
   ret i32 %call
 }

test/wasm/Inputs/archive2.ll

+target triple = "wasm32-unknown-unknown-wasm"
+
 declare i32 @foo() local_unnamed_addr #1
 
 define i32 @bar() local_unnamed_addr #0 {
 entry:
   %call = tail call i32 @foo() #2
   ret i32 %call
 }

test/wasm/Inputs/call-indirect.ll

+target triple = "wasm32-unknown-unknown-wasm"
+
 @indirect_bar = internal local_unnamed_addr global i64 ()* @bar, align 4
 @indirect_foo = internal local_unnamed_addr global i32 ()* @foo, align 4
 
 declare i32 @foo() local_unnamed_addr
 
 define i64 @bar() {
 entry:
   ret i64 1

test/wasm/Inputs/comdat1.ll

+target triple = "wasm32-unknown-unknown-wasm"
+
 $inlineFn = comdat any
 @constantData = weak_odr constant [3 x i8] c"abc", comdat($inlineFn)
 define linkonce_odr i32 @inlineFn() comdat {
 entry:
   ret i32 ptrtoint ([3 x i8]* @constantData to i32)
 }
 
 define i32 @callInline1() {
 entry:
     ret i32 ptrtoint (i32 ()* @inlineFn to i32)
 }

test/wasm/Inputs/comdat2.ll

+target triple = "wasm32-unknown-unknown-wasm"
+
 $inlineFn = comdat any
 @constantData = weak_odr constant [3 x i8] c"abc", comdat($inlineFn)
 define linkonce_odr i32 @inlineFn() comdat {
 entry:
   ret i32 ptrtoint ([3 x i8]* @constantData to i32)
 }
 
 define i32 @callInline2() {
 entry:
     ret i32 ptrtoint (i32 ()* @inlineFn to i32)
 }

test/wasm/Inputs/global-ctor-dtor.ll

+target triple = "wasm32-unknown-unknown-wasm"
+
 define hidden void @myctor() {
 entry:
   ret void
 }
 
 define hidden void @mydtor() {
 entry:
   %ptr = alloca i32

test/wasm/Inputs/hello.ll

+target triple = "wasm32-unknown-unknown-wasm"
+
 ; Wasm module generated from the following C code:
 ;   void puts(const char*);
 ;   void hello() { puts("hello\n"); }
 
 @hello_str = unnamed_addr constant [7 x i8] c"hello\0A\00", align 1
 
 ; Function Attrs: nounwind
 define hidden void @hello() local_unnamed_addr #0 {
 entry:
   tail call void @puts(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @hello_str, i32 0, i32 0))
   ret void
 }
 
 ; Function Attrs: nounwind
 declare void @puts(i8* nocapture readonly) local_unnamed_addr #1

test/wasm/Inputs/hidden.ll

+target triple = "wasm32-unknown-unknown-wasm"
+
 ; Function Attrs: norecurse nounwind readnone
 define hidden i32 @archiveHidden() #0 {
 entry:
     ret i32 0
 }
 
 ; Function Attrs: norecurse nounwind readnone
 define i32 @archiveDefault() #1 {
 entry:
     ret i32 0
 }

test/wasm/Inputs/locals-duplicate1.ll

+target triple = "wasm32-unknown-unknown-wasm"
+
 ; Will collide: local (internal linkage) with global (external) linkage
 @colliding_global1 = internal default global i32 0, align 4
 ; Will collide: global with local
 @colliding_global2 = default global i32 0, align 4
 ; Will collide: local with local
 @colliding_global3 = internal default global i32 0, align 4
 
 ; Will collide: local with global

test/wasm/Inputs/locals-duplicate2.ll

+target triple = "wasm32-unknown-unknown-wasm"
+
 ; Will collide: local (internal linkage) with global (external) linkage
 @colliding_global1 = default global i32 0, align 4
 ; Will collide: global with local
 @colliding_global2 = internal default global i32 0, align 4
 ; Will collide: local with local
 @colliding_global3 = internal default global i32 0, align 4
 
 ; Will collide: local with global

test/wasm/Inputs/many-funcs.ll

+target triple = "wasm32-unknown-unknown-wasm"
+
 @g0 = global i32 1, align 4
 @foo = global i32 1, align 4
 
 define i32 @f1() {
 entry:
   %0 = load i32, i32* @foo, align 4
   ret i32 %0
 }

test/wasm/Inputs/ret32.ll

+target triple = "wasm32-unknown-unknown-wasm"
+
 ; Function Attrs: norecurse nounwind readnone
 define i32 @ret32(float %arg) #0 {
 entry:
     ret i32 0
      ; ptrtoint (i32 (float)* @ret32 to i32)
 }

test/wasm/Inputs/ret64.ll

+target triple = "wasm32-unknown-unknown-wasm"
+
 define i64 @ret64(double %arg) local_unnamed_addr #0 {
 entry:
     ret i64 1
 }

test/wasm/Inputs/weak-alias.ll

+target triple = "wasm32-unknown-unknown-wasm"
+
 ; Function Attrs: norecurse nounwind readnone
 define i32 @direct_fn() #0 {
 entry:
   ret i32 0
 }
 
 @alias_fn = weak alias i32 (), i32 ()* @direct_fn
 

test/wasm/Inputs/weak-symbol1.ll

+target triple = "wasm32-unknown-unknown-wasm"
+
 define weak i32 @weakFn() #0 {
 entry:
   ret i32 1
 }
 
 define i32 @exportWeak1() {
 entry:
     ret i32 ptrtoint (i32 ()* @weakFn to i32)
 }
 
 @weakGlobal = weak global i32 1

test/wasm/Inputs/weak-symbol2.ll

+target triple = "wasm32-unknown-unknown-wasm"
+
 define weak i32 @weakFn() #0 {
 entry:
   ret i32 2
 }
 
 define i32 @exportWeak2() {
 entry:
     ret i32 ptrtoint (i32 ()* @weakFn to i32)
 }
 
 @weakGlobal = weak global i32 2

test/wasm/alias.ll

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

test/wasm/archive.ll

-; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %s -o %t.o
-; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %S/Inputs/archive1.ll -o %t.a1.o
-; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %S/Inputs/archive2.ll -o %t.a2.o
-; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %S/Inputs/hello.ll -o %t.a3.o
+; 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 %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 %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
 
 define i32 @_start() local_unnamed_addr #0 {
 entry:
   %call1 = call i32 @foo() #2
   %call2 = call i32 @missing_func() #2
   ret i32 %call2

test/wasm/call-indirect.ll

-; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %p/Inputs/call-indirect.ll -o %t2.o
-; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %s -o %t.o
+; RUN: llc -filetype=obj %p/Inputs/call-indirect.ll -o %t2.o
+; RUN: llc -filetype=obj %s -o %t.o
 ; RUN: lld -flavor wasm -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"
+
 @indirect_func = local_unnamed_addr global i32 ()* @foo, align 4
 
 ; Function Attrs: norecurse nounwind readnone
 define i32 @foo() #0 {
 entry:
   ret i32 2
 }
 

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 -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:
   %call = call i32 @inlineFn()
   ret void
 }
 

test/wasm/conflict.test

-# RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %p/Inputs/ret32.ll -o %t.ret32.o
+# RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
 # RUN: not lld -flavor wasm -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

test/wasm/data-layout.ll

-; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %p/Inputs/hello.ll -o %t.hello.o
-; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %s -o %t.o
+; 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 --allow-undefined -o %t.wasm %t.o %t.hello.o

test/wasm/entry.ll

-; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %s -o %t.o
+; 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 -e entry -o %t1.wasm %t.o
 ; RUN: obj2yaml %t1.wasm | FileCheck %s

test/wasm/export.ll

-; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %s -o %t.o
+; RUN: llc -filetype=obj %s -o %t.o
 ; RUN: not lld -flavor wasm --export=missing -o %t.wasm %t.o 2>&1 | FileCheck -check-prefix=CHECK-ERROR %s
 ; RUN: lld -flavor wasm --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
 }
 
 define i32 @_start() local_unnamed_addr {
 entry:
   ret i32 0

test/wasm/function-imports-first.ll

-; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %p/Inputs/ret32.ll -o %t.ret32.o
-; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %s -o %t.o
+; RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
+; RUN: llc -filetype=obj %s -o %t.o
 ; RUN: lld -flavor wasm -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
   ret void
 }
 
 declare i32 @ret32(float) local_unnamed_addr #1

test/wasm/function-imports.ll

-; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %p/Inputs/ret32.ll -o %t.ret32.o
-; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %s -o %t.o
+; RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
+; RUN: llc -filetype=obj %s -o %t.o
 ; RUN: lld -flavor wasm -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
   ret void
 }
 
 declare i32 @ret32(float) local_unnamed_addr #1

test/wasm/function-index.test

-# RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %p/Inputs/ret32.ll -o %t.ret32.o
-# RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %p/Inputs/ret64.ll -o %t.ret64.o
+# 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 -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 ]

test/wasm/import-memory.test

-# RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %p/Inputs/ret32.ll -o %t.ret32.o
+# RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
 # RUN: lld -flavor wasm -entry ret32 --import-memory -o %t.wasm %t.ret32.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

test/wasm/init-fini.ll

-; RUN: llc -mtriple=wasm32-unknown-unknown-wasm -filetype=obj -o %t.o %s
-; RUN: llc -mtriple=wasm32-unknown-unknown-wasm -filetype=obj %S/Inputs/global-ctor-dtor.ll -o %t.global-ctor-dtor.o
+; RUN: llc -filetype=obj -o %t.o %s
+; RUN: llc -filetype=obj %S/Inputs/global-ctor-dtor.ll -o %t.global-ctor-dtor.o
+
+target triple = "wasm32-unknown-unknown-wasm"
 
 define hidden void @func1() {
 entry:
   ret void
 }
 
 define hidden void @func2() {
 entry:

test/wasm/invalid-stack-size.ll

-; RUN: llc -mtriple=wasm32-unknown-unknown-wasm -filetype=obj %s -o %t.o
+; RUN: llc -filetype=obj %s -o %t.o
 ; RUN: not lld -flavor wasm -o %t.wasm -z stack-size=1 %t.o 2>&1 | FileCheck %s
 
+target triple = "wasm32-unknown-unknown-wasm"
+
 define i32 @_start() local_unnamed_addr #1 {
 entry:
   ret i32 0
 }
 
 ; CHECK: error: stack size must be 16-byte aligned

test/wasm/load-undefined.ll

 ; 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 -mtriple=wasm32-unknown-unknown-wasm %S/Inputs/ret64.ll -o %t.o
-; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %S/Inputs/ret32.ll -o %t2.o
-; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %s -o %t3.o
+; 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 -o %t3.o
 ; RUN: llvm-ar rcs %t2.a %t2.o
 ; RUN: lld -flavor wasm %t3.o %t2.a %t.o -o %t.wasm -u ret32 --undefined ret64
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
+target triple = "wasm32-unknown-unknown-wasm"
+
 define i32 @_start() local_unnamed_addr {
 entry:
   ret i32 1
 }
 
 ; CHECK:        - Type:            EXPORT
 ; CHECK-NEXT:     Exports:
 ; CHECK-NEXT:       - Name:            memory

test/wasm/local-symbols.ll

-; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %s -o %t.o
+; RUN: llc -filetype=obj %s -o %t.o
 ; RUN: lld -flavor wasm -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 {
 entry:
   ret i32 2
 }
 

test/wasm/locals-duplicate.test

-; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %p/Inputs/locals-duplicate1.ll -o %t1.o
-; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %p/Inputs/locals-duplicate2.ll -o %t2.o
+; 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 --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

test/wasm/many-functions.ll

-; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %p/Inputs/many-funcs.ll -o %t.many.o
-; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %s -o %t.o
+; 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 -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"
+
 define i32 @func() {
 entry:
   %call = tail call i32 @func()
   ret i32 %call
 }
 
 ; CHECK:        - Type:            CODE
 ; CHECK-NEXT:     Relocations:

test/wasm/relocatable.ll

-; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %p/Inputs/hello.ll -o %t.hello.o
-; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %s -o %t.o
+; RUN: llc -filetype=obj %p/Inputs/hello.ll -o %t.hello.o
+; RUN: llc -filetype=obj %s -o %t.o
 ; RUN: lld -flavor wasm -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()
   %call2 = tail call i32 @bar_import()
   ret i32 1
 }
 

test/wasm/signature-mismatch.ll

-; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %p/Inputs/ret32.ll -o %t.ret32.o
-; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %s -o %t.main.o
+; 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
 
+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
 }
 
 declare i32 @ret32(i32, i64, i32) local_unnamed_addr #1
 
 ; CHECK: error: function signature mismatch: ret32
 ; CHECK-NEXT: >>> defined as (I32, I64, I32) -> I32 in {{.*}}.main.o
 ; CHECK-NEXT: >>> defined as (F32) -> I32 in {{.*}}.ret32.o

test/wasm/stack-pointer.ll

-; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %s -o %t.o
+; RUN: llc -filetype=obj %s -o %t.o
 ; RUN: lld -flavor wasm --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
   ret i32 0
 }
 
 ; CHECK:      --- !WASM

test/wasm/strip-debug.test

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

test/wasm/symbol-type-mismatch.ll

-; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %s -o %t.o
-; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %p/Inputs/ret32.ll -o %t.ret32.o
+; 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 -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

test/wasm/undefined-entry.test

-RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %p/Inputs/ret32.ll -o %t.ret32.o
+RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
 RUN: not lld -flavor wasm -o %t.wasm %t.ret32.o 2>&1 | FileCheck %s
 
 CHECK: error: undefined symbol: _start
 
 RUN: not lld -flavor wasm -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 -entry=foo --allow-undefined -o %t.wasm %t.ret32.o

test/wasm/undefined.ll

-; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %s -o %t.o
+; RUN: llc -filetype=obj %s -o %t.o
 ; RUN: lld -flavor wasm --allow-undefined -o %t.wasm %t.o
 
 ; Fails due to undefined 'foo'
 ; RUN: not lld -flavor wasm -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 --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
 }

test/wasm/version.ll

-; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %s -o %t.o
+; RUN: llc -filetype=obj %s -o %t.o
 ; RUN: lld -flavor wasm -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

test/wasm/visibility-hidden.ll

-; RUN: llc -mtriple=wasm32-unknown-unknown-wasm -filetype=obj -o %t.o %s
-; RUN: llc -mtriple=wasm32-unknown-unknown-wasm -filetype=obj %S/Inputs/hidden.ll -o %t2.o
+; 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 %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() {
 entry:
     ret i32 0
 }
 
 define i32 @objectDefault() {
 entry:
     ret i32 0

test/wasm/weak-alias-overide.ll

-; RUN: llc -mtriple=wasm32-unknown-unknown-wasm -filetype=obj -o %t.o %s
-; RUN: llc -mtriple=wasm32-unknown-unknown-wasm -filetype=obj %S/Inputs/weak-alias.ll -o %t2.o
+; RUN: llc -filetype=obj -o %t.o %s
+; RUN: llc -filetype=obj %S/Inputs/weak-alias.ll -o %t2.o
 ; RUN: lld -flavor wasm %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 {
   ret i32 1
 }
 
 ; Function Attrs: nounwind uwtable
 define void @_start() local_unnamed_addr #1 {
 entry:
   %call = tail call i32 @alias_fn() #2

test/wasm/weak-alias.ll

-; RUN: llc -mtriple=wasm32-unknown-unknown-wasm -filetype=obj -o %t.o %s
-; RUN: llc -mtriple=wasm32-unknown-unknown-wasm -filetype=obj %S/Inputs/weak-alias.ll -o %t2.o
+; RUN: llc -filetype=obj -o %t.o %s
+; RUN: llc -filetype=obj %S/Inputs/weak-alias.ll -o %t2.o
 ; RUN: lld -flavor wasm %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
 
 ; Function Attrs: nounwind uwtable
 define i32 @_start() local_unnamed_addr #1 {
 entry:
   %call = tail call i32 @alias_fn() #2
   ret i32 %call
 }

test/wasm/weak-symbols.ll

-; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %p/Inputs/weak-symbol1.ll -o %t1.o
-; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %p/Inputs/weak-symbol2.ll -o %t2.o
-; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %s -o %t.o
+; 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 -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 i32 @_start() local_unnamed_addr {
 entry:
   %call = call i32 @weakFn()
   %val = load i32, i32* @weakGlobal, align 4
   ret i32 %val

test/wasm/weak-undefined.ll

-; RUN: llc -mtriple=wasm32-unknown-unknown-wasm -filetype=obj -o %t.o %s
+; RUN: llc -filetype=obj -o %t.o %s
 ; RUN: lld -flavor wasm -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
 
 declare extern_weak i32 @foo()
 
 define i8* @get_address_of_foo() #0 {
 entry:
   ret i8* bitcast (i32 ()* @foo to i8*)
 }