From patchwork Tue Feb 21 12:01:50 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Arthur Cohen X-Patchwork-Id: 60018 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:adf:eb09:0:0:0:0:0 with SMTP id s9csp1836674wrn; Tue, 21 Feb 2023 04:36:38 -0800 (PST) X-Google-Smtp-Source: AK7set+qYbsWa39pAqwRCIR+DqqzDHvVEX7eo1r/zdaC2j1vFnnPQ3vjdfvhwBv/bU44BvDja6bG X-Received: by 2002:a17:906:58c6:b0:8de:1eb6:d09c with SMTP id e6-20020a17090658c600b008de1eb6d09cmr2503677ejs.13.1676982998706; Tue, 21 Feb 2023 04:36:38 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1676982998; cv=none; d=google.com; s=arc-20160816; b=0msQYAvX8M4JtfRUcR5h1LXOQppkj6/LF0XIZb+/rSY+dLeULan7eaTzQg5mi6lp5C pQ2jMga5zVG/dlCC2iHW/ohQmjbeneVgUr5YOW9TMRo8uCszrQiwdJ55+noIHOidbkLA eZe6p5lNEXvATFXCUsld2XjO5JdcWAiRKnYZxMMicV96KkFesJnVTDlCMI6Ad8ai1HD3 noKByxcOWDWQ7W72S5ZOJ/Y4Ce5KoC/wq13K8IlwTW8lQpgqVXkGJyn+dn/8G82560j7 2rq07zlM5E+IAXa5x4PMOwDF1X6a5fJfV7+hTaHSNAHDw/wCJQ9KMiNrJ+fELuzdKcQU PKWA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:reply-to:list-subscribe:list-help:list-post :list-archive:list-unsubscribe:list-id:precedence :content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:dkim-signature:dmarc-filter :delivered-to; bh=rloLSKS9lkl2psQzOflci4DtRK9bodiWEJkUGeWDtYg=; b=POVlOwV88mzjSn8OrDX1Pr40wx/NGBey9tBfrcFj2OYz+T/fAo7N3Tkdf16tKlQcW6 cp60R7nlXX3Q2UYY2UpFYDElVIMqzSLqaA0zSv2PgyzmM/xXjFQ66+yCeIubwlRfgf4R KhvGssjWAD7J89KpmqCij6u/HF0yB4cVwNRs0sIRfUIG797gpcpDkM5nkg1XEqWfDxvL gzNSGm/n+YKPlZ6V+lWlGY9yzdPwDRcejXTyMF4iMJTiWUVxnmH3Os0ATYL24r/7fpbK /KjjyM+CzV1yqXaKAUv6R2tdWOicx5ke5A/wjsCkq+RHYh6n1Y9rl53aAvWQXRBn96qu DZxw== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@embecosm.com header.s=google header.b=Te0qgIBJ; spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 8.43.85.97 as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org" Received: from sourceware.org (ip-8-43-85-97.sourceware.org. [8.43.85.97]) by mx.google.com with ESMTPS id ex17-20020a170907955100b008d2060ebc6esi6205587ejc.564.2023.02.21.04.36.38 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 21 Feb 2023 04:36:38 -0800 (PST) Received-SPF: pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 8.43.85.97 as permitted sender) client-ip=8.43.85.97; Authentication-Results: mx.google.com; dkim=pass header.i=@embecosm.com header.s=google header.b=Te0qgIBJ; spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 8.43.85.97 as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org" Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 624C1391284B for ; Tue, 21 Feb 2023 12:13:03 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from mail-wr1-x435.google.com (mail-wr1-x435.google.com [IPv6:2a00:1450:4864:20::435]) by sourceware.org (Postfix) with ESMTPS id 91B35383FDC3 for ; Tue, 21 Feb 2023 12:04:12 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 91B35383FDC3 Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=embecosm.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=embecosm.com Received: by mail-wr1-x435.google.com with SMTP id t13so4090141wrv.13 for ; Tue, 21 Feb 2023 04:04:12 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=embecosm.com; s=google; h=content-transfer-encoding:mime-version:reply-to:references :in-reply-to:message-id:date:subject:cc:to:from:from:to:cc:subject :date:message-id:reply-to; bh=rloLSKS9lkl2psQzOflci4DtRK9bodiWEJkUGeWDtYg=; b=Te0qgIBJhFm38yvlYMi3MNgr2QThNgLmvRuOLITdDXYYil3eLt9ilkKGSFr0Qibzx2 6gTVnke9dPDOdIbvdqYYTFvuPfu8R4AD8T7HjZ7FtKMcO+gqZfH3ME1EnaToEMyowvfA EXbAIT9ubtKX2spA9hNWtERhDWB0gIb3DXw5qTu3bk2sUhpK1gT+jhY9lwtJ1Z0RK/+v GfDLEBS3u91DpCZNUFFix+FNnBezFj9HMYL1z2kf4td5Jf/3TsNgHLlE+Pj1loklOg+b iFm7DWLBUtOy/QVCFFv6dTaUTPy1b26aqtzpQVDMJZpn2FZpPfW5UYG5Rz34z8G4y5ul BaJg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:reply-to:references :in-reply-to:message-id:date:subject:cc:to:from:x-gm-message-state :from:to:cc:subject:date:message-id:reply-to; bh=rloLSKS9lkl2psQzOflci4DtRK9bodiWEJkUGeWDtYg=; b=wGt8QYIB/0ZBCDOI0fcRQnNIQX/B1bWnjArjr5ZX1fsBMT7UWC6fXRylh1aM/yf9zK Mtx1NfI+oqISd9rZZkdmu/Xwl08rXIlNFEvhuFP4XfEwI7fAeYBUGs3hvY5Ad7SX3Yoi zObNdHUQb/78rtxb9YOPpCgHOdnYVk3Ah4YHkptQ4UkdmSOLl63K9iGqLFBucdSwxfRL STq8LLsgMtCr13cwHKtkreAmo/SzHGCX/U1jHJyychuY9j6sW2E8ut4lSbbEVaxZ46uK 0//Zfc6l4ON/MgD+tSXeJmVoQUokdC4sW18lRdvVYNhdvz+NpS1mCDto8QeSy5ueiYx6 nhMw== X-Gm-Message-State: AO0yUKUrLzCcRdjkcdSjit1LkTvHaHn7Z28pl0pYqxoIBRdH7hk4frag yNPOe9oJ/8C35PoarCpFGPzrfgCOZxjlM3qiRA== X-Received: by 2002:a5d:5c0d:0:b0:2c5:67e3:808d with SMTP id cc13-20020a5d5c0d000000b002c567e3808dmr2745512wrb.35.1676981051903; Tue, 21 Feb 2023 04:04:11 -0800 (PST) Received: from platypus.localdomain ([62.23.166.218]) by smtp.gmail.com with ESMTPSA id c15-20020adffb4f000000b002c55b0e6ef1sm5013811wrs.4.2023.02.21.04.04.10 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 21 Feb 2023 04:04:11 -0800 (PST) From: arthur.cohen@embecosm.com To: gcc-patches@gcc.gnu.org Cc: gcc-rust@gcc.gnu.org, Arthur Cohen Subject: [committed 060/103] gccrs: intrinsics: Add early implementation for atomic_store_{seqcst, relaxed, release} Date: Tue, 21 Feb 2023 13:01:50 +0100 Message-Id: <20230221120230.596966-61-arthur.cohen@embecosm.com> X-Mailer: git-send-email 2.39.1 In-Reply-To: <20230221120230.596966-1-arthur.cohen@embecosm.com> References: <20230221120230.596966-1-arthur.cohen@embecosm.com> MIME-Version: 1.0 X-Spam-Status: No, score=-14.8 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: arthur.cohen@embecosm.com Errors-To: gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org Sender: "Gcc-patches" X-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1758444124855333937?= X-GMAIL-MSGID: =?utf-8?q?1758444124855333937?= From: Arthur Cohen gcc/rust/ChangeLog: * backend/rust-builtins.cc (BuiltinsContext::setup_atomic_fns): New function. (BuiltinsContext::setup): Call `setup_atomic_fns`. * backend/rust-builtins.h: Declare `setup_atomic_fns`. * backend/rust-compile-intrinsic.cc (atomic_store_handler_inner): New function. (atomic_store_handler): New handler. (make_unsigned_long_tree): Add helper around making unsigned long trees. (prefetch_data_handler): Use `make_unsigned_long_tree`. (build_atomic_builtin_name): New function. gcc/testsuite/ChangeLog: * rust/compile/torture/intrinsics-4.rs: New test. * rust/compile/torture/intrinsics-5.rs: New test. * rust/execute/torture/atomic_store.rs: New test. --- gcc/rust/backend/rust-builtins.cc | 36 ++++ gcc/rust/backend/rust-builtins.h | 2 +- gcc/rust/backend/rust-compile-intrinsic.cc | 165 +++++++++++++++--- .../rust/compile/torture/intrinsics-4.rs | 20 +++ .../rust/compile/torture/intrinsics-5.rs | 35 ++++ .../rust/execute/torture/atomic_store.rs | 32 ++++ 6 files changed, 268 insertions(+), 22 deletions(-) create mode 100644 gcc/testsuite/rust/compile/torture/intrinsics-4.rs create mode 100644 gcc/testsuite/rust/compile/torture/intrinsics-5.rs create mode 100644 gcc/testsuite/rust/execute/torture/atomic_store.rs diff --git a/gcc/rust/backend/rust-builtins.cc b/gcc/rust/backend/rust-builtins.cc index d6f8cb6f495..64e06e1a240 100644 --- a/gcc/rust/backend/rust-builtins.cc +++ b/gcc/rust/backend/rust-builtins.cc @@ -68,11 +68,47 @@ BuiltinsContext::setup_math_fns () math_function_type_f32, builtin_const); } +void +BuiltinsContext::setup_atomic_fns () +{ + define_builtin ("atomic_store", BUILT_IN_ATOMIC_STORE, "__atomic_store", NULL, + build_function_type_list (void_type_node, size_type_node, + build_pointer_type (void_type_node), + const_ptr_type_node, + integer_type_node, NULL_TREE), + 0); + define_builtin ("atomic_store_n", BUILT_IN_ATOMIC_STORE_N, "__atomic_store_n", + NULL, + build_varargs_function_type_list (void_type_node, NULL_TREE), + 0); + define_builtin ("atomic_store_1", BUILT_IN_ATOMIC_STORE_1, "__atomic_store_1", + NULL, + build_varargs_function_type_list (void_type_node, NULL_TREE), + 0); + define_builtin ("atomic_store_2", BUILT_IN_ATOMIC_STORE_2, "__atomic_store_2", + NULL, + build_varargs_function_type_list (void_type_node, NULL_TREE), + 0); + define_builtin ("atomic_store_4", BUILT_IN_ATOMIC_STORE_4, "__atomic_store_4", + NULL, + build_varargs_function_type_list (void_type_node, NULL_TREE), + 0); + define_builtin ("atomic_store_8", BUILT_IN_ATOMIC_STORE_8, "__atomic_store_8", + NULL, + build_varargs_function_type_list (void_type_node, NULL_TREE), + 0); + define_builtin ("atomic_store_16", BUILT_IN_ATOMIC_STORE_16, + "__atomic_store_16", NULL, + build_varargs_function_type_list (void_type_node, NULL_TREE), + 0); +} + void BuiltinsContext::setup () { setup_math_fns (); setup_overflow_fns (); + setup_atomic_fns (); define_builtin ("unreachable", BUILT_IN_UNREACHABLE, "__builtin_unreachable", NULL, build_function_type (void_type_node, void_list_node), diff --git a/gcc/rust/backend/rust-builtins.h b/gcc/rust/backend/rust-builtins.h index e421fa43755..c2825107faf 100644 --- a/gcc/rust/backend/rust-builtins.h +++ b/gcc/rust/backend/rust-builtins.h @@ -86,8 +86,8 @@ private: BuiltinsContext (); void setup_overflow_fns (); - void setup_math_fns (); + void setup_atomic_fns (); void setup (); diff --git a/gcc/rust/backend/rust-compile-intrinsic.cc b/gcc/rust/backend/rust-compile-intrinsic.cc index 2a2091ccc25..7c592dabb38 100644 --- a/gcc/rust/backend/rust-compile-intrinsic.cc +++ b/gcc/rust/backend/rust-compile-intrinsic.cc @@ -93,6 +93,17 @@ prefetch_write_data (Context *ctx, TyTy::FnType *fntype) return prefetch_data_handler (ctx, fntype, Prefetch::Write); } +static tree +atomic_store_handler_inner (Context *ctx, TyTy::FnType *fntype, int ordering); + +static inline std::function +atomic_store_handler (int ordering) +{ + return [ordering] (Context *ctx, TyTy::FnType *fntype) { + return atomic_store_handler_inner (ctx, fntype, ordering); + }; +} + static inline tree sorry_handler (Context *ctx, TyTy::FnType *fntype) { @@ -105,18 +116,22 @@ sorry_handler (Context *ctx, TyTy::FnType *fntype) static const std::map> generic_intrinsics = { - {"offset", &offset_handler}, - {"size_of", &sizeof_handler}, - {"transmute", &transmute_handler}, - {"rotate_left", &rotate_left_handler}, - {"rotate_right", &rotate_right_handler}, - {"wrapping_add", &wrapping_add_handler}, - {"wrapping_sub", &wrapping_sub_handler}, - {"wrapping_mul", &wrapping_mul_handler}, - {"copy_nonoverlapping", ©_nonoverlapping_handler}, - {"prefetch_read_data", &prefetch_read_data}, - {"prefetch_write_data", &prefetch_write_data}, - {"atomic_load", &sorry_handler}, + {"offset", offset_handler}, + {"size_of", sizeof_handler}, + {"transmute", transmute_handler}, + {"rotate_left", rotate_left_handler}, + {"rotate_right", rotate_right_handler}, + {"wrapping_add", wrapping_add_handler}, + {"wrapping_sub", wrapping_sub_handler}, + {"wrapping_mul", wrapping_mul_handler}, + {"copy_nonoverlapping", copy_nonoverlapping_handler}, + {"prefetch_read_data", prefetch_read_data}, + {"prefetch_write_data", prefetch_write_data}, + {"atomic_load", sorry_handler}, + {"atomic_store_seqcst", atomic_store_handler (__ATOMIC_SEQ_CST)}, + {"atomic_store_release", atomic_store_handler (__ATOMIC_RELEASE)}, + {"atomic_store_relaxed", atomic_store_handler (__ATOMIC_RELAXED)}, + {"atomic_store_unordered", atomic_store_handler (__ATOMIC_RELAXED)}, }; Intrinsics::Intrinsics (Context *ctx) : ctx (ctx) {} @@ -551,6 +566,16 @@ copy_nonoverlapping_handler (Context *ctx, TyTy::FnType *fntype) return fndecl; } +static tree +make_unsigned_long_tree (Context *ctx, unsigned long value) +{ + mpz_t mpz_value; + mpz_init_set_ui (mpz_value, value); + + return ctx->get_backend ()->integer_constant_expression (integer_type_node, + mpz_value); +} + static tree prefetch_data_handler (Context *ctx, TyTy::FnType *fntype, Prefetch kind) { @@ -576,16 +601,8 @@ prefetch_data_handler (Context *ctx, TyTy::FnType *fntype, Prefetch kind) auto addr = ctx->get_backend ()->var_expression (args[0], Location ()); auto locality = ctx->get_backend ()->var_expression (args[1], Location ()); + auto rw_flag = make_unsigned_long_tree (ctx, kind == Prefetch::Write ? 1 : 0); - mpz_t zero; - mpz_t one; - mpz_init_set_ui (zero, 0); - mpz_init_set_ui (one, 1); - - auto rw_flag_value = kind == Prefetch::Write ? one : zero; - auto rw_flag - = ctx->get_backend ()->integer_constant_expression (integer_type_node, - rw_flag_value); auto prefetch_raw = NULL_TREE; auto ok = BuiltinsContext::get ().lookup_simple_builtin ("prefetch", &prefetch_raw); @@ -597,6 +614,9 @@ prefetch_data_handler (Context *ctx, TyTy::FnType *fntype, Prefetch kind) = ctx->get_backend ()->call_expression (prefetch, {addr, rw_flag, locality}, nullptr, Location ()); + TREE_READONLY (prefetch_call) = 0; + TREE_SIDE_EFFECTS (prefetch_call) = 1; + ctx->add_statement (prefetch_call); finalize_intrinsic_block (ctx, fndecl); @@ -604,5 +624,108 @@ prefetch_data_handler (Context *ctx, TyTy::FnType *fntype, Prefetch kind) return fndecl; } +static std::string +build_atomic_builtin_name (Location locus, tree operand_type) +{ + static const std::map allowed_types = { + {"i8", "1"}, {"i16", "2"}, {"i32", "4"}, {"i64", "8"}, + {"i128", "16"}, {"isize", "8"}, {"u8", "1"}, {"u16", "2"}, + {"u32", "4"}, {"u64", "8"}, {"u128", "16"}, {"usize", "8"}, + }; + + // TODO: Can we maybe get the generic version (atomic_store_n) to work... This + // would be so much better + + std::string result = "atomic_store_"; + + auto type_name = std::string (TYPE_NAME_STRING (operand_type)); + if (type_name == "usize" || type_name == "isize") + { + rust_sorry_at ( + locus, "atomics are not yet available for size types (usize, isize)"); + return ""; + } + + // FIXME: Can we have a better looking name here? + // Instead of `::::`? + // Maybe instead of giving the tree node, pass the resolved Tyty before it + // gets compiled? + // + // Or should we perform this check somwhere else in the compiler? + auto type_size_str = allowed_types.find (type_name); + if (type_size_str == allowed_types.end ()) + { + rust_error_at (locus, + "atomic intrinsics are only available for basic integer " + "types: got type %qs", + type_name.c_str ()); + return ""; + } + + result += type_size_str->second; + + return result; +} + +static tree +atomic_store_handler_inner (Context *ctx, TyTy::FnType *fntype, int ordering) +{ + rust_assert (fntype->get_params ().size () == 2); + rust_assert (fntype->get_num_substitutions () == 1); + + tree lookup = NULL_TREE; + if (check_for_cached_intrinsic (ctx, fntype, &lookup)) + return lookup; + + auto fndecl = compile_intrinsic_function (ctx, fntype); + + // Most intrinsic functions are pure but not the atomic ones + TREE_READONLY (fndecl) = 0; + TREE_SIDE_EFFECTS (fndecl) = 1; + + // setup the params + std::vector param_vars; + std::vector types; + compile_fn_params (ctx, fntype, fndecl, ¶m_vars, &types); + + auto ok = ctx->get_backend ()->function_set_parameters (fndecl, param_vars); + rust_assert (ok); + + enter_intrinsic_block (ctx, fndecl); + + auto dst = ctx->get_backend ()->var_expression (param_vars[0], Location ()); + TREE_READONLY (dst) = 0; + + auto value = ctx->get_backend ()->var_expression (param_vars[1], Location ()); + auto memorder = make_unsigned_long_tree (ctx, ordering); + + auto builtin_name + = build_atomic_builtin_name (fntype->get_locus (), TREE_TYPE (types[0])); + if (builtin_name.empty ()) + return error_mark_node; + + tree atomic_store_raw = nullptr; + BuiltinsContext::get ().lookup_simple_builtin (builtin_name, + &atomic_store_raw); + rust_assert (atomic_store_raw); + + auto atomic_store + = build_fold_addr_expr_loc (Location ().gcc_location (), atomic_store_raw); + + auto store_call + = ctx->get_backend ()->call_expression (atomic_store, + {dst, value, memorder}, nullptr, + Location ()); + + TREE_READONLY (store_call) = 0; + TREE_SIDE_EFFECTS (store_call) = 1; + + ctx->add_statement (store_call); + + finalize_intrinsic_block (ctx, fndecl); + + return fndecl; +} + } // namespace Compile } // namespace Rust diff --git a/gcc/testsuite/rust/compile/torture/intrinsics-4.rs b/gcc/testsuite/rust/compile/torture/intrinsics-4.rs new file mode 100644 index 00000000000..243d4460089 --- /dev/null +++ b/gcc/testsuite/rust/compile/torture/intrinsics-4.rs @@ -0,0 +1,20 @@ +trait Copy {} + +extern "rust-intrinsic" { + pub fn atomic_store_seqcst(dst: *mut T, val: T); + pub fn atomic_store_release(dst: *mut T, val: T); + pub fn atomic_store_relaxed(dst: *mut T, val: T); + // pub fn atomic_store_unordered(dst: *mut T, val: T); +} + +fn main() { + let mut dst = 15; + let new_value = 14; + + unsafe { + atomic_store_seqcst(&mut dst, new_value); + atomic_store_release(&mut dst, new_value); + atomic_store_relaxed(&mut dst, new_value); + // atomic_store_unordered(&mut dst, new_value); + } +} diff --git a/gcc/testsuite/rust/compile/torture/intrinsics-5.rs b/gcc/testsuite/rust/compile/torture/intrinsics-5.rs new file mode 100644 index 00000000000..e0087720cc4 --- /dev/null +++ b/gcc/testsuite/rust/compile/torture/intrinsics-5.rs @@ -0,0 +1,35 @@ +trait Copy {} + +extern "rust-intrinsic" { + pub fn atomic_store_seqcst(dst: *mut T, value: T); + // { dg-error "atomic intrinsics are only available for basic integer types: got type .intrinsics_5::VeryLargeType." "" { target *-*-* } .-1 } + // { dg-error "atomic intrinsics are only available for basic integer types: got type .bool." "" { target *-*-* } .-2 } +} + +struct VeryLargeType { + a0: i128, + a1: i128, + a2: i128, + a3: i128, +} + +impl VeryLargeType { + pub fn new(value: i128) -> VeryLargeType { + VeryLargeType { + a0: value, + a1: 0, + a2: 0, + a3: 0, + } + } +} + +fn main() { + let mut dst = VeryLargeType::new(0); + let mut b = false; + + unsafe { + atomic_store_seqcst(&mut dst, VeryLargeType::new(1)); + atomic_store_seqcst(&mut b, true); + } +} diff --git a/gcc/testsuite/rust/execute/torture/atomic_store.rs b/gcc/testsuite/rust/execute/torture/atomic_store.rs new file mode 100644 index 00000000000..9f248b4f823 --- /dev/null +++ b/gcc/testsuite/rust/execute/torture/atomic_store.rs @@ -0,0 +1,32 @@ +trait Copy {} + +extern "rust-intrinsic" { + pub fn atomic_store_seqcst(dst: *mut T, val: T); + pub fn atomic_store_release(dst: *mut T, val: T); + pub fn atomic_store_relaxed(dst: *mut T, val: T); + pub fn atomic_store_unordered(dst: *mut T, val: T); +} + +fn main() -> i32 { + let mut dst = 15; + let one; + let two; + let three; + let four; + + unsafe { + atomic_store_seqcst(&mut dst, 1); + one = dst; + + atomic_store_release(&mut dst, 2); + two = dst; + + atomic_store_relaxed(&mut dst, 3); + three = dst; + + atomic_store_unordered(&mut dst, 4); + four = dst; + } + + (four + three + two + one) - 10 +}