llvm/test/CodeGen/WebAssembly/comparisons-f32.ll

   1 ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-keep-registers | FileCheck %s
   2
   3 ; Test that basic 32-bit floating-point comparison operations assemble as
   4 ; expected.
   5
   6 target triple = "wasm32-unknown-unknown"
   7
   8 ; CHECK-LABEL: ord_f32:
   9 ; CHECK-NEXT: .functype ord_f32 (f32, f32) -> (i32){{$}}
  10 ; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}}
  11 ; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 0{{$}}
  12 ; CHECK-NEXT: f32.eq $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
  13 ; CHECK-NEXT: local.get $push[[L2:[0-9]+]]=, 1{{$}}
  14 ; CHECK-NEXT: local.get $push[[L3:[0-9]+]]=, 1{{$}}
  15 ; CHECK-NEXT: f32.eq $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}}
  16 ; CHECK-NEXT: i32.and $push[[NUM2:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM1]]{{$}}
  17 ; CHECK-NEXT: return $pop[[NUM2]]{{$}}
  18 define i32 @ord_f32(float %x, float %y) {
  19   %a = fcmp ord float %x, %y
  20   %b = zext i1 %a to i32
  21   ret i32 %b
  22 }
  23
  24 ; CHECK-LABEL: uno_f32:
  25 ; CHECK-NEXT: .functype uno_f32 (f32, f32) -> (i32){{$}}
  26 ; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}}
  27 ; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 0{{$}}
  28 ; CHECK-NEXT: f32.ne $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
  29 ; CHECK-NEXT: local.get $push[[L2:[0-9]+]]=, 1{{$}}
  30 ; CHECK-NEXT: local.get $push[[L3:[0-9]+]]=, 1{{$}}
  31 ; CHECK-NEXT: f32.ne $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}}
  32 ; CHECK-NEXT: i32.or $push[[NUM2:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM1]]{{$}}
  33 ; CHECK-NEXT: return $pop[[NUM2]]{{$}}
  34 define i32 @uno_f32(float %x, float %y) {
  35   %a = fcmp uno float %x, %y
  36   %b = zext i1 %a to i32
  37   ret i32 %b
  38 }
  39
  40 ; CHECK-LABEL: oeq_f32:
  41 ; CHECK-NEXT: .functype oeq_f32 (f32, f32) -> (i32){{$}}
  42 ; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}}
  43 ; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}}
  44 ; CHECK-NEXT: f32.eq $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
  45 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
  46 define i32 @oeq_f32(float %x, float %y) {
  47   %a = fcmp oeq float %x, %y
  48   %b = zext i1 %a to i32
  49   ret i32 %b
  50 }
  51
  52 ; CHECK-LABEL: une_f32:
  53 ; CHECK: f32.ne $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
  54 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
  55 define i32 @une_f32(float %x, float %y) {
  56   %a = fcmp une float %x, %y
  57   %b = zext i1 %a to i32
  58   ret i32 %b
  59 }
  60
  61 ; CHECK-LABEL: olt_f32:
  62 ; CHECK: f32.lt $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
  63 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
  64 define i32 @olt_f32(float %x, float %y) {
  65   %a = fcmp olt float %x, %y
  66   %b = zext i1 %a to i32
  67   ret i32 %b
  68 }
  69
  70 ; CHECK-LABEL: ole_f32:
  71 ; CHECK: f32.le $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
  72 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
  73 define i32 @ole_f32(float %x, float %y) {
  74   %a = fcmp ole float %x, %y
  75   %b = zext i1 %a to i32
  76   ret i32 %b
  77 }
  78
  79 ; CHECK-LABEL: ogt_f32:
  80 ; CHECK: f32.gt $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
  81 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
  82 define i32 @ogt_f32(float %x, float %y) {
  83   %a = fcmp ogt float %x, %y
  84   %b = zext i1 %a to i32
  85   ret i32 %b
  86 }
  87
  88 ; CHECK-LABEL: oge_f32:
  89 ; CHECK: f32.ge $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
  90 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
  91 define i32 @oge_f32(float %x, float %y) {
  92   %a = fcmp oge float %x, %y
  93   %b = zext i1 %a to i32
  94   ret i32 %b
  95 }
  96
  97 ; Expanded comparisons, which also check for NaN.
  98 ; These simply rely on SDAG's Expand cond code action.
  99
 100 ; CHECK-LABEL: ueq_f32:
 101 ; CHECK-NEXT: .functype ueq_f32 (f32, f32) -> (i32){{$}}
 102 ; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}}
 103 ; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}}
 104 ; CHECK-NEXT: f32.gt $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
 105 ; CHECK-NEXT: local.get $push[[L2:[0-9]+]]=, 0{{$}}
 106 ; CHECK-NEXT: local.get $push[[L3:[0-9]+]]=, 1{{$}}
 107 ; CHECK-NEXT: f32.lt $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}}
 108 ; CHECK-NEXT: i32.or $push[[NUM2:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM1]]{{$}}
 109 ; CHECK-NEXT: i32.const $push[[C0:[0-9]+]]=, 1
 110 ; CHECK-NEXT: i32.xor $push[[NUM3:[0-9]+]]=, $pop[[NUM2]], $pop[[C0]]{{$}}
 111 ; CHECK-NEXT: return $pop[[NUM3]]{{$}}
 112 define i32 @ueq_f32(float %x, float %y) {
 113   %a = fcmp ueq float %x, %y
 114   %b = zext i1 %a to i32
 115   ret i32 %b
 116 }
 117
 118 ; CHECK-LABEL: one_f32:
 119 ; CHECK-NEXT: .functype one_f32 (f32, f32) -> (i32){{$}}
 120 ; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}}
 121 ; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}}
 122 ; CHECK-NEXT: f32.gt $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
 123 ; CHECK-NEXT: local.get $push[[L2:[0-9]+]]=, 0{{$}}
 124 ; CHECK-NEXT: local.get $push[[L3:[0-9]+]]=, 1{{$}}
 125 ; CHECK-NEXT: f32.lt $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}}
 126 ; CHECK-NEXT: i32.or $push[[NUM4:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM1]]{{$}}
 127 ; CHECK-NEXT: return $pop[[NUM4]]
 128 define i32 @one_f32(float %x, float %y) {
 129   %a = fcmp one float %x, %y
 130   %b = zext i1 %a to i32
 131   ret i32 %b
 132 }
 133
 134 ; CHECK-LABEL: ult_f32:
 135 ; CHECK-NEXT: .functype ult_f32 (f32, f32) -> (i32){{$}}
 136 ; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}}
 137 ; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}}
 138 ; CHECK-NEXT: f32.ge $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
 139 ; CHECK-NEXT: i32.const $push[[C0:[0-9]+]]=, 1
 140 ; CHECK-NEXT: i32.xor $push[[NUM2:[0-9]+]]=, $pop[[NUM0]], $pop[[C0]]{{$}}
 141 ; CHECK-NEXT: return $pop[[NUM2]]{{$}}
 142 define i32 @ult_f32(float %x, float %y) {
 143   %a = fcmp ult float %x, %y
 144   %b = zext i1 %a to i32
 145   ret i32 %b
 146 }
 147
 148 ; CHECK-LABEL: ule_f32:
 149 ; CHECK-NEXT: .functype ule_f32 (f32, f32) -> (i32){{$}}
 150 ; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}}
 151 ; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}}
 152 ; CHECK-NEXT: f32.gt $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
 153 ; CHECK-NEXT: i32.const $push[[C0:[0-9]+]]=, 1
 154 ; CHECK-NEXT: i32.xor $push[[NUM2:[0-9]+]]=, $pop[[NUM0]], $pop[[C0]]{{$}}
 155 ; CHECK-NEXT: return $pop[[NUM2]]{{$}}
 156 define i32 @ule_f32(float %x, float %y) {
 157   %a = fcmp ule float %x, %y
 158   %b = zext i1 %a to i32
 159   ret i32 %b
 160 }
 161
 162 ; CHECK-LABEL: ugt_f32:
 163 ; CHECK-NEXT: .functype ugt_f32 (f32, f32) -> (i32){{$}}
 164 ; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}}
 165 ; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}}
 166 ; CHECK-NEXT: f32.le $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
 167 ; CHECK-NEXT: i32.const $push[[C0:[0-9]+]]=, 1
 168 ; CHECK-NEXT: i32.xor $push[[NUM2:[0-9]+]]=, $pop[[NUM0]], $pop[[C0]]{{$}}
 169 ; CHECK-NEXT: return $pop[[NUM2]]{{$}}
 170 define i32 @ugt_f32(float %x, float %y) {
 171   %a = fcmp ugt float %x, %y
 172   %b = zext i1 %a to i32
 173   ret i32 %b
 174 }
 175
 176 ; CHECK-LABEL: uge_f32:
 177 ; CHECK-NEXT: .functype uge_f32 (f32, f32) -> (i32){{$}}
 178 ; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}}
 179 ; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}}
 180 ; CHECK-NEXT: f32.lt $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
 181 ; CHECK-NEXT: i32.const $push[[C0:[0-9]+]]=, 1
 182 ; CHECK-NEXT: i32.xor $push[[NUM2:[0-9]+]]=, $pop[[NUM0]], $pop[[C0]]{{$}}
 183 ; CHECK-NEXT: return $pop[[NUM2]]{{$}}
 184 define i32 @uge_f32(float %x, float %y) {
 185   %a = fcmp uge float %x, %y
 186   %b = zext i1 %a to i32
 187   ret i32 %b
 188 }
 189
 190 ; CHECK-LABEL: olt_f32_branch
 191 ; CHECK:      local.get $push[[L4:[0-9]+]]=, 0
 192 ; CHECK-NEXT: local.get $push[[L3:[0-9]+]]=, 1
 193 ; CHECK-NEXT: f32.lt    $push[[NUM0:[0-9]+]]=, $pop[[L4]], $pop[[L3]]
 194 ; CHECK-NEXT: i32.eqz   $push[[NUM3:[0-9]+]]=, $pop[[NUM0]]
 195 ; CHECK-NEXT: br_if     0, $pop[[NUM3]]
 196 ; CHECK-NEXT: call      call1
 197 define void @olt_f32_branch(float %a, float %b) {
 198 entry:
 199   %cmp = fcmp olt float %a, %b
 200   br i1 %cmp, label %if.then, label %if.end
 201
 202 if.then:
 203   tail call void @call1()
 204   br label %if.end
 205
 206 if.end:
 207   ret void
 208 }
 209
 210 ; CHECK-LABEL: ole_f32_branch
 211 ; CHECK:      local.get $push[[L4:[0-9]+]]=, 0
 212 ; CHECK-NEXT: local.get $push[[L3:[0-9]+]]=, 1
 213 ; CHECK-NEXT: f32.le    $push[[NUM0:[0-9]+]]=, $pop[[L4]], $pop[[L3]]
 214 ; CHECK-NEXT: i32.eqz   $push[[NUM3:[0-9]+]]=, $pop[[NUM0]]
 215 ; CHECK-NEXT: br_if     0, $pop[[NUM3]]
 216 ; CHECK-NEXT: call      call1
 217 define void @ole_f32_branch(float %a, float %b) {
 218 entry:
 219   %cmp = fcmp ole float %a, %b
 220   br i1 %cmp, label %if.then, label %if.end
 221
 222 if.then:
 223   tail call void @call1()
 224   br label %if.end
 225
 226 if.end:
 227   ret void
 228 }
 229
 230 ; CHECK-LABEL: ugt_f32_branch
 231 ; CHECK:      local.get $push[[L4:[0-9]+]]=, 0
 232 ; CHECK-NEXT: local.get $push[[L3:[0-9]+]]=, 1
 233 ; CHECK-NEXT: f32.le    $push[[NUM0:[0-9]+]]=, $pop[[L4]], $pop[[L3]]
 234 ; CHECK-NEXT: i32.eqz   $push[[NUM3:[0-9]+]]=, $pop[[NUM0]]
 235 ; CHECK-NEXT: br_if     0, $pop[[NUM3]]
 236 ; CHECK-NEXT: call      call1
 237 define void @ugt_f32_branch(float %a, float %b) {
 238 entry:
 239   %cmp = fcmp ugt float %a, %b
 240   br i1 %cmp, label %if.end, label %if.then
 241
 242 if.then:
 243   tail call void @call1()
 244   br label %if.end
 245
 246 if.end:
 247   ret void
 248 }
 249
 250 ; CHECK-LABEL: ogt_f32_branch
 251 ; CHECK:      local.get $push[[L4:[0-9]+]]=, 0
 252 ; CHECK-NEXT: local.get $push[[L3:[0-9]+]]=, 1
 253 ; CHECK-NEXT: f32.gt    $push[[NUM0:[0-9]+]]=, $pop[[L4]], $pop[[L3]]
 254 ; CHECK-NEXT: i32.eqz   $push[[NUM3:[0-9]+]]=, $pop[[NUM0]]
 255 ; CHECK-NEXT: br_if     0, $pop[[NUM3]]
 256 ; CHECK-NEXT: call      call1
 257 define void @ogt_f32_branch(float %a, float %b) {
 258 entry:
 259   %cmp = fcmp ogt float %a, %b
 260   br i1 %cmp, label %if.then, label %if.end
 261
 262 if.then:
 263   tail call void @call1()
 264   br label %if.end
 265
 266 if.end:
 267   ret void
 268 }
 269
 270 ; CHECK-LABEL: ult_f32_branch
 271 ; CHECK:      local.get $push[[L4:[0-9]+]]=, 0
 272 ; CHECK-NEXT: local.get $push[[L3:[0-9]+]]=, 1
 273 ; CHECK-NEXT: f32.ge    $push[[NUM0:[0-9]+]]=, $pop[[L4]], $pop[[L3]]
 274 ; CHECK-NEXT: i32.eqz   $push[[NUM3:[0-9]+]]=, $pop[[NUM0]]
 275 ; CHECK-NEXT: br_if     0, $pop[[NUM3]]
 276 ; CHECK-NEXT: call      call1
 277 define void @ult_f32_branch(float %a, float %b) {
 278 entry:
 279   %cmp = fcmp ult float %a, %b
 280   br i1 %cmp, label %if.end, label %if.then
 281
 282 if.then:
 283   tail call void @call1()
 284   br label %if.end
 285
 286 if.end:
 287   ret void
 288 }
 289
 290 ; CHECK-LABEL: ule_f32_branch
 291 ; CHECK:      local.get $push[[L4:[0-9]+]]=, 0
 292 ; CHECK-NEXT: local.get $push[[L3:[0-9]+]]=, 1
 293 ; CHECK-NEXT: f32.ge    $push[[NUM0:[0-9]+]]=, $pop[[L4]], $pop[[L3]]
 294 ; CHECK-NEXT: i32.eqz   $push[[NUM3:[0-9]+]]=, $pop[[NUM0]]
 295 ; CHECK-NEXT: br_if     0, $pop[[NUM3]]
 296 ; CHECK-NEXT: call      call1
 297 define void @ule_f32_branch(float %a, float %b) {
 298 entry:
 299   %cmp = fcmp ult float %a, %b
 300   br i1 %cmp, label %if.end, label %if.then
 301
 302 if.then:
 303   tail call void @call1()
 304   br label %if.end
 305
 306 if.end:
 307   ret void
 308 }
 309
 310 ; CHECK-LABEL: xor_zext_switch
 311 ; CHECK:      i32.const $push[[L1:[0-9]+]]=, 0
 312 ; CHECK-NEXT: br_if     0, $pop[[L1]]
 313 ; CHECK-NEXT: block
 314 ; CHECK-NEXT: block
 315 ; CHECK-NEXT: local.get $push[[L3:[0-9]+]]=, 0
 316 ; CHECK-NEXT: local.get $push[[L2:[0-9]+]]=, 1
 317 ; CHECK-NEXT: f32.ge    $push[[L0:[0-9]+]]=, $pop[[L3]], $pop[[L2]]
 318 ; CHECK-NEXT: br_table  $pop[[L0]], 0, 1, 0
 319 define void @xor_zext_switch(float %a, float %b) {
 320 entry:
 321   %cmp = fcmp ult float %a, %b
 322   %zext = zext i1 %cmp to i32
 323   %xor = xor i32 %zext, 1
 324   switch i32 %xor, label %exit [
 325     i32 0, label %sw.bb.1
 326     i32 1, label %sw.bb.2
 327   ]
 328
 329 sw.bb.1:
 330   tail call void @foo1()
 331   br label %exit
 332
 333 sw.bb.2:
 334   tail call void @foo2()
 335   br label %exit
 336
 337 exit:
 338   ret void
 339 }
 340
 341 ; CHECK-LABEL: xor_add_switch
 342 ; CHECK:      local.get $push[[L8:[0-9]+]]=, 0
 343 ; CHECK-NEXT: local.get $push[[L7:[0-9]+]]=, 1
 344 ; CHECK-NEXT: f32.ge    $push[[L1:[0-9]+]]=, $pop[[L8]], $pop[[L7]]
 345 ; CHECK-NEXT: i32.const $push[[L2:[0-9]+]]=, 1
 346 ; CHECK-NEXT: i32.xor   $push[[L3:[0-9]+]]=, $pop[[L1]], $pop[[L2]]
 347 ; CHECK-NEXT: i32.const $push[[L6:[0-9]+]]=, 1
 348 ; CHECK-NEXT: i32.add   $push[[L4:[0-9]+]]=, $pop[[L3]], $pop[[L6]]
 349 ; CHECK-NEXT: i32.const $push[[L5:[0-9]+]]=, 1
 350 ; CHECK-NEXT: i32.xor   $push[[L0:[0-9]+]]=, $pop[[L4]], $pop[[L5]]
 351 ; CHECK-NEXT: br_table  $pop[[L0]], 0, 1, 2, 3
 352 define void @xor_add_switch(float %a, float %b) {
 353 entry:
 354   %cmp = fcmp ult float %a, %b
 355   %zext = zext i1 %cmp to i32
 356   %add = add nsw nuw i32 %zext, 1
 357   %xor = xor i32 %add, 1
 358   switch i32 %xor, label %exit [
 359     i32 0, label %sw.bb.1
 360     i32 1, label %sw.bb.2
 361     i32 2, label %sw.bb.3
 362   ]
 363
 364 sw.bb.1:
 365   tail call void @foo1()
 366   br label %exit
 367
 368 sw.bb.2:
 369   tail call void @foo2()
 370   br label %exit
 371
 372 sw.bb.3:
 373   tail call void @foo3()
 374   br label %exit
 375
 376 exit:
 377   ret void
 378 }
 379
 380 declare void @foo1()
 381 declare void @foo2()
 382 declare void @foo3()
 383 declare void @call1()