From 6ee874f1353933b1427b5e2953358eb3424090d5 Mon Sep 17 00:00:00 2001 From: Iain Buclaw <ibuclaw@gdcproject.org> Date: Tue, 14 Jul 2020 18:45:42 +0200 Subject: d: Refactor matching and lowering of intrinsic functions. Intrinsics are now matched explicitly, rather than through a common alias where there are multiple overrides for a common intrinsic. Where there is a corresponding DECL_FUNCTION_CODE, that is now stored in the D intrinsic array. All run-time std.math intrinsics have been removed, as the library implementation already forwards to core.math. gcc/d/ChangeLog: * d-tree.h (DEF_D_INTRINSIC): Rename second argument from A to B. * intrinsics.cc (intrinsic_decl): Add built_in field. (DEF_D_INTRINSIC): Rename second argument from ALIAS to BUILTIN. (maybe_set_intrinsic): Handle new intrinsic codes. (expand_intrinsic_bt): Likewise. (expand_intrinsic_checkedint): Likewise. (expand_intrinsic_bswap): Remove. (expand_intrinsic_sqrt): Remove. (maybe_expand_intrinsic): Group together intrinsic cases that map directly to gcc built-ins. * intrinsics.def (DEF_D_BUILTIN): Rename second argument from A to B. Update all callers to pass equivalent DECL_FUNCTION_CODE. (DEF_CTFE_BUILTIN): Likewise. (STD_COS): Remove intrinsic. (STD_FABS): Remove intrinsic. (STD_LDEXP): Remove intrinsic. (STD_RINT): Remove intrinsic. (STD_RNDTOL): Remove intrinsic. (STD_SIN): Remove intrinsic. (STD_SQRTF): Remove intrinsic. (STD_SQRT): Remove intrinsic. (STD_SQRTL): Remove intrinsic. gcc/testsuite/ChangeLog: * gdc.dg/intrinsics.d: New test. --- gcc/testsuite/gdc.dg/intrinsics.d | 117 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 117 insertions(+) create mode 100644 gcc/testsuite/gdc.dg/intrinsics.d (limited to 'gcc/testsuite') diff --git a/gcc/testsuite/gdc.dg/intrinsics.d b/gcc/testsuite/gdc.dg/intrinsics.d new file mode 100644 index 0000000..e10c06d --- /dev/null +++ b/gcc/testsuite/gdc.dg/intrinsics.d @@ -0,0 +1,117 @@ +// { dg-do compile } +// { dg-options "-fdump-tree-original" } +import core.bitop; +import core.checkedint; +import core.math; +import core.stdc.stdarg; + +////////////////////////////////////////////////////// +// core.bitop + +// { dg-final { scan-tree-dump-not " bsf " "original" } } +int test_bsf(uint a) { return bsf(a); } +int test_bsf(ulong a) { return bsf(a); } +// { dg-final { scan-tree-dump-not " bsr " "original" } } +int test_bsr(uint a) { return bsr(a); } +int test_bsr(ulong a) { return bsr(a); } +// { dg-final { scan-tree-dump-not " bt " "original" } } +int test_bt(size_t *a, size_t b) { return bt(a, b); } +// { dg-final { scan-tree-dump-not " btc " "original" } } +int test_btc(size_t *a, size_t b) { return btc(a, b); } +// { dg-final { scan-tree-dump-not " btr " "original" } } +int test_btr(size_t *a, size_t b) { return btr(a, b); } +// { dg-final { scan-tree-dump-not " bts " "original" } } +int test_bts(size_t *a, size_t b) { return bts(a, b); } +// { dg-final { scan-tree-dump-not " bswap " "original" } } +uint test_bswap(uint a) { return bswap(a); } +ulong test_bswap(ulong a) { return bswap(a); } +// { dg-final { scan-tree-dump-not " popcnt " "original" } } +int test_popcnt(uint a) { return popcnt(a); } +int test_popcnt(ulong a) { return popcnt(a); } +// { dg-final { scan-tree-dump-not " volatileLoad " "original" } } +ubyte test_volatileLoad(ubyte *a) { return volatileLoad(a); } +ushort test_volatileLoad(ushort *a) { return volatileLoad(a); } +uint test_volatileLoad(uint *a) { return volatileLoad(a); } +ulong test_volatileLoad(ulong *a) { return volatileLoad(a); } +// { dg-final { scan-tree-dump-not " volatileStore " "original" } } +void test_volatileStore(ubyte *a, ubyte b) { return volatileStore(a, b); } +void test_volatileStore(ushort *a, ushort b) { return volatileStore(a, b); } +void test_volatileStore(uint *a, uint b) { return volatileStore(a, b); } +void test_volatileStore(ulong *a, ulong b) { return volatileStore(a, b); } + +////////////////////////////////////////////////////// +// core.checkedint + +// { dg-final { scan-tree-dump-not " adds " "original" } } +int test_adds(int a, int b, ref bool c) { return adds(a, b, c); } +long test_adds(long a, long b, ref bool c) { return adds(a, b, c); } +// { dg-final { scan-tree-dump-not " addu " "original" } } +uint test_addu(uint a, uint b, ref bool c) { return addu(a, b, c); } +ulong test_addu(ulong a, ulong b, ref bool c) { return addu(a, b, c); } +// { dg-final { scan-tree-dump-not " subs " "original" } } +int test_subs(int a, int b, ref bool c) { return subs(a, b, c); } +long test_subs(long a, long b, ref bool c) { return subs(a, b, c); } +// { dg-final { scan-tree-dump-not " subu " "original" } } +uint test_subu(uint a, uint b, ref bool c) { return subu(a, b, c); } +ulong test_subu(ulong a, ulong b, ref bool c) { return subu(a, b, c); } +// { dg-final { scan-tree-dump-not " negs " "original" } } +int test_negs(int a, ref bool b) { return negs(a, b); } +long test_negs(long a, ref bool b) { return negs(a, b); } +// { dg-final { scan-tree-dump-not " muls " "original" } } +int test_muls(int a, int b, ref bool c) { return muls(a, b, c); } +long test_muls(long a, long b, ref bool c) { return muls(a, b, c); } +// { dg-final { scan-tree-dump-not " mulu " "original" } } +uint test_mulu(uint a, uint b, ref bool c) { return mulu(a, b, c); } +ulong test_mulu(ulong a, uint b, ref bool c) { return mulu(a, b, c); } +ulong test_mulu(ulong a, ulong b, ref bool c) { return mulu(a, b, c); } + +////////////////////////////////////////////////////// +// core.math + +// { dg-final { scan-tree-dump-not " cos " "original" } } +float test_cos(float a) { return cos(a); } +double test_cos(double a) { return cos(a); } +real test_cos(real a) { return cos(a); } +// { dg-final { scan-tree-dump-not " sin " "original" } } +float test_sin(float a) { return sin(a); } +double test_sin(double a) { return sin(a); } +real test_sin(real a) { return sin(a); } +// { dg-final { scan-tree-dump-not " rndtol " "original" } } +long test_rndtol(float a) { return rndtol(a); } +long test_rndtol(double a) { return rndtol(a); } +long test_rndtol(real a) { return rndtol(a); } +// { dg-final { scan-tree-dump-not " sqrt " "original" } } +float test_sqrt(float a) { return sqrt(a); } +double test_sqrt(double a) { return sqrt(a); } +real test_sqrt(real a) { return sqrt(a); } +// { dg-final { scan-tree-dump-not " ldexp " "original" } } +float test_ldexp(float a, int b) { return ldexp(a, b); } +double test_ldexp(double a, int b) { return ldexp(a, b); } +real test_ldexp(real a, int b) { return ldexp(a, b); } +// { dg-final { scan-tree-dump-not " fabs " "original" } } +float test_fabs(float a) { return fabs(a); } +double test_fabs(double a) { return fabs(a); } +real test_fabs(real a) { return fabs(a); } +// { dg-final { scan-tree-dump-not " rint " "original" } } +float test_rint(float a) { return rint(a); } +double test_rint(double a) { return rint(a); } +real test_rint(real a) { return rint(a); } +// { dg-final { scan-tree-dump-not " toPrec " "original" } } +float test_toPrec(float a) { return toPrec!float(a); } +float test_toPrec(double a) { return toPrec!float(a); } +float test_toPrec(real a) { return toPrec!float(a); } +double test_toPrec(float a) { return toPrec!double(a); } +double test_toPrec(double a) { return toPrec!double(a); } +double test_toPrec(real a) { return toPrec!double(a); } +real test_toPrec(float a) { return toPrec!real(a); } +real test_toPrec(double a) { return toPrec!real(a); } +real test_toPrec(real a) { return toPrec!real(a); } + +////////////////////////////////////////////////////// +// core.stdc.stdarg + +// { dg-final { scan-tree-dump-not " va_arg " "original" } } +void test_va_arg(...) { int a; return va_arg!int(_argptr, a); } +int test_va_arg(...) { return va_arg!int(_argptr); } +// { dg-final { scan-tree-dump-not " va_start " "original" } } +void test_va_start(int a, ...) { return va_start(_argptr, a); } -- cgit v1.1