llvm/test/CodeGen/SPIRV/instructions/fcmp.ll

   1 ; RUN: llc -O0 -mtriple=spirv32-unknown-unknown %s -o - | FileCheck %s
   2
   3 ; CHECK-DAG: OpName [[UEQ:%.*]] "test_ueq"
   4 ; CHECK-DAG: OpName [[OEQ:%.*]] "test_oeq"
   5 ; CHECK-DAG: OpName [[UNE:%.*]] "test_une"
   6 ; CHECK-DAG: OpName [[ONE:%.*]] "test_one"
   7 ; CHECK-DAG: OpName [[ULT:%.*]] "test_ult"
   8 ; CHECK-DAG: OpName [[OLT:%.*]] "test_olt"
   9 ; CHECK-DAG: OpName [[ULE:%.*]] "test_ule"
  10 ; CHECK-DAG: OpName [[OLE:%.*]] "test_ole"
  11 ; CHECK-DAG: OpName [[UGT:%.*]] "test_ugt"
  12 ; CHECK-DAG: OpName [[OGT:%.*]] "test_ogt"
  13 ; CHECK-DAG: OpName [[UGE:%.*]] "test_uge"
  14 ; CHECK-DAG: OpName [[OGE:%.*]] "test_oge"
  15 ; CHECK-DAG: OpName [[UNO:%.*]] "test_uno"
  16 ; CHECK-DAG: OpName [[ORD:%.*]] "test_ord"
  17
  18 ; CHECK-DAG: OpName [[v3UEQ:%.*]] "test_v3_ueq"
  19 ; CHECK-DAG: OpName [[v3OEQ:%.*]] "test_v3_oeq"
  20 ; CHECK-DAG: OpName [[v3UNE:%.*]] "test_v3_une"
  21 ; CHECK-DAG: OpName [[v3ONE:%.*]] "test_v3_one"
  22 ; CHECK-DAG: OpName [[v3ULT:%.*]] "test_v3_ult"
  23 ; CHECK-DAG: OpName [[v3OLT:%.*]] "test_v3_olt"
  24 ; CHECK-DAG: OpName [[v3ULE:%.*]] "test_v3_ule"
  25 ; CHECK-DAG: OpName [[v3OLE:%.*]] "test_v3_ole"
  26 ; CHECK-DAG: OpName [[v3UGT:%.*]] "test_v3_ugt"
  27 ; CHECK-DAG: OpName [[v3OGT:%.*]] "test_v3_ogt"
  28 ; CHECK-DAG: OpName [[v3UGE:%.*]] "test_v3_uge"
  29 ; CHECK-DAG: OpName [[v3OGE:%.*]] "test_v3_oge"
  30 ; CHECK-DAG: OpName [[v3UNO:%.*]] "test_v3_uno"
  31 ; CHECK-DAG: OpName [[v3ORD:%.*]] "test_v3_ord"
  32
  33 ; CHECK:      [[UEQ]] = OpFunction
  34 ; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
  35 ; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
  36 ; CHECK-NEXT: OpLabel
  37 ; CHECK-NEXT: [[R:%.*]] = OpFUnordEqual {{%.+}} [[A]] [[B]]
  38 ; CHECK-NEXT: OpReturnValue [[R]]
  39 ; CHECK-NEXT: OpFunctionEnd
  40 define i1 @test_ueq(float %a, float %b) {
  41   %r = fcmp ueq float %a, %b
  42   ret i1 %r
  43 }
  44
  45 ; CHECK:      [[OEQ]] = OpFunction
  46 ; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
  47 ; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
  48 ; CHECK-NEXT: OpLabel
  49 ; CHECK-NEXT: [[R:%.*]] = OpFOrdEqual {{%.+}} [[A]] [[B]]
  50 ; CHECK-NEXT: OpReturnValue [[R]]
  51 ; CHECK-NEXT: OpFunctionEnd
  52 define i1 @test_oeq(float %a, float %b) {
  53   %r = fcmp oeq float %a, %b
  54   ret i1 %r
  55 }
  56
  57 ; CHECK:      [[UNE]] = OpFunction
  58 ; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
  59 ; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
  60 ; CHECK-NEXT: OpLabel
  61 ; CHECK-NEXT: [[R:%.*]] = OpFUnordNotEqual {{%.+}} [[A]] [[B]]
  62 ; CHECK-NEXT: OpReturnValue [[R]]
  63 ; CHECK-NEXT: OpFunctionEnd
  64 define i1 @test_une(float %a, float %b) {
  65   %r = fcmp une float %a, %b
  66   ret i1 %r
  67 }
  68
  69 ; CHECK:      [[ONE]] = OpFunction
  70 ; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
  71 ; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
  72 ; CHECK-NEXT: OpLabel
  73 ; CHECK-NEXT: [[R:%.*]] = OpFOrdNotEqual {{%.+}} [[A]] [[B]]
  74 ; CHECK-NEXT: OpReturnValue [[R]]
  75 ; CHECK-NEXT: OpFunctionEnd
  76 define i1 @test_one(float %a, float %b) {
  77   %r = fcmp one float %a, %b
  78   ret i1 %r
  79 }
  80
  81 ; CHECK:      [[ULT]] = OpFunction
  82 ; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
  83 ; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
  84 ; CHECK-NEXT: OpLabel
  85 ; CHECK-NEXT: [[R:%.*]] = OpFUnordLessThan {{%.+}} [[A]] [[B]]
  86 ; CHECK-NEXT: OpReturnValue [[R]]
  87 ; CHECK-NEXT: OpFunctionEnd
  88 define i1 @test_ult(float %a, float %b) {
  89   %r = fcmp ult float %a, %b
  90   ret i1 %r
  91 }
  92
  93 ; CHECK:      [[OLT]] = OpFunction
  94 ; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
  95 ; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
  96 ; CHECK-NEXT: OpLabel
  97 ; CHECK-NEXT: [[R:%.*]] = OpFOrdLessThan {{%.+}} [[A]] [[B]]
  98 ; CHECK-NEXT: OpReturnValue [[R]]
  99 ; CHECK-NEXT: OpFunctionEnd
 100 define i1 @test_olt(float %a, float %b) {
 101   %r = fcmp olt float %a, %b
 102   ret i1 %r
 103 }
 104
 105 ; CHECK:      [[ULE]] = OpFunction
 106 ; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
 107 ; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
 108 ; CHECK-NEXT: OpLabel
 109 ; CHECK-NEXT: [[R:%.*]] = OpFUnordLessThanEqual {{%.+}} [[A]] [[B]]
 110 ; CHECK-NEXT: OpReturnValue [[R]]
 111 ; CHECK-NEXT: OpFunctionEnd
 112 define i1 @test_ule(float %a, float %b) {
 113   %r = fcmp ule float %a, %b
 114   ret i1 %r
 115 }
 116
 117 ; CHECK:      [[OLE]] = OpFunction
 118 ; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
 119 ; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
 120 ; CHECK-NEXT: OpLabel
 121 ; CHECK-NEXT: [[R:%.*]] = OpFOrdLessThanEqual {{%.+}} [[A]] [[B]]
 122 ; CHECK-NEXT: OpReturnValue [[R]]
 123 ; CHECK-NEXT: OpFunctionEnd
 124 define i1 @test_ole(float %a, float %b) {
 125   %r = fcmp ole float %a, %b
 126   ret i1 %r
 127 }
 128
 129 ; CHECK:      [[UGT]] = OpFunction
 130 ; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
 131 ; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
 132 ; CHECK-NEXT: OpLabel
 133 ; CHECK-NEXT: [[R:%.*]] = OpFUnordGreaterThan {{%.+}} [[A]] [[B]]
 134 ; CHECK-NEXT: OpReturnValue [[R]]
 135 ; CHECK-NEXT: OpFunctionEnd
 136 define i1 @test_ugt(float %a, float %b) {
 137   %r = fcmp ugt float %a, %b
 138   ret i1 %r
 139 }
 140
 141 ; CHECK:      [[OGT]] = OpFunction
 142 ; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
 143 ; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
 144 ; CHECK-NEXT: OpLabel
 145 ; CHECK-NEXT: [[R:%.*]] = OpFOrdGreaterThan {{%.+}} [[A]] [[B]]
 146 ; CHECK-NEXT: OpReturnValue [[R]]
 147 ; CHECK-NEXT: OpFunctionEnd
 148 define i1 @test_ogt(float %a, float %b) {
 149   %r = fcmp ogt float %a, %b
 150   ret i1 %r
 151 }
 152
 153 ; CHECK:      [[UGE]] = OpFunction
 154 ; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
 155 ; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
 156 ; CHECK-NEXT: OpLabel
 157 ; CHECK-NEXT: [[R:%.*]] = OpFUnordGreaterThanEqual {{%.+}} [[A]] [[B]]
 158 ; CHECK-NEXT: OpReturnValue [[R]]
 159 ; CHECK-NEXT: OpFunctionEnd
 160 define i1 @test_uge(float %a, float %b) {
 161   %r = fcmp uge float %a, %b
 162   ret i1 %r
 163 }
 164
 165 ; CHECK:      [[OGE]] = OpFunction
 166 ; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
 167 ; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
 168 ; CHECK-NEXT: OpLabel
 169 ; CHECK-NEXT: [[R:%.*]] = OpFOrdGreaterThanEqual {{%.+}} [[A]] [[B]]
 170 ; CHECK-NEXT: OpReturnValue [[R]]
 171 ; CHECK-NEXT: OpFunctionEnd
 172 define i1 @test_oge(float %a, float %b) {
 173   %r = fcmp oge float %a, %b
 174   ret i1 %r
 175 }
 176
 177 ; CHECK:      [[ORD]] = OpFunction
 178 ; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
 179 ; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
 180 ; CHECK-NEXT: OpLabel
 181 ; CHECK-NEXT: [[R:%.*]] = OpOrdered {{%.+}} [[A]] [[B]]
 182 ; CHECK-NEXT: OpReturnValue [[R]]
 183 ; CHECK-NEXT: OpFunctionEnd
 184 define i1 @test_ord(float %a, float %b) {
 185   %r = fcmp ord float %a, %b
 186   ret i1 %r
 187 }
 188
 189 ; CHECK:      [[UNO]] = OpFunction
 190 ; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
 191 ; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
 192 ; CHECK-NEXT: OpLabel
 193 ; CHECK-NEXT: [[R:%.*]] = OpUnordered {{%.+}} [[A]] [[B]]
 194 ; CHECK-NEXT: OpReturnValue [[R]]
 195 ; CHECK-NEXT: OpFunctionEnd
 196 define i1 @test_uno(float %a, float %b) {
 197   %r = fcmp uno float %a, %b
 198   ret i1 %r
 199 }
 200
 201 ; CHECK:      [[v3UEQ]] = OpFunction
 202 ; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
 203 ; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
 204 ; CHECK-NEXT: OpLabel
 205 ; CHECK-NEXT: [[R:%.*]] = OpFUnordEqual {{%.+}} [[A]] [[B]]
 206 ; CHECK-NEXT: OpReturnValue [[R]]
 207 ; CHECK-NEXT: OpFunctionEnd
 208 define <3 x i1> @test_v3_ueq(<3 x float> %a, <3 x float> %b) {
 209   %r = fcmp ueq <3 x float> %a, %b
 210   ret <3 x i1> %r
 211 }
 212
 213 ; CHECK:      [[v3OEQ]] = OpFunction
 214 ; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
 215 ; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
 216 ; CHECK-NEXT: OpLabel
 217 ; CHECK-NEXT: [[R:%.*]] = OpFOrdEqual {{%.+}} [[A]] [[B]]
 218 ; CHECK-NEXT: OpReturnValue [[R]]
 219 ; CHECK-NEXT: OpFunctionEnd
 220 define <3 x i1> @test_v3_oeq(<3 x float> %a, <3 x float> %b) {
 221   %r = fcmp oeq <3 x float> %a, %b
 222   ret <3 x i1> %r
 223 }
 224
 225 ; CHECK:      [[v3UNE]] = OpFunction
 226 ; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
 227 ; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
 228 ; CHECK-NEXT: OpLabel
 229 ; CHECK-NEXT: [[R:%.*]] = OpFUnordNotEqual {{%.+}} [[A]] [[B]]
 230 ; CHECK-NEXT: OpReturnValue [[R]]
 231 ; CHECK-NEXT: OpFunctionEnd
 232 define <3 x i1> @test_v3_une(<3 x float> %a, <3 x float> %b) {
 233   %r = fcmp une <3 x float> %a, %b
 234   ret <3 x i1> %r
 235 }
 236
 237 ; CHECK:      [[v3ONE]] = OpFunction
 238 ; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
 239 ; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
 240 ; CHECK-NEXT: OpLabel
 241 ; CHECK-NEXT: [[R:%.*]] = OpFOrdNotEqual {{%.+}} [[A]] [[B]]
 242 ; CHECK-NEXT: OpReturnValue [[R]]
 243 ; CHECK-NEXT: OpFunctionEnd
 244 define <3 x i1> @test_v3_one(<3 x float> %a, <3 x float> %b) {
 245   %r = fcmp one <3 x float> %a, %b
 246   ret <3 x i1> %r
 247 }
 248
 249 ; CHECK:      [[v3ULT]] = OpFunction
 250 ; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
 251 ; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
 252 ; CHECK-NEXT: OpLabel
 253 ; CHECK-NEXT: [[R:%.*]] = OpFUnordLessThan {{%.+}} [[A]] [[B]]
 254 ; CHECK-NEXT: OpReturnValue [[R]]
 255 ; CHECK-NEXT: OpFunctionEnd
 256 define <3 x i1> @test_v3_ult(<3 x float> %a, <3 x float> %b) {
 257   %r = fcmp ult <3 x float> %a, %b
 258   ret <3 x i1> %r
 259 }
 260
 261 ; CHECK:      [[v3OLT]] = OpFunction
 262 ; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
 263 ; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
 264 ; CHECK-NEXT: OpLabel
 265 ; CHECK-NEXT: [[R:%.*]] = OpFOrdLessThan {{%.+}} [[A]] [[B]]
 266 ; CHECK-NEXT: OpReturnValue [[R]]
 267 ; CHECK-NEXT: OpFunctionEnd
 268 define <3 x i1> @test_v3_olt(<3 x float> %a, <3 x float> %b) {
 269   %r = fcmp olt <3 x float> %a, %b
 270   ret <3 x i1> %r
 271 }
 272
 273 ; CHECK:      [[v3ULE]] = OpFunction
 274 ; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
 275 ; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
 276 ; CHECK-NEXT: OpLabel
 277 ; CHECK-NEXT: [[R:%.*]] = OpFUnordLessThanEqual {{%.+}} [[A]] [[B]]
 278 ; CHECK-NEXT: OpReturnValue [[R]]
 279 ; CHECK-NEXT: OpFunctionEnd
 280 define <3 x i1> @test_v3_ule(<3 x float> %a, <3 x float> %b) {
 281   %r = fcmp ule <3 x float> %a, %b
 282   ret <3 x i1> %r
 283 }
 284
 285 ; CHECK:      [[v3OLE]] = OpFunction
 286 ; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
 287 ; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
 288 ; CHECK-NEXT: OpLabel
 289 ; CHECK-NEXT: [[R:%.*]] = OpFOrdLessThanEqual {{%.+}} [[A]] [[B]]
 290 ; CHECK-NEXT: OpReturnValue [[R]]
 291 ; CHECK-NEXT: OpFunctionEnd
 292 define <3 x i1> @test_v3_ole(<3 x float> %a, <3 x float> %b) {
 293   %r = fcmp ole <3 x float> %a, %b
 294   ret <3 x i1> %r
 295 }
 296
 297 ; CHECK:      [[v3UGT]] = OpFunction
 298 ; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
 299 ; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
 300 ; CHECK-NEXT: OpLabel
 301 ; CHECK-NEXT: [[R:%.*]] = OpFUnordGreaterThan {{%.+}} [[A]] [[B]]
 302 ; CHECK-NEXT: OpReturnValue [[R]]
 303 ; CHECK-NEXT: OpFunctionEnd
 304 define <3 x i1> @test_v3_ugt(<3 x float> %a, <3 x float> %b) {
 305   %r = fcmp ugt <3 x float> %a, %b
 306   ret <3 x i1> %r
 307 }
 308
 309 ; CHECK:      [[v3OGT]] = OpFunction
 310 ; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
 311 ; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
 312 ; CHECK-NEXT: OpLabel
 313 ; CHECK-NEXT: [[R:%.*]] = OpFOrdGreaterThan {{%.+}} [[A]] [[B]]
 314 ; CHECK-NEXT: OpReturnValue [[R]]
 315 ; CHECK-NEXT: OpFunctionEnd
 316 define <3 x i1> @test_v3_ogt(<3 x float> %a, <3 x float> %b) {
 317   %r = fcmp ogt <3 x float> %a, %b
 318   ret <3 x i1> %r
 319 }
 320
 321 ; CHECK:      [[v3UGE]] = OpFunction
 322 ; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
 323 ; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
 324 ; CHECK-NEXT: OpLabel
 325 ; CHECK-NEXT: [[R:%.*]] = OpFUnordGreaterThanEqual {{%.+}} [[A]] [[B]]
 326 ; CHECK-NEXT: OpReturnValue [[R]]
 327 ; CHECK-NEXT: OpFunctionEnd
 328 define <3 x i1> @test_v3_uge(<3 x float> %a, <3 x float> %b) {
 329   %r = fcmp uge <3 x float> %a, %b
 330   ret <3 x i1> %r
 331 }
 332
 333 ; CHECK:      [[v3OGE]] = OpFunction
 334 ; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
 335 ; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
 336 ; CHECK-NEXT: OpLabel
 337 ; CHECK-NEXT: [[R:%.*]] = OpFOrdGreaterThanEqual {{%.+}} [[A]] [[B]]
 338 ; CHECK-NEXT: OpReturnValue [[R]]
 339 ; CHECK-NEXT: OpFunctionEnd
 340 define <3 x i1> @test_v3_oge(<3 x float> %a, <3 x float> %b) {
 341   %r = fcmp oge <3 x float> %a, %b
 342   ret <3 x i1> %r
 343 }
 344
 345 ; CHECK:      [[v3ORD]] = OpFunction
 346 ; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
 347 ; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
 348 ; CHECK-NEXT: OpLabel
 349 ; CHECK-NEXT: [[R:%.*]] = OpOrdered {{%.+}} [[A]] [[B]]
 350 ; CHECK-NEXT: OpReturnValue [[R]]
 351 ; CHECK-NEXT: OpFunctionEnd
 352 define <3 x i1> @test_v3_ord(<3 x float> %a, <3 x float> %b) {
 353   %r = fcmp ord <3 x float> %a, %b
 354   ret <3 x i1> %r
 355 }
 356
 357 ; CHECK:      [[v3UNO]] = OpFunction
 358 ; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
 359 ; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
 360 ; CHECK-NEXT: OpLabel
 361 ; CHECK-NEXT: [[R:%.*]] = OpUnordered {{%.+}} [[A]] [[B]]
 362 ; CHECK-NEXT: OpReturnValue [[R]]
 363 ; CHECK-NEXT: OpFunctionEnd
 364 define <3 x i1> @test_v3_uno(<3 x float> %a, <3 x float> %b) {
 365   %r = fcmp uno <3 x float> %a, %b
 366   ret <3 x i1> %r
 367 }