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