From patchwork Fri Nov 17 15:24:39 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Richard Sandiford X-Patchwork-Id: 119165 Delivered-To: patch@linaro.org Received: by 10.80.225.132 with SMTP id k4csp763988edl; Fri, 17 Nov 2017 07:25:03 -0800 (PST) X-Google-Smtp-Source: AGs4zMZ0sWUl12oLjpRW57ee/JwnNtNWE18VkRa2xoG4+8A1ymyGY1kjujw2t/rF9AIiOusqn67c X-Received: by 10.159.194.204 with SMTP id u12mr5609370plz.191.1510932303051; Fri, 17 Nov 2017 07:25:03 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1510932303; cv=none; d=google.com; s=arc-20160816; b=POX8JPhso5xg/ks2DM8R4uEJyYju9Y8vCzJbBsTumpewqaKfc3rjZnMOas/toNHzBE NalUhVvGLfEe9gZcdsZ3ZOfC/EASUonP+b7tiMckYk81aDW2M9FhkaEF/MksuTd3+KUr 62/pX8pkSEVoe2TbaMSmffzziJnzi9H5Kp+XxTeCSZdjm3PTUp9pmmhVqGsl5hoPcwAP oT+WpG0SXe6u7Dj/bqmAD/hrouTkxIrIPHMTO9KY3AzlgzTvR19QV98LDrGdxAnbOk/g m4bux0ReRlnItdNXcNh1BvHQvQEk5UD8McVv4fe/cmRoof+L0IdR01aYCAakWCWTMB7k XNkg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=mime-version:user-agent:message-id:date:subject:mail-followup-to:to :from:delivered-to:sender:list-help:list-post:list-archive :list-unsubscribe:list-id:precedence:mailing-list:dkim-signature :domainkey-signature:arc-authentication-results; bh=oDI03kUfxVDTVlDuKkzRFxHXf0TU0rbycbMsmBXcTys=; b=B2rZrEXkeEyZIghLUD5m2BLmPgDVqf1TCPfBwfxTJk/JaZJhCos0FK1Y6P+v0WkxF1 1ZKOECa7vfVd8b2DzV5rshOecakiqpEm5s7Tj0VxMhiG12COtKOZabw69ivDGA+YXrtz a3XkgIVwDMzN9LEX7titgGELAyNQgYZuVBrjA0IZUSm+5nyjBg5ouTz29TzDwxNaHLeX GcFQSwWq4khVfIHY5x8cLp0avEVtQh2T+V3PiVQfqVpdJVdmEwnFFhqbQAgyOdXBDrJR CiFBXirC34ARxmxGRmROUpprnTpSPYictjg2ViYWPhoSERlg4v076nlI8eoT0Q8Tz/kI 0CaA== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@gcc.gnu.org header.s=default header.b=mzNwJmQ/; spf=pass (google.com: domain of gcc-patches-return-467153-patch=linaro.org@gcc.gnu.org designates 209.132.180.131 as permitted sender) smtp.mailfrom=gcc-patches-return-467153-patch=linaro.org@gcc.gnu.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from sourceware.org (server1.sourceware.org. [209.132.180.131]) by mx.google.com with ESMTPS id p8si2950838plr.145.2017.11.17.07.25.02 for (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Fri, 17 Nov 2017 07:25:03 -0800 (PST) Received-SPF: pass (google.com: domain of gcc-patches-return-467153-patch=linaro.org@gcc.gnu.org designates 209.132.180.131 as permitted sender) client-ip=209.132.180.131; Authentication-Results: mx.google.com; dkim=pass header.i=@gcc.gnu.org header.s=default header.b=mzNwJmQ/; spf=pass (google.com: domain of gcc-patches-return-467153-patch=linaro.org@gcc.gnu.org designates 209.132.180.131 as permitted sender) smtp.mailfrom=gcc-patches-return-467153-patch=linaro.org@gcc.gnu.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=linaro.org DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:from :to:subject:date:message-id:mime-version:content-type; q=dns; s= default; b=ZI03c+bTHTkK6OPJxkLjTen19xIMyA0T8SJjeXt/NpQWoRjVEQUlC zaiOgnAmwN7ropNiAz+4i6Hq7QJ7TbflnGklnhEoeWGUw2UqL+dXC3t044XfTdK/ oqOF21EYR+RV81Cot+bHulGo8nLhkQKnsKITTF5y4UVTqSVBq+Z36A= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:from :to:subject:date:message-id:mime-version:content-type; s= default; bh=pE7k7gDF6aEWuH6fsSXf2EaZkpU=; b=mzNwJmQ/ApRHQiEik5Zz 0AcPg3aKe/NpOGYwKa9fRhSHMsEVNb9rGx99NdE2pRwrdXrVnYr9YwOeKi9xN9rd cS6doWOZcL10aRJTWfsgSXDtU1eQFhQUHqJypvxJczxSaPxZLcmxDBqsj04jd4HV 4ibbVfnz/Lt3VHs7lh2RGtI= Received: (qmail 56920 invoked by alias); 17 Nov 2017 15:24:47 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Received: (qmail 56908 invoked by uid 89); 17 Nov 2017 15:24:46 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-15.3 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, KAM_ASCII_DIVIDERS, KB_WAM_FROM_NAME_SINGLEWORD, RCVD_IN_DNSWL_NONE, SPF_PASS autolearn=ham version=3.3.2 spammy= X-HELO: mail-wr0-f180.google.com Received: from mail-wr0-f180.google.com (HELO mail-wr0-f180.google.com) (209.85.128.180) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Fri, 17 Nov 2017 15:24:43 +0000 Received: by mail-wr0-f180.google.com with SMTP id o14so2409287wrf.9 for ; Fri, 17 Nov 2017 07:24:43 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:mail-followup-to:subject:date:message-id :user-agent:mime-version; bh=oDI03kUfxVDTVlDuKkzRFxHXf0TU0rbycbMsmBXcTys=; b=BD8Ff1kuN3E1xcM6cYs3EiwSxs3s/eE99NSR+wdK77Uyb7DVELUCSIeljKiqRQpSB9 kpmPd/AbrlhXKmEpHw5If4kIbKLc73Nnr8gtH2C3ax2dVl52+QYAyF6GTdybOaArX108 L59gsQJ6vYa/4WdvkVt888O7Ynil03NyqwLRFxLx6EeLcZ4lLmDQ8nBUqlAeH44WlOxW qSmflemwSdqQLmfwy/MjOk2A69EhoUtBD4ZqWmgqf5a9KONmcSWF06lIDZPKoQknunKX VRHdkaJTGHsork+Gkz2fvsq2YlguUhAqHzkMlY+lmSWdNfLmrc1gxmTGYd8pMbt1gIgh 3M6g== X-Gm-Message-State: AJaThX6ZOrvVDi6wzIjlvq7+ZLPf/oHqyoziFSvNPks5t/nfisTqr7WU IunhZ6jmpjhvip9H4Zkt60IJDE2qV7s= X-Received: by 10.223.202.1 with SMTP id o1mr4949356wrh.233.1510932281146; Fri, 17 Nov 2017 07:24:41 -0800 (PST) Received: from localhost ([2.25.234.120]) by smtp.gmail.com with ESMTPSA id n32sm3779180wrb.62.2017.11.17.07.24.39 for (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Fri, 17 Nov 2017 07:24:40 -0800 (PST) From: Richard Sandiford To: gcc-patches@gcc.gnu.org Mail-Followup-To: gcc-patches@gcc.gnu.org, richard.sandiford@linaro.org Subject: Add support for vectorising live-out values using SVE LASTB Date: Fri, 17 Nov 2017 15:24:39 +0000 Message-ID: <87wp2px70o.fsf@linaro.org> User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/25.3 (gnu/linux) MIME-Version: 1.0 This patch uses the SVE LASTB instruction to optimise cases in which a value produced by the final scalar iteration of a vectorised loop is live outside the loop. Previously this situation would stop us from using a fully-masked loop. Tested on aarch64-linux-gnu (with and without SVE), x86_64-linux-gnu and powerpc64le-linux-gnu. OK to install? Richard 2017-11-17 Richard Sandiford Alan Hayward David Sherwood gcc/ * doc/md.texi (extract_last_@var{m}): Document. * optabs.def (extract_last_optab): New optab. * internal-fn.def (EXTRACT_LAST): New internal function. * internal-fn.c (cond_unary_direct): New macro. (expand_cond_unary_optab_fn): Likewise. (direct_cond_unary_optab_supported_p): Likewise. * tree-vect-loop.c (vectorizable_live_operation): Allow fully-masked loops using EXTRACT_LAST. * config/aarch64/aarch64-sve.md (aarch64_sve_lastb): Rename to... (extract_last_): ...this optab. (vec_extract): Update accordingly. gcc/testsuite/ * gcc.target/aarch64/sve_live_1.c: New test. * gcc.target/aarch64/sve_live_1_run.c: Likewise. Index: gcc/doc/md.texi =================================================================== --- gcc/doc/md.texi 2017-11-17 15:23:55.844062247 +0000 +++ gcc/doc/md.texi 2017-11-17 15:23:56.035829132 +0000 @@ -5268,6 +5268,14 @@ of a vector of mode @var{m}. Operand 1 is the scalar result. The mode of the scalar result is the same as one element of @var{m}. +@cindex @code{extract_last_@var{m}} instruction pattern +@item @code{extract_last_@var{m}} +Find the last set bit in mask operand 1 and extract the associated element +of vector operand 2. Store the result in scalar operand 0. Operand 2 +has vector mode @var{m} while operand 0 has the mode appropriate for one +element of @var{m}. Operand 1 has the usual mask mode for vectors of mode +@var{m}; see @code{TARGET_VECTORIZE_GET_MASK_MODE}. + @cindex @code{sdot_prod@var{m}} instruction pattern @item @samp{sdot_prod@var{m}} @cindex @code{udot_prod@var{m}} instruction pattern Index: gcc/optabs.def =================================================================== --- gcc/optabs.def 2017-11-17 15:23:55.844062247 +0000 +++ gcc/optabs.def 2017-11-17 15:23:56.035829132 +0000 @@ -307,6 +307,8 @@ OPTAB_D (reduc_and_scal_optab, "reduc_a OPTAB_D (reduc_ior_scal_optab, "reduc_ior_scal_$a") OPTAB_D (reduc_xor_scal_optab, "reduc_xor_scal_$a") +OPTAB_D (extract_last_optab, "extract_last_$a") + OPTAB_D (sdot_prod_optab, "sdot_prod$I$a") OPTAB_D (ssum_widen_optab, "widen_ssum$I$a3") OPTAB_D (udot_prod_optab, "udot_prod$I$a") Index: gcc/internal-fn.def =================================================================== --- gcc/internal-fn.def 2017-11-17 15:23:55.844062247 +0000 +++ gcc/internal-fn.def 2017-11-17 15:23:56.035829132 +0000 @@ -142,6 +142,10 @@ DEF_INTERNAL_COND_OPTAB_FN (XOR, ECF_CON DEF_INTERNAL_OPTAB_FN (RSQRT, ECF_CONST, rsqrt, unary) +/* Extract the last active element from a vector. */ +DEF_INTERNAL_OPTAB_FN (EXTRACT_LAST, ECF_CONST | ECF_NOTHROW, + extract_last, cond_unary) + /* Unary math functions. */ DEF_INTERNAL_FLT_FN (ACOS, ECF_CONST, acos, unary) DEF_INTERNAL_FLT_FN (ASIN, ECF_CONST, asin, unary) Index: gcc/internal-fn.c =================================================================== --- gcc/internal-fn.c 2017-11-17 15:23:55.844062247 +0000 +++ gcc/internal-fn.c 2017-11-17 15:23:56.035829132 +0000 @@ -88,6 +88,7 @@ #define store_lanes_direct { 0, 0, false #define mask_store_lanes_direct { 0, 0, false } #define unary_direct { 0, 0, true } #define binary_direct { 0, 0, true } +#define cond_unary_direct { 1, 1, true } #define cond_binary_direct { 1, 1, true } #define while_direct { 0, 2, false } @@ -2826,6 +2827,9 @@ #define expand_unary_optab_fn(FN, STMT, #define expand_binary_optab_fn(FN, STMT, OPTAB) \ expand_direct_optab_fn (FN, STMT, OPTAB, 2) +#define expand_cond_unary_optab_fn(FN, STMT, OPTAB) \ + expand_direct_optab_fn (FN, STMT, OPTAB, 2) + #define expand_cond_binary_optab_fn(FN, STMT, OPTAB) \ expand_direct_optab_fn (FN, STMT, OPTAB, 3) @@ -2902,6 +2906,7 @@ multi_vector_optab_supported_p (convert_ #define direct_unary_optab_supported_p direct_optab_supported_p #define direct_binary_optab_supported_p direct_optab_supported_p +#define direct_cond_unary_optab_supported_p direct_optab_supported_p #define direct_cond_binary_optab_supported_p direct_optab_supported_p #define direct_mask_load_optab_supported_p direct_optab_supported_p #define direct_load_lanes_optab_supported_p multi_vector_optab_supported_p Index: gcc/tree-vect-loop.c =================================================================== --- gcc/tree-vect-loop.c 2017-11-17 15:23:55.844062247 +0000 +++ gcc/tree-vect-loop.c 2017-11-17 15:23:56.036742308 +0000 @@ -7643,16 +7643,43 @@ vectorizable_live_operation (gimple *stm if (!vec_stmt) { + /* No transformation required. */ if (LOOP_VINFO_CAN_FULLY_MASK_P (loop_vinfo)) { - if (dump_enabled_p ()) - dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, - "can't use a fully-masked loop because " - "a value is live outside the loop.\n"); - LOOP_VINFO_CAN_FULLY_MASK_P (loop_vinfo) = false; + if (!direct_internal_fn_supported_p (IFN_EXTRACT_LAST, vectype, + OPTIMIZE_FOR_SPEED)) + { + if (dump_enabled_p ()) + dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, + "can't use a fully-masked loop because " + "the target doesn't support extract last " + "reduction.\n"); + LOOP_VINFO_CAN_FULLY_MASK_P (loop_vinfo) = false; + } + else if (slp_node) + { + if (dump_enabled_p ()) + dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, + "can't use a fully-masked loop because an " + "SLP statement is live after the loop.\n"); + LOOP_VINFO_CAN_FULLY_MASK_P (loop_vinfo) = false; + } + else if (ncopies > 1) + { + if (dump_enabled_p ()) + dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, + "can't use a fully-masked loop because" + " ncopies is greater than 1.\n"); + LOOP_VINFO_CAN_FULLY_MASK_P (loop_vinfo) = false; + } + else + { + gcc_assert (ncopies == 1 && !slp_node); + vect_record_loop_mask (loop_vinfo, + &LOOP_VINFO_MASKS (loop_vinfo), + 1, vectype); + } } - - /* No transformation required. */ return true; } @@ -7686,6 +7713,8 @@ vectorizable_live_operation (gimple *stm { enum vect_def_type dt = STMT_VINFO_DEF_TYPE (stmt_info); vec_lhs = vect_get_vec_def_for_operand_1 (stmt, dt); + gcc_checking_assert (ncopies == 1 + || !LOOP_VINFO_FULLY_MASKED_P (loop_vinfo)); /* For multiple copies, get the last copy. */ for (int i = 1; i < ncopies; ++i) @@ -7696,15 +7725,39 @@ vectorizable_live_operation (gimple *stm bitstart = int_const_binop (MINUS_EXPR, vec_bitsize, bitsize); } - /* Create a new vectorized stmt for the uses of STMT and insert outside the - loop. */ gimple_seq stmts = NULL; - tree bftype = TREE_TYPE (vectype); - if (VECTOR_BOOLEAN_TYPE_P (vectype)) - bftype = build_nonstandard_integer_type (tree_to_uhwi (bitsize), 1); - tree new_tree = build3 (BIT_FIELD_REF, bftype, vec_lhs, bitsize, bitstart); - new_tree = force_gimple_operand (fold_convert (lhs_type, new_tree), &stmts, - true, NULL_TREE); + tree new_tree; + if (LOOP_VINFO_FULLY_MASKED_P (loop_vinfo)) + { + /* Emit: + + SCALAR_RES = EXTRACT_LAST + + where VEC_LHS is the vectorized live-out result and MASK is + the loop mask for the final iteration. */ + gcc_assert (ncopies == 1 && !slp_node); + tree scalar_type = TREE_TYPE (STMT_VINFO_VECTYPE (stmt_info)); + tree scalar_res = make_ssa_name (scalar_type); + tree mask = vect_get_loop_mask (gsi, &LOOP_VINFO_MASKS (loop_vinfo), + 1, vectype, 0); + gcall *new_stmt = gimple_build_call_internal (IFN_EXTRACT_LAST, + 2, mask, vec_lhs); + gimple_call_set_lhs (new_stmt, scalar_res); + gimple_seq_add_stmt (&stmts, new_stmt); + + /* Convert the extracted vector element to the required scalar type. */ + new_tree = gimple_convert (&stmts, lhs_type, scalar_res); + } + else + { + tree bftype = TREE_TYPE (vectype); + if (VECTOR_BOOLEAN_TYPE_P (vectype)) + bftype = build_nonstandard_integer_type (tree_to_uhwi (bitsize), 1); + new_tree = build3 (BIT_FIELD_REF, bftype, vec_lhs, bitsize, bitstart); + new_tree = force_gimple_operand (fold_convert (lhs_type, new_tree), + &stmts, true, NULL_TREE); + } + if (stmts) gsi_insert_seq_on_edge_immediate (single_exit (loop), stmts); Index: gcc/config/aarch64/aarch64-sve.md =================================================================== --- gcc/config/aarch64/aarch64-sve.md 2017-11-17 15:23:55.844062247 +0000 +++ gcc/config/aarch64/aarch64-sve.md 2017-11-17 15:23:56.034915957 +0000 @@ -345,8 +345,7 @@ (define_expand "vec_extract" /* The last element can be extracted with a LASTB and a false predicate. */ rtx sel = force_reg (mode, CONST0_RTX (mode)); - emit_insn (gen_aarch64_sve_lastb (operands[0], sel, - operands[1])); + emit_insn (gen_extract_last_ (operands[0], sel, operands[1])); DONE; } if (!CONST_INT_P (operands[2])) @@ -365,8 +364,7 @@ (define_expand "vec_extract" emit_insn (gen_vec_cmp (sel, cmp, series, zero)); /* Select the element using LASTB. */ - emit_insn (gen_aarch64_sve_lastb (operands[0], sel, - operands[1])); + emit_insn (gen_extract_last_ (operands[0], sel, operands[1])); DONE; } } @@ -431,7 +429,7 @@ (define_insn "*vec_extract_ex ;; Extract the last active element of operand 1 into operand 0. ;; If no elements are active, extract the last inactive element instead. -(define_insn "aarch64_sve_lastb" +(define_insn "extract_last_" [(set (match_operand: 0 "register_operand" "=r, w") (unspec: [(match_operand: 1 "register_operand" "Upl, Upl") Index: gcc/testsuite/gcc.target/aarch64/sve_live_1.c =================================================================== --- /dev/null 2017-11-14 14:28:07.424493901 +0000 +++ gcc/testsuite/gcc.target/aarch64/sve_live_1.c 2017-11-17 15:23:56.035829132 +0000 @@ -0,0 +1,41 @@ +/* { dg-do assemble } */ +/* { dg-options "-O2 -ftree-vectorize -march=armv8-a+sve --save-temps" } */ + +#include + +#define EXTRACT_LAST(TYPE) \ + TYPE __attribute__ ((noinline, noclone)) \ + test_##TYPE (TYPE *x, int n, TYPE value) \ + { \ + TYPE last; \ + for (int j = 0; j < n; ++j) \ + { \ + last = x[j]; \ + x[j] = last * value; \ + } \ + return last; \ + } + +#define TEST_ALL(T) \ + T (uint8_t) \ + T (uint16_t) \ + T (uint32_t) \ + T (uint64_t) \ + T (_Float16) \ + T (float) \ + T (double) + +TEST_ALL (EXTRACT_LAST) + +/* { dg-final { scan-assembler-times {\twhilelo\tp[0-7].b, } 2 } } */ +/* { dg-final { scan-assembler-times {\twhilelo\tp[0-7].h, } 4 } } */ +/* { dg-final { scan-assembler-times {\twhilelo\tp[0-7].s, } 4 } } */ +/* { dg-final { scan-assembler-times {\twhilelo\tp[0-7].d, } 4 } } */ + +/* { dg-final { scan-assembler-times {\tlastb\tw[0-9]+, p[0-7], z[0-9]+\.b\n} 1 } } */ +/* { dg-final { scan-assembler-times {\tlastb\tw[0-9]+, p[0-7], z[0-9]+\.h\n} 1 } } */ +/* { dg-final { scan-assembler-times {\tlastb\tw[0-9]+, p[0-7], z[0-9]+\.s\n} 1 } } */ +/* { dg-final { scan-assembler-times {\tlastb\tx[0-9]+, p[0-7], z[0-9]+\.d\n} 1 } } */ +/* { dg-final { scan-assembler-times {\tlastb\th[0-9]+, p[0-7], z[0-9]+\.h\n} 1 } } */ +/* { dg-final { scan-assembler-times {\tlastb\ts[0-9]+, p[0-7], z[0-9]+\.s\n} 1 } } */ +/* { dg-final { scan-assembler-times {\tlastb\td[0-9]+, p[0-7], z[0-9]+\.d\n} 1 } } */ Index: gcc/testsuite/gcc.target/aarch64/sve_live_1_run.c =================================================================== --- /dev/null 2017-11-14 14:28:07.424493901 +0000 +++ gcc/testsuite/gcc.target/aarch64/sve_live_1_run.c 2017-11-17 15:23:56.035829132 +0000 @@ -0,0 +1,35 @@ +/* { dg-do run { target { aarch64_sve_hw } } } */ +/* { dg-options "-O2 -ftree-vectorize -fno-inline -march=armv8-a+sve" } */ + +#include "sve_live_1.c" + +#define N 107 +#define OP 70 + +#define TEST_LOOP(TYPE) \ + { \ + TYPE a[N]; \ + for (int i = 0; i < N; ++i) \ + { \ + a[i] = i * 2 + (i % 3); \ + asm volatile ("" ::: "memory"); \ + } \ + TYPE expected = a[N - 1]; \ + TYPE res = test_##TYPE (a, N, OP); \ + if (res != expected) \ + __builtin_abort (); \ + for (int i = 0; i < N; ++i) \ + { \ + TYPE old = i * 2 + (i % 3); \ + if (a[i] != (TYPE) (old * (TYPE) OP)) \ + __builtin_abort (); \ + asm volatile ("" ::: "memory"); \ + } \ + } + +int __attribute__ ((optimize (1))) +main (void) +{ + TEST_ALL (TEST_LOOP); + return 0; +}