1 // FIXME: This file should not be using -O1; that makes it depend on the entire LLVM IR optimizer. 2 3 // RUN: %clang_cc1 %s -O1 -fno-experimental-new-pass-manager -emit-llvm -triple x86_64-unknown-unknown -o - | FileCheck %s --check-prefix=X86 4 // RUN: %clang_cc1 %s -O1 -fno-experimental-new-pass-manager -emit-llvm -triple x86_64-pc-win64 -o - | FileCheck %s --check-prefix=X86 5 // RUN: %clang_cc1 %s -O1 -fno-experimental-new-pass-manager -emit-llvm -triple i686-unknown-unknown -o - | FileCheck %s --check-prefix=X86 6 // RUN: %clang_cc1 %s -O1 -fno-experimental-new-pass-manager -emit-llvm -triple powerpc-unknown-unknown -o - | FileCheck %s --check-prefix=PPC 7 // RUN: %clang_cc1 %s -O1 -fno-experimental-new-pass-manager -emit-llvm -triple armv7-none-linux-gnueabi -o - | FileCheck %s --check-prefix=ARM 8 // RUN: %clang_cc1 %s -O1 -fno-experimental-new-pass-manager -emit-llvm -triple armv7-none-linux-gnueabihf -o - | FileCheck %s --check-prefix=ARMHF 9 // 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 10 // 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 11 12 float _Complex add_float_rr(float a, float b) { 13 // X86-LABEL: @add_float_rr( 14 // X86: fadd 15 // X86-NOT: fadd 16 // X86: ret 17 return a + b; 18 } 19 float _Complex add_float_cr(float _Complex a, float b) { 20 // X86-LABEL: @add_float_cr( 21 // X86: fadd 22 // X86-NOT: fadd 23 // X86: ret 24 return a + b; 25 } 26 float _Complex add_float_rc(float a, float _Complex b) { 27 // X86-LABEL: @add_float_rc( 28 // X86: fadd 29 // X86-NOT: fadd 30 // X86: ret 31 return a + b; 32 } 33 float _Complex add_float_cc(float _Complex a, float _Complex b) { 34 // X86-LABEL: @add_float_cc( 35 // X86: fadd 36 // X86: fadd 37 // X86-NOT: fadd 38 // X86: ret 39 return a + b; 40 } 41 42 float _Complex sub_float_rr(float a, float b) { 43 // X86-LABEL: @sub_float_rr( 44 // X86: fsub 45 // X86-NOT: fsub 46 // X86: ret 47 return a - b; 48 } 49 float _Complex sub_float_cr(float _Complex a, float b) { 50 // X86-LABEL: @sub_float_cr( 51 // X86: fsub 52 // X86-NOT: fsub 53 // X86: ret 54 return a - b; 55 } 56 float _Complex sub_float_rc(float a, float _Complex b) { 57 // X86-LABEL: @sub_float_rc( 58 // X86: fsub 59 // X86: fsub float -0.{{0+}}e+00, 60 // X86-NOT: fsub 61 // X86: ret 62 return a - b; 63 } 64 float _Complex sub_float_cc(float _Complex a, float _Complex b) { 65 // X86-LABEL: @sub_float_cc( 66 // X86: fsub 67 // X86: fsub 68 // X86-NOT: fsub 69 // X86: ret 70 return a - b; 71 } 72 73 float _Complex mul_float_rr(float a, float b) { 74 // X86-LABEL: @mul_float_rr( 75 // X86: fmul 76 // X86-NOT: fmul 77 // X86: ret 78 return a * b; 79 } 80 float _Complex mul_float_cr(float _Complex a, float b) { 81 // X86-LABEL: @mul_float_cr( 82 // X86: fmul 83 // X86: fmul 84 // X86-NOT: fmul 85 // X86: ret 86 return a * b; 87 } 88 float _Complex mul_float_rc(float a, float _Complex b) { 89 // X86-LABEL: @mul_float_rc( 90 // X86: fmul 91 // X86: fmul 92 // X86-NOT: fmul 93 // X86: ret 94 return a * b; 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 float %[[AC]], %[[BD]] 103 // X86: %[[RI:[^ ]+]] = fadd float 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 return a * b; 112 } 113 114 float _Complex div_float_rr(float a, float b) { 115 // X86-LABEL: @div_float_rr( 116 // X86: fdiv 117 // X86-NOT: fdiv 118 // X86: ret 119 return a / b; 120 } 121 float _Complex div_float_cr(float _Complex a, float b) { 122 // X86-LABEL: @div_float_cr( 123 // X86: fdiv 124 // X86: fdiv 125 // X86-NOT: fdiv 126 // X86: ret 127 return a / b; 128 } 129 float _Complex div_float_rc(float a, float _Complex b) { 130 // X86-LABEL: @div_float_rc( 131 // X86-NOT: fdiv 132 // X86: call {{.*}} @__divsc3( 133 // X86: ret 134 135 // a / b = (A+iB) / (C+iD) = ((AC+BD)/(CC+DD)) + i((BC-AD)/(CC+DD)) 136 // AARCH64-FASTMATH-LABEL: @div_float_rc(float %a, [2 x float] %b.coerce) 137 // A = a 138 // B = 0 139 // AARCH64-FASTMATH: [[C:%.*]] = extractvalue [2 x float] %b.coerce, 0 140 // AARCH64-FASTMATH: [[D:%.*]] = extractvalue [2 x float] %b.coerce, 1 141 // 142 // AARCH64-FASTMATH: [[AC:%.*]] = fmul fast float [[C]], %a 143 // BD = 0 144 // ACpBD = AC 145 // 146 // AARCH64-FASTMATH: [[CC:%.*]] = fmul fast float [[C]], [[C]] 147 // AARCH64-FASTMATH: [[DD:%.*]] = fmul fast float [[D]], [[D]] 148 // AARCH64-FASTMATH: [[CCpDD:%.*]] = fadd fast float [[CC]], [[DD]] 149 // 150 // BC = 0 151 // AARCH64-FASTMATH: [[AD:%.*]] = fmul fast float [[D]], %a 152 // AARCH64-FASTMATH: [[BCmAD:%.*]] = fdiv fast float [[AC]], [[CCpDD]] 153 // AARCH64-FASTMATH: [[DIV:%.*]] = fdiv fast float [[AD]], [[CCpDD]] 154 // AARCH64-FASTMATH: fsub fast float -0.000000e+00, [[DIV]] 155 // AARCH64-FASTMATH: ret 156 return a / b; 157 } 158 float _Complex div_float_cc(float _Complex a, float _Complex b) { 159 // X86-LABEL: @div_float_cc( 160 // X86-NOT: fdiv 161 // X86: call {{.*}} @__divsc3( 162 // X86: ret 163 164 // a / b = (A+iB) / (C+iD) = ((AC+BD)/(CC+DD)) + i((BC-AD)/(CC+DD)) 165 // AARCH64-FASTMATH-LABEL: @div_float_cc([2 x float] %a.coerce, [2 x float] %b.coerce) 166 // AARCH64-FASTMATH: [[A:%.*]] = extractvalue [2 x float] %a.coerce, 0 167 // AARCH64-FASTMATH: [[B:%.*]] = extractvalue [2 x float] %a.coerce, 1 168 // AARCH64-FASTMATH: [[C:%.*]] = extractvalue [2 x float] %b.coerce, 0 169 // AARCH64-FASTMATH: [[D:%.*]] = extractvalue [2 x float] %b.coerce, 1 170 // 171 // AARCH64-FASTMATH: [[AC:%.*]] = fmul fast float [[C]], [[A]] 172 // AARCH64-FASTMATH: [[BD:%.*]] = fmul fast float [[D]], [[B]] 173 // AARCH64-FASTMATH: [[ACpBD:%.*]] = fadd fast float [[AC]], [[BD]] 174 // 175 // AARCH64-FASTMATH: [[CC:%.*]] = fmul fast float [[C]], [[C]] 176 // AARCH64-FASTMATH: [[DD:%.*]] = fmul fast float [[D]], [[D]] 177 // AARCH64-FASTMATH: [[CCpDD:%.*]] = fadd fast float [[CC]], [[DD]] 178 // 179 // AARCH64-FASTMATH: [[BC:%.*]] = fmul fast float [[C]], [[B]] 180 // AARCH64-FASTMATH: [[AD:%.*]] = fmul fast float [[D]], [[A]] 181 // AARCH64-FASTMATH: [[BCmAD:%.*]] = fsub fast float [[BC]], [[AD]] 182 // 183 // AARCH64-FASTMATH: fdiv fast float [[ACpBD]], [[CCpDD]] 184 // AARCH64-FASTMATH: fdiv fast float [[BCmAD]], [[CCpDD]] 185 // AARCH64-FASTMATH: ret 186 return a / b; 187 } 188 189 double _Complex add_double_rr(double a, double b) { 190 // X86-LABEL: @add_double_rr( 191 // X86: fadd 192 // X86-NOT: fadd 193 // X86: ret 194 return a + b; 195 } 196 double _Complex add_double_cr(double _Complex a, double b) { 197 // X86-LABEL: @add_double_cr( 198 // X86: fadd 199 // X86-NOT: fadd 200 // X86: ret 201 return a + b; 202 } 203 double _Complex add_double_rc(double a, double _Complex b) { 204 // X86-LABEL: @add_double_rc( 205 // X86: fadd 206 // X86-NOT: fadd 207 // X86: ret 208 return a + b; 209 } 210 double _Complex add_double_cc(double _Complex a, double _Complex b) { 211 // X86-LABEL: @add_double_cc( 212 // X86: fadd 213 // X86: fadd 214 // X86-NOT: fadd 215 // X86: ret 216 return a + b; 217 } 218 219 double _Complex sub_double_rr(double a, double b) { 220 // X86-LABEL: @sub_double_rr( 221 // X86: fsub 222 // X86-NOT: fsub 223 // X86: ret 224 return a - b; 225 } 226 double _Complex sub_double_cr(double _Complex a, double b) { 227 // X86-LABEL: @sub_double_cr( 228 // X86: fsub 229 // X86-NOT: fsub 230 // X86: ret 231 return a - b; 232 } 233 double _Complex sub_double_rc(double a, double _Complex b) { 234 // X86-LABEL: @sub_double_rc( 235 // X86: fsub 236 // X86: fsub double -0.{{0+}}e+00, 237 // X86-NOT: fsub 238 // X86: ret 239 return a - b; 240 } 241 double _Complex sub_double_cc(double _Complex a, double _Complex b) { 242 // X86-LABEL: @sub_double_cc( 243 // X86: fsub 244 // X86: fsub 245 // X86-NOT: fsub 246 // X86: ret 247 return a - b; 248 } 249 250 double _Complex mul_double_rr(double a, double b) { 251 // X86-LABEL: @mul_double_rr( 252 // X86: fmul 253 // X86-NOT: fmul 254 // X86: ret 255 return a * b; 256 } 257 double _Complex mul_double_cr(double _Complex a, double b) { 258 // X86-LABEL: @mul_double_cr( 259 // X86: fmul 260 // X86: fmul 261 // X86-NOT: fmul 262 // X86: ret 263 return a * b; 264 } 265 double _Complex mul_double_rc(double a, double _Complex b) { 266 // X86-LABEL: @mul_double_rc( 267 // X86: fmul 268 // X86: fmul 269 // X86-NOT: fmul 270 // X86: ret 271 return a * b; 272 } 273 double _Complex mul_double_cc(double _Complex a, double _Complex b) { 274 // X86-LABEL: @mul_double_cc( 275 // X86: %[[AC:[^ ]+]] = fmul 276 // X86: %[[BD:[^ ]+]] = fmul 277 // X86: %[[AD:[^ ]+]] = fmul 278 // X86: %[[BC:[^ ]+]] = fmul 279 // X86: %[[RR:[^ ]+]] = fsub double %[[AC]], %[[BD]] 280 // X86: %[[RI:[^ ]+]] = fadd double 281 // X86-DAG: %[[AD]] 282 // X86-DAG: , 283 // X86-DAG: %[[BC]] 284 // X86: fcmp uno double %[[RR]] 285 // X86: fcmp uno double %[[RI]] 286 // X86: call {{.*}} @__muldc3( 287 // X86: ret 288 return a * b; 289 } 290 291 double _Complex div_double_rr(double a, double b) { 292 // X86-LABEL: @div_double_rr( 293 // X86: fdiv 294 // X86-NOT: fdiv 295 // X86: ret 296 return a / b; 297 } 298 double _Complex div_double_cr(double _Complex a, double b) { 299 // X86-LABEL: @div_double_cr( 300 // X86: fdiv 301 // X86: fdiv 302 // X86-NOT: fdiv 303 // X86: ret 304 return a / b; 305 } 306 double _Complex div_double_rc(double a, double _Complex b) { 307 // X86-LABEL: @div_double_rc( 308 // X86-NOT: fdiv 309 // X86: call {{.*}} @__divdc3( 310 // X86: ret 311 312 // a / b = (A+iB) / (C+iD) = ((AC+BD)/(CC+DD)) + i((BC-AD)/(CC+DD)) 313 // AARCH64-FASTMATH-LABEL: @div_double_rc(double %a, [2 x double] %b.coerce) 314 // A = a 315 // B = 0 316 // AARCH64-FASTMATH: [[C:%.*]] = extractvalue [2 x double] %b.coerce, 0 317 // AARCH64-FASTMATH: [[D:%.*]] = extractvalue [2 x double] %b.coerce, 1 318 // 319 // AARCH64-FASTMATH: [[AC:%.*]] = fmul fast double [[C]], %a 320 // BD = 0 321 // ACpBD = AC 322 // 323 // AARCH64-FASTMATH: [[CC:%.*]] = fmul fast double [[C]], [[C]] 324 // AARCH64-FASTMATH: [[DD:%.*]] = fmul fast double [[D]], [[D]] 325 // AARCH64-FASTMATH: [[CCpDD:%.*]] = fadd fast double [[CC]], [[DD]] 326 // 327 // BC = 0 328 // AARCH64-FASTMATH: [[AD:%.*]] = fmul fast double [[D]], %a 329 // AARCH64-FASTMATH: [[BCmAD:%.*]] = fdiv fast double [[AC]], [[CCpDD]] 330 // AARCH64-FASTMATH: [[DIV:%.*]] = fdiv fast double [[AD]], [[CCpDD]] 331 // AARCH64-FASTMATH: fsub fast double -0.000000e+00, [[DIV]] 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:%.*]] = fdiv fast fp128 [[AC]], [[CCpDD]] 525 // AARCH64-FASTMATH: [[DIV:%.*]] = fdiv fast fp128 [[AD]], [[CCpDD]] 526 // AARCH64-FASTMATH: fsub fast fp128 0xL00000000000000008000000000000000, [[DIV]] 527 // AARCH64-FASTMATH: ret 528 return a / b; 529 } 530 long double _Complex div_long_double_cc(long double _Complex a, long double _Complex b) { 531 // X86-LABEL: @div_long_double_cc( 532 // X86-NOT: fdiv 533 // X86: call {{.*}} @__divxc3( 534 // X86: ret 535 // PPC-LABEL: @div_long_double_cc( 536 // PPC-NOT: fdiv 537 // PPC: call {{.*}} @__divtc3( 538 // PPC: ret 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] %a.coerce, [2 x fp128] %b.coerce) 542 // AARCH64-FASTMATH: [[A:%.*]] = extractvalue [2 x fp128] %a.coerce, 0 543 // AARCH64-FASTMATH: [[B:%.*]] = extractvalue [2 x fp128] %a.coerce, 1 544 // AARCH64-FASTMATH: [[C:%.*]] = extractvalue [2 x fp128] %b.coerce, 0 545 // AARCH64-FASTMATH: [[D:%.*]] = extractvalue [2 x fp128] %b.coerce, 1 546 // 547 // AARCH64-FASTMATH: [[AC:%.*]] = fmul fast fp128 [[C]], [[A]] 548 // AARCH64-FASTMATH: [[BD:%.*]] = fmul fast fp128 [[D]], [[B]] 549 // AARCH64-FASTMATH: [[ACpBD:%.*]] = fadd fast fp128 [[AC]], [[BD]] 550 // 551 // AARCH64-FASTMATH: [[CC:%.*]] = fmul fast fp128 [[C]], [[C]] 552 // AARCH64-FASTMATH: [[DD:%.*]] = fmul fast fp128 [[D]], [[D]] 553 // AARCH64-FASTMATH: [[CCpDD:%.*]] = fadd fast fp128 [[CC]], [[DD]] 554 // 555 // AARCH64-FASTMATH: [[BC:%.*]] = fmul fast fp128 [[C]], [[B]] 556 // AARCH64-FASTMATH: [[AD:%.*]] = fmul fast fp128 [[D]], [[A]] 557 // AARCH64-FASTMATH: [[BCmAD:%.*]] = fsub fast fp128 [[BC]], [[AD]] 558 // 559 // AARCH64-FASTMATH: fdiv fast fp128 [[ACpBD]], [[CCpDD]] 560 // AARCH64-FASTMATH: fdiv fast fp128 [[BCmAD]], [[CCpDD]] 561 // AARCH64-FASTMATH: ret 562 return a / b; 563 } 564 565 // Comparison operators don't rely on library calls or have interseting math 566 // properties, but test that mixed types work correctly here. 567 _Bool eq_float_cr(float _Complex a, float b) { 568 // X86-LABEL: @eq_float_cr( 569 // X86: fcmp oeq 570 // X86: fcmp oeq 571 // X86: and i1 572 // X86: ret 573 return a == b; 574 } 575 _Bool eq_float_rc(float a, float _Complex b) { 576 // X86-LABEL: @eq_float_rc( 577 // X86: fcmp oeq 578 // X86: fcmp oeq 579 // X86: and i1 580 // X86: ret 581 return a == b; 582 } 583 _Bool eq_float_cc(float _Complex a, float _Complex b) { 584 // X86-LABEL: @eq_float_cc( 585 // X86: fcmp oeq 586 // X86: fcmp oeq 587 // X86: and i1 588 // X86: ret 589 return a == b; 590 } 591 _Bool ne_float_cr(float _Complex a, float b) { 592 // X86-LABEL: @ne_float_cr( 593 // X86: fcmp une 594 // X86: fcmp une 595 // X86: or i1 596 // X86: ret 597 return a != b; 598 } 599 _Bool ne_float_rc(float a, float _Complex b) { 600 // X86-LABEL: @ne_float_rc( 601 // X86: fcmp une 602 // X86: fcmp une 603 // X86: or i1 604 // X86: ret 605 return a != b; 606 } 607 _Bool ne_float_cc(float _Complex a, float _Complex b) { 608 // X86-LABEL: @ne_float_cc( 609 // X86: fcmp une 610 // X86: fcmp une 611 // X86: or i1 612 // X86: ret 613 return a != b; 614 } 615 616 // Check that the libcall will obtain proper calling convention on ARM 617 _Complex double foo(_Complex double a, _Complex double b) { 618 // These functions are not defined as floating point helper functions in 619 // Run-time ABI for the ARM architecture document so they must not always 620 // use the base AAPCS. 621 622 // ARM-LABEL: @foo( 623 // ARM: call void @__muldc3 624 625 // ARMHF-LABEL: @foo( 626 // ARMHF: call { double, double } @__muldc3 627 628 // ARM7K-LABEL: @foo( 629 // ARM7K: call { double, double } @__muldc3 630 return a*b; 631 } 632