This is an archive of the discontinued LLVM Phabricator instance.

Differential D46342

[WebAsembly] Update default triple in test files to wasm32-unknown-unkown.
ClosedPublic

Authored by sbc100 on May 1 2018, 5:56 PM.

Details

Reviewers
jgravelle-google
sunfish
dschuff
Commits
rGa5908009cdf9: [WebAsembly] Update default triple in test files to wasm32-unknown-unkown.
rL332007: [WebAsembly] Update default triple in test files to wasm32-unknown-unkown.
Summary

The final -wasm component has been the default for some time now.

Diff Detail

Repository
rL LLVM

Event Timeline

sbc100 created this revision.May 1 2018, 5:56 PM
Herald added subscribers: llvm-commits, sunfish, JDevlieghere and 5 others. · View Herald TranscriptMay 1 2018, 5:56 PM
Harbormaster completed remote builds in B17595: Diff 144817.May 1 2018, 5:56 PM
sbc100 added reviewers: jgravelle-google, sunfish.May 1 2018, 5:57 PM
sbc100 added a reviewer: dschuff.May 10 2018, 9:40 AM

ping

dschuff accepted this revision.May 10 2018, 10:27 AM
This revision is now accepted and ready to land.May 10 2018, 10:27 AM
Closed by commit rL332007: [WebAsembly] Update default triple in test files to wasm32-unknown-unkown. (authored by sbc). · Explain WhyMay 10 2018, 10:53 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
llvm/
trunk/
test/
CodeGen/
WebAssembly/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
8 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
DebugInfo/
WebAssembly/
6 lines
2 lines
MC/
WebAssembly/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
Object/
Inputs/
2 lines
tools/
llvm-nm/
wasm/
2 lines
llvm-objdump/
Inputs/
2 lines
WebAssembly/
2 lines
llvm-readobj/
Inputs/
2 lines

Diff 146159

llvm/trunk/test/CodeGen/WebAssembly/address-offsets.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s
; Test folding constant offsets and symbols into load and store addresses under ; Test folding constant offsets and symbols into load and store addresses under
; a variety of circumstances. ; a variety of circumstances.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
@g = external global [0 x i32], align 4 @g = external global [0 x i32], align 4
; CHECK-LABEL: load_test0: ; CHECK-LABEL: load_test0:
; CHECK-NEXT: result i32{{$}} ; CHECK-NEXT: result i32{{$}}
; CHECK-NEXT: i32.const $push0=, 0{{$}} ; CHECK-NEXT: i32.const $push0=, 0{{$}}
; CHECK-NEXT: i32.load $push1=, g+40($pop0){{$}} ; CHECK-NEXT: i32.load $push1=, g+40($pop0){{$}}
; CHECK-NEXT: return $pop1{{$}} ; CHECK-NEXT: return $pop1{{$}}
▲ Show 20 Lines • Show All 661 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/byval.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -verify-machineinstrs | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -verify-machineinstrs | FileCheck %s
; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -verify-machineinstrs -fast-isel | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -verify-machineinstrs -fast-isel | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
%SmallStruct = type { i32 } %SmallStruct = type { i32 }
%OddStruct = type { i32, i8, i32 } %OddStruct = type { i32, i8, i32 }
%AlignedStruct = type { double, double } %AlignedStruct = type { double, double }
%BigStruct = type { double, double, double, double, double, double, double, double, double, double, double, i8, i8, i8 } %BigStruct = type { double, double, double, double, double, double, double, double, double, double, double, i8, i8, i8 }
%EmptyStruct = type { } %EmptyStruct = type { }
%BigArray = type { [33 x i8] } %BigArray = type { [33 x i8] }
▲ Show 20 Lines • Show All 114 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/call.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-temporary-workarounds=false | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-temporary-workarounds=false | FileCheck %s
; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -fast-isel -fast-isel-abort=1 -wasm-temporary-workarounds=false | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -fast-isel -fast-isel-abort=1 -wasm-temporary-workarounds=false | FileCheck %s
; Test that basic call operations assemble as expected. ; Test that basic call operations assemble as expected.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
declare i32 @i32_nullary() declare i32 @i32_nullary()
declare i32 @i32_unary(i32) declare i32 @i32_unary(i32)
declare i32 @i32_binary(i32, i32) declare i32 @i32_binary(i32, i32)
declare i64 @i64_nullary() declare i64 @i64_nullary()
declare float @float_nullary() declare float @float_nullary()
declare double @double_nullary() declare double @double_nullary()
declare void @void_nullary() declare void @void_nullary()
▲ Show 20 Lines • Show All 163 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/cfg-stackify.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -disable-block-placement -verify-machineinstrs -fast-isel=false -machine-sink-split-probability-threshold=0 -cgp-freq-ratio-to-skip-merge=1000 | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -disable-block-placement -verify-machineinstrs -fast-isel=false -machine-sink-split-probability-threshold=0 -cgp-freq-ratio-to-skip-merge=1000 | FileCheck %s
; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -tail-dup-placement=0 -verify-machineinstrs -fast-isel=false -machine-sink-split-probability-threshold=0 -cgp-freq-ratio-to-skip-merge=1000 | FileCheck -check-prefix=OPT %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -tail-dup-placement=0 -verify-machineinstrs -fast-isel=false -machine-sink-split-probability-threshold=0 -cgp-freq-ratio-to-skip-merge=1000 | FileCheck -check-prefix=OPT %s
; Test the CFG stackifier pass. ; Test the CFG stackifier pass.
; Explicitly disable fast-isel, since it gets implicitly enabled in the ; Explicitly disable fast-isel, since it gets implicitly enabled in the
; optnone test. ; optnone test.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
declare void @something() declare void @something()
; Test that loops are made contiguous, even in the presence of split backedges. ; Test that loops are made contiguous, even in the presence of split backedges.
; CHECK-LABEL: test0: ; CHECK-LABEL: test0:
; CHECK: loop ; CHECK: loop
; CHECK-NEXT: block ; CHECK-NEXT: block
▲ Show 20 Lines • Show All 1,318 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/cfi.ll

; RUN: opt -S -lowertypetests < %s | llc -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s ; RUN: opt -S -lowertypetests < %s | llc -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s
; Tests that we correctly assign indexes for control flow integrity. ; Tests that we correctly assign indexes for control flow integrity.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
@0 = private unnamed_addr constant [2 x void (...)*] [void (...)* bitcast (void ()* @f to void (...)*), void (...)* bitcast (void ()* @g to void (...)*)], align 16 @0 = private unnamed_addr constant [2 x void (...)*] [void (...)* bitcast (void ()* @f to void (...)*), void (...)* bitcast (void ()* @g to void (...)*)], align 16
; CHECK-LABEL: h: ; CHECK-LABEL: h:
; CHECK-NOT: .indidx ; CHECK-NOT: .indidx
define void @h() !type !0 { define void @h() !type !0 {
ret void ret void
} }
Show All 39 Lines

