From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 7905) id 64A8F3839DFF; Tue, 21 Feb 2023 12:04:00 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 64A8F3839DFF DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1676981040; bh=7fGY4KKYIz+8/mXawedzueyum85XXME0T3w6DupIw+c=; h=From:To:Subject:Date:From; b=T+SHADffgru3dFeRR2PhKAOrko/OEkJ0ZXmdurQpUg7YI89g+3AJSmjNR2/uOFHcN LdpKd5xEagUSOWblno3cSkVMrO8QzMJ0KSikzpVUjQCtJWsaviHmsS54AKtP9M3sE5 0rgnRJWj0u5npmyIK3d+hhk9QNALS63oOI8tRIGc= MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Type: text/plain; charset="utf-8" From: Arthur Cohen To: gcc-cvs@gcc.gnu.org Subject: [gcc r13-6256] gccrs: add math intrinsics X-Act-Checkin: gcc X-Git-Author: Raiki Tamura X-Git-Refname: refs/heads/master X-Git-Oldrev: 064bbd0fe10437ab0b2b5a386c77c9e285dda760 X-Git-Newrev: ecb409b23b86363fa085ec32e89e1aeda002cb70 Message-Id: <20230221120400.64A8F3839DFF@sourceware.org> Date: Tue, 21 Feb 2023 12:04:00 +0000 (GMT) List-Id: https://gcc.gnu.org/g:ecb409b23b86363fa085ec32e89e1aeda002cb70 commit r13-6256-gecb409b23b86363fa085ec32e89e1aeda002cb70 Author: Raiki Tamura Date: Fri Dec 16 02:27:59 2022 +0900 gccrs: add math intrinsics gcc/rust/ChangeLog: * backend/rust-builtins.cc (BuiltinsContext::setup_math_fns): New functions. gcc/testsuite/ChangeLog: * rust/compile/torture/intrinsics-math.rs: New test. Diff: --- gcc/rust/backend/rust-builtins.cc | 122 ++++++++++++++- .../rust/compile/torture/intrinsics-math.rs | 173 +++++++++++++++++++++ 2 files changed, 291 insertions(+), 4 deletions(-) diff --git a/gcc/rust/backend/rust-builtins.cc b/gcc/rust/backend/rust-builtins.cc index 66b3becc47a..0517a9aeaf0 100644 --- a/gcc/rust/backend/rust-builtins.cc +++ b/gcc/rust/backend/rust-builtins.cc @@ -59,13 +59,127 @@ BuiltinsContext::setup_overflow_fns () void BuiltinsContext::setup_math_fns () { - tree math_function_type_f32 + tree fn_type_f32_to_f32 = build_function_type_list (float_type_node, float_type_node, NULL_TREE); + tree fn_type_f64_to_f64 + = build_function_type_list (double_type_node, double_type_node, NULL_TREE); + tree fn_type_f32_f32_to_f32 + = build_function_type_list (float_type_node, float_type_node, + float_type_node, NULL_TREE); + tree fn_type_f64_f64_to_f64 + = build_function_type_list (double_type_node, double_type_node, + double_type_node, NULL_TREE); + tree fn_type_f32_i32_to_f32 + = build_function_type_list (float_type_node, float_type_node, + integer_type_node, NULL_TREE); + tree fn_type_f64_i32_to_f64 + = build_function_type_list (double_type_node, double_type_node, + integer_type_node, NULL_TREE); - define_builtin ("sinf32", BUILT_IN_SINF, "__builtin_sinf", "sinf", - math_function_type_f32, builtin_const); define_builtin ("sqrtf32", BUILT_IN_SQRTF, "__builtin_sqrtf", "sqrtf", - math_function_type_f32, builtin_const); + fn_type_f32_to_f32, builtin_const); + define_builtin ("sqrtf64", BUILT_IN_SQRT, "__builtin_sqrt", "sqrt", + fn_type_f64_to_f64, builtin_const); + + define_builtin ("powif32", BUILT_IN_POWIF, "__builtin_powif", "powif", + fn_type_f32_i32_to_f32, builtin_const); + define_builtin ("powif64", BUILT_IN_POWI, "__builtin_powi", "powi", + fn_type_f64_i32_to_f64, builtin_const); + + define_builtin ("sinf32", BUILT_IN_SINF, "__builtin_sinf", "sinf", + fn_type_f32_to_f32, builtin_const); + define_builtin ("sinf64", BUILT_IN_SIN, "__builtin_sin", "sin", + fn_type_f64_to_f64, builtin_const); + + define_builtin ("cosf32", BUILT_IN_COSF, "__builtin_cosf", "cosf", + fn_type_f32_to_f32, builtin_const); + define_builtin ("cosf64", BUILT_IN_COS, "__builtin_cos", "cos", + fn_type_f64_to_f64, builtin_const); + + define_builtin ("powf32", BUILT_IN_POWF, "__builtin_powf", "powf", + fn_type_f32_f32_to_f32, builtin_const); + define_builtin ("powf64", BUILT_IN_POW, "__builtin_pow", "pow", + fn_type_f64_f64_to_f64, builtin_const); + + define_builtin ("expf32", BUILT_IN_EXPF, "__builtin_expf", "expf", + fn_type_f32_to_f32, builtin_const); + define_builtin ("expf64", BUILT_IN_EXP, "__builtin_exp", "exp", + fn_type_f64_to_f64, builtin_const); + + define_builtin ("exp2f32", BUILT_IN_EXP2F, "__builtin_exp2f", "exp2f", + fn_type_f32_to_f32, builtin_const); + define_builtin ("exp2f64", BUILT_IN_EXP2, "__builtin_exp2", "exp2", + fn_type_f64_to_f64, builtin_const); + + define_builtin ("logf32", BUILT_IN_LOGF, "__builtin_logf", "logf", + fn_type_f32_to_f32, builtin_const); + define_builtin ("logf64", BUILT_IN_LOG, "__builtin_log", "log", + fn_type_f64_to_f64, builtin_const); + + define_builtin ("log10f32", BUILT_IN_LOG10F, "__builtin_log10f", "log10f", + fn_type_f32_to_f32, builtin_const); + define_builtin ("log10f64", BUILT_IN_LOG10, "__builtin_log10", "log10", + fn_type_f64_to_f64, builtin_const); + + define_builtin ("log2f32", BUILT_IN_LOG2F, "__builtin_log2f", "log2f", + fn_type_f32_to_f32, builtin_const); + define_builtin ("log2f64", BUILT_IN_LOG2, "__builtin_log2", "log2", + fn_type_f64_to_f64, builtin_const); + + define_builtin ("fmaf32", BUILT_IN_FMAF, "__builtin_fmaf", "fmaf", + fn_type_f32_f32_to_f32, builtin_const); + define_builtin ("fmaf64", BUILT_IN_FMA, "__builtin_fma", "fma", + fn_type_f64_f64_to_f64, builtin_const); + + define_builtin ("fabsf32", BUILT_IN_FABSF, "__builtin_fabsf", "fabsf", + fn_type_f32_to_f32, builtin_const); + define_builtin ("fabsf64", BUILT_IN_FABS, "__builtin_fabs", "fabs", + fn_type_f64_to_f64, builtin_const); + + define_builtin ("minnumf32", BUILT_IN_FMINF, "__builtin_fminf", "fminf", + fn_type_f32_f32_to_f32, builtin_const); + define_builtin ("minnumf64", BUILT_IN_FMIN, "__builtin_fmin", "fmin", + fn_type_f64_f64_to_f64, builtin_const); + + define_builtin ("maxnumf32", BUILT_IN_FMAXF, "__builtin_fmaxf", "fmaxf", + fn_type_f32_f32_to_f32, builtin_const); + define_builtin ("maxnumf64", BUILT_IN_FMAX, "__builtin_fmax", "fmax", + fn_type_f64_f64_to_f64, builtin_const); + + define_builtin ("copysignf32", BUILT_IN_COPYSIGNF, "__builtin_copysignf", + "copysignf", fn_type_f32_f32_to_f32, builtin_const); + define_builtin ("copysignf64", BUILT_IN_COPYSIGN, "__builtin_copysign", + "copysign", fn_type_f64_f64_to_f64, builtin_const); + + define_builtin ("floorf32", BUILT_IN_FLOORF, "__builtin_floorf", "floorf", + fn_type_f32_to_f32, builtin_const); + define_builtin ("floorf64", BUILT_IN_FLOOR, "__builtin_floor", "floor", + fn_type_f64_to_f64, builtin_const); + + define_builtin ("ceilf32", BUILT_IN_CEILF, "__builtin_ceilf", "ceilf", + fn_type_f32_to_f32, builtin_const); + define_builtin ("ceilf64", BUILT_IN_CEIL, "__builtin_ceil", "ceil", + fn_type_f64_to_f64, builtin_const); + + define_builtin ("truncf32", BUILT_IN_TRUNCF, "__builtin_truncf", "truncf", + fn_type_f32_to_f32, builtin_const); + define_builtin ("truncf64", BUILT_IN_TRUNC, "__builtin_trunc", "trunc", + fn_type_f64_to_f64, builtin_const); + + define_builtin ("rintf32", BUILT_IN_RINTF, "__builtin_rintf", "rintf", + fn_type_f32_to_f32, builtin_const); + define_builtin ("rintf64", BUILT_IN_RINT, "__builtin_rint", "rint", + fn_type_f64_to_f64, builtin_const); + + define_builtin ("nearbyintf32", BUILT_IN_NEARBYINTF, "__builtin_nearbyintf", + "nearbyintf", fn_type_f32_to_f32, builtin_const); + define_builtin ("nearbyintf64", BUILT_IN_NEARBYINT, "__builtin_nearbyint", + "nearbyint", fn_type_f64_to_f64, builtin_const); + + define_builtin ("roundf32", BUILT_IN_ROUNDF, "__builtin_roundf", "roundf", + fn_type_f32_to_f32, builtin_const); + define_builtin ("roundf64", BUILT_IN_ROUND, "__builtin_round", "round", + fn_type_f64_to_f64, builtin_const); } void diff --git a/gcc/testsuite/rust/compile/torture/intrinsics-math.rs b/gcc/testsuite/rust/compile/torture/intrinsics-math.rs new file mode 100644 index 00000000000..fb329baafdd --- /dev/null +++ b/gcc/testsuite/rust/compile/torture/intrinsics-math.rs @@ -0,0 +1,173 @@ +// { dg-additional-options -fdump-tree-original } + +#![feature(intrinsics)] +extern "rust-intrinsic" { + pub fn sqrtf32(x: f32) -> f32; + pub fn sqrtf64(x: f64) -> f64; + + pub fn sinf32(x: f32) -> f32; + pub fn sinf64(x: f64) -> f64; + + pub fn cosf32(x: f32) -> f32; + pub fn cosf64(x: f64) -> f64; + + pub fn powf32(a: f32, x: f32) -> f32; + pub fn powf64(a: f64, x: f64) -> f64; + + pub fn expf32(x: f32) -> f32; + pub fn expf64(x: f64) -> f64; + + pub fn exp2f32(x: f32) -> f32; + pub fn exp2f64(x: f64) -> f64; + + pub fn logf32(x: f32) -> f32; + pub fn logf64(x: f64) -> f64; + + pub fn log10f32(x: f32) -> f32; + pub fn log10f64(x: f64) -> f64; + + pub fn log2f32(x: f32) -> f32; + pub fn log2f64(x: f64) -> f64; + + pub fn fmaf32(a: f32, b: f32, c: f32) -> f32; + pub fn fmaf64(a: f64, b: f64, c: f64) -> f64; + + pub fn fabsf32(x: f32) -> f32; + pub fn fabsf64(x: f64) -> f64; + + pub fn minnumf32(x: f32, y: f32) -> f32; + pub fn minnumf64(x: f64, y: f64) -> f64; + + pub fn maxnumf32(x: f32, y: f32) -> f32; + pub fn maxnumf64(x: f64, y: f64) -> f64; + + pub fn copysignf32(x: f32, y: f32) -> f32; + pub fn copysignf64(x: f64, y: f64) -> f64; + + pub fn floorf32(x: f32) -> f32; + pub fn floorf64(x: f64) -> f64; + + pub fn ceilf32(x: f32) -> f32; + pub fn ceilf64(x: f64) -> f64; + + pub fn truncf32(x: f32) -> f32; + pub fn truncf64(x: f64) -> f64; + + pub fn rintf32(x: f32) -> f32; + pub fn rintf64(x: f64) -> f64; + + pub fn nearbyintf32(x: f32) -> f32; + pub fn nearbyintf64(x: f64) -> f64; + + pub fn roundf32(x: f32) -> f32; + pub fn roundf64(x: f64) -> f64; +} + +fn main() { + unsafe fn foo() { + let mut f32; + let mut f64; + + f32 = sqrtf32(1f32); + // { dg-final { scan-tree-dump-times {(?n)f32 = __builtin_sqrtf \(1\.0e\+0\);$} 1 original } } + f64 = sqrtf64(2f64); + // { dg-final { scan-tree-dump-times {(?n)f64 = __builtin_sqrt \(2\.0e\+0\);$} 1 original } } + + f32 = sinf32(39f32); + // { dg-final { scan-tree-dump-times {(?n)f32 = __builtin_sinf \(3\.9e\+1\);$} 1 original } } + f64 = sinf64(40f64); + // { dg-final { scan-tree-dump-times {(?n)f64 = __builtin_sin \(4\.0e\+1\);$} 1 original } } + + f32 = cosf32(5f32); + // { dg-final { scan-tree-dump-times {(?n)f32 = __builtin_cosf \(5\.0e\+0\);$} 1 original } } + f64 = cosf64(6f64); + // { dg-final { scan-tree-dump-times {(?n)f64 = __builtin_cos \(6\.0e\+0\);$} 1 original } } + + f32 = powf32(7f32, 8f32); + // { dg-final { scan-tree-dump-times {(?n)f32 = __builtin_powf \(7\.0e\+0, 8\.0e\+0\);$} 1 original } } + f64 = powf64(9f64, 10f64); + // { dg-final { scan-tree-dump-times {(?n)f64 = __builtin_pow \(9\.0e\+0, 1\.0e\+1\);$} 1 original } } + + f32 = expf32(11f32); + // { dg-final { scan-tree-dump-times {(?n)f32 = __builtin_expf \(1\.1e\+1\);$} 1 original } } + f64 = expf64(12f64); + // { dg-final { scan-tree-dump-times {(?n)f64 = __builtin_exp \(1\.2e\+1\);$} 1 original } } + + f32 = exp2f32(13f32); + // { dg-final { scan-tree-dump-times {(?n)f32 = __builtin_expf \(1\.1e\+1\);$} 1 original } } + f64 = exp2f64(14f64); + // { dg-final { scan-tree-dump-times {(?n)f64 = __builtin_exp \(1\.2e\+1\);$} 1 original } } + + f32 = logf32(15f32); + // { dg-final { scan-tree-dump-times {(?n)f32 = __builtin_logf \(1\.5e\+1\);$} 1 original } } + f64 = logf64(16f64); + // { dg-final { scan-tree-dump-times {(?n)f64 = __builtin_log \(1\.6e\+1\);$} 1 original } } + + f32 = log10f32(17f32); + // { dg-final { scan-tree-dump-times {(?n)f32 = __builtin_log10f \(1\.7e\+1\);$} 1 original } } + f64 = log10f64(18f64); + // { dg-final { scan-tree-dump-times {(?n)f64 = __builtin_log10 \(1\.8e\+1\);$} 1 original } } + + f32 = log2f32(19f32); + // { dg-final { scan-tree-dump-times {(?n)f32 = __builtin_log2f \(1\.9e\+1\);$} 1 original } } + f64 = log2f64(20f64); + // { dg-final { scan-tree-dump-times {(?n)f64 = __builtin_log2 \(2\.0e\+1\);$} 1 original } } + + f32 = fmaf32(21f32, 22f32, 23f32); + // { dg-final { scan-tree-dump-times {(?n)f32 = __builtin_fmaf \(2\.1e\+1, 2\.2e\+1, 2\.3e\+1\);$} 1 original } } + f64 = fmaf64(24f64, 25f64, 26f64); + // { dg-final { scan-tree-dump-times {(?n)f64 = __builtin_fma \(2\.4e\+1, 2\.5e\+1, 2\.6e\+1\);$} 1 original } } + + f32 = fabsf32(27f32); + // { dg-final { scan-tree-dump-times {(?n)f32 = __builtin_fabsf \(2\.7e\+1\);$} 1 original } } + f64 = fabsf64(28f64); + // { dg-final { scan-tree-dump-times {(?n)f64 = __builtin_fabs \(2\.8e\+1\);$} 1 original } } + + f32 = minnumf32(29f32, 30f32); + // { dg-final { scan-tree-dump-times {(?n)f32 = __builtin_fminf \(2\.9e\+1, 3\.0e\+1\);$} 1 original } } + f64 = minnumf64(31f64, 32f64); + // { dg-final { scan-tree-dump-times {(?n)f64 = __builtin_fmin \(3\.1e\+1, 3\.2e\+1\);$} 1 original } } + + f32 = maxnumf32(33f32, 34f32); + // { dg-final { scan-tree-dump-times {(?n)f32 = __builtin_fmaxf \(3\.3e\+1, 3\.4e\+1\);$} 1 original } } + f64 = maxnumf64(35f64, 36f64); + // { dg-final { scan-tree-dump-times {(?n)f64 = __builtin_fmax \(3\.5e\+1, 3\.6e\+1\);$} 1 original } } + + f32 = copysignf32(37f32, 38f32); + // { dg-final { scan-tree-dump-times {(?n)f32 = __builtin_copysignf \(3\.7e\+1, 3\.8e\+1\);$} 1 original } } + f64 = copysignf64(39f64, 40f64); + // { dg-final { scan-tree-dump-times {(?n)f64 = __builtin_copysign \(3\.9e\+1, 4\.0e\+1\);$} 1 original } } + + f32 = floorf32(41f32); + // { dg-final { scan-tree-dump-times {(?n)f32 = __builtin_floorf \(4\.1e\+1\);$} 1 original } } + f64 = floorf64(42f64); + // { dg-final { scan-tree-dump-times {(?n)f64 = __builtin_floor \(4\.2e\+1\);$} 1 original } } + + f32 = ceilf32(43f32); + // { dg-final { scan-tree-dump-times {(?n)f32 = __builtin_ceilf \(4\.3e\+1\);$} 1 original } } + f64 = ceilf64(44f64); + // { dg-final { scan-tree-dump-times {(?n)f64 = __builtin_ceil \(4\.4e\+1\);$} 1 original } } + + f32 = truncf32(45f32); + // { dg-final { scan-tree-dump-times {(?n)f32 = __builtin_truncf \(4\.5e\+1\);$} 1 original } } + f64 = truncf64(46f64); + // { dg-final { scan-tree-dump-times {(?n)f64 = __builtin_trunc \(4\.6e\+1\);$} 1 original } } + + f32 = rintf32(47f32); + // { dg-final { scan-tree-dump-times {(?n)f32 = __builtin_rintf \(4\.7e\+1\);$} 1 original } } + f64 = rintf64(48f64); + // { dg-final { scan-tree-dump-times {(?n)f64 = __builtin_rint \(4\.8e\+1\);$} 1 original } } + + f32 = nearbyintf32(49f32); + // { dg-final { scan-tree-dump-times {(?n)f32 = __builtin_nearbyintf \(4\.9e\+1\);$} 1 original } } + f64 = nearbyintf64(50f64); + // { dg-final { scan-tree-dump-times {(?n)f64 = __builtin_nearbyint \(5\.0e\+1\);$} 1 original } } + + f32 = roundf32(51f32); + // { dg-final { scan-tree-dump-times {(?n)f32 = __builtin_roundf \(5\.1e\+1\);$} 1 original } } + f64 = roundf64(52f64); + // { dg-final { scan-tree-dump-times {(?n)f64 = __builtin_round \(5\.2e\+1\);$} 1 original } } + } + + unsafe { foo() }; +}