From patchwork Tue Dec 5 13:11:27 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Richard Biener X-Patchwork-Id: 174048 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:bcd1:0:b0:403:3b70:6f57 with SMTP id r17csp3420139vqy; Tue, 5 Dec 2023 05:15:40 -0800 (PST) X-Google-Smtp-Source: AGHT+IHCJS3qz6dcl9ovivvfE3iG6vOqLw2AbJX59u2DJtxDUqfPrYQeMt829zIunTw0yb3W/vTk X-Received: by 2002:a05:6808:f8d:b0:3b2:db86:209 with SMTP id o13-20020a0568080f8d00b003b2db860209mr5324036oiw.38.1701782139831; Tue, 05 Dec 2023 05:15:39 -0800 (PST) ARC-Seal: i=2; a=rsa-sha256; t=1701782139; cv=pass; d=google.com; s=arc-20160816; b=g7WTp55K/4c87kNzh5x/vlHHcy/hEy9q8yswNGbHG8CKQaY/Fkdt++VDSNpt1MtfnM zvxEpo7CPLWpIjVynp6RoaiQB7AJcyJw0SscYBoZlzEC07klSrXxa4dFC0GNrg+t26sb WAWUebbdHSn+GOuCR1NUXZJyNTdNpeBRV3jhHq1DGclboywcBdUl7qrv5hYmf+zXYIOe MioDrcreoMmbt4sqTC60yy9vBpNimHNO50bQ+5uB8tdRC1x+lOIOHNLlfztldZFhKRWO Aei5JGiAx9IgwJmGr5L6tsAlE5jubSAkzdPjOVZ9vOREbE6UymaXIi/q0LIJPui5zsAc 5i5g== ARC-Message-Signature: i=2; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=message-id:errors-to:list-subscribe:list-help:list-post :list-archive:list-unsubscribe:list-id:precedence:mime-version :subject:cc:to:from:date:dkim-signature:dkim-signature:arc-filter :dmarc-filter:delivered-to; bh=6OTMdAWQ0z71qaGdxEx6WveNQ6Rsi1GjG3vL1ZNvmAg=; fh=Hz/QWAL2vMAbrm3W16QrnQrLktFWGNewssxaKtdN1w4=; b=zACU+8wefyocEqSxG/+vAGzhWSYjB95PLYnAtVEn3CgoOFsEsGu1wOT/sxOJy+BqVi rJTDAqpShlN31VY28PF0mfMBPbyyB+vhYv90c7Em3K3IJnGAjEHnqMdwN3nTWYoMZIB2 rbgqzDuwsX36UP10LwFwQ7upLH7ZWl85sNsLtqWiGqputoYEqecW8obcuz5z63taFy8U UodFvndbStFOtHcai61N9vp59GR6im7WTDsWCTgJ0mN4c7aw4zcyL3D0PBNVGZbfP1Ao 6ML2SmJh/qq/96THBjWUiO1h+aHf7bChyS+nQu0HRdDFtYW1v3C4rOSC+U0FUbNJezHd aDsQ== ARC-Authentication-Results: i=2; mx.google.com; dkim=pass header.i=@suse.de header.s=susede2_rsa header.b=fpMpcaWX; dkim=neutral (no key) header.i=@suse.de header.s=susede2_ed25519 header.b="r9iE/+3W"; arc=pass (i=1); 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=suse.de Received: from server2.sourceware.org (server2.sourceware.org. [8.43.85.97]) by mx.google.com with ESMTPS id c2-20020a0561023a4200b00462a0ac9d1dsi731042vsu.593.2023.12.05.05.15.39 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 05 Dec 2023 05:15:39 -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=@suse.de header.s=susede2_rsa header.b=fpMpcaWX; dkim=neutral (no key) header.i=@suse.de header.s=susede2_ed25519 header.b="r9iE/+3W"; arc=pass (i=1); 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=suse.de Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 8FFE73857BA7 for ; Tue, 5 Dec 2023 13:15:39 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from smtp-out1.suse.de (smtp-out1.suse.de [195.135.223.130]) by sourceware.org (Postfix) with ESMTPS id 0240B3858C2A for ; Tue, 5 Dec 2023 13:15:15 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 0240B3858C2A Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=suse.de Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=suse.de ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 0240B3858C2A Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=195.135.223.130 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1701782116; cv=none; b=sS4qmVPStjVrTtdNUUF+Q0pVtIRzsG4x8in+Q6s/QXUDXxSXHch2tBtBD5Jj88G+BCuiH2SU9FLFN7d4C+MKFJqG5tZBp7VP8s3ZoDBt8cNBJ4y/+2UCat8iIRs1Fq+P7NNQb4GKDHrw4SvARRAm+zOXqa6pUjjQJaRipegGrwM= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1701782116; c=relaxed/simple; bh=JBH4w85KQdK3C9tIkwjUdZczpxQi/+DtZlbcWuKV9PE=; h=DKIM-Signature:DKIM-Signature:Date:From:To:Subject:MIME-Version; b=T2sQ94GZ7F1v00PniKZnqr+LXTYZq/ugo88h8VT43UXmqi2Puj3YdNjppFgsjHFX4Kb6zRemvHU5s22RVjZDyZ+bXgLnJzklkLC6hil8tWkyI/GQ5x6O3z2DK4L4tz80nGbo8frTN4e0/E3xAADzh3r7AEgQGNwLZPi5JGmTEHQ= ARC-Authentication-Results: i=1; server2.sourceware.org Received: from [10.168.4.150] (unknown [10.168.4.150]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by smtp-out1.suse.de (Postfix) with ESMTPS id 57F1B2204F; Tue, 5 Dec 2023 13:15:12 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.de; s=susede2_rsa; t=1701782112; h=from:from:reply-to:date:date:to:to:cc:cc:mime-version:mime-version: content-type:content-type; bh=6OTMdAWQ0z71qaGdxEx6WveNQ6Rsi1GjG3vL1ZNvmAg=; b=fpMpcaWXCFj0Oul0EqTRUshvvkdNWW+dJcNGAGCkJxWdfLLVNCDJWKYsP3PiLD3/QXante +kfPU6Rnud8ZGJBCm96A7xkJO5XCpSqIzurt2IkTyu6IgpPkG9Uk0Uwqug/4QJKcaRVWmh 54YuLlbjZwCniYP/jEEWg0wsz7V6i0k= DKIM-Signature: v=1; a=ed25519-sha256; c=relaxed/relaxed; d=suse.de; s=susede2_ed25519; t=1701782112; h=from:from:reply-to:date:date:to:to:cc:cc:mime-version:mime-version: content-type:content-type; bh=6OTMdAWQ0z71qaGdxEx6WveNQ6Rsi1GjG3vL1ZNvmAg=; b=r9iE/+3WLGqqoJlvo/e6523V8YvvWYa+Cxzv8gGbmxVb+BDjN4AO2yqDthOt7OAloSgAZc 7Sh84abh0lJxMlAg== Date: Tue, 5 Dec 2023 14:11:27 +0100 (CET) From: Richard Biener To: gcc-patches@gcc.gnu.org cc: Jakub Jelinek Subject: [PATCH] middle-end/112830 - avoid gimplifying non-default addr-space assign to memcpy MIME-Version: 1.0 Authentication-Results: smtp-out1.suse.de; none X-Spamd-Result: default: False [-0.60 / 50.00]; ARC_NA(0.00)[]; URIBL_BLOCKED(0.00)[gimplify.cc:url,builtins.cc:url,tree-cfg.cc:url,gcc.target:url]; FROM_HAS_DN(0.00)[]; TO_DN_SOME(0.00)[]; TO_MATCH_ENVRCPT_ALL(0.00)[]; MIME_GOOD(-0.10)[text/plain]; MISSING_MID(2.50)[]; DKIM_SIGNED(0.00)[suse.de:s=susede2_rsa,suse.de:s=susede2_ed25519]; RCPT_COUNT_TWO(0.00)[2]; FUZZY_BLOCKED(0.00)[rspamd.com]; RCVD_COUNT_ZERO(0.00)[0]; FROM_EQ_ENVFROM(0.00)[]; MIME_TRACE(0.00)[0:+]; BAYES_HAM(-3.00)[100.00%] X-Spam-Level: X-Spam-Score: -0.60 X-Spam-Status: No, score=-10.7 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, KAM_SHORT, MISSING_MID, SPF_HELO_NONE, SPF_PASS, TXREP, T_SCC_BODY_TEXT_LINE 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.30 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org Message-Id: <20231205131539.8FFE73857BA7@sourceware.org> X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1784447908907895140 X-GMAIL-MSGID: 1784447908907895140 The following avoids turning aggregate copy involving non-default address-spaces to memcpy since that is not prepared for that. GIMPLE verification no longer accepts WITH_SIZE_EXPR in aggregate copies, the following re-allows that for the RHS. I also needed to adjust one assert in DCE. get_memory_address is used for string builtin expansion, so instead of fixing that up for non-generic address-spaces I've put an assert there. I'll note that the same issue exists for initialization from an empty CTOR which we gimplify to a memset call but since we are not prepared to handle RTL expansion of the original VLA init and I failed to provide test coverage (without extending the GNU C extension for VLA structs) and the Ada frontend (or other frontends) to not have address-space support the patch instead asserts we only see generic address-spaces there. Bootstrapped and tested on x86_64-unknown-linux-gnu for all languages. OK? Thanks, Richard. PR middle-end/112830 * gimplify.cc (gimplify_modify_expr): Avoid turning aggregate copy of non-generic address-spaces to memcpy. (gimplify_modify_expr_to_memcpy): Assert we are dealing with a copy inside the generic address-space. (gimplify_modify_expr_to_memset): Likewise. * tree-cfg.cc (verify_gimple_assign_single): Allow WITH_SIZE_EXPR as part of the RHS of an assignment. * builtins.cc (get_memory_address): Assert we are dealing with the generic address-space. * gcc.target/avr/pr112830.c: New testcase. * gcc.target/i386/pr112830.c: Likewise. --- gcc/builtins.cc | 3 +++ gcc/gimplify.cc | 8 ++++++-- gcc/testsuite/gcc.target/avr/pr112830.c | 12 ++++++++++++ gcc/testsuite/gcc.target/i386/pr112830.c | 9 +++++++++ gcc/tree-cfg.cc | 16 ++++++++++------ gcc/tree-ssa-dce.cc | 3 ++- 6 files changed, 42 insertions(+), 9 deletions(-) create mode 100644 gcc/testsuite/gcc.target/avr/pr112830.c create mode 100644 gcc/testsuite/gcc.target/i386/pr112830.c diff --git a/gcc/builtins.cc b/gcc/builtins.cc index 4fc58a0bda9..aa86ac1545d 100644 --- a/gcc/builtins.cc +++ b/gcc/builtins.cc @@ -1347,6 +1347,9 @@ get_memory_rtx (tree exp, tree len) tree orig_exp = exp, base; rtx addr, mem; + gcc_checking_assert + (ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp))))); + /* When EXP is not resolved SAVE_EXPR, MEM_ATTRS can be still derived from its expression, for expr->a.b only .a.b is recorded. */ if (TREE_CODE (exp) == SAVE_EXPR && !SAVE_EXPR_RESOLVED_P (exp)) diff --git a/gcc/gimplify.cc b/gcc/gimplify.cc index 02f85e7109b..342e43a7f25 100644 --- a/gcc/gimplify.cc +++ b/gcc/gimplify.cc @@ -4887,6 +4887,8 @@ gimplify_modify_expr_to_memcpy (tree *expr_p, tree size, bool want_value, to = TREE_OPERAND (*expr_p, 0); from = TREE_OPERAND (*expr_p, 1); + gcc_assert (ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (TREE_TYPE (to))) + && ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (TREE_TYPE (from)))); /* Mark the RHS addressable. Beware that it may not be possible to do so directly if a temporary has been created by the gimplification. */ @@ -4945,6 +4947,7 @@ gimplify_modify_expr_to_memset (tree *expr_p, tree size, bool want_value, /* Now proceed. */ to = TREE_OPERAND (*expr_p, 0); + gcc_assert (ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (TREE_TYPE (to)))); to_ptr = build_fold_addr_expr_loc (loc, to); gimplify_arg (&to_ptr, seq_p, loc); @@ -6466,8 +6469,9 @@ gimplify_modify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, if (TREE_CODE (from) == CONSTRUCTOR) return gimplify_modify_expr_to_memset (expr_p, size, want_value, pre_p); - - if (is_gimple_addressable (from)) + else if (is_gimple_addressable (from) + && ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (TREE_TYPE (*to_p))) + && ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (TREE_TYPE (from)))) { *from_p = from; return gimplify_modify_expr_to_memcpy (expr_p, size, want_value, diff --git a/gcc/testsuite/gcc.target/avr/pr112830.c b/gcc/testsuite/gcc.target/avr/pr112830.c new file mode 100644 index 00000000000..c305daed06c --- /dev/null +++ b/gcc/testsuite/gcc.target/avr/pr112830.c @@ -0,0 +1,12 @@ +/* { dg-do compile } */ +/* { dg-options "" } */ + +typedef __SIZE_TYPE__ size_t; + +void copy_n (void *vdst, const __memx void *vsrc, size_t n) +{ + typedef struct { char a[n]; } T; + T *dst = (T*) vdst; + const __memx T *src = (const __memx T*) vsrc; + *dst = *src; +} diff --git a/gcc/testsuite/gcc.target/i386/pr112830.c b/gcc/testsuite/gcc.target/i386/pr112830.c new file mode 100644 index 00000000000..2ba610404bf --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/pr112830.c @@ -0,0 +1,9 @@ +/* { dg-do compile } */ +/* { dg-options "" } */ + +void +foo (int n, __seg_fs void *p, __seg_gs void *q) +{ + typedef struct { char t[n]; } T; + *(__seg_fs T *)p = *(__seg_gs T *)q; +} diff --git a/gcc/tree-cfg.cc b/gcc/tree-cfg.cc index 475ea5d99ef..5400805f51a 100644 --- a/gcc/tree-cfg.cc +++ b/gcc/tree-cfg.cc @@ -4673,6 +4673,16 @@ verify_gimple_assign_single (gassign *stmt) error ("%qs in gimple IL", code_name); return true; + case WITH_SIZE_EXPR: + if (!is_gimple_val (TREE_OPERAND (rhs1, 1))) + { + error ("invalid %qs size argument in load", code_name); + debug_generic_stmt (lhs); + debug_generic_stmt (rhs1); + return true; + } + rhs1 = TREE_OPERAND (rhs1, 0); + /* Fallthru. */ case COMPONENT_REF: case BIT_FIELD_REF: case ARRAY_REF: @@ -4810,12 +4820,6 @@ verify_gimple_assign_single (gassign *stmt) } return res; - case WITH_SIZE_EXPR: - error ("%qs RHS in assignment statement", - get_tree_code_name (rhs_code)); - debug_generic_expr (rhs1); - return true; - case OBJ_TYPE_REF: /* FIXME. */ return res; diff --git a/gcc/tree-ssa-dce.cc b/gcc/tree-ssa-dce.cc index bbdf9312c9f..4e371b21a90 100644 --- a/gcc/tree-ssa-dce.cc +++ b/gcc/tree-ssa-dce.cc @@ -469,7 +469,8 @@ find_obviously_necessary_stmts (bool aggressive) static bool ref_may_be_aliased (tree ref) { - gcc_assert (TREE_CODE (ref) != WITH_SIZE_EXPR); + if (TREE_CODE (ref) == WITH_SIZE_EXPR) + ref = TREE_OPERAND (ref, 0); while (handled_component_p (ref)) ref = TREE_OPERAND (ref, 0); if ((TREE_CODE (ref) == MEM_REF || TREE_CODE (ref) == TARGET_MEM_REF)