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