1 // RUN: %clang_cc1 %s -O0 -emit-llvm -triple x86_64-unknown-unknown -o - | FileCheck %s --check-prefix=X86 2 // RUN: %clang_cc1 %s -O0 -emit-llvm -triple x86_64-pc-win64 -o - | FileCheck %s --check-prefix=X86 3 // RUN: %clang_cc1 %s -O0 -emit-llvm -triple i686-unknown-unknown -o - | FileCheck %s --check-prefix=X86 4 // RUN: %clang_cc1 %s -O0 -emit-llvm -triple powerpc-unknown-unknown -o - | FileCheck %s --check-prefix=PPC 5 // RUN: %clang_cc1 %s -O0 -emit-llvm -triple armv7-none-linux-gnueabi -o - | FileCheck %s --check-prefix=ARM 6 // RUN: %clang_cc1 %s -O0 -emit-llvm -triple armv7-none-linux-gnueabihf -o - | FileCheck %s --check-prefix=ARMHF 7 // RUN: %clang_cc1 %s -O0 -emit-llvm -triple thumbv7k-apple-watchos2.0 -o - -target-abi aapcs16 | FileCheck %s --check-prefix=ARM7K 8 // RUN: %clang_cc1 %s -O0 -emit-llvm -triple aarch64-unknown-unknown -ffast-math -ffp-contract=fast -o - | FileCheck %s --check-prefix=AARCH64-FASTMATH 9 // RUN: %clang_cc1 %s -O0 -emit-llvm -triple spir -o - | FileCheck %s --check-prefix=SPIR 10 11 float _Complex add_float_rr(float a, float b) { 12 // X86-LABEL: @add_float_rr( 13 // X86: fadd 14 // X86-NOT: fadd 15 // X86: ret 16 return a + b; 17 } 18 float _Complex add_float_cr(float _Complex a, float b) { 19 // X86-LABEL: @add_float_cr( 20 // X86: fadd 21 // X86-NOT: fadd 22 // X86: ret 23 return a + b; 24 } 25 float _Complex add_float_rc(float a, float _Complex b) { 26 // X86-LABEL: @add_float_rc( 27 // X86: fadd 28 // X86-NOT: fadd 29 // X86: ret 30 return a + b; 31 } 32 float _Complex add_float_cc(float _Complex a, float _Complex b) { 33 // X86-LABEL: @add_float_cc( 34 // X86: fadd 35 // X86: fadd 36 // X86-NOT: fadd 37 // X86: ret 38 return a + b; 39 } 40 41 float _Complex sub_float_rr(float a, float b) { 42 // X86-LABEL: @sub_float_rr( 43 // X86: fsub 44 // X86-NOT: fsub 45 // X86: ret 46 return a - b; 47 } 48 float _Complex sub_float_cr(float _Complex a, float b) { 49 // X86-LABEL: @sub_float_cr( 50 // X86: fsub 51 // X86-NOT: fsub 52 // X86: ret 53 return a - b; 54 } 55 float _Complex sub_float_rc(float a, float _Complex b) { 56 // X86-LABEL: @sub_float_rc( 57 // X86: fsub 58 // X86: fneg 59 // X86-NOT: fsub 60 // X86: ret 61 return a - b; 62 } 63 float _Complex sub_float_cc(float _Complex a, float _Complex b) { 64 // X86-LABEL: @sub_float_cc( 65 // X86: fsub 66 // X86: fsub 67 // X86-NOT: fsub 68 // X86: ret 69 return a - b; 70 } 71 72 float _Complex mul_float_rr(float a, float b) { 73 // X86-LABEL: @mul_float_rr( 74 // X86: fmul 75 // X86-NOT: fmul 76 // X86: ret 77 return a * b; 78 } 79 float _Complex mul_float_cr(float _Complex a, float b) { 80 // X86-LABEL: @mul_float_cr( 81 // X86: fmul 82 // X86: fmul 83 // X86-NOT: fmul 84 // X86: ret 85 return a * b; 86 } 87 float _Complex mul_float_rc(float a, float _Complex b) { 88 // X86-LABEL: @mul_float_rc( 89 // X86: fmul 90 // X86: fmul 91 // X86-NOT: fmul 92 // X86: ret 93 return a * b; 94 } 95 96 float _Complex mul_float_cc(float _Complex a, float _Complex b) { 97 // X86-LABEL: @mul_float_cc( 98 // X86: %[[AC:[^ ]+]] = fmul 99 // X86: %[[BD:[^ ]+]] = fmul 100 // X86: %[[AD:[^ ]+]] = fmul 101 // X86: %[[BC:[^ ]+]] = fmul 102 // X86: %[[RR:[^ ]+]] = fsub 103 // X86: %[[RI:[^ ]+]] = fadd 104 // X86-DAG: %[[AD]] 105 // X86-DAG: , 106 // X86-DAG: %[[BC]] 107 // X86: fcmp uno float %[[RR]] 108 // X86: fcmp uno float %[[RI]] 109 // X86: call {{.*}} @__mulsc3( 110 // X86: ret 111 // SPIR: call spir_func {{.*}} @__mulsc3( 112 return a * b; 113 } 114 115 float _Complex div_float_rr(float a, float b) { 116 // X86-LABEL: @div_float_rr( 117 // X86: fdiv 118 // X86-NOT: fdiv 119 // X86: ret 120 return a / b; 121 } 122 float _Complex div_float_cr(float _Complex a, float b) { 123 // X86-LABEL: @div_float_cr( 124 // X86: fdiv 125 // X86: fdiv 126 // X86-NOT: fdiv 127 // X86: ret 128 return a / b; 129 } 130 float _Complex div_float_rc(float a, float _Complex b) { 131 // X86-LABEL: @div_float_rc( 132 // X86-NOT: fdiv 133 // X86: call {{.*}} @__divsc3( 134 // X86: ret 135 136 // SPIR: call spir_func {{.*}} @__divsc3( 137 138 // a / b = (A+iB) / (C+iD) = ((AC+BD)/(CC+DD)) + i((BC-AD)/(CC+DD)) 139 // AARCH64-FASTMATH-LABEL: @div_float_rc(float noundef %a, [2 x float] noundef %b.coerce) 140 // A = a 141 // B = 0 142 // 143 // AARCH64-FASTMATH: [[AC:%.*]] = fmul fast float 144 // BD = 0 145 // ACpBD = AC 146 // 147 // AARCH64-FASTMATH: [[CC:%.*]] = fmul fast float 148 // AARCH64-FASTMATH: [[DD:%.*]] = fmul fast float 149 // AARCH64-FASTMATH: [[CCpDD:%.*]] = fadd fast float 150 // 151 // BC = 0 152 // AARCH64-FASTMATH: [[AD:%.*]] = fmul fast float 153 // 154 // AARCH64-FASTMATH: fdiv fast float 155 // AARCH64-FASTMATH: fdiv fast float 156 // AARCH64-FASTMATH: ret 157 return a / b; 158 } 159 float _Complex div_float_cc(float _Complex a, float _Complex b) { 160 // X86-LABEL: @div_float_cc( 161 // X86-NOT: fdiv 162 // X86: call {{.*}} @__divsc3( 163 // X86: ret 164 165 // SPIR: call spir_func {{.*}} @__divsc3( 166 167 // a / b = (A+iB) / (C+iD) = ((AC+BD)/(CC+DD)) + i((BC-AD)/(CC+DD)) 168 // AARCH64-FASTMATH-LABEL: @div_float_cc([2 x float] noundef %a.coerce, [2 x float] noundef %b.coerce) 169 // 170 // AARCH64-FASTMATH: [[AC:%.*]] = fmul fast float 171 // AARCH64-FASTMATH: [[BD:%.*]] = fmul fast float 172 // AARCH64-FASTMATH: [[ACpBD:%.*]] = fadd fast float 173 // 174 // AARCH64-FASTMATH: [[CC:%.*]] = fmul fast float 175 // AARCH64-FASTMATH: [[DD:%.*]] = fmul fast float 176 // AARCH64-FASTMATH: [[CCpDD:%.*]] = fadd fast float 177 // 178 // AARCH64-FASTMATH: [[BC:%.*]] = fmul fast float 179 // AARCH64-FASTMATH: [[AD:%.*]] = fmul fast float 180 // AARCH64-FASTMATH: [[BCmAD:%.*]] = fsub fast float 181 // 182 // AARCH64-FASTMATH: fdiv fast float 183 // AARCH64-FASTMATH: fdiv fast float 184 // AARCH64-FASTMATH: ret 185 return a / b; 186 } 187 188 double _Complex add_double_rr(double a, double b) { 189 // X86-LABEL: @add_double_rr( 190 // X86: fadd 191 // X86-NOT: fadd 192 // X86: ret 193 return a + b; 194 } 195 double _Complex add_double_cr(double _Complex a, double b) { 196 // X86-LABEL: @add_double_cr( 197 // X86: fadd 198 // X86-NOT: fadd 199 // X86: ret 200 return a + b; 201 } 202 double _Complex add_double_rc(double a, double _Complex b) { 203 // X86-LABEL: @add_double_rc( 204 // X86: fadd 205 // X86-NOT: fadd 206 // X86: ret 207 return a + b; 208 } 209 double _Complex add_double_cc(double _Complex a, double _Complex b) { 210 // X86-LABEL: @add_double_cc( 211 // X86: fadd 212 // X86: fadd 213 // X86-NOT: fadd 214 // X86: ret 215 return a + b; 216 } 217 218 double _Complex sub_double_rr(double a, double b) { 219 // X86-LABEL: @sub_double_rr( 220 // X86: fsub 221 // X86-NOT: fsub 222 // X86: ret 223 return a - b; 224 } 225 double _Complex sub_double_cr(double _Complex a, double b) { 226 // X86-LABEL: @sub_double_cr( 227 // X86: fsub 228 // X86-NOT: fsub 229 // X86: ret 230 return a - b; 231 } 232 double _Complex sub_double_rc(double a, double _Complex b) { 233 // X86-LABEL: @sub_double_rc( 234 // X86: fsub 235 // X86: fneg 236 // X86-NOT: fsub 237 // X86: ret 238 return a - b; 239 } 240 double _Complex sub_double_cc(double _Complex a, double _Complex b) { 241 // X86-LABEL: @sub_double_cc( 242 // X86: fsub 243 // X86: fsub 244 // X86-NOT: fsub 245 // X86: ret 246 return a - b; 247 } 248 249 double _Complex mul_double_rr(double a, double b) { 250 // X86-LABEL: @mul_double_rr( 251 // X86: fmul 252 // X86-NOT: fmul 253 // X86: ret 254 return a * b; 255 } 256 double _Complex mul_double_cr(double _Complex a, double b) { 257 // X86-LABEL: @mul_double_cr( 258 // X86: fmul 259 // X86: fmul 260 // X86-NOT: fmul 261 // X86: ret 262 return a * b; 263 } 264 double _Complex mul_double_rc(double a, double _Complex b) { 265 // X86-LABEL: @mul_double_rc( 266 // X86: fmul 267 // X86: fmul 268 // X86-NOT: fmul 269 // X86: ret 270 return a * b; 271 } 272 double _Complex mul_double_cc(double _Complex a, double _Complex b) { 273 // X86-LABEL: @mul_double_cc( 274 // X86: %[[AC:[^ ]+]] = fmul 275 // X86: %[[BD:[^ ]+]] = fmul 276 // X86: %[[AD:[^ ]+]] = fmul 277 // X86: %[[BC:[^ ]+]] = fmul 278 // X86: %[[RR:[^ ]+]] = fsub double %[[AC]], %[[BD]] 279 // X86: %[[RI:[^ ]+]] = fadd double 280 // X86-DAG: %[[AD]] 281 // X86-DAG: , 282 // X86-DAG: %[[BC]] 283 // X86: fcmp uno double %[[RR]] 284 // X86: fcmp uno double %[[RI]] 285 // X86: call {{.*}} @__muldc3( 286 // X86: ret 287 288 // SPIR: call spir_func {{.*}} @__muldc3( 289 return a * b; 290 } 291 292 double _Complex div_double_rr(double a, double b) { 293 // X86-LABEL: @div_double_rr( 294 // X86: fdiv 295 // X86-NOT: fdiv 296 // X86: ret 297 return a / b; 298 } 299 double _Complex div_double_cr(double _Complex a, double b) { 300 // X86-LABEL: @div_double_cr( 301 // X86: fdiv 302 // X86: fdiv 303 // X86-NOT: fdiv 304 // X86: ret 305 return a / b; 306 } 307 double _Complex div_double_rc(double a, double _Complex b) { 308 // X86-LABEL: @div_double_rc( 309 // X86-NOT: fdiv 310 // X86: call {{.*}} @__divdc3( 311 // X86: ret 312 313 // SPIR: call spir_func {{.*}} @__divdc3( 314 315 // a / b = (A+iB) / (C+iD) = ((AC+BD)/(CC+DD)) + i((BC-AD)/(CC+DD)) 316 // AARCH64-FASTMATH-LABEL: @div_double_rc(double noundef %a, [2 x double] noundef %b.coerce) 317 // A = a 318 // B = 0 319 // 320 // AARCH64-FASTMATH: [[AC:%.*]] = fmul fast double 321 // BD = 0 322 // ACpBD = AC 323 // 324 // AARCH64-FASTMATH: [[CC:%.*]] = fmul fast double 325 // AARCH64-FASTMATH: [[DD:%.*]] = fmul fast double 326 // AARCH64-FASTMATH: [[CCpDD:%.*]] = fadd fast double 327 // 328 // BC = 0 329 // AARCH64-FASTMATH: [[AD:%.*]] = fmul fast double 330 // 331 // AARCH64-FASTMATH: fdiv fast double 332 // AARCH64-FASTMATH: fdiv fast double 333 // AARCH64-FASTMATH: ret 334 return a / b; 335 } 336 double _Complex div_double_cc(double _Complex a, double _Complex b) { 337 // X86-LABEL: @div_double_cc( 338 // X86-NOT: fdiv 339 // X86: call {{.*}} @__divdc3( 340 // X86: ret 341 342 // SPIR: call spir_func {{.*}} @__divdc3( 343 344 // a / b = (A+iB) / (C+iD) = ((AC+BD)/(CC+DD)) + i((BC-AD)/(CC+DD)) 345 // AARCH64-FASTMATH-LABEL: @div_double_cc([2 x double] noundef %a.coerce, [2 x double] noundef %b.coerce) 346 // 347 // AARCH64-FASTMATH: [[AC:%.*]] = fmul fast double 348 // AARCH64-FASTMATH: [[BD:%.*]] = fmul fast double 349 // AARCH64-FASTMATH: [[ACpBD:%.*]] = fadd fast double 350 // 351 // AARCH64-FASTMATH: [[CC:%.*]] = fmul fast double 352 // AARCH64-FASTMATH: [[DD:%.*]] = fmul fast double 353 // AARCH64-FASTMATH: [[CCpDD:%.*]] = fadd fast double 354 // 355 // AARCH64-FASTMATH: [[BC:%.*]] = fmul fast double 356 // AARCH64-FASTMATH: [[AD:%.*]] = fmul fast double 357 // AARCH64-FASTMATH: [[BCmAD:%.*]] = fsub fast double 358 // 359 // AARCH64-FASTMATH: fdiv fast double 360 // AARCH64-FASTMATH: fdiv fast double 361 // AARCH64-FASTMATH: ret 362 return a / b; 363 } 364 365 long double _Complex add_long_double_rr(long double a, long double b) { 366 // X86-LABEL: @add_long_double_rr( 367 // X86: fadd 368 // X86-NOT: fadd 369 // X86: ret 370 return a + b; 371 } 372 long double _Complex add_long_double_cr(long double _Complex a, long double b) { 373 // X86-LABEL: @add_long_double_cr( 374 // X86: fadd 375 // X86-NOT: fadd 376 // X86: ret 377 return a + b; 378 } 379 long double _Complex add_long_double_rc(long double a, long double _Complex b) { 380 // X86-LABEL: @add_long_double_rc( 381 // X86: fadd 382 // X86-NOT: fadd 383 // X86: ret 384 return a + b; 385 } 386 long double _Complex add_long_double_cc(long double _Complex a, long double _Complex b) { 387 // X86-LABEL: @add_long_double_cc( 388 // X86: fadd 389 // X86: fadd 390 // X86-NOT: fadd 391 // X86: ret 392 return a + b; 393 } 394 395 long double _Complex sub_long_double_rr(long double a, long double b) { 396 // X86-LABEL: @sub_long_double_rr( 397 // X86: fsub 398 // X86-NOT: fsub 399 // X86: ret 400 return a - b; 401 } 402 long double _Complex sub_long_double_cr(long double _Complex a, long double b) { 403 // X86-LABEL: @sub_long_double_cr( 404 // X86: fsub 405 // X86-NOT: fsub 406 // X86: ret 407 return a - b; 408 } 409 long double _Complex sub_long_double_rc(long double a, long double _Complex b) { 410 // X86-LABEL: @sub_long_double_rc( 411 // X86: fsub 412 // X86: fneg 413 // X86-NOT: fsub 414 // X86: ret 415 return a - b; 416 } 417 long double _Complex sub_long_double_cc(long double _Complex a, long double _Complex b) { 418 // X86-LABEL: @sub_long_double_cc( 419 // X86: fsub 420 // X86: fsub 421 // X86-NOT: fsub 422 // X86: ret 423 return a - b; 424 } 425 426 long double _Complex mul_long_double_rr(long double a, long double b) { 427 // X86-LABEL: @mul_long_double_rr( 428 // X86: fmul 429 // X86-NOT: fmul 430 // X86: ret 431 return a * b; 432 } 433 long double _Complex mul_long_double_cr(long double _Complex a, long double b) { 434 // X86-LABEL: @mul_long_double_cr( 435 // X86: fmul 436 // X86: fmul 437 // X86-NOT: fmul 438 // X86: ret 439 return a * b; 440 } 441 long double _Complex mul_long_double_rc(long double a, long double _Complex b) { 442 // X86-LABEL: @mul_long_double_rc( 443 // X86: fmul 444 // X86: fmul 445 // X86-NOT: fmul 446 // X86: ret 447 return a * b; 448 } 449 long double _Complex mul_long_double_cc(long double _Complex a, long double _Complex b) { 450 // X86-LABEL: @mul_long_double_cc( 451 // X86: %[[AC:[^ ]+]] = fmul 452 // X86: %[[BD:[^ ]+]] = fmul 453 // X86: %[[AD:[^ ]+]] = fmul 454 // X86: %[[BC:[^ ]+]] = fmul 455 // X86: %[[RR:[^ ]+]] = fsub x86_fp80 %[[AC]], %[[BD]] 456 // X86: %[[RI:[^ ]+]] = fadd x86_fp80 457 // X86-DAG: %[[AD]] 458 // X86-DAG: , 459 // X86-DAG: %[[BC]] 460 // X86: fcmp uno x86_fp80 %[[RR]] 461 // X86: fcmp uno x86_fp80 %[[RI]] 462 // X86: call {{.*}} @__mulxc3( 463 // X86: ret 464 // PPC-LABEL: @mul_long_double_cc( 465 // PPC: %[[AC:[^ ]+]] = fmul 466 // PPC: %[[BD:[^ ]+]] = fmul 467 // PPC: %[[AD:[^ ]+]] = fmul 468 // PPC: %[[BC:[^ ]+]] = fmul 469 // PPC: %[[RR:[^ ]+]] = fsub ppc_fp128 %[[AC]], %[[BD]] 470 // PPC: %[[RI:[^ ]+]] = fadd ppc_fp128 471 // PPC-DAG: %[[AD]] 472 // PPC-DAG: , 473 // PPC-DAG: %[[BC]] 474 // PPC: fcmp uno ppc_fp128 %[[RR]] 475 // PPC: fcmp uno ppc_fp128 %[[RI]] 476 // PPC: call {{.*}} @__multc3( 477 // PPC: ret 478 // SPIR: call spir_func {{.*}} @__muldc3( 479 return a * b; 480 } 481 482 long double _Complex div_long_double_rr(long double a, long double b) { 483 // X86-LABEL: @div_long_double_rr( 484 // X86: fdiv 485 // X86-NOT: fdiv 486 // X86: ret 487 return a / b; 488 } 489 long double _Complex div_long_double_cr(long double _Complex a, long double b) { 490 // X86-LABEL: @div_long_double_cr( 491 // X86: fdiv 492 // X86: fdiv 493 // X86-NOT: fdiv 494 // X86: ret 495 return a / b; 496 } 497 long double _Complex div_long_double_rc(long double a, long double _Complex b) { 498 // X86-LABEL: @div_long_double_rc( 499 // X86-NOT: fdiv 500 // X86: call {{.*}} @__divxc3( 501 // X86: ret 502 // PPC-LABEL: @div_long_double_rc( 503 // PPC-NOT: fdiv 504 // PPC: call {{.*}} @__divtc3( 505 // PPC: ret 506 // SPIR: call spir_func {{.*}} @__divdc3( 507 508 // a / b = (A+iB) / (C+iD) = ((AC+BD)/(CC+DD)) + i((BC-AD)/(CC+DD)) 509 // AARCH64-FASTMATH-LABEL: @div_long_double_rc(fp128 noundef %a, [2 x fp128] noundef %b.coerce) 510 // A = a 511 // B = 0 512 // 513 // AARCH64-FASTMATH: [[AC:%.*]] = fmul fast fp128 514 // BD = 0 515 // ACpBD = AC 516 // 517 // AARCH64-FASTMATH: [[CC:%.*]] = fmul fast fp128 518 // AARCH64-FASTMATH: [[DD:%.*]] = fmul fast fp128 519 // AARCH64-FASTMATH: [[CCpDD:%.*]] = fadd fast fp128 520 // 521 // BC = 0 522 // AARCH64-FASTMATH: [[AD:%.*]] = fmul fast fp128 523 // 524 // AARCH64-FASTMATH: fdiv fast fp128 525 // AARCH64-FASTMATH: fdiv fast fp128 526 // AARCH64-FASTMATH: ret 527 return a / b; 528 } 529 long double _Complex div_long_double_cc(long double _Complex a, long double _Complex b) { 530 // X86-LABEL: @div_long_double_cc( 531 // X86-NOT: fdiv 532 // X86: call {{.*}} @__divxc3( 533 // X86: ret 534 // PPC-LABEL: @div_long_double_cc( 535 // PPC-NOT: fdiv 536 // PPC: call {{.*}} @__divtc3( 537 // PPC: ret 538 // SPIR: call spir_func {{.*}} @__divdc3( 539 540 // a / b = (A+iB) / (C+iD) = ((AC+BD)/(CC+DD)) + i((BC-AD)/(CC+DD)) 541 // AARCH64-FASTMATH-LABEL: @div_long_double_cc([2 x fp128] noundef %a.coerce, [2 x fp128] noundef %b.coerce) 542 // 543 // AARCH64-FASTMATH: [[AC:%.*]] = fmul fast fp128 544 // AARCH64-FASTMATH: [[BD:%.*]] = fmul fast fp128 545 // AARCH64-FASTMATH: [[ACpBD:%.*]] = fadd fast fp128 546 // 547 // AARCH64-FASTMATH: [[CC:%.*]] = fmul fast fp128 548 // AARCH64-FASTMATH: [[DD:%.*]] = fmul fast fp128 549 // AARCH64-FASTMATH: [[CCpDD:%.*]] = fadd fast fp128 550 // 551 // AARCH64-FASTMATH: [[BC:%.*]] = fmul fast fp128 552 // AARCH64-FASTMATH: [[AD:%.*]] = fmul fast fp128 553 // AARCH64-FASTMATH: [[BCmAD:%.*]] = fsub fast fp128 554 // 555 // AARCH64-FASTMATH: fdiv fast fp128 556 // AARCH64-FASTMATH: fdiv fast fp128 557 // AARCH64-FASTMATH: ret 558 return a / b; 559 } 560 561 // Comparison operators don't rely on library calls or have interseting math 562 // properties, but test that mixed types work correctly here. 563 _Bool eq_float_cr(float _Complex a, float b) { 564 // X86-LABEL: @eq_float_cr( 565 // X86: fcmp oeq 566 // X86: fcmp oeq 567 // X86: and i1 568 // X86: ret 569 return a == b; 570 } 571 _Bool eq_float_rc(float a, float _Complex b) { 572 // X86-LABEL: @eq_float_rc( 573 // X86: fcmp oeq 574 // X86: fcmp oeq 575 // X86: and i1 576 // X86: ret 577 return a == b; 578 } 579 _Bool eq_float_cc(float _Complex a, float _Complex b) { 580 // X86-LABEL: @eq_float_cc( 581 // X86: fcmp oeq 582 // X86: fcmp oeq 583 // X86: and i1 584 // X86: ret 585 return a == b; 586 } 587 _Bool ne_float_cr(float _Complex a, float b) { 588 // X86-LABEL: @ne_float_cr( 589 // X86: fcmp une 590 // X86: fcmp une 591 // X86: or i1 592 // X86: ret 593 return a != b; 594 } 595 _Bool ne_float_rc(float a, float _Complex b) { 596 // X86-LABEL: @ne_float_rc( 597 // X86: fcmp une 598 // X86: fcmp une 599 // X86: or i1 600 // X86: ret 601 return a != b; 602 } 603 _Bool ne_float_cc(float _Complex a, float _Complex b) { 604 // X86-LABEL: @ne_float_cc( 605 // X86: fcmp une 606 // X86: fcmp une 607 // X86: or i1 608 // X86: ret 609 return a != b; 610 } 611 612 // Check that the libcall will obtain proper calling convention on ARM 613 _Complex double foo(_Complex double a, _Complex double b) { 614 // These functions are not defined as floating point helper functions in 615 // Run-time ABI for the ARM architecture document so they must not always 616 // use the base AAPCS. 617 618 // ARM-LABEL: @foo( 619 // ARM: call void @__muldc3 620 621 // SPIR: call spir_func void @__muldc3 622 623 // ARMHF-LABEL: @foo( 624 // ARMHF: call { double, double } @__muldc3 625 626 // ARM7K-LABEL: @foo( 627 // ARM7K: call { double, double } @__muldc3 628 return a*b; 629 } 630