test/CodeGen/WebAssembly/immediates.ll

   1 ; RUN: llc < %s -asm-verbose=false | FileCheck %s
   2
   3 ; Test that basic immediates assemble as expected.
   4
   5 target datalayout = "e-p:32:32-i64:64-n32:64-S128"
   6 target triple = "wasm32-unknown-unknown"
   7
   8 ; CHECK-LABEL: zero_i32:
   9 ; CHECK-NEXT: .result i32{{$}}
  10 ; CHECK-NEXT: i32.const 0{{$}}
  11 ; CHECK-NEXT: set_local @0, pop{{$}}
  12 ; CHECK-NEXT: return @0{{$}}
  13 define i32 @zero_i32() {
  14   ret i32 0
  15 }
  16
  17 ; CHECK-LABEL: one_i32:
  18 ; CHECK-NEXT: .result i32{{$}}
  19 ; CHECK-NEXT: i32.const 1{{$}}
  20 ; CHECK-NEXT: set_local @0, pop{{$}}
  21 ; CHECK-NEXT: return @0{{$}}
  22 define i32 @one_i32() {
  23   ret i32 1
  24 }
  25
  26 ; CHECK-LABEL: max_i32:
  27 ; CHECK-NEXT: .result i32{{$}}
  28 ; CHECK-NEXT: i32.const 2147483647{{$}}
  29 ; CHECK-NEXT: set_local @0, pop{{$}}
  30 ; CHECK-NEXT: return @0{{$}}
  31 define i32 @max_i32() {
  32   ret i32 2147483647
  33 }
  34
  35 ; CHECK-LABEL: min_i32:
  36 ; CHECK-NEXT: .result i32{{$}}
  37 ; CHECK-NEXT: i32.const -2147483648{{$}}
  38 ; CHECK-NEXT: set_local @0, pop{{$}}
  39 ; CHECK-NEXT: return @0{{$}}
  40 define i32 @min_i32() {
  41   ret i32 -2147483648
  42 }
  43
  44 ; CHECK-LABEL: zero_i64:
  45 ; CHECK-NEXT: .result i64{{$}}
  46 ; CHECK-NEXT: i64.const 0{{$}}
  47 ; CHECK-NEXT: set_local @0, pop{{$}}
  48 ; CHECK-NEXT: return @0{{$}}
  49 define i64 @zero_i64() {
  50   ret i64 0
  51 }
  52
  53 ; CHECK-LABEL: one_i64:
  54 ; CHECK-NEXT: .result i64{{$}}
  55 ; CHECK-NEXT: i64.const 1{{$}}
  56 ; CHECK-NEXT: set_local @0, pop{{$}}
  57 ; CHECK-NEXT: return @0{{$}}
  58 define i64 @one_i64() {
  59   ret i64 1
  60 }
  61
  62 ; CHECK-LABEL: max_i64:
  63 ; CHECK-NEXT: .result i64{{$}}
  64 ; CHECK-NEXT: i64.const 9223372036854775807{{$}}
  65 ; CHECK-NEXT: set_local @0, pop{{$}}
  66 ; CHECK-NEXT: return @0{{$}}
  67 define i64 @max_i64() {
  68   ret i64 9223372036854775807
  69 }
  70
  71 ; CHECK-LABEL: min_i64:
  72 ; CHECK-NEXT: .result i64{{$}}
  73 ; CHECK-NEXT: i64.const -9223372036854775808{{$}}
  74 ; CHECK-NEXT: set_local @0, pop{{$}}
  75 ; CHECK-NEXT: return @0{{$}}
  76 define i64 @min_i64() {
  77   ret i64 -9223372036854775808
  78 }
  79
  80 ; CHECK-LABEL: negzero_f32:
  81 ; CHECK-NEXT: .result f32{{$}}
  82 ; CHECK-NEXT: f32.const -0x0p0{{$}}
  83 ; CHECK-NEXT: set_local @0, pop{{$}}
  84 ; CHECK-NEXT: return @0{{$}}
  85 define float @negzero_f32() {
  86   ret float -0.0
  87 }
  88
  89 ; CHECK-LABEL: zero_f32:
  90 ; CHECK-NEXT: .result f32{{$}}
  91 ; CHECK-NEXT: f32.const 0x0p0{{$}}
  92 ; CHECK-NEXT: set_local @0, pop{{$}}
  93 ; CHECK-NEXT: return @0{{$}}
  94 define float @zero_f32() {
  95   ret float 0.0
  96 }
  97
  98 ; CHECK-LABEL: one_f32:
  99 ; CHECK-NEXT: .result f32{{$}}
 100 ; CHECK-NEXT: f32.const 0x1p0{{$}}
 101 ; CHECK-NEXT: set_local @0, pop{{$}}
 102 ; CHECK-NEXT: return @0{{$}}
 103 define float @one_f32() {
 104   ret float 1.0
 105 }
 106
 107 ; CHECK-LABEL: two_f32:
 108 ; CHECK-NEXT: .result f32{{$}}
 109 ; CHECK-NEXT: f32.const 0x1p1{{$}}
 110 ; CHECK-NEXT: set_local @0, pop{{$}}
 111 ; CHECK-NEXT: return @0{{$}}
 112 define float @two_f32() {
 113   ret float 2.0
 114 }
 115
 116 ; CHECK-LABEL: nan_f32:
 117 ; CHECK-NEXT: .result f32{{$}}
 118 ; CHECK-NEXT: f32.const nan
 119 ; CHECK-NEXT: set_local @0, pop{{$}}
 120 ; CHECK-NEXT: return @0{{$}}
 121 define float @nan_f32() {
 122   ret float 0x7FF8000000000000
 123 }
 124
 125 ; CHECK-LABEL: negnan_f32:
 126 ; CHECK-NEXT: .result f32{{$}}
 127 ; CHECK-NEXT: f32.const -nan
 128 ; CHECK-NEXT: set_local @0, pop{{$}}
 129 ; CHECK-NEXT: return @0{{$}}
 130 define float @negnan_f32() {
 131   ret float 0xFFF8000000000000
 132 }
 133
 134 ; CHECK-LABEL: inf_f32:
 135 ; CHECK-NEXT: .result f32{{$}}
 136 ; CHECK-NEXT: f32.const infinity
 137 ; CHECK-NEXT: set_local @0, pop{{$}}
 138 ; CHECK-NEXT: return @0{{$}}
 139 define float @inf_f32() {
 140   ret float 0x7FF0000000000000
 141 }
 142
 143 ; CHECK-LABEL: neginf_f32:
 144 ; CHECK-NEXT: .result f32{{$}}
 145 ; CHECK-NEXT: f32.const -infinity
 146 ; CHECK-NEXT: set_local @0, pop{{$}}
 147 ; CHECK-NEXT: return @0{{$}}
 148 define float @neginf_f32() {
 149   ret float 0xFFF0000000000000
 150 }
 151
 152 ; CHECK-LABEL: negzero_f64:
 153 ; CHECK-NEXT: .result f64{{$}}
 154 ; CHECK-NEXT: f64.const -0x0p0{{$}}
 155 ; CHECK-NEXT: set_local @0, pop{{$}}
 156 ; CHECK-NEXT: return @0{{$}}
 157 define double @negzero_f64() {
 158   ret double -0.0
 159 }
 160
 161 ; CHECK-LABEL: zero_f64:
 162 ; CHECK-NEXT: .result f64{{$}}
 163 ; CHECK-NEXT: f64.const 0x0p0{{$}}
 164 ; CHECK-NEXT: set_local @0, pop{{$}}
 165 ; CHECK-NEXT: return @0{{$}}
 166 define double @zero_f64() {
 167   ret double 0.0
 168 }
 169
 170 ; CHECK-LABEL: one_f64:
 171 ; CHECK-NEXT: .result f64{{$}}
 172 ; CHECK-NEXT: f64.const 0x1p0{{$}}
 173 ; CHECK-NEXT: set_local @0, pop{{$}}
 174 ; CHECK-NEXT: return @0{{$}}
 175 define double @one_f64() {
 176   ret double 1.0
 177 }
 178
 179 ; CHECK-LABEL: two_f64:
 180 ; CHECK-NEXT: .result f64{{$}}
 181 ; CHECK-NEXT: f64.const 0x1p1{{$}}
 182 ; CHECK-NEXT: set_local @0, pop{{$}}
 183 ; CHECK-NEXT: return @0{{$}}
 184 define double @two_f64() {
 185   ret double 2.0
 186 }
 187
 188 ; CHECK-LABEL: nan_f64:
 189 ; CHECK-NEXT: .result f64{{$}}
 190 ; CHECK-NEXT: f64.const nan
 191 ; CHECK-NEXT: set_local @0, pop{{$}}
 192 ; CHECK-NEXT: return @0{{$}}
 193 define double @nan_f64() {
 194   ret double 0x7FF8000000000000
 195 }
 196
 197 ; CHECK-LABEL: negnan_f64:
 198 ; CHECK-NEXT: .result f64{{$}}
 199 ; CHECK-NEXT: f64.const -nan
 200 ; CHECK-NEXT: set_local @0, pop{{$}}
 201 ; CHECK-NEXT: return @0{{$}}
 202 define double @negnan_f64() {
 203   ret double 0xFFF8000000000000
 204 }
 205
 206 ; CHECK-LABEL: inf_f64:
 207 ; CHECK-NEXT: .result f64{{$}}
 208 ; CHECK-NEXT: f64.const infinity
 209 ; CHECK-NEXT: set_local @0, pop{{$}}
 210 ; CHECK-NEXT: return @0{{$}}
 211 define double @inf_f64() {
 212   ret double 0x7FF0000000000000
 213 }
 214
 215 ; CHECK-LABEL: neginf_f64:
 216 ; CHECK-NEXT: .result f64{{$}}
 217 ; CHECK-NEXT: f64.const -infinity
 218 ; CHECK-NEXT: set_local @0, pop{{$}}
 219 ; CHECK-NEXT: return @0{{$}}
 220 define double @neginf_f64() {
 221   ret double 0xFFF0000000000000
 222 }