From patchwork Tue Aug 8 13:51:00 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jakub Jelinek X-Patchwork-Id: 132525 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:c44e:0:b0:3f2:4152:657d with SMTP id w14csp2131900vqr; Tue, 8 Aug 2023 06:51:56 -0700 (PDT) X-Google-Smtp-Source: AGHT+IF0EUq1I0ULxPP/ubCNhjedaVfNFCNZR90FxxuhWlUbpb/2Pin6qVXCZmsfru2vtzY/yzPT X-Received: by 2002:a17:906:845a:b0:994:1956:2331 with SMTP id e26-20020a170906845a00b0099419562331mr10059927ejy.13.1691502716056; Tue, 08 Aug 2023 06:51:56 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1691502716; cv=none; d=google.com; s=arc-20160816; b=Uto7867eQ6RKDIXkVltoMLFgencHPtdPwDj9ZRuZEsdeOKJTYY/K/cOhcwPNnA5s3z w0oWzLBkJQYxgrGo34l3q7HExobugrW6e4GNkgnPmshvrWMk5Ydq35OQ4GZpzMpxo7zB hlBR/RyqwD+5vrSwDtuGRdovgO9tWDqqCvtQV6nZJGwMQrLBnLtLM0s4XynVvgSipnGH bF3mPJ4rGSasVgQx4sHBnTkuVjBMBy6gBqV6eDSFhxj6lKcqtYwOBAxK9v5nouMJmx+i FgArHtmRJjLY8rKYDCVaMYweC+4rlIa3o3gjxH4xSBZIpU+x8P7+fWou9CteCkTGpud+ TWUw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:reply-to:from:list-subscribe:list-help:list-post :list-archive:list-unsubscribe:list-id:precedence :content-disposition:in-reply-to:mime-version:references:message-id :subject:cc:to:date:dmarc-filter:delivered-to:dkim-signature :dkim-filter; bh=itF39gpSL0elnMbjLgY4dV58cux//v/P04QWCrnTeis=; fh=93B2EkbdSZtlf0r5fbRgrRBI22A7uhJ3jVicEXL/JQs=; b=d3v7Eo+XiriJOzUzfOfvDvQlN2CQ9Mf8YYM9Sn+43wnUV6+AJn8DLSCkWsYNRmSjND l3V5eeuzMz40jdiZnr4Gr5K7qNa9PRT1RBPGxEENp6ceJEAvx7qhrBVaZxYgUZm8XdsS JM1hJMT24xJYho63dKcMkPkGs9EoJavQIzGMj2AMboIODLt4pU0YWUdtrqxFRSP9+X8W KeThMDtgQ6P1jkmEtv/XyhK5oQN3K29aJNRMroC3awDXGiubgWtYGgGQXK0RQd+7F6q/ CPJbVPvD3ZvfiINDuh5EFBF6qPozSuNKlhmP17BKtUbwpJt2vG2EiXJVdcwKgCTg2Gx+ LYwQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@gcc.gnu.org header.s=default header.b=EdDL+r9T; 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"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=gnu.org Received: from server2.sourceware.org (ip-8-43-85-97.sourceware.org. [8.43.85.97]) by mx.google.com with ESMTPS id r4-20020a1709062cc400b0098d2f718ac3si6623754ejr.609.2023.08.08.06.51.55 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 08 Aug 2023 06:51:56 -0700 (PDT) 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=@gcc.gnu.org header.s=default header.b=EdDL+r9T; 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"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=gnu.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id D0F053858D33 for ; Tue, 8 Aug 2023 13:51:54 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org D0F053858D33 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1691502714; bh=itF39gpSL0elnMbjLgY4dV58cux//v/P04QWCrnTeis=; h=Date:To:Cc:Subject:References:In-Reply-To:List-Id: List-Unsubscribe:List-Archive:List-Post:List-Help:List-Subscribe: From:Reply-To:From; b=EdDL+r9TZJkn66MwX5UiMcebI9iFtUAJot1T8KdhnWeF7trha9R4YZsCVJ1vzWeoO xFGg8z7icjtEjBbBTgwIe6LiJdgTbZcCH7wB5QyeVOK5w0javBv12oGdt+lnf+Jsw2 +DjD8DNc4/2fggcoWLhvO0MWs7+d20+Ym9SLyXt4= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by sourceware.org (Postfix) with ESMTPS id 4DEDC3858D20 for ; Tue, 8 Aug 2023 13:51:07 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 4DEDC3858D20 Received: from mimecast-mx02.redhat.com (mimecast-mx02.redhat.com [66.187.233.88]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-452-iW1ZTwCxP5i0JlyJMg4FWA-1; Tue, 08 Aug 2023 09:51:05 -0400 X-MC-Unique: iW1ZTwCxP5i0JlyJMg4FWA-1 Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.rdu2.redhat.com [10.11.54.6]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id 0CC7F8019DC; Tue, 8 Aug 2023 13:51:05 +0000 (UTC) Received: from tucnak.zalov.cz (unknown [10.45.224.18]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 9020B2166B25; Tue, 8 Aug 2023 13:51:04 +0000 (UTC) Received: from tucnak.zalov.cz (localhost [127.0.0.1]) by tucnak.zalov.cz (8.17.1/8.17.1) with ESMTPS id 378Dp18b3701626 (version=TLSv1.3 cipher=TLS_AES_256_GCM_SHA384 bits=256 verify=NOT); Tue, 8 Aug 2023 15:51:02 +0200 Received: (from jakub@localhost) by tucnak.zalov.cz (8.17.1/8.17.1/Submit) id 378Dp07t3701625; Tue, 8 Aug 2023 15:51:00 +0200 Date: Tue, 8 Aug 2023 15:51:00 +0200 To: Joseph Myers Cc: gcc-patches@gcc.gnu.org Subject: [PATCH] testsuite: Add runtime _BitInt stdatomic.h tests [PR102989] Message-ID: References: <83b8b7f3-43fb-98b5-904b-3931cc8cd38f@codesourcery.com> MIME-Version: 1.0 In-Reply-To: <83b8b7f3-43fb-98b5-904b-3931cc8cd38f@codesourcery.com> X-Scanned-By: MIMEDefang 3.1 on 10.11.54.6 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Disposition: inline X-Spam-Status: No, score=-3.2 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, KAM_LOTSOFHASH, RCVD_IN_DNSWL_NONE, RCVD_IN_MSPIKE_H4, RCVD_IN_MSPIKE_WL, SPF_HELO_NONE, SPF_NONE, 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: , X-Patchwork-Original-From: Jakub Jelinek via Gcc-patches From: Jakub Jelinek Reply-To: Jakub Jelinek Errors-To: gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org Sender: "Gcc-patches" X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1773669152043604104 X-GMAIL-MSGID: 1773669152043604104 Hi! On Thu, Aug 03, 2023 at 05:19:54PM +0000, Joseph Myers wrote: > It would be good to have execution tests for these operations (so probably > in gcc.dg/atomic so that libatomic is linked in automatically as needed). Ok, following patch does that, tested on x86_64-linux. 2023-08-08 Jakub Jelinek PR c/102989 * gcc.dg/atomic/stdatomic-bitint-1.c: New test. * gcc.dg/atomic/stdatomic-bitint-2.c: New test. Jakub --- gcc/testsuite/gcc.dg/atomic/stdatomic-bitint-1.c.jj 2023-08-08 12:50:45.721702269 +0200 +++ gcc/testsuite/gcc.dg/atomic/stdatomic-bitint-1.c 2023-08-08 14:12:42.989306477 +0200 @@ -0,0 +1,442 @@ +/* PR c/102989 */ +/* { dg-do run { target bitint } } */ +/* { dg-options "-std=c2x -pedantic-errors" } */ + +#include + +extern void abort (void); + +#if __BITINT_MAXWIDTH__ >= 127 +_Atomic _BitInt(127) v; +_BitInt(127) count, res; +const _BitInt(127) init = ~(_BitInt(127)) 0wb; + +void +test_fetch_add () +{ + atomic_init (&v, 13505789527944801758751150119415226784wb); + count = -64910836855286429164283779649638556795wb; + + if (atomic_fetch_add_explicit (&v, count, memory_order_relaxed) + != 13505789527944801758751150119415226784wb) + abort (); + + if (atomic_fetch_add_explicit (&v, 2227507280963412295355244564739509222wb, + memory_order_consume) + != -51405047327341627405532629530223330011wb) + abort (); + + if (atomic_fetch_add_explicit (&v, count, memory_order_acquire) + != -49177540046378215110177384965483820789wb) + abort (); + + if (atomic_fetch_add_explicit (&v, 42245667388877614520169143618236120405wb, + memory_order_release) + != 56052806558804587457226139100761728144wb) + abort (); + + if (atomic_fetch_add_explicit (&v, count, memory_order_acq_rel) + != -71842709512787029754292020996886257179wb) + abort (); + + if (atomic_fetch_add_explicit (&v, 77995075987640754057679086146674392947wb, + memory_order_seq_cst) + != 33387637092395772813111503069359291754wb) + abort (); + + if (atomic_fetch_add (&v, 11810767284628435493328779846084830297wb) + != -58758470380432704860896714499850421027wb) + abort (); + + if (atomic_load (&v) != -46947703095804269367567934653765590730wb) + abort (); +} + +void +test_fetch_sub () +{ + atomic_store_explicit (&v, 30796781768365552851024605388374299173wb, + memory_order_release); + count = 32457177597484647488149720668185011722wb; + + if (atomic_fetch_sub_explicit (&v, count, memory_order_relaxed) + != 30796781768365552851024605388374299173wb) + abort (); + + if (atomic_fetch_sub_explicit (&v, 54614103079293459991417218347656369566wb, + memory_order_consume) + != -1660395829119094637125115279810712549wb) + abort (); + + if (atomic_fetch_sub_explicit (&v, count, memory_order_acquire) + != -56274498908412554628542333627467082115wb) + abort (); + + if (atomic_fetch_sub_explicit (&v, -44514083923735151931107302009741400482wb, + memory_order_release) + != 81409506954572029614995249420232011891wb) + abort (); + + if (atomic_fetch_sub_explicit (&v, count, memory_order_acq_rel) + != -44217592582162050185584752285910693355wb) + abort (); + + if (atomic_fetch_sub_explicit (&v, 30348078982452392099140613411731040827wb, + memory_order_seq_cst) + != -76674770179646697673734472954095705077wb) + abort (); + + if (atomic_fetch_sub (&v, -82224045897086857020012824788652775087wb) + != 63118334298370141958812217350057359824wb) + abort (); + + if (atomic_load_explicit (&v, memory_order_acquire) + != -24798803265012232752862261577173970817wb) + abort (); +} + +void +test_fetch_and () +{ + atomic_store (&v, init); + + if (atomic_fetch_and_explicit (&v, 0, memory_order_relaxed) != init) + abort (); + + if (atomic_fetch_and_explicit (&v, init, memory_order_consume) != 0) + abort (); + + if (atomic_fetch_and_explicit (&v, 0, memory_order_acquire) != 0) + abort (); + + v = ~v; + if (atomic_fetch_and_explicit (&v, init, memory_order_release) != init) + abort (); + + if (atomic_fetch_and_explicit (&v, 0, memory_order_acq_rel) != init) + abort (); + + if (atomic_fetch_and_explicit (&v, 0, memory_order_seq_cst) != 0) + abort (); + + if (atomic_fetch_and (&v, 0) != 0) + abort (); +} + +void +test_fetch_xor () +{ + v = init; + count = 0; + + if (atomic_fetch_xor_explicit (&v, count, memory_order_relaxed) != init) + abort (); + + if (atomic_fetch_xor_explicit (&v, ~count, memory_order_consume) != init) + abort (); + + if (atomic_fetch_xor_explicit (&v, 0, memory_order_acquire) != 0) + abort (); + + if (atomic_fetch_xor_explicit (&v, ~count, memory_order_release) != 0) + abort (); + + if (atomic_fetch_xor_explicit (&v, 0, memory_order_acq_rel) != init) + abort (); + + if (atomic_fetch_xor_explicit (&v, ~count, memory_order_seq_cst) != init) + abort (); + + if (atomic_fetch_xor (&v, ~count) != 0) + abort (); +} + +void +test_fetch_or () +{ + v = 0; + count = 17592186044416wb; + + if (atomic_fetch_or_explicit (&v, count, memory_order_relaxed) != 0) + abort (); + + count *= 2; + if (atomic_fetch_or_explicit (&v, 35184372088832wb, memory_order_consume) + != 17592186044416wb) + abort (); + + count *= 2; + if (atomic_fetch_or_explicit (&v, count, memory_order_acquire) + != 52776558133248wb) + abort (); + + count *= 2; + if (atomic_fetch_or_explicit (&v, 140737488355328wb, memory_order_release) + != 123145302310912wb) + abort (); + + count *= 2; + if (atomic_fetch_or_explicit (&v, count, memory_order_acq_rel) + != 263882790666240wb) + abort (); + + count *= 2; + if (atomic_fetch_or_explicit (&v, count, memory_order_seq_cst) + != 545357767376896wb) + abort (); + + count *= 2; + if (atomic_fetch_or (&v, count) != 1108307720798208wb) + abort (); +} + + +/* Test the OP routines with a result which isn't used. */ + +void +test_add () +{ + v = 0; + count = 4722366482869645213696wb; + + atomic_fetch_add (&v, count); + if (v != 4722366482869645213696wb) + abort (); + + atomic_fetch_add_explicit (&v, count, memory_order_consume); + if (v != 9444732965739290427392wb) + abort (); + + atomic_fetch_add (&v, 4722366482869645213696wb); + if (v != 14167099448608935641088wb) + abort (); + + atomic_fetch_add_explicit (&v, 4722366482869645213696wb, + memory_order_release); + if (v != 18889465931478580854784wb) + abort (); + + atomic_fetch_add (&v, 4722366482869645213696wb); + if (v != 23611832414348226068480wb) + abort (); + + atomic_fetch_add_explicit (&v, count, memory_order_seq_cst); + if (v != 28334198897217871282176wb) + abort (); +} + +void +test_sub () +{ + v = res = -3638804536836293398783417724445294828wb; + count = 0; + + atomic_fetch_sub (&v, count + 1); + if (v != --res) + abort (); + + atomic_fetch_sub_explicit (&v, count + 1, memory_order_consume); + if (v != --res) + abort (); + + atomic_fetch_sub (&v, 1); + if (v != --res) + abort (); + + atomic_fetch_sub_explicit (&v, 1, memory_order_release); + if (v != --res) + abort (); + + atomic_fetch_sub (&v, count + 1); + if (v != --res) + abort (); + + atomic_fetch_sub_explicit (&v, count + 1, memory_order_seq_cst); + if (v != --res) + abort (); +} + +void +test_and () +{ + v = init; + + atomic_fetch_and (&v, 0); + if (v != 0) + abort (); + + v = init; + atomic_fetch_and_explicit (&v, init, memory_order_consume); + if (v != init) + abort (); + + atomic_fetch_and (&v, 0); + if (v != 0) + abort (); + + v = ~v; + atomic_fetch_and_explicit (&v, init, memory_order_release); + if (v != init) + abort (); + + atomic_fetch_and (&v, 0); + if (v != 0) + abort (); + + v = ~v; + atomic_fetch_and_explicit (&v, 0, memory_order_seq_cst); + if (v != 0) + abort (); +} + +void +test_xor () +{ + v = init; + count = 0; + + atomic_fetch_xor (&v, count); + if (v != init) + abort (); + + atomic_fetch_xor_explicit (&v, ~count, memory_order_consume); + if (v != 0) + abort (); + + atomic_fetch_xor (&v, 0); + if (v != 0) + abort (); + + atomic_fetch_xor_explicit (&v, ~count, memory_order_release); + if (v != init) + abort (); + + atomic_fetch_xor_explicit (&v, 0, memory_order_acq_rel); + if (v != init) + abort (); + + atomic_fetch_xor (&v, ~count); + if (v != 0) + abort (); +} + +void +test_or () +{ + v = 0; + count = 19342813113834066795298816wb; + + atomic_fetch_or (&v, count); + if (v != 19342813113834066795298816wb) + abort (); + + count *= 2; + atomic_fetch_or_explicit (&v, count, memory_order_consume); + if (v != 58028439341502200385896448wb) + abort (); + + count *= 2; + atomic_fetch_or (&v, 77371252455336267181195264wb); + if (v != 135399691796838467567091712wb) + abort (); + + count *= 2; + atomic_fetch_or_explicit (&v, 154742504910672534362390528wb, + memory_order_release); + if (v != 290142196707511001929482240wb) + abort (); + + count *= 2; + atomic_fetch_or (&v, count); + if (v != 599627206528856070654263296wb) + abort (); + + count *= 2; + atomic_fetch_or_explicit (&v, count, memory_order_seq_cst); + if (v != 1218597226171546208103825408wb) + abort (); +} + +void +test_exchange (void) +{ + atomic_store (&v, 15794812138349191682564933935017390008wb); + if (atomic_exchange (&v, -2166613183393424891717146518563613668wb) + != 15794812138349191682564933935017390008wb + || atomic_load (&v) != -2166613183393424891717146518563613668wb) + abort (); + if (atomic_exchange_explicit (&v, 61251098386268815852902382804483910638wb, + memory_order_relaxed) + != -2166613183393424891717146518563613668wb + || (atomic_load_explicit (&v, memory_order_acquire) + != 61251098386268815852902382804483910638wb)) + abort (); + + count = -2166613183393424891717146518563613668wb; + if (atomic_compare_exchange_strong (&v, &count, + -36677332297536901313774263310237646448wb)) + abort (); + if (count != 61251098386268815852902382804483910638wb + || atomic_load (&v) != 61251098386268815852902382804483910638wb) + abort (); + if (!atomic_compare_exchange_strong (&v, &count, + -36677332297536901313774263310237646448wb)) + abort (); + if (count != 61251098386268815852902382804483910638wb + || atomic_load (&v) != -36677332297536901313774263310237646448wb) + abort (); + + count = -2166613183393424891717146518563613668wb; + if (atomic_compare_exchange_strong_explicit (&v, &count, + 73949932022761409003352953944661689416wb, + memory_order_seq_cst, + memory_order_relaxed)) + abort (); + if (count != -36677332297536901313774263310237646448wb + || atomic_load (&v) != -36677332297536901313774263310237646448wb) + abort (); + if (!atomic_compare_exchange_strong_explicit (&v, &count, + 73949932022761409003352953944661689416wb, + memory_order_seq_cst, + memory_order_seq_cst)) + abort (); + if (count != -36677332297536901313774263310237646448wb + || atomic_load (&v) != 73949932022761409003352953944661689416wb) + abort (); + + count = atomic_load (&v); + do + res = count + -82256758205518164043596305502815392646wb; + while (!atomic_compare_exchange_weak (&v, &count, res)); + if (atomic_load (&v) != -8306826182756755040243351558153703230wb) + abort (); + + count = atomic_load_explicit (&v, memory_order_acquire); + do + res = count + 48855144829609538366772317026461909818wb; + while (!atomic_compare_exchange_weak_explicit (&v, &count, res, + memory_order_relaxed, + memory_order_relaxed)); + if (atomic_load (&v) != 40548318646852783326528965468308206588wb) + abort (); +} +#endif + +int +main () +{ +#if __BITINT_MAXWIDTH__ >= 127 + test_fetch_add (); + test_fetch_sub (); + test_fetch_and (); + test_fetch_xor (); + test_fetch_or (); + test_add (); + test_sub (); + test_and (); + test_xor (); + test_or (); + test_exchange (); +#endif + return 0; +} --- gcc/testsuite/gcc.dg/atomic/stdatomic-bitint-2.c.jj 2023-08-08 14:13:30.189642285 +0200 +++ gcc/testsuite/gcc.dg/atomic/stdatomic-bitint-2.c 2023-08-08 15:46:24.856469613 +0200 @@ -0,0 +1,450 @@ +/* PR c/102989 */ +/* { dg-do run { target bitint } } */ +/* { dg-options "-std=c2x -pedantic-errors" } */ + +#include + +extern void abort (void); + +#if __BITINT_MAXWIDTH__ >= 575 +_Atomic _BitInt(575) v; +_BitInt(575) count, res; +const _BitInt(575) init = ~(_BitInt(575)) 0wb; + +void +test_fetch_add () +{ + atomic_init (&v, 59465222573183779324781274162178653782927579944977967117312772499849358939735575735090252965265846823956223131844773977101864574011188590603103408821590130462520809924774161wb); + count = 21849324526703540909725517290562575722142104889154621021004438836543599493803029317660194646869455042293514095831327249339063542203879269024249546998746919066599380031180974wb; + + if (atomic_fetch_add_explicit (&v, count, memory_order_relaxed) + != 59465222573183779324781274162178653782927579944977967117312772499849358939735575735090252965265846823956223131844773977101864574011188590603103408821590130462520809924774161wb) + abort (); + + if (atomic_fetch_add_explicit (&v, -48324598397571087754171506195219221853271763472221035086980364394554212400270766919963305485900701475788840363160834710492683133292253640988518950921616217692973141455340373wb, + memory_order_consume) + != -42350653636664946795744469057082365512495989716473331818714316710055654119727328532407752918486220628549098485331968443234754400938307745356420121730609534429183196118394433wb) + abort (); + + if (atomic_fetch_add_explicit (&v, count, memory_order_acquire) + != 32989948702316232480335285257522007651797921361911553051336846941838746033267838132787142126234600390460896864515266515948244982922814218638834004898720831836147048500614762wb) + abort (); + + if (atomic_fetch_add_explicit (&v, 6958312589905983216078981134518695082538588883298046610645489916662738759809700053844918067866491080683973037493524864531300139437943661326918145212620326291059845453630984wb, + memory_order_release) + != 54839273229019773390060802548084583373940026251066174072341285778382345527070867450447336773104055432754410960346593765287308525126693487663083551897467750902746428531795736wb) + abort (); + + if (atomic_fetch_add_explicit (&v, count, memory_order_acq_rel) + != 61797585818925756606139783682603278456478615134364220682986775695045084286880567504292254840970546513438383997840118629818608664564637148990001697110088077193806273985426720wb) + abort (); + + if (atomic_fetch_add_explicit (&v, -40070085597220253007443375012839311464160438432662764715171645999337062215395237625623334979615599652975898123428005079853660189572782012739700306191422569739682093304494995wb, + memory_order_seq_cst) + != -40018290390922969514385959536657740838944954527087078253040313514859928772582336763205751042781520939066937619336623790518010310384859186969521833442111587697897732057741874wb) + abort (); + + if (atomic_fetch_add (&v, 7196090098608011755205055682070541953902689411792805630101863619558545582022760829169235622333653743217332966939875542415224317593660770300818700993340012969018217868600175wb) + != 43576824748409044508421925960326542714460281590856076988819568532251621565288359196329114508224401902755999970243440799304012017195734405274550937917412426520723560712112699wb) + abort (); + + if (atomic_load (&v) != 50772914847017056263626981642397084668362971002648882618921432151810167147311120025498350130558055645973332937183316341719236334789395175575369638910752439489741778580712874wb) + abort (); +} + +void +test_fetch_sub () +{ + atomic_store_explicit (&v, -24875491091433158113922205635657739252057730543056417031972993454853665637813018617125143194799847437263037065304695383952916979113678037118532311779822859742705294727822376wb, + memory_order_release); + count = 6813702694653136917886567607003795360731391695538381923575500076220746287948057449348609672603971831069550813465757196210073636056135824219022209113495061317682354090030599wb; + + if (atomic_fetch_sub_explicit (&v, count, memory_order_relaxed) + != -24875491091433158113922205635657739252057730543056417031972993454853665637813018617125143194799847437263037065304695383952916979113678037118532311779822859742705294727822376wb) + abort (); + + if (atomic_fetch_sub_explicit (&v, 8502925336737158389204618905966437550402192530184998378452912098895816391400915282714213521081597588768568861040471642522181200007537708168290327879425612502090295717806034wb, + memory_order_consume) + != -31689193786086295031808773242661534612789122238594798955548493531074411925761076066473752867403819268332587878770452580162990615169813861337554520893317921060387648817852975wb) + abort (); + + if (atomic_fetch_sub_explicit (&v, count, memory_order_acquire) + != -40192119122823453421013392148627972163191314768779797334001405629970228317161991349187966388485416857101156739810924222685171815177351569505844848772743533562477944535659009wb) + abort (); + + if (atomic_fetch_sub_explicit (&v, -14654459030451169455889477114198307761108411115104251375487725308584250511764953921137486025925617622862411621191578047606524662379041353882420330350079004108508600686109553wb, + memory_order_release) + != -47005821817476590338899959755631767523922706464318179257576905706190974605110048798536576061089388688170707553276681418895245451233487393724867057886238594880160298625689608wb) + abort (); + + if (atomic_fetch_sub_explicit (&v, count, memory_order_acq_rel) + != -32351362787025420883010482641433459762814295349213927882089180397606724093345094877399090035163771065308295932085103371288720788854446039842446727536159590771651697939580055wb) + abort (); + + if (atomic_fetch_sub_explicit (&v, 22886836433700729148520267039236396292049781709943309196356241086882444816631218673962641435859436811686812355905147988710440709035301495069683757516099446883747069843672565wb, + memory_order_seq_cst) + != -39165065481678557800897050248437255123545687044752309805664680473827470381293152326747699707767742896377846745550860567498794424910581864061468936649654652089334052029610654wb) + abort (); + + if (atomic_fetch_sub (&v, 49406467535448986167225179068150076098092817730200780462287871488076089290458383699602612866098591282427581289588523598202726797161439183859560135056424525356253246480887928wb) + != 61613298821172980080833943222149943601970205795910300955010606485738697355341562584447859386994342786734176611552061113466447383207492245852620383385192484985222264201066349wb) + abort (); + + if (atomic_load_explicit (&v, memory_order_acquire) + != 12206831285723993913608764153999867503877388065709520492722734997662608064883178884845246520895751504306595321963537515263720586046053061993060248328767959628969017720178421wb) + abort (); +} + +void +test_fetch_and () +{ + atomic_store (&v, init); + + if (atomic_fetch_and_explicit (&v, 0, memory_order_relaxed) != init) + abort (); + + if (atomic_fetch_and_explicit (&v, init, memory_order_consume) != 0) + abort (); + + if (atomic_fetch_and_explicit (&v, 0, memory_order_acquire) != 0) + abort (); + + v = ~v; + if (atomic_fetch_and_explicit (&v, init, memory_order_release) != init) + abort (); + + if (atomic_fetch_and_explicit (&v, 0, memory_order_acq_rel) != init) + abort (); + + if (atomic_fetch_and_explicit (&v, 0, memory_order_seq_cst) != 0) + abort (); + + if (atomic_fetch_and (&v, 0) != 0) + abort (); +} + +void +test_fetch_xor () +{ + v = init; + count = 0; + + if (atomic_fetch_xor_explicit (&v, count, memory_order_relaxed) != init) + abort (); + + if (atomic_fetch_xor_explicit (&v, ~count, memory_order_consume) != init) + abort (); + + if (atomic_fetch_xor_explicit (&v, 0, memory_order_acquire) != 0) + abort (); + + if (atomic_fetch_xor_explicit (&v, ~count, memory_order_release) != 0) + abort (); + + if (atomic_fetch_xor_explicit (&v, 0, memory_order_acq_rel) != init) + abort (); + + if (atomic_fetch_xor_explicit (&v, ~count, memory_order_seq_cst) != init) + abort (); + + if (atomic_fetch_xor (&v, ~count) != 0) + abort (); +} + +void +test_fetch_or () +{ + v = 0wb; + count = 28269553036454149273332760011886696253239742350009903329945699220681916416wb; + + if (atomic_fetch_or_explicit (&v, count, memory_order_relaxed) != 0wb) + abort (); + + count *= 2; + if (atomic_fetch_or_explicit (&v, 56539106072908298546665520023773392506479484700019806659891398441363832832wb, + memory_order_consume) + != 28269553036454149273332760011886696253239742350009903329945699220681916416wb) + abort (); + + count *= 2; + if (atomic_fetch_or_explicit (&v, count, memory_order_acquire) + != 84808659109362447819998280035660088759719227050029709989837097662045749248wb) + abort (); + + count *= 2; + if (atomic_fetch_or_explicit (&v, 226156424291633194186662080095093570025917938800079226639565593765455331328wb, + memory_order_release) + != 197886871255179044913329320083206873772678196450069323309619894544773414912wb) + abort (); + + count *= 2; + if (atomic_fetch_or_explicit (&v, count, memory_order_acq_rel) + != 424043295546812239099991400178300443798596135250148549949185488310228746240wb) + abort (); + + count *= 2; + if (atomic_fetch_or_explicit (&v, count, memory_order_seq_cst) + != 876356144130078627473315560368487583850432012850307003228316675841139408896wb) + abort (); + + count *= 2; + if (atomic_fetch_or (&v, count) != 1780981841296611404219963880748861863954103768050623909786579050902960734208wb) + abort (); +} + + +/* Test the OP routines with a result which isn't used. */ + +void +test_add () +{ + v = 0; + count = 1486842905609751694333995980623369134886360644481888406879896752089037065255179570086557965294767349553406889549100250674362935254187127254353474822610854717612397677wb; + + atomic_fetch_add (&v, count); + if (v != 1486842905609751694333995980623369134886360644481888406879896752089037065255179570086557965294767349553406889549100250674362935254187127254353474822610854717612397677wb) + abort (); + + atomic_fetch_add_explicit (&v, count, memory_order_consume); + if (v != 2973685811219503388667991961246738269772721288963776813759793504178074130510359140173115930589534699106813779098200501348725870508374254508706949645221709435224795354wb) + abort (); + + atomic_fetch_add (&v, 1486842905609751694333995980623369134886360644481888406879896752089037065255179570086557965294767349553406889549100250674362935254187127254353474822610854717612397677wb); + if (v != 4460528716829255083001987941870107404659081933445665220639690256267111195765538710259673895884302048660220668647300752023088805762561381763060424467832564152837193031wb) + abort (); + + atomic_fetch_add_explicit (&v, 1486842905609751694333995980623369134886360644481888406879896752089037065255179570086557965294767349553406889549100250674362935254187127254353474822610854717612397677wb, + memory_order_release); + if (v != 5947371622439006777335983922493476539545442577927553627519587008356148261020718280346231861179069398213627558196401002697451741016748509017413899290443418870449590708wb) + abort (); + + atomic_fetch_add (&v, 1486842905609751694333995980623369134886360644481888406879896752089037065255179570086557965294767349553406889549100250674362935254187127254353474822610854717612397677wb); + if (v != 7434214528048758471669979903116845674431803222409442034399483760445185326275897850432789826473836747767034447745501253371814676270935636271767374113054273588061988385wb) + abort (); + + atomic_fetch_add_explicit (&v, count, memory_order_seq_cst); + if (v != 8921057433658510166003975883740214809318163866891330441279380512534222391531077420519347791768604097320441337294601504046177611525122763526120848935665128305674386062wb) + abort (); +} + +void +test_sub () +{ + v = res = 55339930658115792138308584702507715233391812567721958037499562620485942364609138719919541704955047331226014242859673113345829202990143617633801993282898070230404539826267403wb; + count = 0; + + atomic_fetch_sub (&v, count + 2266681016524228072657464685355732111725088152428495977635446886262656759828446929716740827028716649170693025791717921736186782036315322643449879013364541057wb); + res -= 2266681016524228072657464685355732111725088152428495977635446886262656759828446929716740827028716649170693025791717921736186782036315322643449879013364541057wb; + if (v != res) + abort (); + + atomic_fetch_sub_explicit (&v, count + 2266681016524228072657464685355732111725088152428495977635446886262656759828446929716740827028716649170693025791717921736186782036315322643449879013364541057wb, memory_order_consume); + res -= 2266681016524228072657464685355732111725088152428495977635446886262656759828446929716740827028716649170693025791717921736186782036315322643449879013364541057wb; + if (v != res) + abort (); + + atomic_fetch_sub (&v, 2266681016524228072657464685355732111725088152428495977635446886262656759828446929716740827028716649170693025791717921736186782036315322643449879013364541057wb); + res -= 2266681016524228072657464685355732111725088152428495977635446886262656759828446929716740827028716649170693025791717921736186782036315322643449879013364541057wb; + if (v != res) + abort (); + + atomic_fetch_sub_explicit (&v, 2266681016524228072657464685355732111725088152428495977635446886262656759828446929716740827028716649170693025791717921736186782036315322643449879013364541057wb, memory_order_release); + res -= 2266681016524228072657464685355732111725088152428495977635446886262656759828446929716740827028716649170693025791717921736186782036315322643449879013364541057wb; + if (v != res) + abort (); + + atomic_fetch_sub (&v, count + 2266681016524228072657464685355732111725088152428495977635446886262656759828446929716740827028716649170693025791717921736186782036315322643449879013364541057wb); + res -= 2266681016524228072657464685355732111725088152428495977635446886262656759828446929716740827028716649170693025791717921736186782036315322643449879013364541057wb; + if (v != res) + abort (); + + atomic_fetch_sub_explicit (&v, count + 2266681016524228072657464685355732111725088152428495977635446886262656759828446929716740827028716649170693025791717921736186782036315322643449879013364541057wb, memory_order_seq_cst); + res -= 2266681016524228072657464685355732111725088152428495977635446886262656759828446929716740827028716649170693025791717921736186782036315322643449879013364541057wb; + if (v != res) + abort (); +} + +void +test_and () +{ + v = init; + + atomic_fetch_and (&v, 0); + if (v != 0) + abort (); + + v = init; + atomic_fetch_and_explicit (&v, init, memory_order_consume); + if (v != init) + abort (); + + atomic_fetch_and (&v, 0); + if (v != 0) + abort (); + + v = ~v; + atomic_fetch_and_explicit (&v, init, memory_order_release); + if (v != init) + abort (); + + atomic_fetch_and (&v, 0); + if (v != 0) + abort (); + + v = ~v; + atomic_fetch_and_explicit (&v, 0, memory_order_seq_cst); + if (v != 0) + abort (); +} + +void +test_xor () +{ + v = init; + count = 0; + + atomic_fetch_xor (&v, count); + if (v != init) + abort (); + + atomic_fetch_xor_explicit (&v, ~count, memory_order_consume); + if (v != 0) + abort (); + + atomic_fetch_xor (&v, 0); + if (v != 0) + abort (); + + atomic_fetch_xor_explicit (&v, ~count, memory_order_release); + if (v != init) + abort (); + + atomic_fetch_xor_explicit (&v, 0, memory_order_acq_rel); + if (v != init) + abort (); + + atomic_fetch_xor (&v, ~count); + if (v != 0) + abort (); +} + +void +test_or () +{ + v = 0; + count = 19342813113834066795298816wb; + + atomic_fetch_or (&v, count); + if (v != 19342813113834066795298816wb) + abort (); + + count *= 2; + atomic_fetch_or_explicit (&v, count, memory_order_consume); + if (v != 58028439341502200385896448wb) + abort (); + + count *= 2; + atomic_fetch_or (&v, 77371252455336267181195264wb); + if (v != 135399691796838467567091712wb) + abort (); + + count *= 2; + atomic_fetch_or_explicit (&v, 154742504910672534362390528wb, + memory_order_release); + if (v != 290142196707511001929482240wb) + abort (); + + count *= 2; + atomic_fetch_or (&v, count); + if (v != 599627206528856070654263296wb) + abort (); + + count *= 2; + atomic_fetch_or_explicit (&v, count, memory_order_seq_cst); + if (v != 1218597226171546208103825408wb) + abort (); +} + +void +test_exchange (void) +{ + atomic_store (&v, -285679222948993342888321238830899996788334328454283006589115162661816862491992700267590986826514460282130796141107636816730207482542791159837024986802592659048696136633096wb); + if (atomic_exchange (&v, 5310030317361876753340683501073244375280341322936688061997080395958520351093955920782059690068348979597317732862920837580508090330213951646930178946470395395144632931547601wb) + != -285679222948993342888321238830899996788334328454283006589115162661816862491992700267590986826514460282130796141107636816730207482542791159837024986802592659048696136633096wb + || atomic_load (&v) != 5310030317361876753340683501073244375280341322936688061997080395958520351093955920782059690068348979597317732862920837580508090330213951646930178946470395395144632931547601wb) + abort (); + if (atomic_exchange_explicit (&v, -4427613371507571222951705350055906255006016685171218855857415580222001757304647519678682295710994407542058879878792272713121656498918585491540313864044915269100507689612649wb, + memory_order_relaxed) + != 5310030317361876753340683501073244375280341322936688061997080395958520351093955920782059690068348979597317732862920837580508090330213951646930178946470395395144632931547601wb + || (atomic_load_explicit (&v, memory_order_acquire) + != -4427613371507571222951705350055906255006016685171218855857415580222001757304647519678682295710994407542058879878792272713121656498918585491540313864044915269100507689612649wb)) + abort (); + + count = 5310030317361876753340683501073244375280341322936688061997080395958520351093955920782059690068348979597317732862920837580508090330213951646930178946470395395144632931547601wb; + if (atomic_compare_exchange_strong (&v, &count, + 8894166061872682036448354332319628975793195843703235778626260413018342611721096976767565811189387129127069300488196032026080940074010266394902215699511191435840967345778707wb)) + abort (); + if (count != -4427613371507571222951705350055906255006016685171218855857415580222001757304647519678682295710994407542058879878792272713121656498918585491540313864044915269100507689612649wb + || atomic_load (&v) != -4427613371507571222951705350055906255006016685171218855857415580222001757304647519678682295710994407542058879878792272713121656498918585491540313864044915269100507689612649wb) + abort (); + if (!atomic_compare_exchange_strong (&v, &count, + 8894166061872682036448354332319628975793195843703235778626260413018342611721096976767565811189387129127069300488196032026080940074010266394902215699511191435840967345778707wb)) + abort (); + if (count != -4427613371507571222951705350055906255006016685171218855857415580222001757304647519678682295710994407542058879878792272713121656498918585491540313864044915269100507689612649wb + || atomic_load (&v) != 8894166061872682036448354332319628975793195843703235778626260413018342611721096976767565811189387129127069300488196032026080940074010266394902215699511191435840967345778707wb) + abort (); + + count = 5310030317361876753340683501073244375280341322936688061997080395958520351093955920782059690068348979597317732862920837580508090330213951646930178946470395395144632931547601wb; + if (atomic_compare_exchange_strong_explicit (&v, &count, + -20263258027145541347005514871938569231358927704236809883668741851321168433670480594273940614283839738125120292424689828120954658857299483460682957837178666219043928324493674wb, + memory_order_seq_cst, + memory_order_relaxed)) + abort (); + if (count != 8894166061872682036448354332319628975793195843703235778626260413018342611721096976767565811189387129127069300488196032026080940074010266394902215699511191435840967345778707wb + || atomic_load (&v) != 8894166061872682036448354332319628975793195843703235778626260413018342611721096976767565811189387129127069300488196032026080940074010266394902215699511191435840967345778707wb) + abort (); + if (!atomic_compare_exchange_strong_explicit (&v, &count, + -20263258027145541347005514871938569231358927704236809883668741851321168433670480594273940614283839738125120292424689828120954658857299483460682957837178666219043928324493674wb, + memory_order_seq_cst, + memory_order_seq_cst)) + abort (); + if (count != 8894166061872682036448354332319628975793195843703235778626260413018342611721096976767565811189387129127069300488196032026080940074010266394902215699511191435840967345778707wb + || atomic_load (&v) != -20263258027145541347005514871938569231358927704236809883668741851321168433670480594273940614283839738125120292424689828120954658857299483460682957837178666219043928324493674wb) + abort (); + + count = atomic_load (&v); + do + res = count + 3438682542819842029328613486899299339199839206022263296398180581126218550036955367421469273900216774711772362599086182416923053671263751262393559525082445581168420546542404wb; + while (!atomic_compare_exchange_weak (&v, &count, res)); + if (atomic_load (&v) != -16824575484325699317676901385039269892159088498214546587270561270194949883633525226852471340383622963413347929825603645704031605186035732198289398312096220637875507777951270wb) + abort (); + + count = atomic_load_explicit (&v, memory_order_acquire); + do + res = count + 55351299008567209999272942257960316150846002020561006740901388462123844029522178721330031429855007927083338249659817829635668878607777961512926342979905691183772323299904096wb; + while (!atomic_compare_exchange_weak_explicit (&v, &count, res, + memory_order_relaxed, + memory_order_relaxed)); + if (atomic_load (&v) != 38526723524241510681596040872921046258686913522346460153630827191928894145888653494477560089471384963669990319834214183931637273421742229314636944667809470545896815521952826wb) + abort (); +} +#endif + +int +main () +{ +#if __BITINT_MAXWIDTH__ >= 575 + test_fetch_add (); + test_fetch_sub (); + test_fetch_and (); + test_fetch_xor (); + test_fetch_or (); + test_add (); + test_sub (); + test_and (); + test_xor (); + test_or (); + test_exchange (); +#endif + return 0; +}