+63









Zahira Ammarguellat
Joseph Huber
Guray Ozen
Nishant Patel
Jessica Clarke
Petr Hosek
Joseph Huber
Craig Topper
Alexander Yermolovich
Usama Hameed
Philip Reames
Evgenii Kudriashov
Fangrui Song
Aart Bik
Valentin Clement
Youngsuk Kim
Arthur Eubanks
Jan Svoboda
Walter Erquinigo
Eric
Fazlay Rabbi
Pete Lawrence
Jonas Devlieghere
Adrian Prantl
Owen Pan
LLVM GN Syncbot
Med Ismail Bennani
Congcong Cai
Rik Huijzer
Wang Pengcheng
Yuanfang Chen
Kazu Hirata
Mehdi Amini
Aiden Grossman
Rana Pratap Reddy
Yingwei Zheng
Piotr Zegar
KAWASHIMA Takahiro
Tobias Hieta
Luke Lau
Shivam Gupta
cor3ntin
Yeting Kuo
Stanislav Mekhanoshin
David Spickett
Matthew Devereau
Martin Storsjö
Qiu Chaofan
Pierre van Houtryve
Mikael Holmen
Uday Bondhugula
Nikita Popov
Johannes Reifferscheid
Benjamin Kramer
Oliver Stannard
Dmitry Vyukov
Benjamin Maxwell
Piotr Sobczak
Simon Pilgrim
Timm Bäder
Sunil Kuravinakop
zhongyunde 00443407
Christudasan Devadasan
bjacob
Weining Lu
Andrzej Warzyński
Jay Foad
Markus Mützel
Erik Jonsson
Pete Steinfeld
Alexey Bataev
Louis Dionne
Qizhi Hu
b40c534656
This patch adds the #pragma CX_LIMITED_RANGE defined in the C specification. It also adds the options -f[no]cx-limited-range and -f[no]cx-fortran-rules. -fcx-limited-range enables algebraic formulas for complex multiplication and division. This option is enabled with -ffast-math. -fcx-fortran-rules enables algebraic formulas for complex multiplication and enables Smith’s algorithm for complex division (SMITH, R. L. Algorithm 116: Complex division. Commun. ACM 5, 8 (1962)). --------- Signed-off-by: Med Ismail Bennani <ismail@bennani.ma> Co-authored-by: Joseph Huber <jhuber6@vols.utk.edu> Co-authored-by: Guray Ozen <guray.ozen@gmail.com> Co-authored-by: Nishant Patel <nishant.b.patel@intel.com> Co-authored-by: Jessica Clarke <jrtc27@jrtc27.com> Co-authored-by: Petr Hosek <phosek@google.com> Co-authored-by: Joseph Huber <35342157+jhuber6@users.noreply.github.com> Co-authored-by: Craig Topper <craig.topper@sifive.com> Co-authored-by: Alexander Yermolovich <43973793+ayermolo@users.noreply.github.com> Co-authored-by: Usama Hameed <u_hameed@apple.com> Co-authored-by: Philip Reames <preames@rivosinc.com> Co-authored-by: Evgenii Kudriashov <evgenii.kudriashov@intel.com> Co-authored-by: Fangrui Song <i@maskray.me> Co-authored-by: Aart Bik <39774503+aartbik@users.noreply.github.com> Co-authored-by: Valentin Clement <clementval@gmail.com> Co-authored-by: Youngsuk Kim <youngsuk.kim@hpe.com> Co-authored-by: Arthur Eubanks <aeubanks@google.com> Co-authored-by: Jan Svoboda <jan_svoboda@apple.com> Co-authored-by: Walter Erquinigo <a20012251@gmail.com> Co-authored-by: Eric <eric@efcs.ca> Co-authored-by: Fazlay Rabbi <106703039+mdfazlay@users.noreply.github.com> Co-authored-by: Pete Lawrence <plawrence@apple.com> Co-authored-by: Jonas Devlieghere <jonas@devlieghere.com> Co-authored-by: Adrian Prantl <aprantl@apple.com> Co-authored-by: Owen Pan <owenpiano@gmail.com> Co-authored-by: LLVM GN Syncbot <llvmgnsyncbot@gmail.com> Co-authored-by: Med Ismail Bennani <ismail@bennani.ma> Co-authored-by: Congcong Cai <congcongcai0907@163.com> Co-authored-by: Rik Huijzer <github@huijzer.xyz> Co-authored-by: Wang Pengcheng <wangpengcheng.pp@bytedance.com> Co-authored-by: Yuanfang Chen <tabloid.adroit@gmail.com> Co-authored-by: Kazu Hirata <kazu@google.com> Co-authored-by: Mehdi Amini <joker.eph@gmail.com> Co-authored-by: Aiden Grossman <agrossman154@yahoo.com> Co-authored-by: Rana Pratap Reddy <109514914+ranapratap55@users.noreply.github.com> Co-authored-by: Yingwei Zheng <dtcxzyw2333@gmail.com> Co-authored-by: Piotr Zegar <me@piotrzegar.pl> Co-authored-by: KAWASHIMA Takahiro <t-kawashima@fujitsu.com> Co-authored-by: Tobias Hieta <tobias@hieta.se> Co-authored-by: Luke Lau <luke@igalia.com> Co-authored-by: Shivam Gupta <shivam98.tkg@gmail.com> Co-authored-by: cor3ntin <corentinjabot@gmail.com> Co-authored-by: Yeting Kuo <46629943+yetingk@users.noreply.github.com> Co-authored-by: Stanislav Mekhanoshin <rampitec@users.noreply.github.com> Co-authored-by: David Spickett <david.spickett@linaro.org> Co-authored-by: Matthew Devereau <matthew.devereau@arm.com> Co-authored-by: Martin Storsjö <martin@martin.st> Co-authored-by: Qiu Chaofan <qiucofan@cn.ibm.com> Co-authored-by: Pierre van Houtryve <pierre.vanhoutryve@amd.com> Co-authored-by: Mikael Holmen <mikael.holmen@ericsson.com> Co-authored-by: Uday Bondhugula <uday@polymagelabs.com> Co-authored-by: Nikita Popov <npopov@redhat.com> Co-authored-by: Johannes Reifferscheid <jreiffers@google.com> Co-authored-by: Benjamin Kramer <benny.kra@googlemail.com> Co-authored-by: Oliver Stannard <oliver.stannard@arm.com> Co-authored-by: Dmitry Vyukov <dvyukov@google.com> Co-authored-by: Benjamin Maxwell <benjamin.maxwell@arm.com> Co-authored-by: Piotr Sobczak <piotr.sobczak@amd.com> Co-authored-by: Simon Pilgrim <llvm-dev@redking.me.uk> Co-authored-by: Timm Bäder <tbaeder@redhat.com> Co-authored-by: Sunil Kuravinakop <koops@hpe.com> Co-authored-by: zhongyunde 00443407 <zhongyunde@huawei.com> Co-authored-by: Christudasan Devadasan <Christudasan.Devadasan@amd.com> Co-authored-by: bjacob <jacob.benoit.1@gmail.com> Co-authored-by: Weining Lu <luweining@loongson.cn> Co-authored-by: Andrzej Warzyński <andrzej.warzynski@arm.com> Co-authored-by: Jay Foad <jay.foad@amd.com> Co-authored-by: Markus Mützel <markus.muetzel@gmx.de> Co-authored-by: Erik Jonsson <erik.j.jonsson@ericsson.com> Co-authored-by: Pete Steinfeld <47540744+psteinfeld@users.noreply.github.com> Co-authored-by: Alexey Bataev <a.bataev@outlook.com> Co-authored-by: Louis Dionne <ldionne.2@gmail.com> Co-authored-by: Qizhi Hu <836744285@qq.com>
908 lines
25 KiB
C
908 lines
25 KiB
C
// RUN: %clang_cc1 %s -O0 -emit-llvm -triple x86_64-unknown-unknown -o - | FileCheck %s --check-prefix=X86
|
|
// RUN: %clang_cc1 %s -O0 -emit-llvm -triple x86_64-pc-win64 -o - | FileCheck %s --check-prefix=X86
|
|
// RUN: %clang_cc1 %s -O0 -emit-llvm -triple i686-unknown-unknown -o - | FileCheck %s --check-prefix=X86
|
|
// RUN: %clang_cc1 %s -O0 -emit-llvm -triple powerpc-unknown-unknown -o - | FileCheck %s --check-prefix=PPC
|
|
// RUN: %clang_cc1 %s -O0 -emit-llvm -triple armv7-none-linux-gnueabi -o - | FileCheck %s --check-prefix=ARM
|
|
// RUN: %clang_cc1 %s -O0 -emit-llvm -triple armv7-none-linux-gnueabihf -o - | FileCheck %s --check-prefix=ARMHF
|
|
// RUN: %clang_cc1 %s -O0 -emit-llvm -triple thumbv7k-apple-watchos2.0 -o - -target-abi aapcs16 | FileCheck %s --check-prefix=ARM7K
|
|
// RUN: %clang_cc1 %s -O0 -emit-llvm -triple aarch64-unknown-unknown -ffast-math -ffp-contract=fast -complex-range=fortran -o - | FileCheck %s --check-prefix=AARCH64-FASTMATH
|
|
// RUN: %clang_cc1 %s -O0 -emit-llvm -triple spir -o - | FileCheck %s --check-prefix=SPIR
|
|
|
|
float _Complex add_float_rr(float a, float b) {
|
|
// X86-LABEL: @add_float_rr(
|
|
// X86: fadd
|
|
// X86-NOT: fadd
|
|
// X86: ret
|
|
return a + b;
|
|
}
|
|
float _Complex add_float_cr(float _Complex a, float b) {
|
|
// X86-LABEL: @add_float_cr(
|
|
// X86: fadd
|
|
// X86-NOT: fadd
|
|
// X86: ret
|
|
return a + b;
|
|
}
|
|
float _Complex add_float_rc(float a, float _Complex b) {
|
|
// X86-LABEL: @add_float_rc(
|
|
// X86: fadd
|
|
// X86-NOT: fadd
|
|
// X86: ret
|
|
return a + b;
|
|
}
|
|
float _Complex add_float_cc(float _Complex a, float _Complex b) {
|
|
// X86-LABEL: @add_float_cc(
|
|
// X86: fadd
|
|
// X86: fadd
|
|
// X86-NOT: fadd
|
|
// X86: ret
|
|
return a + b;
|
|
}
|
|
|
|
float _Complex sub_float_rr(float a, float b) {
|
|
// X86-LABEL: @sub_float_rr(
|
|
// X86: fsub
|
|
// X86-NOT: fsub
|
|
// X86: ret
|
|
return a - b;
|
|
}
|
|
float _Complex sub_float_cr(float _Complex a, float b) {
|
|
// X86-LABEL: @sub_float_cr(
|
|
// X86: fsub
|
|
// X86-NOT: fsub
|
|
// X86: ret
|
|
return a - b;
|
|
}
|
|
float _Complex sub_float_rc(float a, float _Complex b) {
|
|
// X86-LABEL: @sub_float_rc(
|
|
// X86: fsub
|
|
// X86: fneg
|
|
// X86-NOT: fsub
|
|
// X86: ret
|
|
return a - b;
|
|
}
|
|
float _Complex sub_float_cc(float _Complex a, float _Complex b) {
|
|
// X86-LABEL: @sub_float_cc(
|
|
// X86: fsub
|
|
// X86: fsub
|
|
// X86-NOT: fsub
|
|
// X86: ret
|
|
return a - b;
|
|
}
|
|
|
|
float _Complex mul_float_rr(float a, float b) {
|
|
// X86-LABEL: @mul_float_rr(
|
|
// X86: fmul
|
|
// X86-NOT: fmul
|
|
// X86: ret
|
|
return a * b;
|
|
}
|
|
float _Complex mul_float_cr(float _Complex a, float b) {
|
|
// X86-LABEL: @mul_float_cr(
|
|
// X86: fmul
|
|
// X86: fmul
|
|
// X86-NOT: fmul
|
|
// X86: ret
|
|
return a * b;
|
|
}
|
|
float _Complex mul_float_rc(float a, float _Complex b) {
|
|
// X86-LABEL: @mul_float_rc(
|
|
// X86: fmul
|
|
// X86: fmul
|
|
// X86-NOT: fmul
|
|
// X86: ret
|
|
return a * b;
|
|
}
|
|
|
|
float _Complex mul_float_cc(float _Complex a, float _Complex b) {
|
|
// X86-LABEL: @mul_float_cc(
|
|
// X86: %[[AC:[^ ]+]] = fmul
|
|
// X86: %[[BD:[^ ]+]] = fmul
|
|
// X86: %[[AD:[^ ]+]] = fmul
|
|
// X86: %[[BC:[^ ]+]] = fmul
|
|
// X86: %[[RR:[^ ]+]] = fsub
|
|
// X86: %[[RI:[^ ]+]] = fadd
|
|
// X86-DAG: %[[AD]]
|
|
// X86-DAG: ,
|
|
// X86-DAG: %[[BC]]
|
|
// X86: fcmp uno float %[[RR]]
|
|
// X86: fcmp uno float %[[RI]]
|
|
// X86: call {{.*}} @__mulsc3(
|
|
// X86: ret
|
|
// SPIR: call spir_func {{.*}} @__mulsc3(
|
|
return a * b;
|
|
}
|
|
|
|
float _Complex div_float_rr(float a, float b) {
|
|
// X86-LABEL: @div_float_rr(
|
|
// X86: fdiv
|
|
// X86-NOT: fdiv
|
|
// X86: ret
|
|
return a / b;
|
|
}
|
|
float _Complex div_float_cr(float _Complex a, float b) {
|
|
// X86-LABEL: @div_float_cr(
|
|
// X86: fdiv
|
|
// X86: fdiv
|
|
// X86-NOT: fdiv
|
|
// X86: ret
|
|
return a / b;
|
|
}
|
|
float _Complex div_float_rc(float a, float _Complex b) {
|
|
// X86-LABEL: @div_float_rc(
|
|
// X86-NOT: fdiv
|
|
// X86: call {{.*}} @__divsc3(
|
|
// X86: ret
|
|
|
|
// SPIR: call spir_func {{.*}} @__divsc3(
|
|
|
|
// a / b = (A+iB) / (C+iD) = (E+iF)
|
|
// if (|C| >= |D|)
|
|
// DdC = D/C
|
|
// CpRD = C+DdC*D
|
|
// E = (A+B*DdC)/CpRD
|
|
// F = (B-A*DdC)/CpRD
|
|
// else
|
|
// CdD = C/D
|
|
// DpRC= D+CdD*C
|
|
// E = (A*CdD+B)/DpRC
|
|
// F = (B*CdD-A)/DpRC
|
|
// AARCH64-FASTMATH-LABEL: @div_float_rc(float noundef nofpclass(nan inf) %a, [2 x float] noundef nofpclass(nan inf) alignstack(8) %b.coerce)
|
|
// |C|
|
|
// AARCH64-FASTMATH: call {{.*}}float @llvm.fabs.f32(float {{.*}})
|
|
// |D|
|
|
// AARCH64-FASTMATH-NEXT: call {{.*}}float @llvm.fabs.f32(float {{.*}})
|
|
// AARCH64-FASTMATH-NEXT: fcmp {{.*}}ugt float
|
|
// AARCH64-FASTMATH-NEXT: br i1 {{.*}}, label
|
|
// AARCH64-FASTMATH: abs_rhsr_greater_or_equal_abs_rhsi:
|
|
|
|
// |C| >= |D|
|
|
// DdC=D/C
|
|
// AARCH64-FASTMATH-NEXT: fdiv {{.*}}float
|
|
|
|
// CpRD=C+CdC*D
|
|
// AARCH64-FASTMATH-NEXT: fmul {{.*}}float
|
|
// AARCH64-FASTMATH-NEXT: fadd {{.*}}float
|
|
|
|
// A+BR/CpRD
|
|
// AARCH64-FASTMATH-NEXT: fmul {{.*}}float
|
|
// AARCH64-FASTMATH-NEXT: fadd {{.*}}float
|
|
// AARCH64-FASTMATH-NEXT: fdiv {{.*}}float
|
|
|
|
// B-AR/CpRD
|
|
// AARCH64-FASTMATH-NEXT: fmul {{.*}}float
|
|
// AARCH64-FASTMATH-NEXT: fsub {{.*}}float
|
|
// AARCH64-FASTMATH-NEXT: fdiv {{.*}}float
|
|
// AARCH64-FASTMATH-NEXT: br label
|
|
// AARCH64-FASTMATH: abs_rhsr_less_than_abs_rhsi:
|
|
|
|
// |C| < |D|
|
|
// CdD=C/D
|
|
// AARCH64-FASTMATH-NEXT: fdiv {{.*}}float
|
|
|
|
// DpRC=D+CdD*C
|
|
// AARCH64-FASTMATH-NEXT: fmul {{.*}}float
|
|
// AARCH64-FASTMATH-NEXT: fadd {{.*}}float
|
|
|
|
// (A*CdD+B)/DpRC
|
|
// AARCH64-FASTMATH-NEXT: fmul {{.*}}float
|
|
// AARCH64-FASTMATH-NEXT: fadd {{.*}}float
|
|
// AARCH64-FASTMATH-NEXT: fdiv {{.*}}float
|
|
|
|
// (BCdD-A)/DpRC
|
|
// AARCH64-FASTMATH-NEXT: fmul {{.*}}float
|
|
// AARCH64-FASTMATH-NEXT: fsub {{.*}}float
|
|
// AARCH64-FASTMATH-NEXT: fdiv {{.*}}float
|
|
|
|
// AARCH64-FASTMATH-NEXT: br label
|
|
// AARCH64-FASTMATH: complex_div:
|
|
// AARCH64-FASTMATH-NEXT: phi {{.*}}float
|
|
// AARCH64-FASTMATH-NEXT: phi {{.*}}float
|
|
// AARCH64-FASTMATH: ret
|
|
return a / b;
|
|
}
|
|
float _Complex div_float_cc(float _Complex a, float _Complex b) {
|
|
// X86-LABEL: @div_float_cc(
|
|
// X86-NOT: fdiv
|
|
// X86: call {{.*}} @__divsc3(
|
|
// X86: ret
|
|
|
|
// SPIR: call spir_func {{.*}} @__divsc3(
|
|
|
|
// a / b = (A+iB) / (C+iD) = (E+iF)
|
|
// if (|C| >= |D|)
|
|
// DdC = D/C
|
|
// CpRD = C+DdC*D
|
|
// E = (A+B*DdC)/CpRD
|
|
// F = (B-A*DdC)/CpRD
|
|
// else
|
|
// CdD = C/D
|
|
// DpRC= D+CdD*C
|
|
// E = (A*CdD+B)/DpRC
|
|
// F = (B*CdD-A)/DpRC
|
|
// 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)
|
|
// |C|
|
|
// AARCH64-FASTMATH: call {{.*}}float @llvm.fabs.f32(float {{.*}})
|
|
// |D|
|
|
// AARCH64-FASTMATH-NEXT: call {{.*}}float @llvm.fabs.f32(float {{.*}})
|
|
// AARCH64-FASTMATH-NEXT: fcmp {{.*}}ugt float
|
|
// AARCH64-FASTMATH-NEXT: br i1 {{.*}}, label
|
|
// AARCH64-FASTMATH: abs_rhsr_greater_or_equal_abs_rhsi:
|
|
|
|
// |C| >= |D|
|
|
// DdC=D/C
|
|
// AARCH64-FASTMATH-NEXT: fdiv {{.*}}float
|
|
|
|
// CpRD=C+CdC*D
|
|
// AARCH64-FASTMATH-NEXT: fmul {{.*}}float
|
|
// AARCH64-FASTMATH-NEXT: fadd {{.*}}float
|
|
|
|
// A+BR/CpRD
|
|
// AARCH64-FASTMATH-NEXT: fmul {{.*}}float
|
|
// AARCH64-FASTMATH-NEXT: fadd {{.*}}float
|
|
// AARCH64-FASTMATH-NEXT: fdiv {{.*}}float
|
|
|
|
// B-AR/CpRD
|
|
// AARCH64-FASTMATH-NEXT: fmul {{.*}}float
|
|
// AARCH64-FASTMATH-NEXT: fsub {{.*}}float
|
|
// AARCH64-FASTMATH-NEXT: fdiv {{.*}}float
|
|
// AARCH64-FASTMATH-NEXT: br label
|
|
// AARCH64-FASTMATH: abs_rhsr_less_than_abs_rhsi:
|
|
|
|
// |C| < |D|
|
|
// CdD=C/D
|
|
// AARCH64-FASTMATH-NEXT: fdiv {{.*}}float
|
|
|
|
// DpRC=D+CdD*C
|
|
// AARCH64-FASTMATH-NEXT: fmul {{.*}}float
|
|
// AARCH64-FASTMATH-NEXT: fadd {{.*}}float
|
|
|
|
// (A*CdD+B)/DpRC
|
|
// AARCH64-FASTMATH-NEXT: fmul {{.*}}float
|
|
// AARCH64-FASTMATH-NEXT: fadd {{.*}}float
|
|
// AARCH64-FASTMATH-NEXT: fdiv {{.*}}float
|
|
|
|
// (BCdD-A)/DpRC
|
|
// AARCH64-FASTMATH-NEXT: fmul {{.*}}float
|
|
// AARCH64-FASTMATH-NEXT: fsub {{.*}}float
|
|
// AARCH64-FASTMATH-NEXT: fdiv {{.*}}float
|
|
|
|
// AARCH64-FASTMATH-NEXT: br label
|
|
// AARCH64-FASTMATH: complex_div:
|
|
// AARCH64-FASTMATH-NEXT: phi {{.*}}float
|
|
// AARCH64-FASTMATH-NEXT: phi {{.*}}float
|
|
return a / b;
|
|
}
|
|
|
|
double _Complex add_double_rr(double a, double b) {
|
|
// X86-LABEL: @add_double_rr(
|
|
// X86: fadd
|
|
// X86-NOT: fadd
|
|
// X86: ret
|
|
return a + b;
|
|
}
|
|
double _Complex add_double_cr(double _Complex a, double b) {
|
|
// X86-LABEL: @add_double_cr(
|
|
// X86: fadd
|
|
// X86-NOT: fadd
|
|
// X86: ret
|
|
return a + b;
|
|
}
|
|
double _Complex add_double_rc(double a, double _Complex b) {
|
|
// X86-LABEL: @add_double_rc(
|
|
// X86: fadd
|
|
// X86-NOT: fadd
|
|
// X86: ret
|
|
return a + b;
|
|
}
|
|
double _Complex add_double_cc(double _Complex a, double _Complex b) {
|
|
// X86-LABEL: @add_double_cc(
|
|
// X86: fadd
|
|
// X86: fadd
|
|
// X86-NOT: fadd
|
|
// X86: ret
|
|
return a + b;
|
|
}
|
|
|
|
double _Complex sub_double_rr(double a, double b) {
|
|
// X86-LABEL: @sub_double_rr(
|
|
// X86: fsub
|
|
// X86-NOT: fsub
|
|
// X86: ret
|
|
return a - b;
|
|
}
|
|
double _Complex sub_double_cr(double _Complex a, double b) {
|
|
// X86-LABEL: @sub_double_cr(
|
|
// X86: fsub
|
|
// X86-NOT: fsub
|
|
// X86: ret
|
|
return a - b;
|
|
}
|
|
double _Complex sub_double_rc(double a, double _Complex b) {
|
|
// X86-LABEL: @sub_double_rc(
|
|
// X86: fsub
|
|
// X86: fneg
|
|
// X86-NOT: fsub
|
|
// X86: ret
|
|
return a - b;
|
|
}
|
|
double _Complex sub_double_cc(double _Complex a, double _Complex b) {
|
|
// X86-LABEL: @sub_double_cc(
|
|
// X86: fsub
|
|
// X86: fsub
|
|
// X86-NOT: fsub
|
|
// X86: ret
|
|
return a - b;
|
|
}
|
|
|
|
double _Complex mul_double_rr(double a, double b) {
|
|
// X86-LABEL: @mul_double_rr(
|
|
// X86: fmul
|
|
// X86-NOT: fmul
|
|
// X86: ret
|
|
return a * b;
|
|
}
|
|
double _Complex mul_double_cr(double _Complex a, double b) {
|
|
// X86-LABEL: @mul_double_cr(
|
|
// X86: fmul
|
|
// X86: fmul
|
|
// X86-NOT: fmul
|
|
// X86: ret
|
|
return a * b;
|
|
}
|
|
double _Complex mul_double_rc(double a, double _Complex b) {
|
|
// X86-LABEL: @mul_double_rc(
|
|
// X86: fmul
|
|
// X86: fmul
|
|
// X86-NOT: fmul
|
|
// X86: ret
|
|
return a * b;
|
|
}
|
|
double _Complex mul_double_cc(double _Complex a, double _Complex b) {
|
|
// X86-LABEL: @mul_double_cc(
|
|
// X86: %[[AC:[^ ]+]] = fmul
|
|
// X86: %[[BD:[^ ]+]] = fmul
|
|
// X86: %[[AD:[^ ]+]] = fmul
|
|
// X86: %[[BC:[^ ]+]] = fmul
|
|
// X86: %[[RR:[^ ]+]] = fsub double %[[AC]], %[[BD]]
|
|
// X86: %[[RI:[^ ]+]] = fadd double
|
|
// X86-DAG: %[[AD]]
|
|
// X86-DAG: ,
|
|
// X86-DAG: %[[BC]]
|
|
// X86: fcmp uno double %[[RR]]
|
|
// X86: fcmp uno double %[[RI]]
|
|
// X86: call {{.*}} @__muldc3(
|
|
// X86: ret
|
|
|
|
// SPIR: call spir_func {{.*}} @__muldc3(
|
|
return a * b;
|
|
}
|
|
|
|
double _Complex div_double_rr(double a, double b) {
|
|
// X86-LABEL: @div_double_rr(
|
|
// X86: fdiv
|
|
// X86-NOT: fdiv
|
|
// X86: ret
|
|
return a / b;
|
|
}
|
|
double _Complex div_double_cr(double _Complex a, double b) {
|
|
// X86-LABEL: @div_double_cr(
|
|
// X86: fdiv
|
|
// X86: fdiv
|
|
// X86-NOT: fdiv
|
|
// X86: ret
|
|
return a / b;
|
|
}
|
|
double _Complex div_double_rc(double a, double _Complex b) {
|
|
// X86-LABEL: @div_double_rc(
|
|
// X86-NOT: fdiv
|
|
// X86: call {{.*}} @__divdc3(
|
|
// X86: ret
|
|
|
|
// SPIR: call spir_func {{.*}} @__divdc3(
|
|
|
|
// a / b = (A+iB) / (C+iD) = (E+iF)
|
|
// if (|C| >= |D|)
|
|
// DdC = D/C
|
|
// CpRD = C+DdC*D
|
|
// E = (A+B*DdC)/CpRD
|
|
// F = (B-A*DdC)/CpRD
|
|
// else
|
|
// CdD = C/D
|
|
// DpRC= D+CdD*C
|
|
// E = (A*CdD+B)/DpRC
|
|
// F = (B*CdD-A)/DpRC
|
|
// AARCH64-FASTMATH-LABEL: @div_double_rc(double noundef nofpclass(nan inf) %a, [2 x double] noundef nofpclass(nan inf) alignstack(8) %b.coerce)
|
|
// |C|
|
|
// AARCH64-FASTMATH: call {{.*}}double @llvm.fabs.f64(double {{.*}})
|
|
// |D|
|
|
// AARCH64-FASTMATH-NEXT: call {{.*}}double @llvm.fabs.f64(double {{.*}})
|
|
// AARCH64-FASTMATH-NEXT: fcmp {{.*}}ugt double
|
|
// AARCH64-FASTMATH-NEXT: br i1 {{.*}}, label
|
|
// AARCH64-FASTMATH: abs_rhsr_greater_or_equal_abs_rhsi:
|
|
|
|
// |C| >= |D|
|
|
// DdC=D/C
|
|
// AARCH64-FASTMATH-NEXT: fdiv {{.*}}double
|
|
|
|
// CpRD=C+CdC*D
|
|
// AARCH64-FASTMATH-NEXT: fmul {{.*}}double
|
|
// AARCH64-FASTMATH-NEXT: fadd {{.*}}double
|
|
|
|
// A+BR/CpRD
|
|
// AARCH64-FASTMATH-NEXT: fmul {{.*}}double
|
|
// AARCH64-FASTMATH-NEXT: fadd {{.*}}double
|
|
// AARCH64-FASTMATH-NEXT: fdiv {{.*}}double
|
|
|
|
// B-AR/CpRD
|
|
// AARCH64-FASTMATH-NEXT: fmul {{.*}}double
|
|
// AARCH64-FASTMATH-NEXT: fsub {{.*}}double
|
|
// AARCH64-FASTMATH-NEXT: fdiv {{.*}}double
|
|
// AARCH64-FASTMATH-NEXT: br label
|
|
// AARCH64-FASTMATH: abs_rhsr_less_than_abs_rhsi:
|
|
|
|
// |C| < |D|
|
|
// CdD=C/D
|
|
// AARCH64-FASTMATH-NEXT: fdiv {{.*}}double
|
|
|
|
// DpRC=D+CdD*C
|
|
// AARCH64-FASTMATH-NEXT: fmul {{.*}}double
|
|
// AARCH64-FASTMATH-NEXT: fadd {{.*}}double
|
|
|
|
// (A*CdD+B)/DpRC
|
|
// AARCH64-FASTMATH-NEXT: fmul {{.*}}double
|
|
// AARCH64-FASTMATH-NEXT: fadd {{.*}}double
|
|
// AARCH64-FASTMATH-NEXT: fdiv {{.*}}double
|
|
|
|
// (BCdD-A)/DpRC
|
|
// AARCH64-FASTMATH-NEXT: fmul {{.*}}double
|
|
// AARCH64-FASTMATH-NEXT: fsub {{.*}}double
|
|
// AARCH64-FASTMATH-NEXT: fdiv {{.*}}double
|
|
|
|
// AARCH64-FASTMATH-NEXT: br label
|
|
// AARCH64-FASTMATH: complex_div:
|
|
// AARCH64-FASTMATH-NEXT: phi {{.*}}double
|
|
// AARCH64-FASTMATH-NEXT: phi {{.*}}double
|
|
// AARCH64-FASTMATH: ret
|
|
return a / b;
|
|
}
|
|
double _Complex div_double_cc(double _Complex a, double _Complex b) {
|
|
// X86-LABEL: @div_double_cc(
|
|
// X86-NOT: fdiv
|
|
// X86: call {{.*}} @__divdc3(
|
|
// X86: ret
|
|
|
|
// SPIR: call spir_func {{.*}} @__divdc3(
|
|
|
|
// a / b = (A+iB) / (C+iD) = (E+iF)
|
|
// if (|C| >= |D|)
|
|
// DdC = D/C
|
|
// CpRD = C+DdC*D
|
|
// E = (A+B*DdC)/CpRD
|
|
// F = (B-A*DdC)/CpRD
|
|
// else
|
|
// CdD = C/D
|
|
// DpRC= D+CdD*C
|
|
// E = (A*CdD+B)/DpRC
|
|
// F = (B*CdD-A)/DpRC
|
|
// 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)
|
|
// |C|
|
|
// AARCH64-FASTMATH: call {{.*}}double @llvm.fabs.f64(double {{.*}})
|
|
// |D|
|
|
// AARCH64-FASTMATH-NEXT: call {{.*}}double @llvm.fabs.f64(double {{.*}})
|
|
// AARCH64-FASTMATH-NEXT: fcmp {{.*}}ugt double
|
|
// AARCH64-FASTMATH-NEXT: br i1 {{.*}}, label
|
|
// AARCH64-FASTMATH: abs_rhsr_greater_or_equal_abs_rhsi:
|
|
|
|
// |C| >= |D|
|
|
// DdC=D/C
|
|
// AARCH64-FASTMATH-NEXT: fdiv {{.*}}double
|
|
|
|
// CpRD=C+CdC*D
|
|
// AARCH64-FASTMATH-NEXT: fmul {{.*}}double
|
|
// AARCH64-FASTMATH-NEXT: fadd {{.*}}double
|
|
|
|
// A+BR/CpRD
|
|
// AARCH64-FASTMATH-NEXT: fmul {{.*}}double
|
|
// AARCH64-FASTMATH-NEXT: fadd {{.*}}double
|
|
// AARCH64-FASTMATH-NEXT: fdiv {{.*}}double
|
|
|
|
// B-AR/CpRD
|
|
// AARCH64-FASTMATH-NEXT: fmul {{.*}}double
|
|
// AARCH64-FASTMATH-NEXT: fsub {{.*}}double
|
|
// AARCH64-FASTMATH-NEXT: fdiv {{.*}}double
|
|
// AARCH64-FASTMATH-NEXT: br label
|
|
// AARCH64-FASTMATH: abs_rhsr_less_than_abs_rhsi:
|
|
|
|
// |C| < |D|
|
|
// CdD=C/D
|
|
// AARCH64-FASTMATH-NEXT: fdiv {{.*}}double
|
|
|
|
// DpRC=D+CdD*C
|
|
// AARCH64-FASTMATH-NEXT: fmul {{.*}}double
|
|
// AARCH64-FASTMATH-NEXT: fadd {{.*}}double
|
|
|
|
// (A*CdD+B)/DpRC
|
|
// AARCH64-FASTMATH-NEXT: fmul {{.*}}double
|
|
// AARCH64-FASTMATH-NEXT: fadd {{.*}}double
|
|
// AARCH64-FASTMATH-NEXT: fdiv {{.*}}double
|
|
|
|
// (BCdD-A)/DpRC
|
|
// AARCH64-FASTMATH-NEXT: fmul {{.*}}double
|
|
// AARCH64-FASTMATH-NEXT: fsub {{.*}}double
|
|
// AARCH64-FASTMATH-NEXT: fdiv {{.*}}double
|
|
|
|
// AARCH64-FASTMATH-NEXT: br label
|
|
// AARCH64-FASTMATH: complex_div:
|
|
// AARCH64-FASTMATH-NEXT: phi {{.*}}double
|
|
// AARCH64-FASTMATH-NEXT: phi {{.*}}double
|
|
// AARCH64-FASTMATH: ret
|
|
return a / b;
|
|
}
|
|
|
|
long double _Complex add_long_double_rr(long double a, long double b) {
|
|
// X86-LABEL: @add_long_double_rr(
|
|
// X86: fadd
|
|
// X86-NOT: fadd
|
|
// X86: ret
|
|
return a + b;
|
|
}
|
|
long double _Complex add_long_double_cr(long double _Complex a, long double b) {
|
|
// X86-LABEL: @add_long_double_cr(
|
|
// X86: fadd
|
|
// X86-NOT: fadd
|
|
// X86: ret
|
|
return a + b;
|
|
}
|
|
long double _Complex add_long_double_rc(long double a, long double _Complex b) {
|
|
// X86-LABEL: @add_long_double_rc(
|
|
// X86: fadd
|
|
// X86-NOT: fadd
|
|
// X86: ret
|
|
return a + b;
|
|
}
|
|
long double _Complex add_long_double_cc(long double _Complex a, long double _Complex b) {
|
|
// X86-LABEL: @add_long_double_cc(
|
|
// X86: fadd
|
|
// X86: fadd
|
|
// X86-NOT: fadd
|
|
// X86: ret
|
|
return a + b;
|
|
}
|
|
|
|
long double _Complex sub_long_double_rr(long double a, long double b) {
|
|
// X86-LABEL: @sub_long_double_rr(
|
|
// X86: fsub
|
|
// X86-NOT: fsub
|
|
// X86: ret
|
|
return a - b;
|
|
}
|
|
long double _Complex sub_long_double_cr(long double _Complex a, long double b) {
|
|
// X86-LABEL: @sub_long_double_cr(
|
|
// X86: fsub
|
|
// X86-NOT: fsub
|
|
// X86: ret
|
|
return a - b;
|
|
}
|
|
long double _Complex sub_long_double_rc(long double a, long double _Complex b) {
|
|
// X86-LABEL: @sub_long_double_rc(
|
|
// X86: fsub
|
|
// X86: fneg
|
|
// X86-NOT: fsub
|
|
// X86: ret
|
|
return a - b;
|
|
}
|
|
long double _Complex sub_long_double_cc(long double _Complex a, long double _Complex b) {
|
|
// X86-LABEL: @sub_long_double_cc(
|
|
// X86: fsub
|
|
// X86: fsub
|
|
// X86-NOT: fsub
|
|
// X86: ret
|
|
return a - b;
|
|
}
|
|
|
|
long double _Complex mul_long_double_rr(long double a, long double b) {
|
|
// X86-LABEL: @mul_long_double_rr(
|
|
// X86: fmul
|
|
// X86-NOT: fmul
|
|
// X86: ret
|
|
return a * b;
|
|
}
|
|
long double _Complex mul_long_double_cr(long double _Complex a, long double b) {
|
|
// X86-LABEL: @mul_long_double_cr(
|
|
// X86: fmul
|
|
// X86: fmul
|
|
// X86-NOT: fmul
|
|
// X86: ret
|
|
return a * b;
|
|
}
|
|
long double _Complex mul_long_double_rc(long double a, long double _Complex b) {
|
|
// X86-LABEL: @mul_long_double_rc(
|
|
// X86: fmul
|
|
// X86: fmul
|
|
// X86-NOT: fmul
|
|
// X86: ret
|
|
return a * b;
|
|
}
|
|
long double _Complex mul_long_double_cc(long double _Complex a, long double _Complex b) {
|
|
// X86-LABEL: @mul_long_double_cc(
|
|
// X86: %[[AC:[^ ]+]] = fmul
|
|
// X86: %[[BD:[^ ]+]] = fmul
|
|
// X86: %[[AD:[^ ]+]] = fmul
|
|
// X86: %[[BC:[^ ]+]] = fmul
|
|
// X86: %[[RR:[^ ]+]] = fsub x86_fp80 %[[AC]], %[[BD]]
|
|
// X86: %[[RI:[^ ]+]] = fadd x86_fp80
|
|
// X86-DAG: %[[AD]]
|
|
// X86-DAG: ,
|
|
// X86-DAG: %[[BC]]
|
|
// X86: fcmp uno x86_fp80 %[[RR]]
|
|
// X86: fcmp uno x86_fp80 %[[RI]]
|
|
// X86: call {{.*}} @__mulxc3(
|
|
// X86: ret
|
|
// PPC-LABEL: @mul_long_double_cc(
|
|
// PPC: %[[AC:[^ ]+]] = fmul
|
|
// PPC: %[[BD:[^ ]+]] = fmul
|
|
// PPC: %[[AD:[^ ]+]] = fmul
|
|
// PPC: %[[BC:[^ ]+]] = fmul
|
|
// PPC: %[[RR:[^ ]+]] = fsub ppc_fp128 %[[AC]], %[[BD]]
|
|
// PPC: %[[RI:[^ ]+]] = fadd ppc_fp128
|
|
// PPC-DAG: %[[AD]]
|
|
// PPC-DAG: ,
|
|
// PPC-DAG: %[[BC]]
|
|
// PPC: fcmp uno ppc_fp128 %[[RR]]
|
|
// PPC: fcmp uno ppc_fp128 %[[RI]]
|
|
// PPC: call {{.*}} @__multc3(
|
|
// PPC: ret
|
|
// SPIR: call spir_func {{.*}} @__muldc3(
|
|
return a * b;
|
|
}
|
|
|
|
long double _Complex div_long_double_rr(long double a, long double b) {
|
|
// X86-LABEL: @div_long_double_rr(
|
|
// X86: fdiv
|
|
// X86-NOT: fdiv
|
|
// X86: ret
|
|
return a / b;
|
|
}
|
|
long double _Complex div_long_double_cr(long double _Complex a, long double b) {
|
|
// X86-LABEL: @div_long_double_cr(
|
|
// X86: fdiv
|
|
// X86: fdiv
|
|
// X86-NOT: fdiv
|
|
// X86: ret
|
|
return a / b;
|
|
}
|
|
long double _Complex div_long_double_rc(long double a, long double _Complex b) {
|
|
// X86-LABEL: @div_long_double_rc(
|
|
// X86-NOT: fdiv
|
|
// X86: call {{.*}} @__divxc3(
|
|
// X86: ret
|
|
// PPC-LABEL: @div_long_double_rc(
|
|
// PPC-NOT: fdiv
|
|
// PPC: call {{.*}} @__divtc3(
|
|
// PPC: ret
|
|
// SPIR: call spir_func {{.*}} @__divdc3(
|
|
|
|
// a / b = (A+iB) / (C+iD) = (E+iF)
|
|
// if (|C| >= |D|)
|
|
// DdC = D/C
|
|
// CpRD = C+DdC*D
|
|
// E = (A+B*DdC)/CpRD
|
|
// F = (B-A*DdC)/CpRD
|
|
// else
|
|
// CdD = C/D
|
|
// DpRC= D+CdD*C
|
|
// E = (A*CdD+B)/DpRC
|
|
// F = (B*CdD-A)/DpRC
|
|
// AARCH64-FASTMATH-LABEL: @div_long_double_rc(fp128 noundef nofpclass(nan inf) %a, [2 x fp128] noundef nofpclass(nan inf) alignstack(16) %b.coerce)
|
|
// |C|
|
|
// AARCH64-FASTMATH: call {{.*}}fp128 @llvm.fabs.f128(fp128 {{.*}})
|
|
// |D|
|
|
// AARCH64-FASTMATH-NEXT: call {{.*}}fp128 @llvm.fabs.f128(fp128 {{.*}})
|
|
// AARCH64-FASTMATH-NEXT: fcmp {{.*}}ugt fp128
|
|
// AARCH64-FASTMATH-NEXT: br i1 {{.*}}, label
|
|
// AARCH64-FASTMATH: abs_rhsr_greater_or_equal_abs_rhsi:
|
|
|
|
// |C| >= |D|
|
|
// DdC=D/C
|
|
// AARCH64-FASTMATH-NEXT: fdiv {{.*}}fp128
|
|
|
|
// CpRD=C+CdC*D
|
|
// AARCH64-FASTMATH-NEXT: fmul {{.*}}fp128
|
|
// AARCH64-FASTMATH-NEXT: fadd {{.*}}fp128
|
|
|
|
// A+BR/CpRD
|
|
// AARCH64-FASTMATH-NEXT: fmul {{.*}}fp128
|
|
// AARCH64-FASTMATH-NEXT: fadd {{.*}}fp128
|
|
// AARCH64-FASTMATH-NEXT: fdiv {{.*}}fp128
|
|
|
|
// B-AR/CpRD
|
|
// AARCH64-FASTMATH-NEXT: fmul {{.*}}fp128
|
|
// AARCH64-FASTMATH-NEXT: fsub {{.*}}fp128
|
|
// AARCH64-FASTMATH-NEXT: fdiv {{.*}}fp128
|
|
// AARCH64-FASTMATH-NEXT: br label
|
|
// AARCH64-FASTMATH: abs_rhsr_less_than_abs_rhsi:
|
|
|
|
// |C| < |D|
|
|
// CdD=C/D
|
|
// AARCH64-FASTMATH-NEXT: fdiv {{.*}}fp128
|
|
|
|
// DpRC=D+CdD*C
|
|
// AARCH64-FASTMATH-NEXT: fmul {{.*}}fp128
|
|
// AARCH64-FASTMATH-NEXT: fadd {{.*}}fp128
|
|
|
|
// (A*CdD+B)/DpRC
|
|
// AARCH64-FASTMATH-NEXT: fmul {{.*}}fp128
|
|
// AARCH64-FASTMATH-NEXT: fadd {{.*}}fp128
|
|
// AARCH64-FASTMATH-NEXT: fdiv {{.*}}fp128
|
|
|
|
// (BCdD-A)/DpRC
|
|
// AARCH64-FASTMATH-NEXT: fmul {{.*}}fp128
|
|
// AARCH64-FASTMATH-NEXT: fsub {{.*}}fp128
|
|
// AARCH64-FASTMATH-NEXT: fdiv {{.*}}fp128
|
|
|
|
// AARCH64-FASTMATH-NEXT: br label
|
|
// AARCH64-FASTMATH: complex_div:
|
|
// AARCH64-FASTMATH-NEXT: phi {{.*}}fp128
|
|
// AARCH64-FASTMATH-NEXT: phi {{.*}}fp128
|
|
// AARCH64-FASTMATH: ret
|
|
return a / b;
|
|
}
|
|
long double _Complex div_long_double_cc(long double _Complex a, long double _Complex b) {
|
|
// X86-LABEL: @div_long_double_cc(
|
|
// X86-NOT: fdiv
|
|
// X86: call {{.*}} @__divxc3(
|
|
// X86: ret
|
|
// PPC-LABEL: @div_long_double_cc(
|
|
// PPC-NOT: fdiv
|
|
// PPC: call {{.*}} @__divtc3(
|
|
// PPC: ret
|
|
// SPIR: call spir_func {{.*}} @__divdc3(
|
|
|
|
// a / b = (A+iB) / (C+iD) = (E+iF)
|
|
// if (|C| >= |D|)
|
|
// DdC = D/C
|
|
// CpRD = C+DdC*D
|
|
// E = (A+B*DdC)/CpRD
|
|
// F = (B-A*DdC)/CpRD
|
|
// else
|
|
// CdD = C/D
|
|
// DpRC= D+CdD*C
|
|
// E = (A*CdD+B)/DpRC
|
|
// F = (B*CdD-A)/DpRC
|
|
// 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)
|
|
// |C|
|
|
// AARCH64-FASTMATH: call {{.*}}fp128 @llvm.fabs.f128(fp128 {{.*}})
|
|
// |D|
|
|
// AARCH64-FASTMATH-NEXT: call {{.*}}fp128 @llvm.fabs.f128(fp128 {{.*}})
|
|
// AARCH64-FASTMATH-NEXT: fcmp {{.*}}ugt fp128
|
|
// AARCH64-FASTMATH-NEXT: br i1 {{.*}}, label
|
|
// AARCH64-FASTMATH: abs_rhsr_greater_or_equal_abs_rhsi:
|
|
|
|
// |C| >= |D|
|
|
// DdC=D/C
|
|
// AARCH64-FASTMATH-NEXT: fdiv {{.*}}fp128
|
|
|
|
// CpRD=C+CdC*D
|
|
// AARCH64-FASTMATH-NEXT: fmul {{.*}}fp128
|
|
// AARCH64-FASTMATH-NEXT: fadd {{.*}}fp128
|
|
|
|
// A+BR/CpRD
|
|
// AARCH64-FASTMATH-NEXT: fmul {{.*}}fp128
|
|
// AARCH64-FASTMATH-NEXT: fadd {{.*}}fp128
|
|
// AARCH64-FASTMATH-NEXT: fdiv {{.*}}fp128
|
|
|
|
// B-AR/CpRD
|
|
// AARCH64-FASTMATH-NEXT: fmul {{.*}}fp128
|
|
// AARCH64-FASTMATH-NEXT: fsub {{.*}}fp128
|
|
// AARCH64-FASTMATH-NEXT: fdiv {{.*}}fp128
|
|
// AARCH64-FASTMATH-NEXT: br label
|
|
// AARCH64-FASTMATH: abs_rhsr_less_than_abs_rhsi:
|
|
|
|
// |C| < |D|
|
|
// CdD=C/D
|
|
// AARCH64-FASTMATH-NEXT: fdiv {{.*}}fp128
|
|
|
|
// DpRC=D+CdD*C
|
|
// AARCH64-FASTMATH-NEXT: fmul {{.*}}fp128
|
|
// AARCH64-FASTMATH-NEXT: fadd {{.*}}fp128
|
|
|
|
// (A*CdD+B)/DpRC
|
|
// AARCH64-FASTMATH-NEXT: fmul {{.*}}fp128
|
|
// AARCH64-FASTMATH-NEXT: fadd {{.*}}fp128
|
|
// AARCH64-FASTMATH-NEXT: fdiv {{.*}}fp128
|
|
|
|
// (BCdD-A)/DpRC
|
|
// AARCH64-FASTMATH-NEXT: fmul {{.*}}fp128
|
|
// AARCH64-FASTMATH-NEXT: fsub {{.*}}fp128
|
|
// AARCH64-FASTMATH-NEXT: fdiv {{.*}}fp128
|
|
|
|
// AARCH64-FASTMATH-NEXT: br label
|
|
// AARCH64-FASTMATH: complex_div:
|
|
// AARCH64-FASTMATH-NEXT: phi {{.*}}fp128
|
|
// AARCH64-FASTMATH-NEXT: phi {{.*}}fp128
|
|
// AARCH64-FASTMATH: ret
|
|
return a / b;
|
|
}
|
|
|
|
// Comparison operators don't rely on library calls or have interseting math
|
|
// properties, but test that mixed types work correctly here.
|
|
_Bool eq_float_cr(float _Complex a, float b) {
|
|
// X86-LABEL: @eq_float_cr(
|
|
// X86: fcmp oeq
|
|
// X86: fcmp oeq
|
|
// X86: and i1
|
|
// X86: ret
|
|
return a == b;
|
|
}
|
|
_Bool eq_float_rc(float a, float _Complex b) {
|
|
// X86-LABEL: @eq_float_rc(
|
|
// X86: fcmp oeq
|
|
// X86: fcmp oeq
|
|
// X86: and i1
|
|
// X86: ret
|
|
return a == b;
|
|
}
|
|
_Bool eq_float_cc(float _Complex a, float _Complex b) {
|
|
// X86-LABEL: @eq_float_cc(
|
|
// X86: fcmp oeq
|
|
// X86: fcmp oeq
|
|
// X86: and i1
|
|
// X86: ret
|
|
return a == b;
|
|
}
|
|
_Bool ne_float_cr(float _Complex a, float b) {
|
|
// X86-LABEL: @ne_float_cr(
|
|
// X86: fcmp une
|
|
// X86: fcmp une
|
|
// X86: or i1
|
|
// X86: ret
|
|
return a != b;
|
|
}
|
|
_Bool ne_float_rc(float a, float _Complex b) {
|
|
// X86-LABEL: @ne_float_rc(
|
|
// X86: fcmp une
|
|
// X86: fcmp une
|
|
// X86: or i1
|
|
// X86: ret
|
|
return a != b;
|
|
}
|
|
_Bool ne_float_cc(float _Complex a, float _Complex b) {
|
|
// X86-LABEL: @ne_float_cc(
|
|
// X86: fcmp une
|
|
// X86: fcmp une
|
|
// X86: or i1
|
|
// X86: ret
|
|
return a != b;
|
|
}
|
|
|
|
// Check that the libcall will obtain proper calling convention on ARM
|
|
_Complex double foo(_Complex double a, _Complex double b) {
|
|
// These functions are not defined as floating point helper functions in
|
|
// Run-time ABI for the ARM architecture document so they must not always
|
|
// use the base AAPCS.
|
|
|
|
// ARM-LABEL: @foo(
|
|
// ARM: call void @__muldc3
|
|
|
|
// SPIR: call spir_func void @__muldc3
|
|
|
|
// ARMHF-LABEL: @foo(
|
|
// ARMHF: call { double, double } @__muldc3
|
|
|
|
// ARM7K-LABEL: @foo(
|
|
// ARM7K: call { double, double } @__muldc3
|
|
return a*b;
|
|
}
|
|
|
|
typedef _Complex double ComplexDouble;
|
|
typedef double Double;
|
|
|
|
float _Complex double_cr_sugar(ComplexDouble a, Double b) {
|
|
// X86-LABEL: @double_cr_sugar(
|
|
// X86: fmul
|
|
// X86: fmul
|
|
// X86-NOT: fmul
|
|
// X86: ret
|
|
return a *= b;
|
|
}
|