OLD | NEW |
(Empty) | |
| 1 ; RUIN: %llvm2ice --verbose none %s | FileCheck %s |
| 2 ; RUIN: %llvm2ice --verbose none %s | FileCheck --check-prefix=ERRORS %s |
| 3 ; RUN: %szdiff --llvm2ice=%llvm2ice %s | FileCheck --check-prefix=DUMP %s |
| 4 |
| 5 @__init_array_start = internal constant [0 x i8] zeroinitializer, align 4 |
| 6 @__fini_array_start = internal constant [0 x i8] zeroinitializer, align 4 |
| 7 @__tls_template_start = internal constant [0 x i8] zeroinitializer, align 8 |
| 8 @__tls_template_alignment = internal constant [4 x i8] c"\01\00\00\00", align 4 |
| 9 |
| 10 define internal i32 @doubleArgs(double %a, i32 %b, double %c) { |
| 11 entry: |
| 12 ret i32 %b |
| 13 } |
| 14 ; CHECK: doubleArgs: |
| 15 ; CHECK: mov eax, dword ptr [esp+12] |
| 16 ; CHECK-NEXT: ret |
| 17 |
| 18 define internal i32 @floatArgs(float %a, i32 %b, float %c) { |
| 19 entry: |
| 20 ret i32 %b |
| 21 } |
| 22 ; CHECK: floatArgs: |
| 23 ; CHECK: mov eax, dword ptr [esp+8] |
| 24 ; CHECK-NEXT: ret |
| 25 |
| 26 define internal i32 @passFpArgs(float %a, double %b, float %c, double %d, float
%e, double %f) { |
| 27 entry: |
| 28 %call = call i32 @ignoreFpArgsNoInline(float %a, i32 123, double %b) |
| 29 %call1 = call i32 @ignoreFpArgsNoInline(float %c, i32 123, double %d) |
| 30 %call2 = call i32 @ignoreFpArgsNoInline(float %e, i32 123, double %f) |
| 31 %add = add i32 %call1, %call |
| 32 %add3 = add i32 %add, %call2 |
| 33 ret i32 %add3 |
| 34 } |
| 35 ; CHECK: passFpArgs: |
| 36 ; CHECK: push 123 |
| 37 ; CHECK: call ignoreFpArgsNoInline |
| 38 ; CHECK: push 123 |
| 39 ; CHECK: call ignoreFpArgsNoInline |
| 40 ; CHECK: push 123 |
| 41 ; CHECK: call ignoreFpArgsNoInline |
| 42 |
| 43 declare i32 @ignoreFpArgsNoInline(float, i32, double) |
| 44 |
| 45 define internal i32 @passFpConstArg(float %a, double %b) { |
| 46 entry: |
| 47 %call = call i32 @ignoreFpArgsNoInline(float %a, i32 123, double 2.340000e+00) |
| 48 ret i32 %call |
| 49 } |
| 50 ; CHECK: passFpConstArg: |
| 51 ; CHECK: push 123 |
| 52 ; CHECK: call ignoreFpArgsNoInline |
| 53 |
| 54 define internal float @returnFloatArg(float %a) { |
| 55 entry: |
| 56 ret float %a |
| 57 } |
| 58 ; CHECK: returnFloatArg: |
| 59 ; CHECK: fld dword ptr [esp |
| 60 |
| 61 define internal double @returnDoubleArg(double %a) { |
| 62 entry: |
| 63 ret double %a |
| 64 } |
| 65 ; CHECK: returnDoubleArg: |
| 66 ; CHECK: fld qword ptr [esp |
| 67 |
| 68 define internal float @returnFloatConst() { |
| 69 entry: |
| 70 ret float 0x3FF3AE1480000000 |
| 71 } |
| 72 ; CHECK: returnFloatConst: |
| 73 ; CHECK: fld |
| 74 |
| 75 define internal double @returnDoubleConst() { |
| 76 entry: |
| 77 ret double 1.230000e+00 |
| 78 } |
| 79 ; CHECK: returnDoubleConst: |
| 80 ; CHECK: fld |
| 81 |
| 82 define internal float @addFloat(float %a, float %b) { |
| 83 entry: |
| 84 %add = fadd float %a, %b |
| 85 ret float %add |
| 86 } |
| 87 ; CHECK: addFloat: |
| 88 ; CHECK: addss |
| 89 ; CHECK: fld |
| 90 |
| 91 define internal double @addDouble(double %a, double %b) { |
| 92 entry: |
| 93 %add = fadd double %a, %b |
| 94 ret double %add |
| 95 } |
| 96 ; CHECK: addDouble: |
| 97 ; CHECK: addsd |
| 98 ; CHECK: fld |
| 99 |
| 100 define internal float @subFloat(float %a, float %b) { |
| 101 entry: |
| 102 %sub = fsub float %a, %b |
| 103 ret float %sub |
| 104 } |
| 105 ; CHECK: subFloat: |
| 106 ; CHECK: subss |
| 107 ; CHECK: fld |
| 108 |
| 109 define internal double @subDouble(double %a, double %b) { |
| 110 entry: |
| 111 %sub = fsub double %a, %b |
| 112 ret double %sub |
| 113 } |
| 114 ; CHECK: subDouble: |
| 115 ; CHECK: subsd |
| 116 ; CHECK: fld |
| 117 |
| 118 define internal float @mulFloat(float %a, float %b) { |
| 119 entry: |
| 120 %mul = fmul float %a, %b |
| 121 ret float %mul |
| 122 } |
| 123 ; CHECK: mulFloat: |
| 124 ; CHECK: mulss |
| 125 ; CHECK: fld |
| 126 |
| 127 define internal double @mulDouble(double %a, double %b) { |
| 128 entry: |
| 129 %mul = fmul double %a, %b |
| 130 ret double %mul |
| 131 } |
| 132 ; CHECK: mulDouble: |
| 133 ; CHECK: mulsd |
| 134 ; CHECK: fld |
| 135 |
| 136 define internal float @divFloat(float %a, float %b) { |
| 137 entry: |
| 138 %div = fdiv float %a, %b |
| 139 ret float %div |
| 140 } |
| 141 ; CHECK: divFloat: |
| 142 ; CHECK: divss |
| 143 ; CHECK: fld |
| 144 |
| 145 define internal double @divDouble(double %a, double %b) { |
| 146 entry: |
| 147 %div = fdiv double %a, %b |
| 148 ret double %div |
| 149 } |
| 150 ; CHECK: divDouble: |
| 151 ; CHECK: divsd |
| 152 ; CHECK: fld |
| 153 |
| 154 define internal float @remFloat(float %a, float %b) { |
| 155 entry: |
| 156 %div = frem float %a, %b |
| 157 ret float %div |
| 158 } |
| 159 ; CHECK: remFloat: |
| 160 ; CHECK: call fmodf |
| 161 |
| 162 define internal double @remDouble(double %a, double %b) { |
| 163 entry: |
| 164 %div = frem double %a, %b |
| 165 ret double %div |
| 166 } |
| 167 ; CHECK: remDouble: |
| 168 ; CHECK: call fmod |
| 169 |
| 170 define internal float @fptrunc(double %a) { |
| 171 entry: |
| 172 %conv = fptrunc double %a to float |
| 173 ret float %conv |
| 174 } |
| 175 ; CHECK: fptrunc: |
| 176 ; CHECK: cvtsd2ss |
| 177 ; CHECK: fld |
| 178 |
| 179 define internal double @fpext(float %a) { |
| 180 entry: |
| 181 %conv = fpext float %a to double |
| 182 ret double %conv |
| 183 } |
| 184 ; CHECK: fpext: |
| 185 ; CHECK: cvtss2sd |
| 186 ; CHECK: fld |
| 187 |
| 188 define internal i64 @doubleToSigned64(double %a) { |
| 189 entry: |
| 190 %conv = fptosi double %a to i64 |
| 191 ret i64 %conv |
| 192 } |
| 193 ; CHECK: doubleToSigned64: |
| 194 ; CHECK: call cvtdtosi64 |
| 195 |
| 196 define internal i64 @floatToSigned64(float %a) { |
| 197 entry: |
| 198 %conv = fptosi float %a to i64 |
| 199 ret i64 %conv |
| 200 } |
| 201 ; CHECK: floatToSigned64: |
| 202 ; CHECK: call cvtftosi64 |
| 203 |
| 204 define internal i64 @doubleToUnsigned64(double %a) { |
| 205 entry: |
| 206 %conv = fptoui double %a to i64 |
| 207 ret i64 %conv |
| 208 } |
| 209 ; CHECK: doubleToUnsigned64: |
| 210 ; CHECK: call cvtdtoui64 |
| 211 |
| 212 define internal i64 @floatToUnsigned64(float %a) { |
| 213 entry: |
| 214 %conv = fptoui float %a to i64 |
| 215 ret i64 %conv |
| 216 } |
| 217 ; CHECK: floatToUnsigned64: |
| 218 ; CHECK: call cvtftoui64 |
| 219 |
| 220 define internal i32 @doubleToSigned32(double %a) { |
| 221 entry: |
| 222 %conv = fptosi double %a to i32 |
| 223 ret i32 %conv |
| 224 } |
| 225 ; CHECK: doubleToSigned32: |
| 226 ; CHECK: cvtsd2si |
| 227 |
| 228 define internal i32 @floatToSigned32(float %a) { |
| 229 entry: |
| 230 %conv = fptosi float %a to i32 |
| 231 ret i32 %conv |
| 232 } |
| 233 ; CHECK: floatToSigned32: |
| 234 ; CHECK: cvtss2si |
| 235 |
| 236 define internal i32 @doubleToUnsigned32(double %a) { |
| 237 entry: |
| 238 %conv = fptoui double %a to i32 |
| 239 ret i32 %conv |
| 240 } |
| 241 ; CHECK: doubleToUnsigned32: |
| 242 ; CHECK: call cvtdtoui32 |
| 243 |
| 244 define internal i32 @floatToUnsigned32(float %a) { |
| 245 entry: |
| 246 %conv = fptoui float %a to i32 |
| 247 ret i32 %conv |
| 248 } |
| 249 ; CHECK: floatToUnsigned32: |
| 250 ; CHECK: call cvtftoui32 |
| 251 |
| 252 define internal i32 @doubleToSigned16(double %a) { |
| 253 entry: |
| 254 %conv = fptosi double %a to i16 |
| 255 %conv.ret_ext = sext i16 %conv to i32 |
| 256 ret i32 %conv.ret_ext |
| 257 } |
| 258 ; CHECK: doubleToSigned16: |
| 259 ; CHECK: cvtsd2si |
| 260 ; CHECK: movsx |
| 261 |
| 262 define internal i32 @floatToSigned16(float %a) { |
| 263 entry: |
| 264 %conv = fptosi float %a to i16 |
| 265 %conv.ret_ext = sext i16 %conv to i32 |
| 266 ret i32 %conv.ret_ext |
| 267 } |
| 268 ; CHECK: floatToSigned16: |
| 269 ; CHECK: cvtss2si |
| 270 ; CHECK: movsx |
| 271 |
| 272 define internal i32 @doubleToUnsigned16(double %a) { |
| 273 entry: |
| 274 %conv = fptoui double %a to i16 |
| 275 %conv.ret_ext = zext i16 %conv to i32 |
| 276 ret i32 %conv.ret_ext |
| 277 } |
| 278 ; CHECK: doubleToUnsigned16: |
| 279 ; CHECK: cvtsd2si |
| 280 ; CHECK: movzx |
| 281 |
| 282 define internal i32 @floatToUnsigned16(float %a) { |
| 283 entry: |
| 284 %conv = fptoui float %a to i16 |
| 285 %conv.ret_ext = zext i16 %conv to i32 |
| 286 ret i32 %conv.ret_ext |
| 287 } |
| 288 ; CHECK: floatToUnsigned16: |
| 289 ; CHECK: cvtss2si |
| 290 ; CHECK: movzx |
| 291 |
| 292 define internal i32 @doubleToSigned8(double %a) { |
| 293 entry: |
| 294 %conv = fptosi double %a to i8 |
| 295 %conv.ret_ext = sext i8 %conv to i32 |
| 296 ret i32 %conv.ret_ext |
| 297 } |
| 298 ; CHECK: doubleToSigned8: |
| 299 ; CHECK: cvtsd2si |
| 300 ; CHECK: movsx |
| 301 |
| 302 define internal i32 @floatToSigned8(float %a) { |
| 303 entry: |
| 304 %conv = fptosi float %a to i8 |
| 305 %conv.ret_ext = sext i8 %conv to i32 |
| 306 ret i32 %conv.ret_ext |
| 307 } |
| 308 ; CHECK: floatToSigned8: |
| 309 ; CHECK: cvtss2si |
| 310 ; CHECK: movsx |
| 311 |
| 312 define internal i32 @doubleToUnsigned8(double %a) { |
| 313 entry: |
| 314 %conv = fptoui double %a to i8 |
| 315 %conv.ret_ext = zext i8 %conv to i32 |
| 316 ret i32 %conv.ret_ext |
| 317 } |
| 318 ; CHECK: doubleToUnsigned8: |
| 319 ; CHECK: cvtsd2si |
| 320 ; CHECK: movzx |
| 321 |
| 322 define internal i32 @floatToUnsigned8(float %a) { |
| 323 entry: |
| 324 %conv = fptoui float %a to i8 |
| 325 %conv.ret_ext = zext i8 %conv to i32 |
| 326 ret i32 %conv.ret_ext |
| 327 } |
| 328 ; CHECK: floatToUnsigned8: |
| 329 ; CHECK: cvtss2si |
| 330 ; CHECK: movzx |
| 331 |
| 332 define internal i32 @doubleToUnsigned1(double %a) { |
| 333 entry: |
| 334 %tobool = fptoui double %a to i1 |
| 335 %tobool.ret_ext = zext i1 %tobool to i32 |
| 336 ret i32 %tobool.ret_ext |
| 337 } |
| 338 ; CHECK: doubleToUnsigned1: |
| 339 ; CHECK: cvtsd2si |
| 340 ; CHECK: and eax, 1 |
| 341 |
| 342 define internal i32 @floatToUnsigned1(float %a) { |
| 343 entry: |
| 344 %tobool = fptoui float %a to i1 |
| 345 %tobool.ret_ext = zext i1 %tobool to i32 |
| 346 ret i32 %tobool.ret_ext |
| 347 } |
| 348 ; CHECK: floatToUnsigned1: |
| 349 ; CHECK: cvtss2si |
| 350 ; CHECK: and eax, 1 |
| 351 |
| 352 define internal double @signed64ToDouble(i64 %a) { |
| 353 entry: |
| 354 %conv = sitofp i64 %a to double |
| 355 ret double %conv |
| 356 } |
| 357 ; CHECK: signed64ToDouble: |
| 358 ; CHECK: call cvtsi64tod |
| 359 ; CHECK: fstp |
| 360 |
| 361 define internal float @signed64ToFloat(i64 %a) { |
| 362 entry: |
| 363 %conv = sitofp i64 %a to float |
| 364 ret float %conv |
| 365 } |
| 366 ; CHECK: signed64ToFloat: |
| 367 ; CHECK: call cvtsi64tof |
| 368 ; CHECK: fstp |
| 369 |
| 370 define internal double @unsigned64ToDouble(i64 %a) { |
| 371 entry: |
| 372 %conv = uitofp i64 %a to double |
| 373 ret double %conv |
| 374 } |
| 375 ; CHECK: unsigned64ToDouble: |
| 376 ; CHECK: call cvtui64tod |
| 377 ; CHECK: fstp |
| 378 |
| 379 define internal float @unsigned64ToFloat(i64 %a) { |
| 380 entry: |
| 381 %conv = uitofp i64 %a to float |
| 382 ret float %conv |
| 383 } |
| 384 ; CHECK: unsigned64ToFloat: |
| 385 ; CHECK: call cvtui64tof |
| 386 ; CHECK: fstp |
| 387 |
| 388 define internal double @signed32ToDouble(i32 %a) { |
| 389 entry: |
| 390 %conv = sitofp i32 %a to double |
| 391 ret double %conv |
| 392 } |
| 393 ; CHECK: signed32ToDouble: |
| 394 ; CHECK: cvtsi2sd |
| 395 ; CHECK: fld |
| 396 |
| 397 define internal float @signed32ToFloat(i32 %a) { |
| 398 entry: |
| 399 %conv = sitofp i32 %a to float |
| 400 ret float %conv |
| 401 } |
| 402 ; CHECK: signed32ToFloat: |
| 403 ; CHECK: cvtsi2ss |
| 404 ; CHECK: fld |
| 405 |
| 406 define internal double @unsigned32ToDouble(i32 %a) { |
| 407 entry: |
| 408 %conv = uitofp i32 %a to double |
| 409 ret double %conv |
| 410 } |
| 411 ; CHECK: unsigned32ToDouble: |
| 412 ; CHECK: call cvtui32tod |
| 413 ; CHECK: fstp |
| 414 |
| 415 define internal float @unsigned32ToFloat(i32 %a) { |
| 416 entry: |
| 417 %conv = uitofp i32 %a to float |
| 418 ret float %conv |
| 419 } |
| 420 ; CHECK: unsigned32ToFloat: |
| 421 ; CHECK: call cvtui32tof |
| 422 ; CHECK: fstp |
| 423 |
| 424 define internal double @signed16ToDouble(i32 %a) { |
| 425 entry: |
| 426 %a.arg_trunc = trunc i32 %a to i16 |
| 427 %conv = sitofp i16 %a.arg_trunc to double |
| 428 ret double %conv |
| 429 } |
| 430 ; CHECK: signed16ToDouble: |
| 431 ; CHECK: cvtsi2sd |
| 432 ; CHECK: fld |
| 433 |
| 434 define internal float @signed16ToFloat(i32 %a) { |
| 435 entry: |
| 436 %a.arg_trunc = trunc i32 %a to i16 |
| 437 %conv = sitofp i16 %a.arg_trunc to float |
| 438 ret float %conv |
| 439 } |
| 440 ; CHECK: signed16ToFloat: |
| 441 ; CHECK: cvtsi2ss |
| 442 ; CHECK: fld |
| 443 |
| 444 define internal double @unsigned16ToDouble(i32 %a) { |
| 445 entry: |
| 446 %a.arg_trunc = trunc i32 %a to i16 |
| 447 %conv = uitofp i16 %a.arg_trunc to double |
| 448 ret double %conv |
| 449 } |
| 450 ; CHECK: unsigned16ToDouble: |
| 451 ; CHECK: cvtsi2sd |
| 452 ; CHECK: fld |
| 453 |
| 454 define internal float @unsigned16ToFloat(i32 %a) { |
| 455 entry: |
| 456 %a.arg_trunc = trunc i32 %a to i16 |
| 457 %conv = uitofp i16 %a.arg_trunc to float |
| 458 ret float %conv |
| 459 } |
| 460 ; CHECK: unsigned16ToFloat: |
| 461 ; CHECK: cvtsi2ss |
| 462 ; CHECK: fld |
| 463 |
| 464 define internal double @signed8ToDouble(i32 %a) { |
| 465 entry: |
| 466 %a.arg_trunc = trunc i32 %a to i8 |
| 467 %conv = sitofp i8 %a.arg_trunc to double |
| 468 ret double %conv |
| 469 } |
| 470 ; CHECK: signed8ToDouble: |
| 471 ; CHECK: cvtsi2sd |
| 472 ; CHECK: fld |
| 473 |
| 474 define internal float @signed8ToFloat(i32 %a) { |
| 475 entry: |
| 476 %a.arg_trunc = trunc i32 %a to i8 |
| 477 %conv = sitofp i8 %a.arg_trunc to float |
| 478 ret float %conv |
| 479 } |
| 480 ; CHECK: signed8ToFloat: |
| 481 ; CHECK: cvtsi2ss |
| 482 ; CHECK: fld |
| 483 |
| 484 define internal double @unsigned8ToDouble(i32 %a) { |
| 485 entry: |
| 486 %a.arg_trunc = trunc i32 %a to i8 |
| 487 %conv = uitofp i8 %a.arg_trunc to double |
| 488 ret double %conv |
| 489 } |
| 490 ; CHECK: unsigned8ToDouble: |
| 491 ; CHECK: cvtsi2sd |
| 492 ; CHECK: fld |
| 493 |
| 494 define internal float @unsigned8ToFloat(i32 %a) { |
| 495 entry: |
| 496 %a.arg_trunc = trunc i32 %a to i8 |
| 497 %conv = uitofp i8 %a.arg_trunc to float |
| 498 ret float %conv |
| 499 } |
| 500 ; CHECK: unsigned8ToFloat: |
| 501 ; CHECK: cvtsi2ss |
| 502 ; CHECK: fld |
| 503 |
| 504 define internal double @unsigned1ToDouble(i32 %a) { |
| 505 entry: |
| 506 %a.arg_trunc = trunc i32 %a to i1 |
| 507 %conv = uitofp i1 %a.arg_trunc to double |
| 508 ret double %conv |
| 509 } |
| 510 ; CHECK: unsigned1ToDouble: |
| 511 ; CHECK: cvtsi2sd |
| 512 ; CHECK: fld |
| 513 |
| 514 define internal float @unsigned1ToFloat(i32 %a) { |
| 515 entry: |
| 516 %a.arg_trunc = trunc i32 %a to i1 |
| 517 %conv = uitofp i1 %a.arg_trunc to float |
| 518 ret float %conv |
| 519 } |
| 520 ; CHECK: unsigned1ToFloat: |
| 521 ; CHECK: cvtsi2ss |
| 522 ; CHECK: fld |
| 523 |
| 524 define internal void @fcmpEq(float %a, float %b, double %c, double %d) { |
| 525 entry: |
| 526 %cmp = fcmp oeq float %a, %b |
| 527 br i1 %cmp, label %if.then, label %if.end |
| 528 |
| 529 if.then: ; preds = %entry |
| 530 call void @func() |
| 531 br label %if.end |
| 532 |
| 533 if.end: ; preds = %if.then, %entry |
| 534 %cmp1 = fcmp oeq double %c, %d |
| 535 br i1 %cmp1, label %if.then2, label %if.end3 |
| 536 |
| 537 if.then2: ; preds = %if.end |
| 538 call void @func() |
| 539 br label %if.end3 |
| 540 |
| 541 if.end3: ; preds = %if.then2, %if.end |
| 542 ret void |
| 543 } |
| 544 ; CHECK: fcmpEq: |
| 545 ; CHECK: ucomiss |
| 546 ; CHECK: jne . |
| 547 ; CHECK-NEXT: jp . |
| 548 ; CHECK: call func |
| 549 ; CHECK: ucomisd |
| 550 ; CHECK: jne . |
| 551 ; CHECK-NEXT: jp . |
| 552 ; CHECK: call func |
| 553 |
| 554 declare void @func() |
| 555 |
| 556 define internal void @fcmpNe(float %a, float %b, double %c, double %d) { |
| 557 entry: |
| 558 %cmp = fcmp une float %a, %b |
| 559 br i1 %cmp, label %if.then, label %if.end |
| 560 |
| 561 if.then: ; preds = %entry |
| 562 call void @func() |
| 563 br label %if.end |
| 564 |
| 565 if.end: ; preds = %if.then, %entry |
| 566 %cmp1 = fcmp une double %c, %d |
| 567 br i1 %cmp1, label %if.then2, label %if.end3 |
| 568 |
| 569 if.then2: ; preds = %if.end |
| 570 call void @func() |
| 571 br label %if.end3 |
| 572 |
| 573 if.end3: ; preds = %if.then2, %if.end |
| 574 ret void |
| 575 } |
| 576 ; CHECK: fcmpNe: |
| 577 ; CHECK: ucomiss |
| 578 ; CHECK: jne . |
| 579 ; CHECK-NEXT: jp . |
| 580 ; CHECK: call func |
| 581 ; CHECK: ucomisd |
| 582 ; CHECK: jne . |
| 583 ; CHECK-NEXT: jp . |
| 584 ; CHECK: call func |
| 585 |
| 586 define internal void @fcmpGt(float %a, float %b, double %c, double %d) { |
| 587 entry: |
| 588 %cmp = fcmp ogt float %a, %b |
| 589 br i1 %cmp, label %if.then, label %if.end |
| 590 |
| 591 if.then: ; preds = %entry |
| 592 call void @func() |
| 593 br label %if.end |
| 594 |
| 595 if.end: ; preds = %if.then, %entry |
| 596 %cmp1 = fcmp ogt double %c, %d |
| 597 br i1 %cmp1, label %if.then2, label %if.end3 |
| 598 |
| 599 if.then2: ; preds = %if.end |
| 600 call void @func() |
| 601 br label %if.end3 |
| 602 |
| 603 if.end3: ; preds = %if.then2, %if.end |
| 604 ret void |
| 605 } |
| 606 ; CHECK: fcmpGt: |
| 607 ; CHECK: ucomiss |
| 608 ; CHECK: ja . |
| 609 ; CHECK: call func |
| 610 ; CHECK: ucomisd |
| 611 ; CHECK: ja . |
| 612 ; CHECK: call func |
| 613 |
| 614 define internal void @fcmpGe(float %a, float %b, double %c, double %d) { |
| 615 entry: |
| 616 %cmp = fcmp ult float %a, %b |
| 617 br i1 %cmp, label %if.end, label %if.then |
| 618 |
| 619 if.then: ; preds = %entry |
| 620 call void @func() |
| 621 br label %if.end |
| 622 |
| 623 if.end: ; preds = %entry, %if.then |
| 624 %cmp1 = fcmp ult double %c, %d |
| 625 br i1 %cmp1, label %if.end3, label %if.then2 |
| 626 |
| 627 if.then2: ; preds = %if.end |
| 628 call void @func() |
| 629 br label %if.end3 |
| 630 |
| 631 if.end3: ; preds = %if.end, %if.then2 |
| 632 ret void |
| 633 } |
| 634 ; CHECK: fcmpGe: |
| 635 ; CHECK: ucomiss |
| 636 ; CHECK: jb . |
| 637 ; CHECK: call func |
| 638 ; CHECK: ucomisd |
| 639 ; CHECK: jb . |
| 640 ; CHECK: call func |
| 641 |
| 642 define internal void @fcmpLt(float %a, float %b, double %c, double %d) { |
| 643 entry: |
| 644 %cmp = fcmp olt float %a, %b |
| 645 br i1 %cmp, label %if.then, label %if.end |
| 646 |
| 647 if.then: ; preds = %entry |
| 648 call void @func() |
| 649 br label %if.end |
| 650 |
| 651 if.end: ; preds = %if.then, %entry |
| 652 %cmp1 = fcmp olt double %c, %d |
| 653 br i1 %cmp1, label %if.then2, label %if.end3 |
| 654 |
| 655 if.then2: ; preds = %if.end |
| 656 call void @func() |
| 657 br label %if.end3 |
| 658 |
| 659 if.end3: ; preds = %if.then2, %if.end |
| 660 ret void |
| 661 } |
| 662 ; CHECK: fcmpLt: |
| 663 ; CHECK: ucomiss |
| 664 ; CHECK: ja . |
| 665 ; CHECK: call func |
| 666 ; CHECK: ucomisd |
| 667 ; CHECK: ja . |
| 668 ; CHECK: call func |
| 669 |
| 670 define internal void @fcmpLe(float %a, float %b, double %c, double %d) { |
| 671 entry: |
| 672 %cmp = fcmp ugt float %a, %b |
| 673 br i1 %cmp, label %if.end, label %if.then |
| 674 |
| 675 if.then: ; preds = %entry |
| 676 call void @func() |
| 677 br label %if.end |
| 678 |
| 679 if.end: ; preds = %entry, %if.then |
| 680 %cmp1 = fcmp ugt double %c, %d |
| 681 br i1 %cmp1, label %if.end3, label %if.then2 |
| 682 |
| 683 if.then2: ; preds = %if.end |
| 684 call void @func() |
| 685 br label %if.end3 |
| 686 |
| 687 if.end3: ; preds = %if.end, %if.then2 |
| 688 ret void |
| 689 } |
| 690 ; CHECK: fcmpLe: |
| 691 ; CHECK: ucomiss |
| 692 ; CHECK: jb . |
| 693 ; CHECK: call func |
| 694 ; CHECK: ucomisd |
| 695 ; CHECK: jb . |
| 696 ; CHECK: call func |
| 697 |
| 698 define internal i32 @fcmpFalseFloat(float %a, float %b) { |
| 699 entry: |
| 700 %cmp = fcmp false float %a, %b |
| 701 %cmp.ret_ext = zext i1 %cmp to i32 |
| 702 ret i32 %cmp.ret_ext |
| 703 } |
| 704 ; CHECK: fcmpFalseFloat: |
| 705 ; CHECK: mov {{.*}}, 0 |
| 706 |
| 707 define internal i32 @fcmpFalseDouble(double %a, double %b) { |
| 708 entry: |
| 709 %cmp = fcmp false double %a, %b |
| 710 %cmp.ret_ext = zext i1 %cmp to i32 |
| 711 ret i32 %cmp.ret_ext |
| 712 } |
| 713 ; CHECK: fcmpFalseDouble: |
| 714 ; CHECK: mov {{.*}}, 0 |
| 715 |
| 716 define internal i32 @fcmpOeqFloat(float %a, float %b) { |
| 717 entry: |
| 718 %cmp = fcmp oeq float %a, %b |
| 719 %cmp.ret_ext = zext i1 %cmp to i32 |
| 720 ret i32 %cmp.ret_ext |
| 721 } |
| 722 ; CHECK: fcmpOeqFloat: |
| 723 ; CHECK: ucomiss |
| 724 ; CHECK: jne . |
| 725 ; CHECK: jp . |
| 726 |
| 727 define internal i32 @fcmpOeqDouble(double %a, double %b) { |
| 728 entry: |
| 729 %cmp = fcmp oeq double %a, %b |
| 730 %cmp.ret_ext = zext i1 %cmp to i32 |
| 731 ret i32 %cmp.ret_ext |
| 732 } |
| 733 ; CHECK: fcmpOeqDouble: |
| 734 ; CHECK: ucomisd |
| 735 ; CHECK: jne . |
| 736 ; CHECK: jp . |
| 737 |
| 738 define internal i32 @fcmpOgtFloat(float %a, float %b) { |
| 739 entry: |
| 740 %cmp = fcmp ogt float %a, %b |
| 741 %cmp.ret_ext = zext i1 %cmp to i32 |
| 742 ret i32 %cmp.ret_ext |
| 743 } |
| 744 ; CHECK: fcmpOgtFloat: |
| 745 ; CHECK: ucomiss |
| 746 ; CHECK: ja . |
| 747 |
| 748 define internal i32 @fcmpOgtDouble(double %a, double %b) { |
| 749 entry: |
| 750 %cmp = fcmp ogt double %a, %b |
| 751 %cmp.ret_ext = zext i1 %cmp to i32 |
| 752 ret i32 %cmp.ret_ext |
| 753 } |
| 754 ; CHECK: fcmpOgtDouble: |
| 755 ; CHECK: ucomisd |
| 756 ; CHECK: ja . |
| 757 |
| 758 define internal i32 @fcmpOgeFloat(float %a, float %b) { |
| 759 entry: |
| 760 %cmp = fcmp oge float %a, %b |
| 761 %cmp.ret_ext = zext i1 %cmp to i32 |
| 762 ret i32 %cmp.ret_ext |
| 763 } |
| 764 ; CHECK: fcmpOgeFloat: |
| 765 ; CHECK: ucomiss |
| 766 ; CHECK: jae . |
| 767 |
| 768 define internal i32 @fcmpOgeDouble(double %a, double %b) { |
| 769 entry: |
| 770 %cmp = fcmp oge double %a, %b |
| 771 %cmp.ret_ext = zext i1 %cmp to i32 |
| 772 ret i32 %cmp.ret_ext |
| 773 } |
| 774 ; CHECK: fcmpOgeDouble: |
| 775 ; CHECK: ucomisd |
| 776 ; CHECK: jae . |
| 777 |
| 778 define internal i32 @fcmpOltFloat(float %a, float %b) { |
| 779 entry: |
| 780 %cmp = fcmp olt float %a, %b |
| 781 %cmp.ret_ext = zext i1 %cmp to i32 |
| 782 ret i32 %cmp.ret_ext |
| 783 } |
| 784 ; CHECK: fcmpOltFloat: |
| 785 ; CHECK: ucomiss |
| 786 ; CHECK: ja . |
| 787 |
| 788 define internal i32 @fcmpOltDouble(double %a, double %b) { |
| 789 entry: |
| 790 %cmp = fcmp olt double %a, %b |
| 791 %cmp.ret_ext = zext i1 %cmp to i32 |
| 792 ret i32 %cmp.ret_ext |
| 793 } |
| 794 ; CHECK: fcmpOltDouble: |
| 795 ; CHECK: ucomisd |
| 796 ; CHECK: ja . |
| 797 |
| 798 define internal i32 @fcmpOleFloat(float %a, float %b) { |
| 799 entry: |
| 800 %cmp = fcmp ole float %a, %b |
| 801 %cmp.ret_ext = zext i1 %cmp to i32 |
| 802 ret i32 %cmp.ret_ext |
| 803 } |
| 804 ; CHECK: fcmpOleFloat: |
| 805 ; CHECK: ucomiss |
| 806 ; CHECK: jae . |
| 807 |
| 808 define internal i32 @fcmpOleDouble(double %a, double %b) { |
| 809 entry: |
| 810 %cmp = fcmp ole double %a, %b |
| 811 %cmp.ret_ext = zext i1 %cmp to i32 |
| 812 ret i32 %cmp.ret_ext |
| 813 } |
| 814 ; CHECK: fcmpOleDouble: |
| 815 ; CHECK: ucomisd |
| 816 ; CHECK: jae . |
| 817 |
| 818 define internal i32 @fcmpOneFloat(float %a, float %b) { |
| 819 entry: |
| 820 %cmp = fcmp one float %a, %b |
| 821 %cmp.ret_ext = zext i1 %cmp to i32 |
| 822 ret i32 %cmp.ret_ext |
| 823 } |
| 824 ; CHECK: fcmpOneFloat: |
| 825 ; CHECK: ucomiss |
| 826 ; CHECK: jne . |
| 827 |
| 828 define internal i32 @fcmpOneDouble(double %a, double %b) { |
| 829 entry: |
| 830 %cmp = fcmp one double %a, %b |
| 831 %cmp.ret_ext = zext i1 %cmp to i32 |
| 832 ret i32 %cmp.ret_ext |
| 833 } |
| 834 ; CHECK: fcmpOneDouble: |
| 835 ; CHECK: ucomisd |
| 836 ; CHECK: jne . |
| 837 |
| 838 define internal i32 @fcmpOrdFloat(float %a, float %b) { |
| 839 entry: |
| 840 %cmp = fcmp ord float %a, %b |
| 841 %cmp.ret_ext = zext i1 %cmp to i32 |
| 842 ret i32 %cmp.ret_ext |
| 843 } |
| 844 ; CHECK: fcmpOrdFloat: |
| 845 ; CHECK: ucomiss |
| 846 ; CHECK: jnp . |
| 847 |
| 848 define internal i32 @fcmpOrdDouble(double %a, double %b) { |
| 849 entry: |
| 850 %cmp = fcmp ord double %a, %b |
| 851 %cmp.ret_ext = zext i1 %cmp to i32 |
| 852 ret i32 %cmp.ret_ext |
| 853 } |
| 854 ; CHECK: fcmpOrdDouble: |
| 855 ; CHECK: ucomisd |
| 856 ; CHECK: jnp . |
| 857 |
| 858 define internal i32 @fcmpUeqFloat(float %a, float %b) { |
| 859 entry: |
| 860 %cmp = fcmp ueq float %a, %b |
| 861 %cmp.ret_ext = zext i1 %cmp to i32 |
| 862 ret i32 %cmp.ret_ext |
| 863 } |
| 864 ; CHECK: fcmpUeqFloat: |
| 865 ; CHECK: ucomiss |
| 866 ; CHECK: je . |
| 867 |
| 868 define internal i32 @fcmpUeqDouble(double %a, double %b) { |
| 869 entry: |
| 870 %cmp = fcmp ueq double %a, %b |
| 871 %cmp.ret_ext = zext i1 %cmp to i32 |
| 872 ret i32 %cmp.ret_ext |
| 873 } |
| 874 ; CHECK: fcmpUeqDouble: |
| 875 ; CHECK: ucomisd |
| 876 ; CHECK: je . |
| 877 |
| 878 define internal i32 @fcmpUgtFloat(float %a, float %b) { |
| 879 entry: |
| 880 %cmp = fcmp ugt float %a, %b |
| 881 %cmp.ret_ext = zext i1 %cmp to i32 |
| 882 ret i32 %cmp.ret_ext |
| 883 } |
| 884 ; CHECK: fcmpUgtFloat: |
| 885 ; CHECK: ucomiss |
| 886 ; CHECK: jb . |
| 887 |
| 888 define internal i32 @fcmpUgtDouble(double %a, double %b) { |
| 889 entry: |
| 890 %cmp = fcmp ugt double %a, %b |
| 891 %cmp.ret_ext = zext i1 %cmp to i32 |
| 892 ret i32 %cmp.ret_ext |
| 893 } |
| 894 ; CHECK: fcmpUgtDouble: |
| 895 ; CHECK: ucomisd |
| 896 ; CHECK: jb . |
| 897 |
| 898 define internal i32 @fcmpUgeFloat(float %a, float %b) { |
| 899 entry: |
| 900 %cmp = fcmp uge float %a, %b |
| 901 %cmp.ret_ext = zext i1 %cmp to i32 |
| 902 ret i32 %cmp.ret_ext |
| 903 } |
| 904 ; CHECK: fcmpUgeFloat: |
| 905 ; CHECK: ucomiss |
| 906 ; CHECK: jbe . |
| 907 |
| 908 define internal i32 @fcmpUgeDouble(double %a, double %b) { |
| 909 entry: |
| 910 %cmp = fcmp uge double %a, %b |
| 911 %cmp.ret_ext = zext i1 %cmp to i32 |
| 912 ret i32 %cmp.ret_ext |
| 913 } |
| 914 ; CHECK: fcmpUgeDouble: |
| 915 ; CHECK: ucomisd |
| 916 ; CHECK: jbe . |
| 917 |
| 918 define internal i32 @fcmpUltFloat(float %a, float %b) { |
| 919 entry: |
| 920 %cmp = fcmp ult float %a, %b |
| 921 %cmp.ret_ext = zext i1 %cmp to i32 |
| 922 ret i32 %cmp.ret_ext |
| 923 } |
| 924 ; CHECK: fcmpUltFloat: |
| 925 ; CHECK: ucomiss |
| 926 ; CHECK: jb . |
| 927 |
| 928 define internal i32 @fcmpUltDouble(double %a, double %b) { |
| 929 entry: |
| 930 %cmp = fcmp ult double %a, %b |
| 931 %cmp.ret_ext = zext i1 %cmp to i32 |
| 932 ret i32 %cmp.ret_ext |
| 933 } |
| 934 ; CHECK: fcmpUltDouble: |
| 935 ; CHECK: ucomisd |
| 936 ; CHECK: jb . |
| 937 |
| 938 define internal i32 @fcmpUleFloat(float %a, float %b) { |
| 939 entry: |
| 940 %cmp = fcmp ule float %a, %b |
| 941 %cmp.ret_ext = zext i1 %cmp to i32 |
| 942 ret i32 %cmp.ret_ext |
| 943 } |
| 944 ; CHECK: fcmpUleFloat: |
| 945 ; CHECK: ucomiss |
| 946 ; CHECK: jbe . |
| 947 |
| 948 define internal i32 @fcmpUleDouble(double %a, double %b) { |
| 949 entry: |
| 950 %cmp = fcmp ule double %a, %b |
| 951 %cmp.ret_ext = zext i1 %cmp to i32 |
| 952 ret i32 %cmp.ret_ext |
| 953 } |
| 954 ; CHECK: fcmpUleDouble: |
| 955 ; CHECK: ucomisd |
| 956 ; CHECK: jbe . |
| 957 |
| 958 define internal i32 @fcmpUneFloat(float %a, float %b) { |
| 959 entry: |
| 960 %cmp = fcmp une float %a, %b |
| 961 %cmp.ret_ext = zext i1 %cmp to i32 |
| 962 ret i32 %cmp.ret_ext |
| 963 } |
| 964 ; CHECK: fcmpUneFloat: |
| 965 ; CHECK: ucomiss |
| 966 ; CHECK: jne . |
| 967 ; CHECK: jp . |
| 968 |
| 969 define internal i32 @fcmpUneDouble(double %a, double %b) { |
| 970 entry: |
| 971 %cmp = fcmp une double %a, %b |
| 972 %cmp.ret_ext = zext i1 %cmp to i32 |
| 973 ret i32 %cmp.ret_ext |
| 974 } |
| 975 ; CHECK: fcmpUneDouble: |
| 976 ; CHECK: ucomisd |
| 977 ; CHECK: jne . |
| 978 ; CHECK: jp . |
| 979 |
| 980 define internal i32 @fcmpUnoFloat(float %a, float %b) { |
| 981 entry: |
| 982 %cmp = fcmp uno float %a, %b |
| 983 %cmp.ret_ext = zext i1 %cmp to i32 |
| 984 ret i32 %cmp.ret_ext |
| 985 } |
| 986 ; CHECK: fcmpUnoFloat: |
| 987 ; CHECK: ucomiss |
| 988 ; CHECK: jp . |
| 989 |
| 990 define internal i32 @fcmpUnoDouble(double %a, double %b) { |
| 991 entry: |
| 992 %cmp = fcmp uno double %a, %b |
| 993 %cmp.ret_ext = zext i1 %cmp to i32 |
| 994 ret i32 %cmp.ret_ext |
| 995 } |
| 996 ; CHECK: fcmpUnoDouble: |
| 997 ; CHECK: ucomisd |
| 998 ; CHECK: jp . |
| 999 |
| 1000 define internal i32 @fcmpTrueFloat(float %a, float %b) { |
| 1001 entry: |
| 1002 %cmp = fcmp true float %a, %b |
| 1003 %cmp.ret_ext = zext i1 %cmp to i32 |
| 1004 ret i32 %cmp.ret_ext |
| 1005 } |
| 1006 ; CHECK: fcmpTrueFloat: |
| 1007 ; CHECK: mov {{.*}}, 1 |
| 1008 |
| 1009 define internal i32 @fcmpTrueDouble(double %a, double %b) { |
| 1010 entry: |
| 1011 %cmp = fcmp true double %a, %b |
| 1012 %cmp.ret_ext = zext i1 %cmp to i32 |
| 1013 ret i32 %cmp.ret_ext |
| 1014 } |
| 1015 ; CHECK: fcmpTrueDouble: |
| 1016 ; CHECK: mov {{.*}}, 1 |
| 1017 |
| 1018 define internal float @loadFloat(i32 %a) { |
| 1019 entry: |
| 1020 %a.asptr = inttoptr i32 %a to float* |
| 1021 %v0 = load float* %a.asptr, align 4 |
| 1022 ret float %v0 |
| 1023 } |
| 1024 ; CHECK: loadFloat: |
| 1025 ; CHECK: movss |
| 1026 ; CHECK: fld |
| 1027 |
| 1028 define internal double @loadDouble(i32 %a) { |
| 1029 entry: |
| 1030 %a.asptr = inttoptr i32 %a to double* |
| 1031 %v0 = load double* %a.asptr, align 8 |
| 1032 ret double %v0 |
| 1033 } |
| 1034 ; CHECK: loadDouble: |
| 1035 ; CHECK: movsd |
| 1036 ; CHECK: fld |
| 1037 |
| 1038 define internal void @storeFloat(i32 %a, float %value) { |
| 1039 entry: |
| 1040 %a.asptr = inttoptr i32 %a to float* |
| 1041 store float %value, float* %a.asptr, align 4 |
| 1042 ret void |
| 1043 } |
| 1044 ; CHECK: storeFloat: |
| 1045 ; CHECK: movss |
| 1046 |
| 1047 define internal void @storeDouble(i32 %a, double %value) { |
| 1048 entry: |
| 1049 %a.asptr = inttoptr i32 %a to double* |
| 1050 store double %value, double* %a.asptr, align 8 |
| 1051 ret void |
| 1052 } |
| 1053 ; CHECK: storeDouble: |
| 1054 ; CHECK: movsd |
| 1055 |
| 1056 define internal void @storeFloatConst(i32 %a) { |
| 1057 entry: |
| 1058 %a.asptr = inttoptr i32 %a to float* |
| 1059 store float 0x3FF3AE1480000000, float* %a.asptr, align 4 |
| 1060 ret void |
| 1061 } |
| 1062 ; CHECK: storeFloatConst: |
| 1063 ; CHECK: mov |
| 1064 ; CHECK: mov |
| 1065 |
| 1066 define internal void @storeDoubleConst(i32 %a) { |
| 1067 entry: |
| 1068 %a.asptr = inttoptr i32 %a to double* |
| 1069 store double 1.230000e+00, double* %a.asptr, align 8 |
| 1070 ret void |
| 1071 } |
| 1072 ; CHECK: storeDoubleConst: |
| 1073 ; CHECK: mov |
| 1074 ; CHECK: mov |
| 1075 |
| 1076 define internal float @selectFloatVarVar(float %a, float %b) { |
| 1077 entry: |
| 1078 %cmp = fcmp olt float %a, %b |
| 1079 %cond = select i1 %cmp, float %a, float %b |
| 1080 ret float %cond |
| 1081 } |
| 1082 ; CHECK: selectFloatVarVar: |
| 1083 ; CHECK: ucomiss |
| 1084 ; CHECK: ja . |
| 1085 ; CHECK: fld |
| 1086 |
| 1087 define internal double @selectDoubleVarVar(double %a, double %b) { |
| 1088 entry: |
| 1089 %cmp = fcmp olt double %a, %b |
| 1090 %cond = select i1 %cmp, double %a, double %b |
| 1091 ret double %cond |
| 1092 } |
| 1093 ; CHECK: selectDoubleVarVar: |
| 1094 ; CHECK: ucomisd |
| 1095 ; CHECK: ja . |
| 1096 ; CHECK: fld |
| 1097 |
| 1098 ; ERRORS-NOT: ICE translation error |
| 1099 ; DUMP-NOT: SZ |
OLD | NEW |