llvm/test/CodeGen/WebAssembly/immediates.ll

   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
  10 target 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]]{{$}}
  16 define 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]]{{$}}
  24 define 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]]{{$}}
  32 define 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]]{{$}}
  40 define 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]]{{$}}
  48 define 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]]{{$}}
  56 define 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]]{{$}}
  64 define 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]]{{$}}
  72 define 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]]{{$}}
  80 define 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]]{{$}}
  88 define 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]]{{$}}
  96 define 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]]{{$}}
 104 define 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]]{{$}}
 112 define 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]]{{$}}
 120 define 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]]{{$}}
 128 define 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]]{{$}}
 136 define 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]]{{$}}
 144 define 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]]{{$}}
 152 define 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]]{{$}}
 160 define 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]]{{$}}
 168 define 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]]{{$}}
 176 define 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]]{{$}}
 184 define 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]]{{$}}
 192 define 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]]{{$}}
 200 define 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]]{{$}}
 208 define 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]]{{$}}
 216 define 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 ; }