clang/test/CodeGen/complex-math.c

   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 nofpclass(nan inf) %a, [2 x float] noundef nofpclass(nan inf) alignstack(8) %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 nofpclass(nan inf) alignstack(8) %a.coerce, [2 x float] noundef nofpclass(nan inf) alignstack(8) %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 nofpclass(nan inf) %a, [2 x double] noundef nofpclass(nan inf) alignstack(8) %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 nofpclass(nan inf) alignstack(8) %a.coerce, [2 x double] noundef nofpclass(nan inf) alignstack(8) %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 nofpclass(nan inf) %a, [2 x fp128] noundef nofpclass(nan inf) alignstack(16) %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 nofpclass(nan inf) alignstack(16) %a.coerce, [2 x fp128] noundef nofpclass(nan inf) alignstack(16) %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
 631 typedef _Complex double ComplexDouble;
 632 typedef double Double;
 633
 634 float _Complex double_cr_sugar(ComplexDouble a, Double b) {
 635   // X86-LABEL: @double_cr_sugar(
 636   // X86: fmul
 637   // X86: fmul
 638   // X86-NOT: fmul
 639   // X86: ret
 640   return a *= b;
 641 }