llvm/trunk/test/CodeGen/WebAssembly/comparisons_f32.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s
; Test that basic 32-bit floating-point comparison operations assemble as ; Test that basic 32-bit floating-point comparison operations assemble as
; expected. ; expected.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK-LABEL: ord_f32: ; CHECK-LABEL: ord_f32:
; CHECK-NEXT: .param f32, f32{{$}} ; CHECK-NEXT: .param f32, f32{{$}}
; CHECK-NEXT: .result i32{{$}} ; CHECK-NEXT: .result i32{{$}}
; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}}
; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 0{{$}}
; CHECK-NEXT: f32.eq $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: f32.eq $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 1{{$}}
▲ Show 20 Lines • Show All 189 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/comparisons_f64.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s
; Test that basic 64-bit floating-point comparison operations assemble as ; Test that basic 64-bit floating-point comparison operations assemble as
; expected. ; expected.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK-LABEL: ord_f64: ; CHECK-LABEL: ord_f64:
; CHECK-NEXT: .param f64, f64{{$}} ; CHECK-NEXT: .param f64, f64{{$}}
; CHECK-NEXT: .result i32{{$}} ; CHECK-NEXT: .result i32{{$}}
; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}}
; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 0{{$}}
; CHECK-NEXT: f64.eq $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: f64.eq $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 1{{$}}
▲ Show 20 Lines • Show All 188 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/comparisons_i32.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s
; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -fast-isel -fast-isel-abort=1 | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -fast-isel -fast-isel-abort=1 | FileCheck %s
; Test that basic 32-bit integer comparison operations assemble as expected. ; Test that basic 32-bit integer comparison operations assemble as expected.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK-LABEL: eq_i32: ; CHECK-LABEL: eq_i32:
; CHECK-NEXT: .param i32, i32{{$}} ; CHECK-NEXT: .param i32, i32{{$}}
; CHECK-NEXT: .result i32{{$}} ; CHECK-NEXT: .result i32{{$}}
; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}}
; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}}
; CHECK-NEXT: i32.eq $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: i32.eq $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
; CHECK-NEXT: return $pop[[NUM]]{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}}
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/comparisons_i64.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s
; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -fast-isel -fast-isel-abort=1 | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -fast-isel -fast-isel-abort=1 | FileCheck %s
; Test that basic 64-bit integer comparison operations assemble as expected. ; Test that basic 64-bit integer comparison operations assemble as expected.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK-LABEL: eq_i64: ; CHECK-LABEL: eq_i64:
; CHECK-NEXT: .param i64, i64{{$}} ; CHECK-NEXT: .param i64, i64{{$}}
; CHECK-NEXT: .result i32{{$}} ; CHECK-NEXT: .result i32{{$}}
; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}}
; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}}
; CHECK-NEXT: i64.eq $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: i64.eq $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
; CHECK-NEXT: return $pop[[NUM]]{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}}
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/conv-trap.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -mattr=-nontrapping-fptoint | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -mattr=-nontrapping-fptoint | FileCheck %s
; Test that basic conversion operations assemble as expected using ; Test that basic conversion operations assemble as expected using
; the trapping opcodes and explicit code to suppress the trapping. ; the trapping opcodes and explicit code to suppress the trapping.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK-LABEL: i32_trunc_s_f32: ; CHECK-LABEL: i32_trunc_s_f32:
; CHECK-NEXT: .param f32{{$}} ; CHECK-NEXT: .param f32{{$}}
; CHECK-NEXT: .result i32{{$}} ; CHECK-NEXT: .result i32{{$}}
; CHECK-NEXT: block ; CHECK-NEXT: block
; CHECK-NEXT: f32.abs $push[[ABS:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: f32.abs $push[[ABS:[0-9]+]]=, $0{{$}}
; CHECK-NEXT: f32.const $push[[LIMIT:[0-9]+]]=, 0x1p31{{$}} ; CHECK-NEXT: f32.const $push[[LIMIT:[0-9]+]]=, 0x1p31{{$}}
; CHECK-NEXT: f32.lt $push[[LT:[0-9]+]]=, $pop[[ABS]], $pop[[LIMIT]]{{$}} ; CHECK-NEXT: f32.lt $push[[LT:[0-9]+]]=, $pop[[ABS]], $pop[[LIMIT]]{{$}}
▲ Show 20 Lines • Show All 152 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/conv.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -mattr=+nontrapping-fptoint | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -mattr=+nontrapping-fptoint | FileCheck %s
; Test that basic conversion operations assemble as expected. ; Test that basic conversion operations assemble as expected.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK-LABEL: i32_wrap_i64: ; CHECK-LABEL: i32_wrap_i64:
; CHECK-NEXT: .param i64{{$}} ; CHECK-NEXT: .param i64{{$}}
; CHECK-NEXT: .result i32{{$}} ; CHECK-NEXT: .result i32{{$}}
; CHECK-NEXT: i32.wrap/i64 $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: i32.wrap/i64 $push[[NUM:[0-9]+]]=, $0{{$}}
; CHECK-NEXT: return $pop[[NUM]]{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}}
define i32 @i32_wrap_i64(i64 %x) { define i32 @i32_wrap_i64(i64 %x) {
%a = trunc i64 %x to i32 %a = trunc i64 %x to i32
▲ Show 20 Lines • Show All 241 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/copysign-casts.ll

; RUN: llc < %s -asm-verbose=false | FileCheck %s ; RUN: llc < %s -asm-verbose=false | FileCheck %s
; DAGCombiner oddly folds casts into the rhs of copysign. Test that they get ; DAGCombiner oddly folds casts into the rhs of copysign. Test that they get
; unfolded. ; unfolded.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
declare double @copysign(double, double) nounwind readnone declare double @copysign(double, double) nounwind readnone
declare float @copysignf(float, float) nounwind readnone declare float @copysignf(float, float) nounwind readnone
; CHECK-LABEL: fold_promote: ; CHECK-LABEL: fold_promote:
; CHECK: f64.promote/f32 $push0=, $pop{{[0-9]+}}{{$}} ; CHECK: f64.promote/f32 $push0=, $pop{{[0-9]+}}{{$}}
; CHECK: f64.copysign $push1=, $pop{{[0-9]+}}, $pop0{{$}} ; CHECK: f64.copysign $push1=, $pop{{[0-9]+}}, $pop0{{$}}
define double @fold_promote(double %a, float %b) { define double @fold_promote(double %a, float %b) {
Show All 13 Lines

llvm/trunk/test/CodeGen/WebAssembly/cpus.ll

; This tests that llc accepts all valid WebAssembly CPUs. ; This tests that llc accepts all valid WebAssembly CPUs.
; RUN: llc < %s -asm-verbose=false -mtriple=wasm32-unknown-unknown-wasm -mcpu=mvp 2>&1 | FileCheck %s ; RUN: llc < %s -asm-verbose=false -mtriple=wasm32-unknown-unknown -mcpu=mvp 2>&1 | FileCheck %s
; RUN: llc < %s -asm-verbose=false -mtriple=wasm64-unknown-unknown-wasm -mcpu=mvp 2>&1 | FileCheck %s ; RUN: llc < %s -asm-verbose=false -mtriple=wasm64-unknown-unknown-wasm -mcpu=mvp 2>&1 | FileCheck %s
; RUN: llc < %s -asm-verbose=false -mtriple=wasm32-unknown-unknown-wasm -mcpu=generic 2>&1 | FileCheck %s ; RUN: llc < %s -asm-verbose=false -mtriple=wasm32-unknown-unknown -mcpu=generic 2>&1 | FileCheck %s
; RUN: llc < %s -asm-verbose=false -mtriple=wasm64-unknown-unknown-wasm -mcpu=generic 2>&1 | FileCheck %s ; RUN: llc < %s -asm-verbose=false -mtriple=wasm64-unknown-unknown-wasm -mcpu=generic 2>&1 | FileCheck %s
; RUN: llc < %s -asm-verbose=false -mtriple=wasm32-unknown-unknown-wasm -mcpu=bleeding-edge 2>&1 | FileCheck %s ; RUN: llc < %s -asm-verbose=false -mtriple=wasm32-unknown-unknown -mcpu=bleeding-edge 2>&1 | FileCheck %s
; RUN: llc < %s -asm-verbose=false -mtriple=wasm64-unknown-unknown-wasm -mcpu=bleeding-edge 2>&1 | FileCheck %s ; RUN: llc < %s -asm-verbose=false -mtriple=wasm64-unknown-unknown-wasm -mcpu=bleeding-edge 2>&1 | FileCheck %s
; RUN: llc < %s -asm-verbose=false -mtriple=wasm32-unknown-unknown-wasm -mcpu=invalidcpu 2>&1 | FileCheck %s --check-prefix=INVALID ; RUN: llc < %s -asm-verbose=false -mtriple=wasm32-unknown-unknown -mcpu=invalidcpu 2>&1 | FileCheck %s --check-prefix=INVALID
; RUN: llc < %s -asm-verbose=false -mtriple=wasm64-unknown-unknown-wasm -mcpu=invalidcpu 2>&1 | FileCheck %s --check-prefix=INVALID ; RUN: llc < %s -asm-verbose=false -mtriple=wasm64-unknown-unknown-wasm -mcpu=invalidcpu 2>&1 | FileCheck %s --check-prefix=INVALID
; CHECK-NOT: is not a recognized processor for this target ; CHECK-NOT: is not a recognized processor for this target
; INVALID: {{.+}} is not a recognized processor for this target ; INVALID: {{.+}} is not a recognized processor for this target
define i32 @f(i32 %i_like_the_web) { define i32 @f(i32 %i_like_the_web) {
ret i32 %i_like_the_web ret i32 %i_like_the_web
} }

llvm/trunk/test/CodeGen/WebAssembly/custom-sections.ll

; RUN: llc < %s -asm-verbose=false | FileCheck %s ; RUN: llc < %s -asm-verbose=false | FileCheck %s
; Test the mechanism for defining user custom sections. ; Test the mechanism for defining user custom sections.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
!0 = !{ !"red", !"foo" } !0 = !{ !"red", !"foo" }
!1 = !{ !"green", !"bar" } !1 = !{ !"green", !"bar" }
!2 = !{ !"green", !"qux" } !2 = !{ !"green", !"qux" }
!wasm.custom_sections = !{ !0, !1, !2 } !wasm.custom_sections = !{ !0, !1, !2 }
; CHECK: .section .custom_section.red,"",@ ; CHECK: .section .custom_section.red,"",@
; CHECK-NEXT: .ascii "foo" ; CHECK-NEXT: .ascii "foo"
; CHECK: .section .custom_section.green,"",@ ; CHECK: .section .custom_section.green,"",@
; CHECK-NEXT: .ascii "bar" ; CHECK-NEXT: .ascii "bar"
; CHECK: .section .custom_section.green,"",@ ; CHECK: .section .custom_section.green,"",@
; CHECK-NEXT: .ascii "qux" ; CHECK-NEXT: .ascii "qux"

llvm/trunk/test/CodeGen/WebAssembly/dbgvalue.ll

; RUN: llc < %s -O0 -verify-machineinstrs | FileCheck %s ; RUN: llc < %s -O0 -verify-machineinstrs | FileCheck %s
; CHECK: %bb.0 ; CHECK: %bb.0
; CHECK: #DEBUG_VALUE: usage:self <- %4 ; CHECK: #DEBUG_VALUE: usage:self <- %4
; CHECK: %bb.1 ; CHECK: %bb.1
; CHECK: DW_TAG_variable ; CHECK: DW_TAG_variable
source_filename = "test/CodeGen/WebAssembly/dbgvalue.ll" source_filename = "test/CodeGen/WebAssembly/dbgvalue.ll"
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
@key = external local_unnamed_addr global [15 x i8], align 1 @key = external local_unnamed_addr global [15 x i8], align 1
@.str = external unnamed_addr constant [33 x i8], align 1 @.str = external unnamed_addr constant [33 x i8], align 1
define internal i32 @0(i8*) local_unnamed_addr !dbg !15 !type !23 { define internal i32 @0(i8*) local_unnamed_addr !dbg !15 !type !23 {
tail call void @llvm.dbg.value(metadata i8* %0, i64 0, metadata !22, metadata !24), !dbg !25 tail call void @llvm.dbg.value(metadata i8* %0, i64 0, metadata !22, metadata !24), !dbg !25
%2 = tail call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str, i32 0, i32 0), i8* %0), !dbg !26 %2 = tail call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str, i32 0, i32 0), i8* %0), !dbg !26
br i1 true, label %a, label %b br i1 true, label %a, label %b
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/dead-vreg.ll

; RUN: llc < %s -asm-verbose=false -verify-machineinstrs | FileCheck %s ; RUN: llc < %s -asm-verbose=false -verify-machineinstrs | FileCheck %s
; Check that unused vregs aren't assigned registers. ; Check that unused vregs aren't assigned registers.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
define void @foo(i32* nocapture %a, i32 %w, i32 %h) { define void @foo(i32* nocapture %a, i32 %w, i32 %h) {
; CHECK-LABEL: foo: ; CHECK-LABEL: foo:
; CHECK-NEXT: .param i32, i32, i32{{$}} ; CHECK-NEXT: .param i32, i32, i32{{$}}
; CHECK-NEXT: .local i32, i32, i32, i32, i32, i32{{$}} ; CHECK-NEXT: .local i32, i32, i32, i32, i32, i32{{$}}
entry: entry:
%cmp.19 = icmp sgt i32 %h, 0 %cmp.19 = icmp sgt i32 %h, 0
br i1 %cmp.19, label %for.cond.1.preheader.lr.ph, label %for.end.7 br i1 %cmp.19, label %for.cond.1.preheader.lr.ph, label %for.end.7
Show All 37 Lines

llvm/trunk/test/CodeGen/WebAssembly/divrem-constant.ll

; RUN: llc < %s -asm-verbose=false | FileCheck %s ; RUN: llc < %s -asm-verbose=false | FileCheck %s
; Test that integer div and rem by constant are optimized appropriately. ; Test that integer div and rem by constant are optimized appropriately.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK-LABEL: test_udiv_2: ; CHECK-LABEL: test_udiv_2:
; CHECK: i32.shr_u ; CHECK: i32.shr_u
define i32 @test_udiv_2(i32 %x) { define i32 @test_udiv_2(i32 %x) {
%t = udiv i32 %x, 2 %t = udiv i32 %x, 2
ret i32 %t ret i32 %t
} }
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/exception.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
declare void @llvm.wasm.throw(i32, i8*) declare void @llvm.wasm.throw(i32, i8*)
declare void @llvm.wasm.rethrow() declare void @llvm.wasm.rethrow()
; CHECK-LABEL: throw: ; CHECK-LABEL: throw:
; CHECK-NEXT: i32.const $push0=, 0 ; CHECK-NEXT: i32.const $push0=, 0
; CHECK-NEXT: throw 0, $pop0 ; CHECK-NEXT: throw 0, $pop0
define void @throw() { define void @throw() {
Show All 10 Lines

llvm/trunk/test/CodeGen/WebAssembly/f16.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s
; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -fast-isel | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -fast-isel | FileCheck %s
; Test that f16 is expanded. ; Test that f16 is expanded.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK-LABEL: demote: ; CHECK-LABEL: demote:
; CHECK-NEXT: .param f32{{$}} ; CHECK-NEXT: .param f32{{$}}
; CHECK-NEXT: .result f32{{$}} ; CHECK-NEXT: .result f32{{$}}
; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}}
; CHECK-NEXT: i32.call $push[[L1:[0-9]+]]=, __gnu_f2h_ieee@FUNCTION, $pop[[L0]]{{$}} ; CHECK-NEXT: i32.call $push[[L1:[0-9]+]]=, __gnu_f2h_ieee@FUNCTION, $pop[[L0]]{{$}}
; CHECK-NEXT: f32.call $push[[L2:[0-9]+]]=, __gnu_h2f_ieee@FUNCTION, $pop[[L1]]{{$}} ; CHECK-NEXT: f32.call $push[[L2:[0-9]+]]=, __gnu_h2f_ieee@FUNCTION, $pop[[L1]]{{$}}
; CHECK-NEXT: return $pop[[L2]]{{$}} ; CHECK-NEXT: return $pop[[L2]]{{$}}
Show All 14 Lines

llvm/trunk/test/CodeGen/WebAssembly/f32.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s
; Test that basic 32-bit floating-point operations assemble as expected. ; Test that basic 32-bit floating-point operations assemble as expected.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
declare float @llvm.fabs.f32(float) declare float @llvm.fabs.f32(float)
declare float @llvm.copysign.f32(float, float) declare float @llvm.copysign.f32(float, float)
declare float @llvm.sqrt.f32(float) declare float @llvm.sqrt.f32(float)
declare float @llvm.ceil.f32(float) declare float @llvm.ceil.f32(float)
declare float @llvm.floor.f32(float) declare float @llvm.floor.f32(float)
declare float @llvm.trunc.f32(float) declare float @llvm.trunc.f32(float)
declare float @llvm.nearbyint.f32(float) declare float @llvm.nearbyint.f32(float)
▲ Show 20 Lines • Show All 142 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/f64.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s
; Test that basic 64-bit floating-point operations assemble as expected. ; Test that basic 64-bit floating-point operations assemble as expected.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
declare double @llvm.fabs.f64(double) declare double @llvm.fabs.f64(double)
declare double @llvm.copysign.f64(double, double) declare double @llvm.copysign.f64(double, double)
declare double @llvm.sqrt.f64(double) declare double @llvm.sqrt.f64(double)
declare double @llvm.ceil.f64(double) declare double @llvm.ceil.f64(double)
declare double @llvm.floor.f64(double) declare double @llvm.floor.f64(double)
declare double @llvm.trunc.f64(double) declare double @llvm.trunc.f64(double)
declare double @llvm.nearbyint.f64(double) declare double @llvm.nearbyint.f64(double)
▲ Show 20 Lines • Show All 142 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/fast-isel-i24.ll

; RUN: llc < %s -O0 ; RUN: llc < %s -O0
; PR36564 ; PR36564
; Test that fast-isel properly copes with i24 arguments and return types. ; Test that fast-isel properly copes with i24 arguments and return types.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
define i24 @add(i24 %x, i24 %y) { define i24 @add(i24 %x, i24 %y) {
%z = add i24 %x, %y %z = add i24 %x, %y
ret i24 %z ret i24 %z
} }
define i24 @return_zero() { define i24 @return_zero() {
ret i24 0 ret i24 0
} }

llvm/trunk/test/CodeGen/WebAssembly/fast-isel-noreg.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -verify-machineinstrs | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -verify-machineinstrs | FileCheck %s
; RUN: llc < %s -asm-verbose=false -fast-isel -verify-machineinstrs | FileCheck %s ; RUN: llc < %s -asm-verbose=false -fast-isel -verify-machineinstrs | FileCheck %s
; Test that FastISel does not generate instructions with NoReg ; Test that FastISel does not generate instructions with NoReg
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK: i32.const $push0=, 0 ; CHECK: i32.const $push0=, 0
define hidden i32 @a() #0 { define hidden i32 @a() #0 {
entry: entry:
ret i32 zext (i1 icmp eq (void (...)* inttoptr (i32 10 to void (...)*), void (...)* null) to i32) ret i32 zext (i1 icmp eq (void (...)* inttoptr (i32 10 to void (...)*), void (...)* null) to i32)
} }
; CHECK: i32.const $push0=, 1 ; CHECK: i32.const $push0=, 1
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/fast-isel.ll

; RUN: llc < %s -asm-verbose=false \ ; RUN: llc < %s -asm-verbose=false \
; RUN: -fast-isel -fast-isel-abort=1 -verify-machineinstrs \ ; RUN: -fast-isel -fast-isel-abort=1 -verify-machineinstrs \
; RUN: -disable-wasm-explicit-locals \ ; RUN: -disable-wasm-explicit-locals \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; This tests very minimal fast-isel functionality. ; This tests very minimal fast-isel functionality.
; CHECK-LABEL: immediate_f32: ; CHECK-LABEL: immediate_f32:
; CHECK: f32.const $push{{[0-9]+}}=, 0x1.4p1{{$}} ; CHECK: f32.const $push{{[0-9]+}}=, 0x1.4p1{{$}}
define float @immediate_f32() { define float @immediate_f32() {
ret float 2.5 ret float 2.5
} }
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/frem.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s
; Test that the frem instruction works. ; Test that the frem instruction works.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK-LABEL: frem32: ; CHECK-LABEL: frem32:
; CHECK-NEXT: .param f32, f32{{$}} ; CHECK-NEXT: .param f32, f32{{$}}
; CHECK-NEXT: .result f32{{$}} ; CHECK-NEXT: .result f32{{$}}
; CHECK-NEXT: {{^}} f32.call $push0=, fmodf@FUNCTION, $0, $1{{$}} ; CHECK-NEXT: {{^}} f32.call $push0=, fmodf@FUNCTION, $0, $1{{$}}
; CHECK-NEXT: return $pop0{{$}} ; CHECK-NEXT: return $pop0{{$}}
define float @frem32(float %x, float %y) { define float @frem32(float %x, float %y) {
%a = frem float %x, %y %a = frem float %x, %y
Show All 12 Lines

llvm/trunk/test/CodeGen/WebAssembly/func.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s
; Test that basic functions assemble as expected. ; Test that basic functions assemble as expected.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK-LABEL: f0: ; CHECK-LABEL: f0:
; CHECK: return{{$}} ; CHECK: return{{$}}
; CHECK: end_function{{$}} ; CHECK: end_function{{$}}
; CHECK: .size f0, ; CHECK: .size f0,
define void @f0() { define void @f0() {
ret void ret void
} }
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/function-bitcasts-varargs.ll

; RUN: llc < %s -asm-verbose=false -wasm-temporary-workarounds=false | FileCheck %s ; RUN: llc < %s -asm-verbose=false -wasm-temporary-workarounds=false | FileCheck %s
; Test that function pointer casts casting away varargs are replaced with ; Test that function pointer casts casting away varargs are replaced with
; wrappers. ; wrappers.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
define void @callWithArgs() { define void @callWithArgs() {
entry: entry:
call void bitcast (void (...)* @underspecified to void (i32, i32)*)(i32 0, i32 1) call void bitcast (void (...)* @underspecified to void (i32, i32)*)(i32 0, i32 1)
call void(...) bitcast (void (i32, i32)* @specified to void (...)*)(i32 0, i32 1) call void(...) bitcast (void (i32, i32)* @specified to void (...)*)(i32 0, i32 1)
ret void ret void
} }
Show All 16 Lines

llvm/trunk/test/CodeGen/WebAssembly/function-bitcasts.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-explicit-locals -enable-emscripten-cxx-exceptions -wasm-temporary-workarounds=false | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-explicit-locals -enable-emscripten-cxx-exceptions -wasm-temporary-workarounds=false | FileCheck %s
; Test that function pointer casts are replaced with wrappers. ; Test that function pointer casts are replaced with wrappers.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
declare void @has_i32_arg(i32) declare void @has_i32_arg(i32)
declare i32 @has_i32_ret() declare i32 @has_i32_ret()
declare void @vararg(...) declare void @vararg(...)
declare void @plain(i32) declare void @plain(i32)
declare void @foo0() declare void @foo0()
declare void @foo1() declare void @foo1()
▲ Show 20 Lines • Show All 152 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/global.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s
; Test that globals assemble as expected. ; Test that globals assemble as expected.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK-NOT: llvm.used ; CHECK-NOT: llvm.used
; CHECK-NOT: llvm.metadata ; CHECK-NOT: llvm.metadata
@llvm.used = appending global [1 x i32*] [i32* @g], section "llvm.metadata" @llvm.used = appending global [1 x i32*] [i32* @g], section "llvm.metadata"
; CHECK: foo: ; CHECK: foo:
; CHECK: i32.const $push0=, 0{{$}} ; CHECK: i32.const $push0=, 0{{$}}
; CHECK-NEXT: i32.load $push1=, answer($pop0){{$}} ; CHECK-NEXT: i32.load $push1=, answer($pop0){{$}}
▲ Show 20 Lines • Show All 208 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/globl.ll

; RUN: llc < %s -asm-verbose=false | FileCheck %s ; RUN: llc < %s -asm-verbose=false | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK: .globl foo ; CHECK: .globl foo
; CHECK: .type foo,@function ; CHECK: .type foo,@function
; CHECK-LABEL: foo: ; CHECK-LABEL: foo:
; CHECK: .size foo, ; CHECK: .size foo,
define i32* @foo() { define i32* @foo() {
ret i32* @bar ret i32* @bar
} }
; CHECK: .type bar,@object ; CHECK: .type bar,@object
; CHECK: .globl bar ; CHECK: .globl bar
; CHECK: .size bar, 4 ; CHECK: .size bar, 4
@bar = global i32 2 @bar = global i32 2

llvm/trunk/test/CodeGen/WebAssembly/i128-returned.ll

; RUN: llc < %s -asm-verbose=false | FileCheck %s ; RUN: llc < %s -asm-verbose=false | FileCheck %s
; Test that the "returned" attribute works with i128 types. ; Test that the "returned" attribute works with i128 types.
; PR36128 ; PR36128
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
declare i128 @bar(i128 returned) declare i128 @bar(i128 returned)
define i128 @foo(i128) { define i128 @foo(i128) {
%r = tail call i128 @bar(i128 %0) %r = tail call i128 @bar(i128 %0)
ret i128 %r ret i128 %r
} }
; CHECK-LABEL: foo: ; CHECK-LABEL: foo:
; CHECK-NEXT: .param i32, i64, i64 ; CHECK-NEXT: .param i32, i64, i64
; CHECK-NOT: .result ; CHECK-NOT: .result
; CHECK: .functype bar, void, i32, i64, i64 ; CHECK: .functype bar, void, i32, i64, i64

llvm/trunk/test/CodeGen/WebAssembly/i128.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s
; Test that basic 128-bit integer operations assemble as expected. ; Test that basic 128-bit integer operations assemble as expected.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
declare i128 @llvm.ctlz.i128(i128, i1) declare i128 @llvm.ctlz.i128(i128, i1)
declare i128 @llvm.cttz.i128(i128, i1) declare i128 @llvm.cttz.i128(i128, i1)
declare i128 @llvm.ctpop.i128(i128) declare i128 @llvm.ctpop.i128(i128)
; CHECK-LABEL: add128: ; CHECK-LABEL: add128:
; CHECK-NEXT: .param i32, i64, i64, i64, i64{{$}} ; CHECK-NEXT: .param i32, i64, i64, i64, i64{{$}}
; CHECK-NOT: .result ; CHECK-NOT: .result
▲ Show 20 Lines • Show All 266 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/i32-load-store-alignment.ll

; RUN: llc < %s -mattr=+atomics -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s ; RUN: llc < %s -mattr=+atomics -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s
; Test loads and stores with custom alignment values. ; Test loads and stores with custom alignment values.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK-LABEL: ldi32_a1: ; CHECK-LABEL: ldi32_a1:
; CHECK-NEXT: .param i32{{$}} ; CHECK-NEXT: .param i32{{$}}
; CHECK-NEXT: .result i32{{$}} ; CHECK-NEXT: .result i32{{$}}
; CHECK-NEXT: i32.load $push[[NUM:[0-9]+]]=, 0($0):p2align=0{{$}} ; CHECK-NEXT: i32.load $push[[NUM:[0-9]+]]=, 0($0):p2align=0{{$}}
; CHECK-NEXT: return $pop[[NUM]]{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}}
define i32 @ldi32_a1(i32 *%p) { define i32 @ldi32_a1(i32 *%p) {
%v = load i32, i32* %p, align 1 %v = load i32, i32* %p, align 1
▲ Show 20 Lines • Show All 224 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/i32.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s
; Test that basic 32-bit integer operations assemble as expected. ; Test that basic 32-bit integer operations assemble as expected.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
declare i32 @llvm.ctlz.i32(i32, i1) declare i32 @llvm.ctlz.i32(i32, i1)
declare i32 @llvm.cttz.i32(i32, i1) declare i32 @llvm.cttz.i32(i32, i1)
declare i32 @llvm.ctpop.i32(i32) declare i32 @llvm.ctpop.i32(i32)
; CHECK-LABEL: add32: ; CHECK-LABEL: add32:
; CHECK-NEXT: .param i32, i32{{$}} ; CHECK-NEXT: .param i32, i32{{$}}
; CHECK-NEXT: .result i32{{$}} ; CHECK-NEXT: .result i32{{$}}
▲ Show 20 Lines • Show All 281 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/i64-load-store-alignment.ll

; RUN: llc < %s -mattr=+atomics -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s ; RUN: llc < %s -mattr=+atomics -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s
; Test loads and stores with custom alignment values. ; Test loads and stores with custom alignment values.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK-LABEL: ldi64_a1: ; CHECK-LABEL: ldi64_a1:
; CHECK-NEXT: .param i32{{$}} ; CHECK-NEXT: .param i32{{$}}
; CHECK-NEXT: .result i64{{$}} ; CHECK-NEXT: .result i64{{$}}
; CHECK-NEXT: i64.load $push[[NUM:[0-9]+]]=, 0($0):p2align=0{{$}} ; CHECK-NEXT: i64.load $push[[NUM:[0-9]+]]=, 0($0):p2align=0{{$}}
; CHECK-NEXT: return $pop[[NUM]]{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}}
define i64 @ldi64_a1(i64 *%p) { define i64 @ldi64_a1(i64 *%p) {
%v = load i64, i64* %p, align 1 %v = load i64, i64* %p, align 1
▲ Show 20 Lines • Show All 334 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/i64.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s
; Test that basic 64-bit integer operations assemble as expected. ; Test that basic 64-bit integer operations assemble as expected.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
declare i64 @llvm.ctlz.i64(i64, i1) declare i64 @llvm.ctlz.i64(i64, i1)
declare i64 @llvm.cttz.i64(i64, i1) declare i64 @llvm.cttz.i64(i64, i1)
declare i64 @llvm.ctpop.i64(i64) declare i64 @llvm.ctpop.i64(i64)
; CHECK-LABEL: add64: ; CHECK-LABEL: add64:
; CHECK-NEXT: .param i64, i64{{$}} ; CHECK-NEXT: .param i64, i64{{$}}
; CHECK-NEXT: .result i64{{$}} ; CHECK-NEXT: .result i64{{$}}
▲ Show 20 Lines • Show All 281 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/ident.ll

; RUN: llc < %s -asm-verbose=false | FileCheck %s ; RUN: llc < %s -asm-verbose=false | FileCheck %s
; Test llvm.ident. ; Test llvm.ident.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK: .ident "hello world" ; CHECK: .ident "hello world"
!llvm.ident = !{!0} !llvm.ident = !{!0}
!0 = !{!"hello world"} !0 = !{!"hello world"}

llvm/trunk/test/CodeGen/WebAssembly/immediates.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s
; Test that basic immediates assemble as expected. ; Test that basic immediates assemble as expected.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK-LABEL: zero_i32: ; CHECK-LABEL: zero_i32:
; CHECK-NEXT: .result i32{{$}} ; CHECK-NEXT: .result i32{{$}}
; CHECK-NEXT: i32.const $push[[NUM:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: i32.const $push[[NUM:[0-9]+]]=, 0{{$}}
; CHECK-NEXT: return $pop[[NUM]]{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}}
define i32 @zero_i32() { define i32 @zero_i32() {
ret i32 0 ret i32 0
} }
▲ Show 20 Lines • Show All 219 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/implicit-def.ll

; RUN: llc -o - %s -asm-verbose=false | FileCheck %s ; RUN: llc -o - %s -asm-verbose=false | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; Test that stackified IMPLICIT_DEF instructions are converted into ; Test that stackified IMPLICIT_DEF instructions are converted into
; CONST_I32 to provide an explicit push. ; CONST_I32 to provide an explicit push.
; CHECK: br_if 2, ; CHECK: br_if 2,
; CHECK: i32.const $push[[L0:[0-9]+]]=, 0{{$}} ; CHECK: i32.const $push[[L0:[0-9]+]]=, 0{{$}}
; CHECK-NEXT: return $pop[[L0]]{{$}} ; CHECK-NEXT: return $pop[[L0]]{{$}}
define i1 @f() { define i1 @f() {
Show All 39 Lines

llvm/trunk/test/CodeGen/WebAssembly/import-module.ll

; RUN: llc < %s -asm-verbose=false | FileCheck %s ; RUN: llc < %s -asm-verbose=false | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
define void @test() { define void @test() {
call void @foo() call void @foo()
call void @plain() call void @plain()
ret void ret void
} }
declare void @foo() #0 declare void @foo() #0
declare void @plain() declare void @plain()
attributes #0 = { "wasm-import-module"="bar" } attributes #0 = { "wasm-import-module"="bar" }
; CHECK-NOT: .import_module plain ; CHECK-NOT: .import_module plain
; CHECK: .import_module foo, bar ; CHECK: .import_module foo, bar
; CHECK-NOT: .import_module plain ; CHECK-NOT: .import_module plain

llvm/trunk/test/CodeGen/WebAssembly/inline-asm-m.ll

; RUN: not llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -no-integrated-as ; RUN: not llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -no-integrated-as
; Test basic inline assembly "m" operands, which are unsupported. Pass ; Test basic inline assembly "m" operands, which are unsupported. Pass
; -no-integrated-as since these aren't actually valid assembly syntax. ; -no-integrated-as since these aren't actually valid assembly syntax.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
define void @bar(i32* %r, i32* %s) { define void @bar(i32* %r, i32* %s) {
entry: entry:
tail call void asm sideeffect "# $0 = bbb($1)", "=*m,*m"(i32* %s, i32* %r) #0, !srcloc !1 tail call void asm sideeffect "# $0 = bbb($1)", "=*m,*m"(i32* %s, i32* %r) #0, !srcloc !1
ret void ret void
} }

llvm/trunk/test/CodeGen/WebAssembly/inline-asm.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -no-integrated-as | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -no-integrated-as | FileCheck %s
; Test basic inline assembly. Pass -no-integrated-as since these aren't ; Test basic inline assembly. Pass -no-integrated-as since these aren't
; actually valid assembly syntax. ; actually valid assembly syntax.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK-LABEL: foo: ; CHECK-LABEL: foo:
; CHECK-NEXT: .param i32{{$}} ; CHECK-NEXT: .param i32{{$}}
; CHECK-NEXT: .result i32{{$}} ; CHECK-NEXT: .result i32{{$}}
; CHECK-NEXT: #APP{{$}} ; CHECK-NEXT: #APP{{$}}
; CHECK-NEXT: # 0 = aaa(0){{$}} ; CHECK-NEXT: # 0 = aaa(0){{$}}
; CHECK-NEXT: #NO_APP{{$}} ; CHECK-NEXT: #NO_APP{{$}}
; CHECK-NEXT: get_local $push0=, 0{{$}} ; CHECK-NEXT: get_local $push0=, 0{{$}}
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/irreducible-cfg.ll

; RUN: llc < %s -asm-verbose=false -verify-machineinstrs -disable-block-placement -disable-wasm-explicit-locals | FileCheck %s ; RUN: llc < %s -asm-verbose=false -verify-machineinstrs -disable-block-placement -disable-wasm-explicit-locals | FileCheck %s
; Test irreducible CFG handling. ; Test irreducible CFG handling.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; A simple loop with two entries. ; A simple loop with two entries.
; CHECK-LABEL: test0: ; CHECK-LABEL: test0:
; CHECK: f64.load ; CHECK: f64.load
; CHECK: i32.const $[[REG:[^,]+]]=, 0{{$}} ; CHECK: i32.const $[[REG:[^,]+]]=, 0{{$}}
; CHECK: br_table $[[REG]], ; CHECK: br_table $[[REG]],
define void @test0(double* %arg, i32 %arg1, i32 %arg2, i32 %arg3) { define void @test0(double* %arg, i32 %arg1, i32 %arg2, i32 %arg3) {
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/legalize.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s
; Test various types and operators that need to be legalized. ; Test various types and operators that need to be legalized.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK-LABEL: shl_i3: ; CHECK-LABEL: shl_i3:
; CHECK: i32.const $push0=, 7{{$}} ; CHECK: i32.const $push0=, 7{{$}}
; CHECK: i32.and $push1=, $1, $pop0{{$}} ; CHECK: i32.and $push1=, $1, $pop0{{$}}
; CHECK: i32.shl $push2=, $0, $pop1{{$}} ; CHECK: i32.shl $push2=, $0, $pop1{{$}}
define i3 @shl_i3(i3 %a, i3 %b, i3* %p) { define i3 @shl_i3(i3 %a, i3 %b, i3* %p) {
%t = shl i3 %a, %b %t = shl i3 %a, %b
ret i3 %t ret i3 %t
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/libcalls.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s
; Test a subset of compiler-rt/libm libcalls expected to be emitted by the wasm backend ; Test a subset of compiler-rt/libm libcalls expected to be emitted by the wasm backend
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
declare fp128 @llvm.sqrt.f128(fp128) declare fp128 @llvm.sqrt.f128(fp128)
declare fp128 @llvm.floor.f128(fp128) declare fp128 @llvm.floor.f128(fp128)
declare fp128 @llvm.trunc.f128(fp128) declare fp128 @llvm.trunc.f128(fp128)
declare fp128 @llvm.nearbyint.f128(fp128) declare fp128 @llvm.nearbyint.f128(fp128)
declare fp128 @llvm.pow.f128(fp128, fp128) declare fp128 @llvm.pow.f128(fp128, fp128)
declare double @llvm.cos.f64(double) declare double @llvm.cos.f64(double)
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/load-ext-atomic.ll

; RUN: llc < %s -mattr=+atomics,+sign-ext -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s ; RUN: llc < %s -mattr=+atomics,+sign-ext -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s
; Test that extending loads are assembled properly. ; Test that extending loads are assembled properly.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK-LABEL: sext_i8_i32: ; CHECK-LABEL: sext_i8_i32:
; CHECK: i32.atomic.load8_u $push0=, 0($0){{$}} ; CHECK: i32.atomic.load8_u $push0=, 0($0){{$}}
; CHECK-NEXT: i32.extend8_s $push1=, $pop0{{$}} ; CHECK-NEXT: i32.extend8_s $push1=, $pop0{{$}}
; CHECK-NEXT: return $pop1{{$}} ; CHECK-NEXT: return $pop1{{$}}
define i32 @sext_i8_i32(i8 *%p) { define i32 @sext_i8_i32(i8 *%p) {
%v = load atomic i8, i8* %p seq_cst, align 1 %v = load atomic i8, i8* %p seq_cst, align 1
%e = sext i8 %v to i32 %e = sext i8 %v to i32
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/load-ext.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s
; Test that extending loads are assembled properly. ; Test that extending loads are assembled properly.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK-LABEL: sext_i8_i32: ; CHECK-LABEL: sext_i8_i32:
; CHECK: i32.load8_s $push0=, 0($0){{$}} ; CHECK: i32.load8_s $push0=, 0($0){{$}}
; CHECK-NEXT: return $pop0{{$}} ; CHECK-NEXT: return $pop0{{$}}
define i32 @sext_i8_i32(i8 *%p) { define i32 @sext_i8_i32(i8 *%p) {
%v = load i8, i8* %p %v = load i8, i8* %p
%e = sext i8 %v to i32 %e = sext i8 %v to i32
ret i32 %e ret i32 %e
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/load-store-i1.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s
; Test that i1 extending loads and truncating stores are assembled properly. ; Test that i1 extending loads and truncating stores are assembled properly.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK-LABEL: load_u_i1_i32: ; CHECK-LABEL: load_u_i1_i32:
; CHECK: i32.load8_u $push[[NUM0:[0-9]+]]=, 0($0){{$}} ; CHECK: i32.load8_u $push[[NUM0:[0-9]+]]=, 0($0){{$}}
; CHECK-NEXT: return $pop[[NUM0]]{{$}} ; CHECK-NEXT: return $pop[[NUM0]]{{$}}
define i32 @load_u_i1_i32(i1* %p) { define i32 @load_u_i1_i32(i1* %p) {
%v = load i1, i1* %p %v = load i1, i1* %p
%e = zext i1 %v to i32 %e = zext i1 %v to i32
ret i32 %e ret i32 %e
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/load.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s
; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -fast-isel -fast-isel-abort=1 | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -fast-isel -fast-isel-abort=1 | FileCheck %s
; Test that basic loads are assembled properly. ; Test that basic loads are assembled properly.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK-LABEL: ldi32: ; CHECK-LABEL: ldi32:
; CHECK-NEXT: .param i32{{$}} ; CHECK-NEXT: .param i32{{$}}
; CHECK-NEXT: .result i32{{$}} ; CHECK-NEXT: .result i32{{$}}
; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}}
; CHECK-NEXT: i32.load $push[[NUM:[0-9]+]]=, 0($pop[[L0]]){{$}} ; CHECK-NEXT: i32.load $push[[NUM:[0-9]+]]=, 0($pop[[L0]]){{$}}
; CHECK-NEXT: return $pop[[NUM]]{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}}
define i32 @ldi32(i32 *%p) { define i32 @ldi32(i32 *%p) {
Show All 36 Lines

llvm/trunk/test/CodeGen/WebAssembly/lower-em-ehsjlj-options.ll

; RUN: llc < %s -enable-emscripten-cxx-exceptions | FileCheck %s --check-prefix=EH ; RUN: llc < %s -enable-emscripten-cxx-exceptions | FileCheck %s --check-prefix=EH
; RUN: llc < %s -enable-emscripten-sjlj | FileCheck %s --check-prefix=SJLJ ; RUN: llc < %s -enable-emscripten-sjlj | FileCheck %s --check-prefix=SJLJ
; RUN: llc < %s | FileCheck %s --check-prefix=NONE ; RUN: llc < %s | FileCheck %s --check-prefix=NONE
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
%struct.__jmp_buf_tag = type { [6 x i32], i32, [32 x i32] } %struct.__jmp_buf_tag = type { [6 x i32], i32, [32 x i32] }
define hidden void @exception() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { define hidden void @exception() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
; EH-LABEL: type exception,@function ; EH-LABEL: type exception,@function
; NONE-LABEL: type exception,@function ; NONE-LABEL: type exception,@function
entry: entry:
invoke void @foo() invoke void @foo()
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/lower-em-exceptions-whitelist.ll

; RUN: opt < %s -wasm-lower-em-ehsjlj -emscripten-cxx-exceptions-whitelist=do_catch -S | FileCheck %s ; RUN: opt < %s -wasm-lower-em-ehsjlj -emscripten-cxx-exceptions-whitelist=do_catch -S | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
define void @dont_catch() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { define void @dont_catch() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
; CHECK-LABEL: @dont_catch( ; CHECK-LABEL: @dont_catch(
entry: entry:
invoke void @foo() invoke void @foo()
to label %invoke.cont unwind label %lpad to label %invoke.cont unwind label %lpad
; CHECK: entry: ; CHECK: entry:
; CHECK-NEXT: call void @foo() ; CHECK-NEXT: call void @foo()
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/lower-em-exceptions.ll

; RUN: opt < %s -wasm-lower-em-ehsjlj -S | FileCheck %s ; RUN: opt < %s -wasm-lower-em-ehsjlj -S | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
@_ZTIi = external constant i8* @_ZTIi = external constant i8*
@_ZTIc = external constant i8* @_ZTIc = external constant i8*
; CHECK-DAG: @[[__THREW__:__THREW__.*]] = global i32 0 ; CHECK-DAG: @[[__THREW__:__THREW__.*]] = global i32 0
; CHECK-DAG: @[[THREWVALUE:__threwValue.*]] = global i32 0 ; CHECK-DAG: @[[THREWVALUE:__threwValue.*]] = global i32 0
; CHECK-DAG: @[[TEMPRET0:__tempRet0.*]] = global i32 0 ; CHECK-DAG: @[[TEMPRET0:__tempRet0.*]] = global i32 0
; Test invoke instruction with clauses (try-catch block) ; Test invoke instruction with clauses (try-catch block)
▲ Show 20 Lines • Show All 182 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/lower-em-sjlj.ll

; RUN: opt < %s -wasm-lower-em-ehsjlj -S | FileCheck %s ; RUN: opt < %s -wasm-lower-em-ehsjlj -S | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
%struct.__jmp_buf_tag = type { [6 x i32], i32, [32 x i32] } %struct.__jmp_buf_tag = type { [6 x i32], i32, [32 x i32] }
@global_var = hidden global i32 0, align 4 @global_var = hidden global i32 0, align 4
; CHECK-DAG: @[[__THREW__:__THREW__.*]] = global i32 0 ; CHECK-DAG: @[[__THREW__:__THREW__.*]] = global i32 0
; CHECK-DAG: @[[THREWVALUE:__threwValue.*]] = global i32 0 ; CHECK-DAG: @[[THREWVALUE:__threwValue.*]] = global i32 0
; CHECK-DAG: @[[TEMPRET0:__tempRet0.*]] = global i32 0 ; CHECK-DAG: @[[TEMPRET0:__tempRet0.*]] = global i32 0
▲ Show 20 Lines • Show All 201 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/lower-global-dtors.ll

; RUN: llc < %s -asm-verbose=false | FileCheck --check-prefix=CHECK --check-prefix=FINI --check-prefix=NULL %s ; RUN: llc < %s -asm-verbose=false | FileCheck --check-prefix=CHECK --check-prefix=FINI --check-prefix=NULL %s
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; Test that @llvm.global_dtors is properly lowered into @llvm.global_ctors, ; Test that @llvm.global_dtors is properly lowered into @llvm.global_ctors,
; grouping dtor calls by priority and associated symbol. ; grouping dtor calls by priority and associated symbol.
declare void @orig_ctor() declare void @orig_ctor()
declare void @orig_dtor0() declare void @orig_dtor0()
declare void @orig_dtor1a() declare void @orig_dtor1a()
declare void @orig_dtor1b() declare void @orig_dtor1b()
▲ Show 20 Lines • Show All 127 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/main-declaration.ll

; RUN: llc < %s -asm-verbose=false -wasm-temporary-workarounds=false | FileCheck %s ; RUN: llc < %s -asm-verbose=false -wasm-temporary-workarounds=false | FileCheck %s
; Test main functions with alternate signatures. ; Test main functions with alternate signatures.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
declare void @main() declare void @main()
define void @foo() { define void @foo() {
call void @main() call void @main()
ret void ret void
} }
; CHECK-NOT: __original_main ; CHECK-NOT: __original_main
; CHECK-LABEL: foo: ; CHECK-LABEL: foo:
; CHECK-NEXT: call main@FUNCTION ; CHECK-NEXT: call main@FUNCTION
; CHECK-NEXT: end_function ; CHECK-NEXT: end_function
; CHECK-NOT: __original_main ; CHECK-NOT: __original_main

llvm/trunk/test/CodeGen/WebAssembly/main.ll

; RUN: llc < %s -asm-verbose=false -wasm-temporary-workarounds=false | FileCheck %s ; RUN: llc < %s -asm-verbose=false -wasm-temporary-workarounds=false | FileCheck %s
; Test main functions with alternate signatures. ; Test main functions with alternate signatures.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
define void @main() { define void @main() {
ret void ret void
} }
; CHECK-LABEL: .L__original_main: ; CHECK-LABEL: .L__original_main:
; CHECK-NEXT: end_function ; CHECK-NEXT: end_function
; CHECK-LABEL: main: ; CHECK-LABEL: main:
; CHECK-NEXT: .param i32, i32 ; CHECK-NEXT: .param i32, i32
; CHECK-NEXT: .result i32 ; CHECK-NEXT: .result i32
; CHECK: call .L__original_main@FUNCTION ; CHECK: call .L__original_main@FUNCTION

llvm/trunk/test/CodeGen/WebAssembly/mem-intrinsics.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -tail-dup-placement=0 | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -tail-dup-placement=0 | FileCheck %s
; Test memcpy, memmove, and memset intrinsics. ; Test memcpy, memmove, and memset intrinsics.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture readonly, i32, i1) declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture readonly, i32, i1)
declare void @llvm.memmove.p0i8.p0i8.i32(i8* nocapture, i8* nocapture readonly, i32, i1) declare void @llvm.memmove.p0i8.p0i8.i32(i8* nocapture, i8* nocapture readonly, i32, i1)
declare void @llvm.memset.p0i8.i32(i8* nocapture, i8, i32, i1) declare void @llvm.memset.p0i8.i32(i8* nocapture, i8, i32, i1)
; Test that return values are optimized. ; Test that return values are optimized.
; CHECK-LABEL: copy_yes: ; CHECK-LABEL: copy_yes:
▲ Show 20 Lines • Show All 126 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/memory-addr32.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s
; Test that basic memory operations assemble as expected with 32-bit addresses. ; Test that basic memory operations assemble as expected with 32-bit addresses.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
declare i32 @llvm.wasm.mem.size.i32(i32) nounwind readonly declare i32 @llvm.wasm.mem.size.i32(i32) nounwind readonly
declare i32 @llvm.wasm.mem.grow.i32(i32, i32) nounwind declare i32 @llvm.wasm.mem.grow.i32(i32, i32) nounwind
declare i32 @llvm.wasm.current.memory.i32() nounwind readonly declare i32 @llvm.wasm.current.memory.i32() nounwind readonly
declare i32 @llvm.wasm.grow.memory.i32(i32) nounwind declare i32 @llvm.wasm.grow.memory.i32(i32) nounwind
; CHECK-LABEL: mem_size: ; CHECK-LABEL: mem_size:
; CHECK-NEXT: .result i32{{$}} ; CHECK-NEXT: .result i32{{$}}
Show All 35 Lines

llvm/trunk/test/CodeGen/WebAssembly/non-executable-stack.ll

; RUN: llc < %s -asm-verbose=false | FileCheck %s ; RUN: llc < %s -asm-verbose=false | FileCheck %s
; Test that we don't emit anything declaring a non-executable stack, ; Test that we don't emit anything declaring a non-executable stack,
; because wasm's stack is always non-executable. ; because wasm's stack is always non-executable.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK-NOT: .note.GNU-stack ; CHECK-NOT: .note.GNU-stack

llvm/trunk/test/CodeGen/WebAssembly/offset-atomics.ll

; RUN: not llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt ; RUN: not llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt
; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -mattr=+atomics,+sign-ext | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -mattr=+atomics,+sign-ext | FileCheck %s
; Test that atomic loads are assembled properly. ; Test that atomic loads are assembled properly.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK-LABEL: load_i32_no_offset: ; CHECK-LABEL: load_i32_no_offset:
; CHECK: i32.atomic.load $push[[NUM:[0-9]+]]=, 0($0){{$}} ; CHECK: i32.atomic.load $push[[NUM:[0-9]+]]=, 0($0){{$}}
; CHECK-NEXT: return $pop[[NUM]]{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}}
define i32 @load_i32_no_offset(i32 *%p) { define i32 @load_i32_no_offset(i32 *%p) {
%v = load atomic i32, i32* %p seq_cst, align 4 %v = load atomic i32, i32* %p seq_cst, align 4
ret i32 %v ret i32 %v
} }
▲ Show 20 Lines • Show All 292 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/offset-folding.ll

; RUN: llc < %s -asm-verbose=false | FileCheck %s ; RUN: llc < %s -asm-verbose=false | FileCheck %s
; Test that constant offsets can be folded into global addresses. ; Test that constant offsets can be folded into global addresses.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
@x = external global [0 x i32] @x = external global [0 x i32]
@y = global [50 x i32] zeroinitializer @y = global [50 x i32] zeroinitializer
; Test basic constant offsets of both defined and external symbols. ; Test basic constant offsets of both defined and external symbols.
; CHECK-LABEL: test0: ; CHECK-LABEL: test0:
; CHECK-NEXT: .result i32{{$}} ; CHECK-NEXT: .result i32{{$}}
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/offset.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-explicit-locals | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-explicit-locals | FileCheck %s
; Test constant load and store address offsets. ; Test constant load and store address offsets.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; With an nuw add, we can fold an offset. ; With an nuw add, we can fold an offset.
; CHECK-LABEL: load_i32_with_folded_offset: ; CHECK-LABEL: load_i32_with_folded_offset:
; CHECK: i32.load $push0=, 24($0){{$}} ; CHECK: i32.load $push0=, 24($0){{$}}
define i32 @load_i32_with_folded_offset(i32* %p) { define i32 @load_i32_with_folded_offset(i32* %p) {
%q = ptrtoint i32* %p to i32 %q = ptrtoint i32* %p to i32
%r = add nuw i32 %q, 24 %r = add nuw i32 %q, 24
▲ Show 20 Lines • Show All 408 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/phi.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -verify-machineinstrs | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -verify-machineinstrs | FileCheck %s
; Test that phis are lowered. ; Test that phis are lowered.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; Basic phi triangle. ; Basic phi triangle.
; CHECK-LABEL: test0: ; CHECK-LABEL: test0:
; CHECK: return $0 ; CHECK: return $0
; CHECK: div_s $push[[NUM0:[0-9]+]]=, $0, $pop[[NUM1:[0-9]+]]{{$}} ; CHECK: div_s $push[[NUM0:[0-9]+]]=, $0, $pop[[NUM1:[0-9]+]]{{$}}
; CHECK: return $pop[[NUM0]]{{$}} ; CHECK: return $pop[[NUM0]]{{$}}
define i32 @test0(i32 %p) { define i32 @test0(i32 %p) {
Show All 34 Lines

llvm/trunk/test/CodeGen/WebAssembly/reg-stackify.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -verify-machineinstrs | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -verify-machineinstrs | FileCheck %s
; Test the register stackifier pass. ; Test the register stackifier pass.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; No because of pointer aliasing. ; No because of pointer aliasing.
; CHECK-LABEL: no0: ; CHECK-LABEL: no0:
; CHECK: return $1{{$}} ; CHECK: return $1{{$}}
define i32 @no0(i32* %p, i32* %q) { define i32 @no0(i32* %p, i32* %q) {
%t = load i32, i32* %q %t = load i32, i32* %q
store i32 0, i32* %p store i32 0, i32* %p
▲ Show 20 Lines • Show All 479 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/return-int32.ll

; RUN: llc < %s -asm-verbose=false | FileCheck %s ; RUN: llc < %s -asm-verbose=false | FileCheck %s
; RUN: llc < %s -asm-verbose=false -fast-isel -fast-isel-abort=1 | FileCheck %s ; RUN: llc < %s -asm-verbose=false -fast-isel -fast-isel-abort=1 | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK-LABEL: return_i32: ; CHECK-LABEL: return_i32:
; CHECK-NEXT: .param i32{{$}} ; CHECK-NEXT: .param i32{{$}}
; CHECK-NEXT: .result i32{{$}} ; CHECK-NEXT: .result i32{{$}}
; CHECK-NEXT: get_local $push0=, 0 ; CHECK-NEXT: get_local $push0=, 0
; CHECK-NEXT: end_function{{$}} ; CHECK-NEXT: end_function{{$}}
define i32 @return_i32(i32 %p) { define i32 @return_i32(i32 %p) {
ret i32 %p ret i32 %p
Show All 21 Lines

llvm/trunk/test/CodeGen/WebAssembly/return-void.ll

; RUN: llc < %s -asm-verbose=false | FileCheck %s ; RUN: llc < %s -asm-verbose=false | FileCheck %s
; RUN: llc < %s -asm-verbose=false -fast-isel -fast-isel-abort=1 | FileCheck %s ; RUN: llc < %s -asm-verbose=false -fast-isel -fast-isel-abort=1 | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK-LABEL: return_void: ; CHECK-LABEL: return_void:
; CHECK-NEXT: end_function{{$}} ; CHECK-NEXT: end_function{{$}}
define void @return_void() { define void @return_void() {
ret void ret void
} }
; CHECK-LABEL: return_void_twice: ; CHECK-LABEL: return_void_twice:
Show All 16 Lines

llvm/trunk/test/CodeGen/WebAssembly/returned.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s
; Test that the "returned" attribute is optimized effectively. ; Test that the "returned" attribute is optimized effectively.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK-LABEL: _Z3foov: ; CHECK-LABEL: _Z3foov:
; CHECK-NEXT: .result i32{{$}} ; CHECK-NEXT: .result i32{{$}}
; CHECK-NEXT: i32.const $push0=, 1{{$}} ; CHECK-NEXT: i32.const $push0=, 1{{$}}
; CHECK-NEXT: {{^}} i32.call $push1=, _Znwm@FUNCTION, $pop0{{$}} ; CHECK-NEXT: {{^}} i32.call $push1=, _Znwm@FUNCTION, $pop0{{$}}
; CHECK-NEXT: {{^}} i32.call $push2=, _ZN5AppleC1Ev@FUNCTION, $pop1{{$}} ; CHECK-NEXT: {{^}} i32.call $push2=, _ZN5AppleC1Ev@FUNCTION, $pop1{{$}}
; CHECK-NEXT: return $pop2{{$}} ; CHECK-NEXT: return $pop2{{$}}
%class.Apple = type { i8 } %class.Apple = type { i8 }
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/select.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s
; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -fast-isel -fast-isel-abort=1 | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -fast-isel -fast-isel-abort=1 | FileCheck %s
; Test that wasm select instruction is selected from LLVM select instruction. ; Test that wasm select instruction is selected from LLVM select instruction.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK-LABEL: select_i32_bool: ; CHECK-LABEL: select_i32_bool:
; CHECK-NEXT: .param i32, i32, i32{{$}} ; CHECK-NEXT: .param i32, i32, i32{{$}}
; CHECK-NEXT: .result i32{{$}} ; CHECK-NEXT: .result i32{{$}}
; CHECK-NEXT: i32.select $push0=, $1, $2, $0{{$}} ; CHECK-NEXT: i32.select $push0=, $1, $2, $0{{$}}
; CHECK-NEXT: return $pop0{{$}} ; CHECK-NEXT: return $pop0{{$}}
define i32 @select_i32_bool(i1 zeroext %a, i32 %b, i32 %c) { define i32 @select_i32_bool(i1 zeroext %a, i32 %b, i32 %c) {
%cond = select i1 %a, i32 %b, i32 %c %cond = select i1 %a, i32 %b, i32 %c
▲ Show 20 Lines • Show All 120 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/signext-arg.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc < %s -asm-verbose=false -disable-wasm-explicit-locals | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-explicit-locals | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
declare i32 @get_int(i16 %arg) declare i32 @get_int(i16 %arg)
define i32 @func_1(i16 %arg1 , i32 %arg2) #0 { define i32 @func_1(i16 %arg1 , i32 %arg2) #0 {
; CHECK-LABEL: func_1: ; CHECK-LABEL: func_1:
; CHECK: i32.const $push1=, 16 ; CHECK: i32.const $push1=, 16
; CHECK-NEXT: i32.shl $push2=, $0, $pop1 ; CHECK-NEXT: i32.shl $push2=, $0, $pop1
; CHECK-NEXT: i32.const $push4=, 16 ; CHECK-NEXT: i32.const $push4=, 16
Show All 9 Lines

llvm/trunk/test/CodeGen/WebAssembly/signext-inreg.ll

; RUN: llc < %s -mattr=+sign-ext -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s ; RUN: llc < %s -mattr=+sign-ext -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s
; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s --check-prefix=NOSIGNEXT ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s --check-prefix=NOSIGNEXT
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK-LABEL: i32_extend8_s: ; CHECK-LABEL: i32_extend8_s:
; CHECK-NEXT: .param i32{{$}} ; CHECK-NEXT: .param i32{{$}}
; CHECK-NEXT: .result i32{{$}} ; CHECK-NEXT: .result i32{{$}}
; CHECK-NEXT: i32.extend8_s $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: i32.extend8_s $push[[NUM:[0-9]+]]=, $0{{$}}
; CHECK-NEXT: return $pop[[NUM]]{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}}
; NOSIGNEXT-LABEL: i32_extend8_s ; NOSIGNEXT-LABEL: i32_extend8_s
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/signext-zeroext.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s
; Test zeroext and signext ABI keywords ; Test zeroext and signext ABI keywords
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK-LABEL: z2s_func: ; CHECK-LABEL: z2s_func:
; CHECK-NEXT: .param i32{{$}} ; CHECK-NEXT: .param i32{{$}}
; CHECK-NEXT: .result i32{{$}} ; CHECK-NEXT: .result i32{{$}}
; CHECK-NEXT: i32.const $push[[NUM0:[0-9]+]]=, 24{{$}} ; CHECK-NEXT: i32.const $push[[NUM0:[0-9]+]]=, 24{{$}}
; CHECK-NEXT: i32.shl $push[[NUM2:[0-9]+]]=, $0, $pop[[NUM0]]{{$}} ; CHECK-NEXT: i32.shl $push[[NUM2:[0-9]+]]=, $0, $pop[[NUM0]]{{$}}
; CHECK-NEXT: i32.const $push[[NUM1:[0-9]+]]=, 24{{$}} ; CHECK-NEXT: i32.const $push[[NUM1:[0-9]+]]=, 24{{$}}
; CHECK-NEXT: i32.shr_s $push[[NUM3:[0-9]+]]=, $pop[[NUM2]], $pop[[NUM1]]{{$}} ; CHECK-NEXT: i32.shr_s $push[[NUM3:[0-9]+]]=, $pop[[NUM2]], $pop[[NUM1]]{{$}}
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/simd-arith.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -mattr=+simd128 | FileCheck %s --check-prefixes CHECK,SIMD128 ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -mattr=+simd128 | FileCheck %s --check-prefixes CHECK,SIMD128
; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -mattr=+simd128 -fast-isel | FileCheck %s --check-prefixes CHECK,SIMD128 ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -mattr=+simd128 -fast-isel | FileCheck %s --check-prefixes CHECK,SIMD128
; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -mattr=-simd128 | FileCheck %s --check-prefixes CHECK,NO-SIMD128 ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -mattr=-simd128 | FileCheck %s --check-prefixes CHECK,NO-SIMD128
; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -mattr=-simd128 -fast-isel | FileCheck %s --check-prefixes CHECK,NO-SIMD128 ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -mattr=-simd128 -fast-isel | FileCheck %s --check-prefixes CHECK,NO-SIMD128
; Test that basic SIMD128 arithmetic operations assemble as expected. ; Test that basic SIMD128 arithmetic operations assemble as expected.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
declare i32 @llvm.ctlz.i32(i32, i1) declare i32 @llvm.ctlz.i32(i32, i1)
declare i32 @llvm.cttz.i32(i32, i1) declare i32 @llvm.cttz.i32(i32, i1)
declare i32 @llvm.ctpop.i32(i32) declare i32 @llvm.ctpop.i32(i32)
; ============================================================================== ; ==============================================================================
; 16 x i8 ; 16 x i8
; ============================================================================== ; ==============================================================================
▲ Show 20 Lines • Show All 141 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/stack-alignment.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
declare void @somefunc(i32*) declare void @somefunc(i32*)
; CHECK-LABEL: underalign: ; CHECK-LABEL: underalign:
; CHECK: get_global $push[[L1:.+]]=, __stack_pointer{{$}} ; CHECK: get_global $push[[L1:.+]]=, __stack_pointer{{$}}
; CHECK-NEXT: i32.const $push[[L2:.+]]=, 16 ; CHECK-NEXT: i32.const $push[[L2:.+]]=, 16
; CHECK-NEXT: i32.sub $push[[L10:.+]]=, $pop[[L1]], $pop[[L2]] ; CHECK-NEXT: i32.sub $push[[L10:.+]]=, $pop[[L1]], $pop[[L2]]
; CHECK-NEXT: tee_local $push{{.+}}=, [[SP:.+]], $pop[[L10]] ; CHECK-NEXT: tee_local $push{{.+}}=, [[SP:.+]], $pop[[L10]]
▲ Show 20 Lines • Show All 137 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/store-trunc.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-explicit-locals | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-explicit-locals | FileCheck %s
; Test that truncating stores are assembled properly. ; Test that truncating stores are assembled properly.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK-LABEL: trunc_i8_i32: ; CHECK-LABEL: trunc_i8_i32:
; CHECK: i32.store8 0($0), $1{{$}} ; CHECK: i32.store8 0($0), $1{{$}}
define void @trunc_i8_i32(i8 *%p, i32 %v) { define void @trunc_i8_i32(i8 *%p, i32 %v) {
%t = trunc i32 %v to i8 %t = trunc i32 %v to i8
store i8 %t, i8* %p store i8 %t, i8* %p
ret void ret void
} }
Show All 32 Lines

llvm/trunk/test/CodeGen/WebAssembly/store.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s
; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -fast-isel -fast-isel-abort=1 | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -fast-isel -fast-isel-abort=1 | FileCheck %s
; Test that basic stores are assembled properly. ; Test that basic stores are assembled properly.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK-LABEL: sti32: ; CHECK-LABEL: sti32:
; CHECK-NEXT: .param i32, i32{{$}} ; CHECK-NEXT: .param i32, i32{{$}}
; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}}
; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}}
; CHECK-NEXT: i32.store 0($pop[[L0]]), $pop[[L1]]{{$}} ; CHECK-NEXT: i32.store 0($pop[[L0]]), $pop[[L1]]{{$}}
; CHECK-NEXT: return{{$}} ; CHECK-NEXT: return{{$}}
define void @sti32(i32 *%p, i32 %v) { define void @sti32(i32 *%p, i32 %v) {
Show All 36 Lines

llvm/trunk/test/CodeGen/WebAssembly/switch.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-block-placement -verify-machineinstrs | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-block-placement -verify-machineinstrs | FileCheck %s
; Test switch instructions. Block placement is disabled because it reorders ; Test switch instructions. Block placement is disabled because it reorders
; the blocks in a way that isn't interesting here. ; the blocks in a way that isn't interesting here.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
declare void @foo0() declare void @foo0()
declare void @foo1() declare void @foo1()
declare void @foo2() declare void @foo2()
declare void @foo3() declare void @foo3()
declare void @foo4() declare void @foo4()
declare void @foo5() declare void @foo5()
▲ Show 20 Lines • Show All 159 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/tls.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -thread-model=single | FileCheck --check-prefix=SINGLE %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -thread-model=single | FileCheck --check-prefix=SINGLE %s
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; SINGLE-LABEL: address_of_tls: ; SINGLE-LABEL: address_of_tls:
define i32 @address_of_tls() { define i32 @address_of_tls() {
; SINGLE: i32.const $push0=, tls ; SINGLE: i32.const $push0=, tls
; SINGLE-NEXT: return $pop0 ; SINGLE-NEXT: return $pop0
ret i32 ptrtoint(i32* @tls to i32) ret i32 ptrtoint(i32* @tls to i32)
} }
; SINGLE: .type tls,@object ; SINGLE: .type tls,@object
; SINGLE-NEXT: .section .bss.tls,"",@ ; SINGLE-NEXT: .section .bss.tls,"",@
; SINGLE-NEXT: .p2align 2 ; SINGLE-NEXT: .p2align 2
; SINGLE-NEXT: tls: ; SINGLE-NEXT: tls:
; SINGLE-NEXT: .int32 0 ; SINGLE-NEXT: .int32 0
@tls = internal thread_local global i32 0 @tls = internal thread_local global i32 0

llvm/trunk/test/CodeGen/WebAssembly/umulo-i64.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-explicit-locals | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-explicit-locals | FileCheck %s
; Test that UMULO works correctly on 64-bit operands. ; Test that UMULO works correctly on 64-bit operands.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK-LABEL: _ZN4core3num21_$LT$impl$u20$u64$GT$15overflowing_mul17h07be88b4cbac028fE: ; CHECK-LABEL: _ZN4core3num21_$LT$impl$u20$u64$GT$15overflowing_mul17h07be88b4cbac028fE:
; CHECK: __multi3 ; CHECK: __multi3
; Function Attrs: inlinehint ; Function Attrs: inlinehint
define void @"_ZN4core3num21_$LT$impl$u20$u64$GT$15overflowing_mul17h07be88b4cbac028fE"(i64, i64) unnamed_addr #0 { define void @"_ZN4core3num21_$LT$impl$u20$u64$GT$15overflowing_mul17h07be88b4cbac028fE"(i64, i64) unnamed_addr #0 {
start: start:
%2 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %0, i64 %1) %2 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %0, i64 %1)
%3 = extractvalue { i64, i1 } %2, 0 %3 = extractvalue { i64, i1 } %2, 0
Show All 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/unreachable.ll

; RUN: llc < %s -asm-verbose=false -verify-machineinstrs | FileCheck %s ; RUN: llc < %s -asm-verbose=false -verify-machineinstrs | FileCheck %s
; RUN: llc < %s -asm-verbose=false -fast-isel -fast-isel-abort=1 -verify-machineinstrs | FileCheck %s ; RUN: llc < %s -asm-verbose=false -fast-isel -fast-isel-abort=1 -verify-machineinstrs | FileCheck %s
; Test that LLVM unreachable instruction and trap intrinsic are lowered to ; Test that LLVM unreachable instruction and trap intrinsic are lowered to
; wasm unreachable ; wasm unreachable
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
declare void @llvm.trap() declare void @llvm.trap()
declare void @llvm.debugtrap() declare void @llvm.debugtrap()
declare void @abort() declare void @abort()
; CHECK-LABEL: f1: ; CHECK-LABEL: f1:
; CHECK: call abort@FUNCTION{{$}} ; CHECK: call abort@FUNCTION{{$}}
; CHECK: unreachable ; CHECK: unreachable
Show All 18 Lines

llvm/trunk/test/CodeGen/WebAssembly/unsupported-function-bitcasts.ll

; RUN: llc < %s -asm-verbose=false | FileCheck %s ; RUN: llc < %s -asm-verbose=false | FileCheck %s
; Test that function pointer casts that require conversions are not converted ; Test that function pointer casts that require conversions are not converted
; to wrappers. In theory some conversions could be supported, but currently no ; to wrappers. In theory some conversions could be supported, but currently no
; conversions are implemented. ; conversions are implemented.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK-LABEL: test: ; CHECK-LABEL: test:
; CHECK-NEXT: i32.const $push[[L0:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: i32.const $push[[L0:[0-9]+]]=, 0{{$}}
; CHECK-NEXT: call has_i64_arg@FUNCTION, $pop[[L0]]{{$}} ; CHECK-NEXT: call has_i64_arg@FUNCTION, $pop[[L0]]{{$}}
; CHECK-NEXT: i32.call $push{{[0-9]+}}=, has_i64_ret@FUNCTION{{$}} ; CHECK-NEXT: i32.call $push{{[0-9]+}}=, has_i64_ret@FUNCTION{{$}}
; CHECK-NEXT: drop ; CHECK-NEXT: drop
; CHECK-NEXT: end_function ; CHECK-NEXT: end_function
Show All 11 Lines

llvm/trunk/test/CodeGen/WebAssembly/unused-argument.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s
; Make sure that argument offsets are correct even if some arguments are unused. ; Make sure that argument offsets are correct even if some arguments are unused.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK-LABEL: unused_first: ; CHECK-LABEL: unused_first:
; CHECK-NEXT: .param i32, i32{{$}} ; CHECK-NEXT: .param i32, i32{{$}}
; CHECK-NEXT: .result i32{{$}} ; CHECK-NEXT: .result i32{{$}}
; CHECK-NEXT: return $1{{$}} ; CHECK-NEXT: return $1{{$}}
define i32 @unused_first(i32 %x, i32 %y) { define i32 @unused_first(i32 %x, i32 %y) {
ret i32 %y ret i32 %y
} }
Show All 17 Lines

llvm/trunk/test/CodeGen/WebAssembly/userstack.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
declare void @ext_func(i64* %ptr) declare void @ext_func(i64* %ptr)
declare void @ext_func_i32(i32* %ptr) declare void @ext_func_i32(i32* %ptr)
; CHECK-LABEL: alloca32: ; CHECK-LABEL: alloca32:
; Check that there is an extra local for the stack pointer. ; Check that there is an extra local for the stack pointer.
; CHECK: .local i32{{$}} ; CHECK: .local i32{{$}}
define void @alloca32() noredzone { define void @alloca32() noredzone {
▲ Show 20 Lines • Show All 321 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/varargs.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -verify-machineinstrs | FileCheck %s ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -verify-machineinstrs | FileCheck %s
; Test varargs constructs. ; Test varargs constructs.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; Test va_start. ; Test va_start.
; TODO: Test va_start. ; TODO: Test va_start.
; CHECK-LABEL: start: ; CHECK-LABEL: start:
; CHECK-NEXT: .param i32, i32 ; CHECK-NEXT: .param i32, i32
; CHECK-NOT: __stack_pointer ; CHECK-NOT: __stack_pointer
define void @start(i8** %ap, ...) { define void @start(i8** %ap, ...) {
▲ Show 20 Lines • Show All 135 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WebAssembly/vtable.ll

; RUN: llc < %s -asm-verbose=false -disable-wasm-explicit-locals | FileCheck %s --check-prefix=TYPEINFONAME ; RUN: llc < %s -asm-verbose=false -disable-wasm-explicit-locals | FileCheck %s --check-prefix=TYPEINFONAME
; RUN: llc < %s -asm-verbose=false -disable-wasm-explicit-locals | FileCheck %s --check-prefix=VTABLE ; RUN: llc < %s -asm-verbose=false -disable-wasm-explicit-locals | FileCheck %s --check-prefix=VTABLE
; RUN: llc < %s -asm-verbose=false -disable-wasm-explicit-locals | FileCheck %s --check-prefix=TYPEINFO ; RUN: llc < %s -asm-verbose=false -disable-wasm-explicit-locals | FileCheck %s --check-prefix=TYPEINFO
; Test that simple vtables assemble as expected. ; Test that simple vtables assemble as expected.
; ;
; The class hierarchy is: ; The class hierarchy is:
; struct A; ; struct A;
; struct B : public A; ; struct B : public A;
; struct C : public A; ; struct C : public A;
; struct D : public B; ; struct D : public B;
; Each with a virtual dtor and method foo. ; Each with a virtual dtor and method foo.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
%struct.A = type { i32 (...)** } %struct.A = type { i32 (...)** }
%struct.B = type { %struct.A } %struct.B = type { %struct.A }
%struct.C = type { %struct.A } %struct.C = type { %struct.A }
%struct.D = type { %struct.B } %struct.D = type { %struct.B }
@_ZTVN10__cxxabiv117__class_type_infoE = external global i8* @_ZTVN10__cxxabiv117__class_type_infoE = external global i8*
@_ZTVN10__cxxabiv120__si_class_type_infoE = external global i8* @_ZTVN10__cxxabiv120__si_class_type_infoE = external global i8*
▲ Show 20 Lines • Show All 151 Lines • Show Last 20 Lines

llvm/trunk/test/DebugInfo/WebAssembly/dbg-declare.ll

; RUN: llc < %s -verify-machineinstrs -mtriple=wasm32-unknown-unknown-wasm | FileCheck %s ; RUN: llc < %s -verify-machineinstrs -mtriple=wasm32-unknown-unknown | FileCheck %s
; RUN: llc < %s -verify-machineinstrs -mtriple=wasm32-unknown-unknown-wasm -fast-isel | FileCheck --check-prefix=CHECK-FAST %s ; RUN: llc < %s -verify-machineinstrs -mtriple=wasm32-unknown-unknown -fast-isel | FileCheck --check-prefix=CHECK-FAST %s
; CHECK: DW_TAG_variable ; CHECK: DW_TAG_variable
; CHECK-FAST: DW_TAG_variable ; CHECK-FAST: DW_TAG_variable
; Test that llvm.dbg.declare() instrinsics do not crash the backend ; Test that llvm.dbg.declare() instrinsics do not crash the backend
source_filename = "test/DebugInfo/WebAssembly/dbg-declare.ll" source_filename = "test/DebugInfo/WebAssembly/dbg-declare.ll"
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
@key = external global [15 x i8], align 1 @key = external global [15 x i8], align 1
define internal zeroext i8 @0(i32, i8 zeroext) !dbg !15 !type !20 { define internal zeroext i8 @0(i32, i8 zeroext) !dbg !15 !type !20 {
%3 = alloca i32, align 4 %3 = alloca i32, align 4
%4 = alloca i8, align 1 %4 = alloca i8, align 1
store i32 %0, i32* %3, align 4 store i32 %0, i32* %3, align 4
call void @llvm.dbg.declare(metadata i32* %3, metadata !21, metadata !22), !dbg !23 call void @llvm.dbg.declare(metadata i32* %3, metadata !21, metadata !22), !dbg !23
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

llvm/trunk/test/DebugInfo/WebAssembly/dbg-loop-loc.ll

Show All 9 Lines
; t = a + b; a = b; b = t; ; t = a + b; a = b; b = t;
; } ; }
; return b; ; return b;
; } ; }
; ModuleID = 'dbg-loop-loc.bc' ; ModuleID = 'dbg-loop-loc.bc'
source_filename = "dbg-loop-loc.c" source_filename = "dbg-loop-loc.c"
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK: .file 1 ; CHECK: .file 1
; CHECK: .loc 1 1 0 ; CHECK: .loc 1 1 0
; CHECK: .loc 1 3 15 ; CHECK: .loc 1 3 15
; CHECK-NEXT: block ; CHECK-NEXT: block
; CHECK-NEXT: loop ; CHECK-NEXT: loop
; CHECK: br 0 ; CHECK: br 0
; CHECK-NOT: .loc 1 0 ; CHECK-NOT: .loc 1 0
▲ Show 20 Lines • Show All 107 Lines • Show Last 20 Lines

llvm/trunk/test/MC/WebAssembly/array-fill.ll

; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s ; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s
; PR33624 ; PR33624
source_filename = "ws.c" source_filename = "ws.c"
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
%struct.bd = type { i8 } %struct.bd = type { i8 }
@gBd = hidden global [2 x %struct.bd] [%struct.bd { i8 1 }, %struct.bd { i8 2 }], align 1 @gBd = hidden global [2 x %struct.bd] [%struct.bd { i8 1 }, %struct.bd { i8 2 }], align 1
; CHECK: - Type: DATA ; CHECK: - Type: DATA
; CHECK: Content: '0102' ; CHECK: Content: '0102'
Show All 13 Lines

llvm/trunk/test/MC/WebAssembly/basic-assembly.s

# RUN: llvm-mc -triple=wasm32-unknown-unknown-elf < %s | FileCheck %s # RUN: llvm-mc -triple=wasm32-unknown-unknown-elf < %s | FileCheck %s
# RUN: llvm-mc -triple=wasm32-unknown-unknown-wasm < %s | FileCheck %s # RUN: llvm-mc -triple=wasm32-unknown-unknown < %s | FileCheck %s
.text .text
.type test0,@function .type test0,@function
test0: test0:
# Test all types: # Test all types:
.param i32, i64 .param i32, i64
.local f32, f64 #, i8x16, i16x8, i32x4, f32x4 .local f32, f64 #, i8x16, i16x8, i32x4, f32x4
# Explicit getlocal/setlocal: # Explicit getlocal/setlocal:
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

llvm/trunk/test/MC/WebAssembly/blockaddress.ll

; TODO(sbc): Make this test pass by adding support for unnamed tempoaries ; TODO(sbc): Make this test pass by adding support for unnamed tempoaries
; in wasm relocations. ; in wasm relocations.
; RUN: not llc -filetype=obj %s -o /dev/null 2>&1 | FileCheck %s ; RUN: not llc -filetype=obj %s -o /dev/null 2>&1 | FileCheck %s
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
@foo = internal global i8* blockaddress(@bar, %addr), align 4 @foo = internal global i8* blockaddress(@bar, %addr), align 4
define hidden i32 @bar() #0 { define hidden i32 @bar() #0 {
entry: entry:
br label %addr br label %addr
addr: addr:
ret i32 0 ret i32 0
} }
; CHECK: LLVM ERROR: relocations for function or section offsets are only supported in metadata sections ; CHECK: LLVM ERROR: relocations for function or section offsets are only supported in metadata sections

llvm/trunk/test/MC/WebAssembly/bss.ll

; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s ; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
@g0 = global i8* null, align 4 @g0 = global i8* null, align 4
@g1 = global i32 0, align 4 @g1 = global i32 0, align 4
%union.u1 = type {} %union.u1 = type {}
@foo = global %union.u1 zeroinitializer, align 1 @foo = global %union.u1 zeroinitializer, align 1
@bar = global %union.u1 zeroinitializer, align 1 @bar = global %union.u1 zeroinitializer, align 1
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

llvm/trunk/test/MC/WebAssembly/comdat.ll

; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s ; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; Import a function just so we can check the index arithmetic for ; Import a function just so we can check the index arithmetic for
; WASM_COMDAT_FUNCTION entries is performed correctly ; WASM_COMDAT_FUNCTION entries is performed correctly
declare i32 @funcImport() declare i32 @funcImport()
define i32 @callImport() { define i32 @callImport() {
entry: entry:
%call = call i32 @funcImport() %call = call i32 @funcImport()
ret i32 %call ret i32 %call
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

llvm/trunk/test/MC/WebAssembly/custom-code-section.ll

; RUN: llc -O2 -filetype=obj %s -o %t.o ; RUN: llc -O2 -filetype=obj %s -o %t.o
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; Wasm silently ignores custom sections for code. ; Wasm silently ignores custom sections for code.
; We had a bug where this cause a crash ; We had a bug where this cause a crash
define hidden void @call_indirect() section "some_section_name" { define hidden void @call_indirect() section "some_section_name" {
entry: entry:
ret void ret void
} }

llvm/trunk/test/MC/WebAssembly/custom-sections.ll

; RUN: llc -filetype=obj %s -o - | llvm-readobj -s | FileCheck %s ; RUN: llc -filetype=obj %s -o - | llvm-readobj -s | FileCheck %s
; Test the mechanism for defining user custom sections. ; Test the mechanism for defining user custom sections.
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
!0 = !{ !"red", !"foo" } !0 = !{ !"red", !"foo" }
!1 = !{ !"green", !"bar" } !1 = !{ !"green", !"bar" }
!2 = !{ !"green", !"qux" } !2 = !{ !"green", !"qux" }
!wasm.custom_sections = !{ !0, !1, !2 } !wasm.custom_sections = !{ !0, !1, !2 }
; CHECK: Section { ; CHECK: Section {
; CHECK: Type: CUSTOM (0x0) ; CHECK: Type: CUSTOM (0x0)
Show All 10 Lines

llvm/trunk/test/MC/WebAssembly/debug-info.ll

Show First 20 Lines • Show All 198 Lines • ▼ Show 20 Lines
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-NEXT: Symbol { ; CHECK-NEXT: Symbol {
; CHECK-NEXT: Name: .debug_line ; CHECK-NEXT: Name: .debug_line
; CHECK-NEXT: Type: SECTION (0x3) ; CHECK-NEXT: Type: SECTION (0x3)
; CHECK-NEXT: Flags: 0x2 ; CHECK-NEXT: Flags: 0x2
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-NEXT:] ; CHECK-NEXT:]
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
source_filename = "test.c" source_filename = "test.c"
@myextern = external global i32, align 4 @myextern = external global i32, align 4
@foo = hidden global i32* @myextern, align 4, !dbg !0 @foo = hidden global i32* @myextern, align 4, !dbg !0
@ptr2 = hidden global void ()* @f2, align 4, !dbg !6 @ptr2 = hidden global void ()* @f2, align 4, !dbg !6
; Function Attrs: noinline nounwind optnone ; Function Attrs: noinline nounwind optnone
Show All 30 Lines

llvm/trunk/test/MC/WebAssembly/dwarfdump.ll

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines
; CHECK-NEXT: DW_AT_name ("f2") ; CHECK-NEXT: DW_AT_name ("f2")
; CHECK-NEXT: DW_AT_decl_file ("/usr/local/google/home/sbc/dev/wasm/simple{{[/\\]}}test.c") ; CHECK-NEXT: DW_AT_decl_file ("/usr/local/google/home/sbc/dev/wasm/simple{{[/\\]}}test.c")
; CHECK-NEXT: DW_AT_decl_line (2) ; CHECK-NEXT: DW_AT_decl_line (2)
; CHECK-NEXT: DW_AT_prototyped (true) ; CHECK-NEXT: DW_AT_prototyped (true)
; CHECK-NEXT: DW_AT_external (true) ; CHECK-NEXT: DW_AT_external (true)
; CHECK: 0x00000069: NULL ; CHECK: 0x00000069: NULL
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
source_filename = "test.c" source_filename = "test.c"
@myextern = external global i32, align 4 @myextern = external global i32, align 4
@foo = hidden global i32* @myextern, align 4, !dbg !0 @foo = hidden global i32* @myextern, align 4, !dbg !0
@ptr2 = hidden global void ()* @f2, align 4, !dbg !6 @ptr2 = hidden global void ()* @f2, align 4, !dbg !6
; Function Attrs: noinline nounwind optnone ; Function Attrs: noinline nounwind optnone
Show All 30 Lines

llvm/trunk/test/MC/WebAssembly/explicit-sections.ll

; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s ; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
%struct.bd = type { i32, i8 } %struct.bd = type { i32, i8 }
@global0 = global i32 8, align 8 @global0 = global i32 8, align 8
@global1 = global %struct.bd { i32 1, i8 3 }, align 8, section ".sec1" @global1 = global %struct.bd { i32 1, i8 3 }, align 8, section ".sec1"
@global2 = global i64 7, align 8, section ".sec1" @global2 = global i64 7, align 8, section ".sec1"
@global3 = global i32 8, align 8, section ".sec2" @global3 = global i32 8, align 8, section ".sec2"
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

llvm/trunk/test/MC/WebAssembly/external-data.ll

; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s ; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; Verify relocations are correctly generated for addresses of externals ; Verify relocations are correctly generated for addresses of externals
; in the data section. ; in the data section.
@myimport = external global i32, align 4 @myimport = external global i32, align 4
@foo = global i64 7, align 4 @foo = global i64 7, align 4
@bar = hidden global i32* @myimport, align 4 @bar = hidden global i32* @myimport, align 4
Show All 19 Lines

llvm/trunk/test/MC/WebAssembly/external-func-address.ll

; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s ; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; Verify that addresses of external functions generate correctly typed ; Verify that addresses of external functions generate correctly typed
; imports and relocations or type R_TABLE_INDEX_I32. ; imports and relocations or type R_TABLE_INDEX_I32.
declare void @f0(i32) #0 declare void @f0(i32) #0
@ptr_to_f0 = hidden global void (i32)* @f0, align 4 @ptr_to_f0 = hidden global void (i32)* @f0, align 4
attributes #0 = { "wasm-import-module"="somewhere" } attributes #0 = { "wasm-import-module"="somewhere" }
Show All 37 Lines

llvm/trunk/test/MC/WebAssembly/file-headers.ll

; RUN: llc -filetype=obj %s -o - | llvm-readobj -file-headers | FileCheck %s ; RUN: llc -filetype=obj %s -o - | llvm-readobj -file-headers | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK: Format: WASM{{$}} ; CHECK: Format: WASM{{$}}
; CHECK: Arch: wasm32{{$}} ; CHECK: Arch: wasm32{{$}}
; CHECK: AddressSize: 32bit{{$}} ; CHECK: AddressSize: 32bit{{$}}
; CHECK: Version: 0x1{{$}} ; CHECK: Version: 0x1{{$}}

llvm/trunk/test/MC/WebAssembly/func-address.ll

; RUN: llc -O2 -filetype=obj %s -o - | llvm-readobj -r -s -expand-relocs | FileCheck %s ; RUN: llc -O2 -filetype=obj %s -o - | llvm-readobj -r -s -expand-relocs | FileCheck %s
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
declare i32 @import1() declare i32 @import1()
declare i32 @import2() declare i32 @import2()
declare i32 @import3() declare i32 @import3()
; call the imports to make sure they are included in the imports section ; call the imports to make sure they are included in the imports section
define hidden void @call_imports() #0 { define hidden void @call_imports() #0 {
entry: entry:
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

llvm/trunk/test/MC/WebAssembly/global-ctor-dtor.ll

; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s ; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
@global1 = global i32 1025, align 8 @global1 = global i32 1025, align 8
declare void @func0() declare void @func0()
declare void @func1() declare void @func1()
declare void @func2() declare void @func2()
declare void @func3() declare void @func3()
▲ Show 20 Lines • Show All 173 Lines • Show Last 20 Lines

llvm/trunk/test/MC/WebAssembly/libcall.ll

; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s ; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
define hidden void @call_memcpy(i8* align 4 %a, i8* align 4 %b) { define hidden void @call_memcpy(i8* align 4 %a, i8* align 4 %b) {
entry: entry:
tail call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %a, i8* align 4 %b, i32 512, i1 false) tail call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %a, i8* align 4 %b, i32 512, i1 false)
ret void ret void
} }
declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture writeonly, i8* nocapture readonly, i32, i1) declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture writeonly, i8* nocapture readonly, i32, i1)
Show All 19 Lines

llvm/trunk/test/MC/WebAssembly/offset.ll

; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s ; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; CHECK: - Type: CODE ; CHECK: - Type: CODE
; CHECK-NEXT: Functions: ; CHECK-NEXT: Functions:
; CHECK-NEXT: - Index: 0 ; CHECK-NEXT: - Index: 0
; CHECK-NEXT: Locals: ; CHECK-NEXT: Locals:
; CHECK-NEXT: Body: 41002802FFFFFFFF0F0B ; CHECK-NEXT: Body: 41002802FFFFFFFF0F0B
define i32 @load_i32_from_negative_address() { define i32 @load_i32_from_negative_address() {
%t = load i32, i32* inttoptr (i32 -1 to i32*) %t = load i32, i32* inttoptr (i32 -1 to i32*)
Show All 10 Lines

llvm/trunk/test/MC/WebAssembly/reloc-code.ll

; RUN: llc -filetype=obj %s -o - | llvm-readobj -r -expand-relocs | FileCheck %s ; RUN: llc -filetype=obj %s -o - | llvm-readobj -r -expand-relocs | FileCheck %s
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; Pointers to functions of two different types ; Pointers to functions of two different types
@a = global i64 ()* inttoptr (i64 5 to i64 ()*), align 8 @a = global i64 ()* inttoptr (i64 5 to i64 ()*), align 8
@b = global i32 ()* inttoptr (i32 7 to i32 ()*), align 8 @b = global i32 ()* inttoptr (i32 7 to i32 ()*), align 8
; External functions ; External functions
declare i32 @c() declare i32 @c()
declare i32 @d() declare i32 @d()
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

llvm/trunk/test/MC/WebAssembly/reloc-data.ll

; RUN: llc -O0 -filetype=obj %s -o - | llvm-readobj -r -expand-relocs | FileCheck %s ; RUN: llc -O0 -filetype=obj %s -o - | llvm-readobj -r -expand-relocs | FileCheck %s
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; foo and bar are external and internal symbols. a and b are pointers ; foo and bar are external and internal symbols. a and b are pointers
; initialized to these locations offset by 2 and -2 elements respecitively. ; initialized to these locations offset by 2 and -2 elements respecitively.
@foo = external global i32, align 4 @foo = external global i32, align 4
@bar = global i64 7, align 4 @bar = global i64 7, align 4
@a = global i32* getelementptr (i32, i32* @foo, i32 2), align 8 @a = global i32* getelementptr (i32, i32* @foo, i32 2), align 8
@b = global i64* getelementptr (i64, i64* @bar, i64 -2), align 8 @b = global i64* getelementptr (i64, i64* @bar, i64 -2), align 8
Show All 37 Lines

llvm/trunk/test/MC/WebAssembly/sections.ll

; RUN: llc -filetype=obj %s -o - | llvm-readobj -s | FileCheck %s ; RUN: llc -filetype=obj %s -o - | llvm-readobj -s | FileCheck %s
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; external function ; external function
declare i32 @a() declare i32 @a()
; global data ; global data
@b = global i32 3, align 4 @b = global i32 3, align 4
; local function ; local function
Show All 31 Lines

llvm/trunk/test/MC/WebAssembly/stack-ptr.ll

; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s ; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; Function that uses explict stack, and should generate a reference to ; Function that uses explict stack, and should generate a reference to
; __stack_pointer, along with the corresponding reloction entry. ; __stack_pointer, along with the corresponding reloction entry.
define hidden void @foo() #0 { define hidden void @foo() #0 {
entry: entry:
alloca i32, align 4 alloca i32, align 4
ret void ret void
} }
Show All 12 Lines

llvm/trunk/test/MC/WebAssembly/unnamed-data.ll

; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s ; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
@.str1 = private unnamed_addr constant [6 x i8] c"hello\00", align 1 @.str1 = private unnamed_addr constant [6 x i8] c"hello\00", align 1
@.str2 = private unnamed_addr constant [6 x i8] c"world\00", align 1 @.str2 = private unnamed_addr constant [6 x i8] c"world\00", align 1
@a = global i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str1, i32 0, i32 0), align 8 @a = global i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str1, i32 0, i32 0), align 8
@b = global i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str2, i32 0, i32 0), align 8 @b = global i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str2, i32 0, i32 0), align 8
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

llvm/trunk/test/MC/WebAssembly/visibility.ll

; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s ; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; Function with __attribute__((visibility("default"))) ; Function with __attribute__((visibility("default")))
define void @defaultVis() #0 { define void @defaultVis() #0 {
entry: entry:
ret void ret void
} }
; Function with __attribute__((visibility("hidden"))) ; Function with __attribute__((visibility("hidden")))
Show All 17 Lines

llvm/trunk/test/MC/WebAssembly/weak-alias.ll

; RUN: llc -filetype=obj %s -o %t.o ; RUN: llc -filetype=obj %s -o %t.o
; RUN: obj2yaml %t.o | FileCheck %s ; RUN: obj2yaml %t.o | FileCheck %s
; RUN: llvm-objdump -t %t.o | FileCheck --check-prefix=CHECK-SYMS %s ; RUN: llvm-objdump -t %t.o | FileCheck --check-prefix=CHECK-SYMS %s
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; 'foo_alias()' is weak alias of function 'foo()' ; 'foo_alias()' is weak alias of function 'foo()'
; 'bar_alias' is weak alias of global variable 'bar' ; 'bar_alias' is weak alias of global variable 'bar'
; Generates two exports of the same function, one of them weak ; Generates two exports of the same function, one of them weak
@bar = global i32 7, align 8 @bar = global i32 7, align 8
@bar_alias = weak hidden alias i32, i32* @bar @bar_alias = weak hidden alias i32, i32* @bar
@foo_alias = weak hidden alias i32 (), i32 ()* @foo @foo_alias = weak hidden alias i32 (), i32 ()* @foo
▲ Show 20 Lines • Show All 209 Lines • Show Last 20 Lines

llvm/trunk/test/MC/WebAssembly/weak.ll

; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s ; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s
target triple = "wasm32-unknown-unknown-wasm" target triple = "wasm32-unknown-unknown"
; Weak external data reference ; Weak external data reference
@weak_external_data = extern_weak global i32, align 4 @weak_external_data = extern_weak global i32, align 4
; Weak function definition ; Weak function definition
define weak hidden i32 @weak_function() local_unnamed_addr #0 { define weak hidden i32 @weak_function() local_unnamed_addr #0 {
entry: entry:
%0 = load i32, i32* @weak_external_data, align 4 %0 = load i32, i32* @weak_external_data, align 4
Show All 22 Lines

llvm/trunk/test/Object/Inputs/trivial.ll

; Input used for generating checked-in binaries (trivial-object-test.*) ; Input used for generating checked-in binaries (trivial-object-test.*)
; llc -mtriple=wasm32-unknown-unknown-wasm trivial.ll -filetype=obj -o trivial-object-test.wasm ; llc -mtriple=wasm32-unknown-unknown trivial.ll -filetype=obj -o trivial-object-test.wasm
@.str = private unnamed_addr constant [13 x i8] c"Hello World\0A\00", align 1 @.str = private unnamed_addr constant [13 x i8] c"Hello World\0A\00", align 1
define i32 @main() nounwind { define i32 @main() nounwind {
entry: entry:
%call = tail call i32 @puts(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str, i32 0, i32 0)) nounwind %call = tail call i32 @puts(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str, i32 0, i32 0)) nounwind
tail call void bitcast (void (...)* @SomeOtherFunction to void ()*)() nounwind tail call void bitcast (void (...)* @SomeOtherFunction to void ()*)() nounwind
ret i32 0 ret i32 0
Show All 9 Lines

llvm/trunk/test/tools/llvm-nm/wasm/local-symbols.ll

; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm -o %t.o %s ; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown -o %t.o %s
; RUN: llvm-nm %t.o | FileCheck %s ; RUN: llvm-nm %t.o | FileCheck %s
@foo = internal global i32 1, align 4 @foo = internal global i32 1, align 4
@bar = global i32 1, align 4 @bar = global i32 1, align 4
; CHECK: 00000004 D bar ; CHECK: 00000004 D bar
; CHECK: 00000000 d foo ; CHECK: 00000000 d foo

llvm/trunk/test/tools/llvm-objdump/Inputs/trivial.ll

; Input used for generating checked-in binaries (trivial.obj.*) ; Input used for generating checked-in binaries (trivial.obj.*)
; llc -mtriple=wasm32-unknown-unknown-wasm trivial.ll -filetype=obj -o trivial.obj.wasm ; llc -mtriple=wasm32-unknown-unknown trivial.ll -filetype=obj -o trivial.obj.wasm
@.str = private unnamed_addr constant [13 x i8] c"Hello World\0A\00", align 1 @.str = private unnamed_addr constant [13 x i8] c"Hello World\0A\00", align 1
define i32 @main() nounwind { define i32 @main() nounwind {
entry: entry:
%call = tail call i32 @puts(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str, i32 0, i32 0)) nounwind %call = tail call i32 @puts(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str, i32 0, i32 0)) nounwind
tail call void bitcast (void (...)* @SomeOtherFunction to void ()*)() nounwind tail call void bitcast (void (...)* @SomeOtherFunction to void ()*)() nounwind
ret i32 0 ret i32 0
Show All 9 Lines

llvm/trunk/test/tools/llvm-objdump/WebAssembly/relocations.test

; RUN: llc -mtriple=wasm32-unknown-unknown-wasm -filetype=obj %s -o - | llvm-objdump -r - | FileCheck %s ; RUN: llc -mtriple=wasm32-unknown-unknown -filetype=obj %s -o - | llvm-objdump -r - | FileCheck %s
@foo = external global i32, align 4 @foo = external global i32, align 4
@bar = global i32* @foo, align 4 @bar = global i32* @foo, align 4
define void @make_call(void ()* nocapture %func) { define void @make_call(void ()* nocapture %func) {
entry: entry:
call void %func() call void %func()
ret void ret void
} }
; CHECK: RELOCATION RECORDS FOR [CODE]: ; CHECK: RELOCATION RECORDS FOR [CODE]:
; CHECK-NEXT: 00000006 R_WEBASSEMBLY_TYPE_INDEX_LEB 1+0 ; CHECK-NEXT: 00000006 R_WEBASSEMBLY_TYPE_INDEX_LEB 1+0
; CHECK: RELOCATION RECORDS FOR [DATA]: ; CHECK: RELOCATION RECORDS FOR [DATA]:
; CHECK-NEXT: 00000006 R_WEBASSEMBLY_MEMORY_ADDR_I32 foo+0 ; CHECK-NEXT: 00000006 R_WEBASSEMBLY_MEMORY_ADDR_I32 foo+0

llvm/trunk/test/tools/llvm-readobj/Inputs/trivial.ll

; Input used for generating checked-in binaries (trivial.obj.*) ; Input used for generating checked-in binaries (trivial.obj.*)
; llc -mtriple=i386-pc-win32 trivial.ll -filetype=obj -o trivial.obj.coff-i386 ; llc -mtriple=i386-pc-win32 trivial.ll -filetype=obj -o trivial.obj.coff-i386
; llc -mtriple=x86_64-pc-win32 trivial.ll -filetype=obj -o trivial.obj.coff-x86-64 ; llc -mtriple=x86_64-pc-win32 trivial.ll -filetype=obj -o trivial.obj.coff-x86-64
; llc -mtriple=i386-linux-gnu trivial.ll -filetype=obj -o trivial.obj.elf-i386 -relocation-model=pic ; llc -mtriple=i386-linux-gnu trivial.ll -filetype=obj -o trivial.obj.elf-i386 -relocation-model=pic
; llc -mtriple=x86_64-linux-gnu trivial.ll -filetype=obj -o trivial.obj.elf-x86-64 -relocation-model=pic ; llc -mtriple=x86_64-linux-gnu trivial.ll -filetype=obj -o trivial.obj.elf-x86-64 -relocation-model=pic
; llc -mtriple=i386-apple-darwin10 trivial.ll -filetype=obj -o trivial.obj.macho-i386 -relocation-model=pic ; llc -mtriple=i386-apple-darwin10 trivial.ll -filetype=obj -o trivial.obj.macho-i386 -relocation-model=pic
; llc -mtriple=x86_64-apple-darwin10 trivial.ll -filetype=obj -o trivial.obj.macho-x86-64 -relocation-model=pic ; llc -mtriple=x86_64-apple-darwin10 trivial.ll -filetype=obj -o trivial.obj.macho-x86-64 -relocation-model=pic
; llc -mtriple=wasm32-unknown-unknown-wasm trivial.ll -filetype=obj -o trivial.obj.wasm ; llc -mtriple=wasm32-unknown-unknown trivial.ll -filetype=obj -o trivial.obj.wasm
@.str = private unnamed_addr constant [13 x i8] c"Hello World\0A\00", align 1 @.str = private unnamed_addr constant [13 x i8] c"Hello World\0A\00", align 1
define i32 @main() nounwind { define i32 @main() nounwind {
entry: entry:
%call = tail call i32 @puts(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str, i32 0, i32 0)) nounwind %call = tail call i32 @puts(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str, i32 0, i32 0)) nounwind
tail call void bitcast (void (...)* @SomeOtherFunction to void ()*)() nounwind tail call void bitcast (void (...)* @SomeOtherFunction to void ()*)() nounwind
ret i32 0 ret i32 0
} }
declare i32 @puts(i8* nocapture) nounwind declare i32 @puts(i8* nocapture) nounwind
declare void @SomeOtherFunction(...) declare void @SomeOtherFunction(...)