1; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-keep-registers | FileCheck %s
2
3; Usually MIPS hosts uses a legacy (non IEEE 754-2008) encoding for NaNs.
4; Tests like `nan_f32` failed in attempt to compare hard-coded IEEE 754-2008
5; NaN value and a legacy NaN value provided by a system.
6; XFAIL: mips-, mipsel-, mips64-, mips64el-
7
8; Test that basic immediates assemble as expected.
9
10target triple = "wasm32-unknown-unknown"
11
12; CHECK-LABEL: zero_i32:
13; CHECK-NEXT: .functype zero_i32 () -> (i32){{$}}
14; CHECK-NEXT: i32.const $push[[NUM:[0-9]+]]=, 0{{$}}
15; CHECK-NEXT: return $pop[[NUM]]{{$}}
16define i32 @zero_i32() {
17  ret i32 0
18}
19
20; CHECK-LABEL: one_i32:
21; CHECK-NEXT: .functype one_i32 () -> (i32){{$}}
22; CHECK-NEXT: i32.const $push[[NUM:[0-9]+]]=, 1{{$}}
23; CHECK-NEXT: return $pop[[NUM]]{{$}}
24define i32 @one_i32() {
25  ret i32 1
26}
27
28; CHECK-LABEL: max_i32:
29; CHECK-NEXT: .functype max_i32 () -> (i32){{$}}
30; CHECK-NEXT: i32.const $push[[NUM:[0-9]+]]=, 2147483647{{$}}
31; CHECK-NEXT: return $pop[[NUM]]{{$}}
32define i32 @max_i32() {
33  ret i32 2147483647
34}
35
36; CHECK-LABEL: min_i32:
37; CHECK-NEXT: .functype min_i32 () -> (i32){{$}}
38; CHECK-NEXT: i32.const $push[[NUM:[0-9]+]]=, -2147483648{{$}}
39; CHECK-NEXT: return $pop[[NUM]]{{$}}
40define i32 @min_i32() {
41  ret i32 -2147483648
42}
43
44; CHECK-LABEL: zero_i64:
45; CHECK-NEXT: .functype zero_i64 () -> (i64){{$}}
46; CHECK-NEXT: i64.const $push[[NUM:[0-9]+]]=, 0{{$}}
47; CHECK-NEXT: return $pop[[NUM]]{{$}}
48define i64 @zero_i64() {
49  ret i64 0
50}
51
52; CHECK-LABEL: one_i64:
53; CHECK-NEXT: .functype one_i64 () -> (i64){{$}}
54; CHECK-NEXT: i64.const $push[[NUM:[0-9]+]]=, 1{{$}}
55; CHECK-NEXT: return $pop[[NUM]]{{$}}
56define i64 @one_i64() {
57  ret i64 1
58}
59
60; CHECK-LABEL: max_i64:
61; CHECK-NEXT: .functype max_i64 () -> (i64){{$}}
62; CHECK-NEXT: i64.const $push[[NUM:[0-9]+]]=, 9223372036854775807{{$}}
63; CHECK-NEXT: return $pop[[NUM]]{{$}}
64define i64 @max_i64() {
65  ret i64 9223372036854775807
66}
67
68; CHECK-LABEL: min_i64:
69; CHECK-NEXT: .functype min_i64 () -> (i64){{$}}
70; CHECK-NEXT: i64.const $push[[NUM:[0-9]+]]=, -9223372036854775808{{$}}
71; CHECK-NEXT: return $pop[[NUM]]{{$}}
72define i64 @min_i64() {
73  ret i64 -9223372036854775808
74}
75
76; CHECK-LABEL: negzero_f32:
77; CHECK-NEXT: .functype negzero_f32 () -> (f32){{$}}
78; CHECK-NEXT: f32.const $push[[NUM:[0-9]+]]=, -0x0p0{{$}}
79; CHECK-NEXT: return $pop[[NUM]]{{$}}
80define float @negzero_f32() {
81  ret float -0.0
82}
83
84; CHECK-LABEL: zero_f32:
85; CHECK-NEXT: .functype zero_f32 () -> (f32){{$}}
86; CHECK-NEXT: f32.const $push[[NUM:[0-9]+]]=, 0x0p0{{$}}
87; CHECK-NEXT: return $pop[[NUM]]{{$}}
88define float @zero_f32() {
89  ret float 0.0
90}
91
92; CHECK-LABEL: one_f32:
93; CHECK-NEXT: .functype one_f32 () -> (f32){{$}}
94; CHECK-NEXT: f32.const $push[[NUM:[0-9]+]]=, 0x1p0{{$}}
95; CHECK-NEXT: return $pop[[NUM]]{{$}}
96define float @one_f32() {
97  ret float 1.0
98}
99
100; CHECK-LABEL: two_f32:
101; CHECK-NEXT: .functype two_f32 () -> (f32){{$}}
102; CHECK-NEXT: f32.const $push[[NUM:[0-9]+]]=, 0x1p1{{$}}
103; CHECK-NEXT: return $pop[[NUM]]{{$}}
104define float @two_f32() {
105  ret float 2.0
106}
107
108; CHECK-LABEL: nan_f32:
109; CHECK-NEXT: .functype nan_f32 () -> (f32){{$}}
110; CHECK-NEXT: f32.const $push[[NUM:[0-9]+]]=, nan{{$}}
111; CHECK-NEXT: return $pop[[NUM]]{{$}}
112define float @nan_f32() {
113  ret float 0x7FF8000000000000
114}
115
116; CHECK-LABEL: negnan_f32:
117; CHECK-NEXT: .functype negnan_f32 () -> (f32){{$}}
118; CHECK-NEXT: f32.const $push[[NUM:[0-9]+]]=, -nan{{$}}
119; CHECK-NEXT: return $pop[[NUM]]{{$}}
120define float @negnan_f32() {
121  ret float 0xFFF8000000000000
122}
123
124; CHECK-LABEL: inf_f32:
125; CHECK-NEXT: .functype inf_f32 () -> (f32){{$}}
126; CHECK-NEXT: f32.const $push[[NUM:[0-9]+]]=, infinity{{$}}
127; CHECK-NEXT: return $pop[[NUM]]{{$}}
128define float @inf_f32() {
129  ret float 0x7FF0000000000000
130}
131
132; CHECK-LABEL: neginf_f32:
133; CHECK-NEXT: .functype neginf_f32 () -> (f32){{$}}
134; CHECK-NEXT: f32.const $push[[NUM:[0-9]+]]=, -infinity{{$}}
135; CHECK-NEXT: return $pop[[NUM]]{{$}}
136define float @neginf_f32() {
137  ret float 0xFFF0000000000000
138}
139
140; CHECK-LABEL: custom_nan_f32:
141; CHECK-NEXT: .functype custom_nan_f32 () -> (f32){{$}}
142; CHECK-NEXT: f32.const $push[[NUM:[0-9]+]]=, -nan:0x6bcdef{{$}}
143; CHECK-NEXT: return $pop[[NUM]]{{$}}
144define float @custom_nan_f32() {
145  ret float 0xFFFD79BDE0000000
146}
147
148; CHECK-LABEL: custom_nans_f32:
149; CHECK-NEXT: .functype custom_nans_f32 () -> (f32){{$}}
150; CHECK-NEXT: f32.const $push[[NUM:[0-9]+]]=, -nan:0x2bcdef{{$}}
151; CHECK-NEXT: return $pop[[NUM]]{{$}}
152define float @custom_nans_f32() {
153  ret float 0xFFF579BDE0000000
154}
155
156; CHECK-LABEL: negzero_f64:
157; CHECK-NEXT: .functype negzero_f64 () -> (f64){{$}}
158; CHECK-NEXT: f64.const $push[[NUM:[0-9]+]]=, -0x0p0{{$}}
159; CHECK-NEXT: return $pop[[NUM]]{{$}}
160define double @negzero_f64() {
161  ret double -0.0
162}
163
164; CHECK-LABEL: zero_f64:
165; CHECK-NEXT: .functype zero_f64 () -> (f64){{$}}
166; CHECK-NEXT: f64.const $push[[NUM:[0-9]+]]=, 0x0p0{{$}}
167; CHECK-NEXT: return $pop[[NUM]]{{$}}
168define double @zero_f64() {
169  ret double 0.0
170}
171
172; CHECK-LABEL: one_f64:
173; CHECK-NEXT: .functype one_f64 () -> (f64){{$}}
174; CHECK-NEXT: f64.const $push[[NUM:[0-9]+]]=, 0x1p0{{$}}
175; CHECK-NEXT: return $pop[[NUM]]{{$}}
176define double @one_f64() {
177  ret double 1.0
178}
179
180; CHECK-LABEL: two_f64:
181; CHECK-NEXT: .functype two_f64 () -> (f64){{$}}
182; CHECK-NEXT: f64.const $push[[NUM:[0-9]+]]=, 0x1p1{{$}}
183; CHECK-NEXT: return $pop[[NUM]]{{$}}
184define double @two_f64() {
185  ret double 2.0
186}
187
188; CHECK-LABEL: nan_f64:
189; CHECK-NEXT: .functype nan_f64 () -> (f64){{$}}
190; CHECK-NEXT: f64.const $push[[NUM:[0-9]+]]=, nan{{$}}
191; CHECK-NEXT: return $pop[[NUM]]{{$}}
192define double @nan_f64() {
193  ret double 0x7FF8000000000000
194}
195
196; CHECK-LABEL: negnan_f64:
197; CHECK-NEXT: .functype negnan_f64 () -> (f64){{$}}
198; CHECK-NEXT: f64.const $push[[NUM:[0-9]+]]=, -nan{{$}}
199; CHECK-NEXT: return $pop[[NUM]]{{$}}
200define double @negnan_f64() {
201  ret double 0xFFF8000000000000
202}
203
204; CHECK-LABEL: inf_f64:
205; CHECK-NEXT: .functype inf_f64 () -> (f64){{$}}
206; CHECK-NEXT: f64.const $push[[NUM:[0-9]+]]=, infinity{{$}}
207; CHECK-NEXT: return $pop[[NUM]]{{$}}
208define double @inf_f64() {
209  ret double 0x7FF0000000000000
210}
211
212; CHECK-LABEL: neginf_f64:
213; CHECK-NEXT: .functype neginf_f64 () -> (f64){{$}}
214; CHECK-NEXT: f64.const $push[[NUM:[0-9]+]]=, -infinity{{$}}
215; CHECK-NEXT: return $pop[[NUM]]{{$}}
216define double @neginf_f64() {
217  ret double 0xFFF0000000000000
218}
219
220;; Custom NaN playloads are currently not always preserved because of the use of
221;; native doubles in the MC layer. TODO: fix this problem or decide we don't
222;; care about preserving NaN payloads.
223
224; XXX-CHECK-LABEL: custom_nan_f64:
225; XXX-CHECK-NEXT: .functype custom_nan_f64 () -> (f64){{$}}
226; XXX-CHECK-NEXT: f64.const $push[[NUM:[0-9]+]]=, -nan:0xabcdef0123456{{$}}
227; XXX-CHECK-NEXT: return $pop[[NUM]]{{$}}
228; define double @custom_nan_f64() {
229;   ret double 0xFFFABCDEF0123456
230; }
231
232; XXX-CHECK-LABEL: custom_nans_f64:
233; XXX-CHECK-NEXT: .functype custom_nans_f64 () -> (f64){{$}}
234; XXX-CHECK-NEXT: f64.const $push[[NUM:[0-9]+]]=, -nan:0x2bcdef0123456{{$}}
235; XXX-CHECK-NEXT: return $pop[[NUM]]{{$}}
236; define double @custom_nans_f64() {
237;   ret double 0xFFF2BCDEF0123456
238; }
239