From patchwork Sat Aug 31 14:56:29 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Alejandro Colomar X-Patchwork-Id: 1979327 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@legolas.ozlabs.org Authentication-Results: legolas.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=kernel.org header.i=@kernel.org header.a=rsa-sha256 header.s=k20201202 header.b=DfjZDrmh; dkim-atps=neutral Authentication-Results: legolas.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=8.43.85.97; helo=server2.sourceware.org; envelope-from=gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=patchwork.ozlabs.org) Received: from server2.sourceware.org (server2.sourceware.org [8.43.85.97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (secp384r1) server-digest SHA384) (No client certificate requested) by legolas.ozlabs.org (Postfix) with ESMTPS id 4Wwylz66BHz1yfK for ; Sun, 1 Sep 2024 00:57:03 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 0CF87385E457 for ; Sat, 31 Aug 2024 14:57:02 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from nyc.source.kernel.org (nyc.source.kernel.org [147.75.193.91]) by sourceware.org (Postfix) with ESMTPS id 506B0385B82F for ; Sat, 31 Aug 2024 14:56:38 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 506B0385B82F Authentication-Results: sourceware.org; dmarc=pass (p=quarantine dis=none) header.from=kernel.org Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=kernel.org ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 506B0385B82F Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=147.75.193.91 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1725116200; cv=none; b=FX5aMDP73tdCFcMBkXZtcUI2cYVDzVI82ab7MHSqbXkPWhAt9E1Cl7QRpIAIm1rTevqhXsHspF28SrqlbE6L9jTLUG9sxRy2+horslAxjJwG8A2bGfi6mfxoosiXbjkQZYe6aImXngZOY3+TgSq27gNrBskluIsL2EHoZ+3pVJ4= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1725116200; c=relaxed/simple; bh=pEj1jFenAjfxwc4v5iq5GCH9zjiN1B0C7OSfviPJH/M=; h=DKIM-Signature:Date:From:To:Subject:Message-ID:MIME-Version; b=f3rjcAJ4X+gPiHXbFkvppRQlZnxWJ9q5zEyW0C/LKjADBt6uJ7gElvBS3DeD/My4ij8d4ZRfEVsl4J+tj5kYWet74w/Gx9kQmcd0aO8XBf4a/j56XGply/N0GHUgd7A4tl4kZOUwpPdIZsSWKBvNw+Pp1ii/9+uldorqoLqoDI0= ARC-Authentication-Results: i=1; server2.sourceware.org Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by nyc.source.kernel.org (Postfix) with ESMTP id E6BE7A407F0; Sat, 31 Aug 2024 14:56:30 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 41040C4CEC0; Sat, 31 Aug 2024 14:56:31 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1725116197; bh=pEj1jFenAjfxwc4v5iq5GCH9zjiN1B0C7OSfviPJH/M=; h=Date:From:To:Cc:Subject:References:In-Reply-To:From; b=DfjZDrmh8+WIialFg2DvuyG8+I/2KwwjcbF9gpYVLuTj6dxbV0KfvN/dgw2bUtnOS kkqdSg6Gh7dRL28mBLtjDWK5+RBK9Eph05KO0KhBaknbmBMvNA3k78gF4E0yE72L3E aQcgQV0VIgadoM03PsEyqisuZwMfuLgllToHUZDcLZyuCSam7ljnBiMTaV9mRDpCLr YyrVqcbNplNbdXwSF4eH1y/HEjJ2JYAbuj8UU6GxPzbMys7a8eLsKqDs5EcVR7JmO0 RnwZDbkPvTvz0uqJ/CFlv+rsITOZ0ZuL0MyMakOrDeQbTGvE5/yKr8YuLpkXy7gU4F 2JtVU+ZYQ60SA== Date: Sat, 31 Aug 2024 16:56:29 +0200 From: Alejandro Colomar To: gcc-patches@gcc.gnu.org Cc: Alejandro Colomar , Joseph Myers , Gabriel Ravier , Jakub Jelinek , Kees Cook , Qing Zhao , Jens Gustedt , David Brown , Florian Weimer , Andreas Schwab , Timm Baeder , Daniel Plakosh , "A. Jiang" , Eugene Zelenko , Aaron Ballman , Paul Koning , Daniel Lundin , Nikolaos Strimpas , JeanHeyd Meneide , Fernando Borretti , Jonathan Protzenko , Chris Bazley , Ville Voutilainen , Alex Celeste , Jakub =?utf-8?q?=C5=81ukasiewicz?= , Douglas McIlroy , Jason Merrill , Xavier Del Campo Romero , Martin Uecker , Siddhesh Poyarekar , DJ Delorie , Carlos O'Donell , Stephen Coady , ganandan@redhat.com, mnewsome@redhat.com Subject: [PATCH v12 1/4] contrib/: Add support for Cc: and Link: tags Message-ID: X-Mailer: git-send-email 2.45.2 References: MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: X-Spam-Status: No, score=-9.9 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, 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~incoming=patchwork.ozlabs.org@gcc.gnu.org contrib/ChangeLog: * gcc-changelog/git_commit.py (GitCommit): Add support for 'Cc: ' and 'Link: ' tags. Cc: Jason Merrill Signed-off-by: Alejandro Colomar --- contrib/gcc-changelog/git_commit.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/contrib/gcc-changelog/git_commit.py b/contrib/gcc-changelog/git_commit.py index 87ecb9e1a17..64fb986b74c 100755 --- a/contrib/gcc-changelog/git_commit.py +++ b/contrib/gcc-changelog/git_commit.py @@ -182,7 +182,8 @@ CO_AUTHORED_BY_PREFIX = 'co-authored-by: ' REVIEW_PREFIXES = ('reviewed-by: ', 'reviewed-on: ', 'signed-off-by: ', 'acked-by: ', 'tested-by: ', 'reported-by: ', - 'suggested-by: ') + 'suggested-by: ', 'cc: ') +LINK_PREFIXES = ('link: ') DATE_FORMAT = '%Y-%m-%d' @@ -524,6 +525,8 @@ class GitCommit: continue elif lowered_line.startswith(REVIEW_PREFIXES): continue + elif lowered_line.startswith(LINK_PREFIXES): + continue else: m = cherry_pick_regex.search(line) if m: From patchwork Sat Aug 31 14:56:38 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Alejandro Colomar X-Patchwork-Id: 1979328 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@legolas.ozlabs.org Authentication-Results: legolas.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=kernel.org header.i=@kernel.org header.a=rsa-sha256 header.s=k20201202 header.b=CeOHUYZO; dkim-atps=neutral Authentication-Results: legolas.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=2620:52:3:1:0:246e:9693:128c; helo=server2.sourceware.org; envelope-from=gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=patchwork.ozlabs.org) Received: from server2.sourceware.org (server2.sourceware.org [IPv6:2620:52:3:1:0:246e:9693:128c]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (secp384r1) server-digest SHA384) (No client certificate requested) by legolas.ozlabs.org (Postfix) with ESMTPS id 4Wwym660Crz1yfK for ; Sun, 1 Sep 2024 00:57:10 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id B08D2386587A for ; Sat, 31 Aug 2024 14:57:08 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from nyc.source.kernel.org (nyc.source.kernel.org [147.75.193.91]) by sourceware.org (Postfix) with ESMTPS id C03773858D28 for ; Sat, 31 Aug 2024 14:56:47 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org C03773858D28 Authentication-Results: sourceware.org; dmarc=pass (p=quarantine dis=none) header.from=kernel.org Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=kernel.org ARC-Filter: OpenARC Filter v1.0.0 sourceware.org C03773858D28 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=147.75.193.91 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1725116211; cv=none; b=d4plwD7PQMRoe882ifP2ZtMQTE0Si2kcHMZ0azpNpv366TzehvjkUtWrsqgwAZ1EI3YdYMWSbno0wGCX7VRphMLzdoBkkxj0jC7Vscg2CVJdkcfgxNFVfgVXCHXgGWCUfRoaGdytbC7GLzBc1lkET2AaG1CJS7Er16dzex/3Zv4= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1725116211; c=relaxed/simple; bh=uqr0mYisX6Z3rZS1lul9oJeNv9LUxlcn4XzjFzs8cQo=; h=DKIM-Signature:Date:From:To:Subject:Message-ID:MIME-Version; b=LXZGMCVFU2cxdKtQHCsFd9dGHhqfmnWr10xER4D8eVGivAcbhY8S3XqVmb931fAgvK5QfjfmwnDvyELM/p5wH98THnDcL0aP7RhJ14qaqRu/ItBDLHjuPfVH21lwSlUqLaM9oRe7g0h+bT7xIJp2j87tG9PpsLdKxzzrSTGAFrQ= ARC-Authentication-Results: i=1; server2.sourceware.org Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by nyc.source.kernel.org (Postfix) with ESMTP id 37178A407F8; Sat, 31 Aug 2024 14:56:40 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 7847BC4CEC0; Sat, 31 Aug 2024 14:56:40 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1725116206; bh=uqr0mYisX6Z3rZS1lul9oJeNv9LUxlcn4XzjFzs8cQo=; h=Date:From:To:Cc:Subject:References:In-Reply-To:From; b=CeOHUYZO++wYx20J1Wr+2gvsB2nOVIVtr+CcD6EXBQTWnFnSdLs4cWJRSaHYNtU7O F1Jblu75ivW6IBvEBNTTKqY2CnB5OVlHNl6muWP0R3MQCDFTjbhNfut262+LQSrZ12 PK5/nPskGosIBETm0A0qmyok2cJsGQzL2qqEBcYIIsiV8QrrDVByp+pS41DqHxr6GH Fnlny3SIJIyAfaVtmg0NbB3jWhmt4oO+4puRrfoWrr/QgzDS6gTFh12G27Z4Zlt7+F BXBwCeJYLiDKi3WUvu4Oeu6VI8pLPaUsDifFcnurBVYkw+qXs2wXx3NeL9zuDjTMn4 QRNr27BtwkxXA== Date: Sat, 31 Aug 2024 16:56:38 +0200 From: Alejandro Colomar To: gcc-patches@gcc.gnu.org Cc: Alejandro Colomar , Joseph Myers , Gabriel Ravier , Jakub Jelinek , Kees Cook , Qing Zhao , Jens Gustedt , David Brown , Florian Weimer , Andreas Schwab , Timm Baeder , Daniel Plakosh , "A. Jiang" , Eugene Zelenko , Aaron Ballman , Paul Koning , Daniel Lundin , Nikolaos Strimpas , JeanHeyd Meneide , Fernando Borretti , Jonathan Protzenko , Chris Bazley , Ville Voutilainen , Alex Celeste , Jakub =?utf-8?q?=C5=81ukasiewicz?= , Douglas McIlroy , Jason Merrill , Xavier Del Campo Romero , Martin Uecker , Siddhesh Poyarekar , DJ Delorie , Carlos O'Donell , Stephen Coady , ganandan@redhat.com, mnewsome@redhat.com, Richard Biener Subject: [PATCH v12 2/4] gcc/: Rename array_type_nelts() => array_type_nelts_minus_one() Message-ID: X-Mailer: git-send-email 2.45.2 References: MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: X-Spam-Status: No, score=-10.0 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, 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~incoming=patchwork.ozlabs.org@gcc.gnu.org The old name was misleading. While at it, also rename some temporary variables that are used with this function, for consistency. Link: gcc/ChangeLog: * tree.cc (array_type_nelts, array_type_nelts_minus_one) * tree.h (array_type_nelts, array_type_nelts_minus_one) * expr.cc (count_type_elements) * config/aarch64/aarch64.cc (pure_scalable_type_info::analyze_array) * config/i386/i386.cc (ix86_canonical_va_list_type): Rename array_type_nelts() => array_type_nelts_minus_one() The old name was misleading. gcc/c/ChangeLog: * c-decl.cc (one_element_array_type_p, get_parm_array_spec) * c-fold.cc (c_fold_array_ref): Rename array_type_nelts() => array_type_nelts_minus_one() gcc/cp/ChangeLog: * decl.cc (reshape_init_array) * init.cc (build_zero_init_1) (build_value_init_noctor) (build_vec_init) (build_delete) * lambda.cc (add_capture) * tree.cc (array_type_nelts_top): Rename array_type_nelts() => array_type_nelts_minus_one() gcc/fortran/ChangeLog: * trans-array.cc (structure_alloc_comps) * trans-openmp.cc (gfc_walk_alloc_comps) (gfc_omp_clause_linear_ctor): Rename array_type_nelts() => array_type_nelts_minus_one() gcc/rust/ChangeLog: * backend/rust-tree.cc (array_type_nelts_top): Rename array_type_nelts() => array_type_nelts_minus_one() Cc: Gabriel Ravier Cc: Martin Uecker Cc: Joseph Myers Cc: Xavier Del Campo Romero Cc: Jakub Jelinek Suggested-by: Richard Biener Signed-off-by: Alejandro Colomar --- gcc/c/c-decl.cc | 10 +++++----- gcc/c/c-fold.cc | 7 ++++--- gcc/config/aarch64/aarch64.cc | 2 +- gcc/config/i386/i386.cc | 2 +- gcc/cp/decl.cc | 2 +- gcc/cp/init.cc | 8 ++++---- gcc/cp/lambda.cc | 3 ++- gcc/cp/tree.cc | 2 +- gcc/expr.cc | 8 ++++---- gcc/fortran/trans-array.cc | 2 +- gcc/fortran/trans-openmp.cc | 4 ++-- gcc/rust/backend/rust-tree.cc | 2 +- gcc/tree.cc | 4 ++-- gcc/tree.h | 2 +- 14 files changed, 30 insertions(+), 28 deletions(-) diff --git a/gcc/c/c-decl.cc b/gcc/c/c-decl.cc index aa7f69d1b7b..c73d3107efb 100644 --- a/gcc/c/c-decl.cc +++ b/gcc/c/c-decl.cc @@ -5358,7 +5358,7 @@ one_element_array_type_p (const_tree type) { if (TREE_CODE (type) != ARRAY_TYPE) return false; - return integer_zerop (array_type_nelts (type)); + return integer_zerop (array_type_nelts_minus_one (type)); } /* Determine whether TYPE is a zero-length array type "[0]". */ @@ -6306,15 +6306,15 @@ get_parm_array_spec (const struct c_parm *parm, tree attrs) for (tree type = parm->specs->type; TREE_CODE (type) == ARRAY_TYPE; type = TREE_TYPE (type)) { - tree nelts = array_type_nelts (type); - if (error_operand_p (nelts)) + tree nelts_minus_one = array_type_nelts_minus_one (type); + if (error_operand_p (nelts_minus_one)) return attrs; - if (TREE_CODE (nelts) != INTEGER_CST) + if (TREE_CODE (nelts_minus_one) != INTEGER_CST) { /* Each variable VLA bound is represented by the dollar sign. */ spec += "$"; - tpbnds = tree_cons (NULL_TREE, nelts, tpbnds); + tpbnds = tree_cons (NULL_TREE, nelts_minus_one, tpbnds); } } tpbnds = nreverse (tpbnds); diff --git a/gcc/c/c-fold.cc b/gcc/c/c-fold.cc index 57b67c74bd8..9ea174f79c4 100644 --- a/gcc/c/c-fold.cc +++ b/gcc/c/c-fold.cc @@ -73,11 +73,12 @@ c_fold_array_ref (tree type, tree ary, tree index) unsigned elem_nchars = (TYPE_PRECISION (elem_type) / TYPE_PRECISION (char_type_node)); unsigned len = (unsigned) TREE_STRING_LENGTH (ary) / elem_nchars; - tree nelts = array_type_nelts (TREE_TYPE (ary)); + tree nelts_minus_one = array_type_nelts_minus_one (TREE_TYPE (ary)); bool dummy1 = true, dummy2 = true; - nelts = c_fully_fold_internal (nelts, true, &dummy1, &dummy2, false, false); + nelts_minus_one = c_fully_fold_internal (nelts_minus_one, true, &dummy1, + &dummy2, false, false); unsigned HOST_WIDE_INT i = tree_to_uhwi (index); - if (!tree_int_cst_le (index, nelts) + if (!tree_int_cst_le (index, nelts_minus_one) || i >= len || i + elem_nchars > len) return NULL_TREE; diff --git a/gcc/config/aarch64/aarch64.cc b/gcc/config/aarch64/aarch64.cc index 27e24ba70ab..21606701725 100644 --- a/gcc/config/aarch64/aarch64.cc +++ b/gcc/config/aarch64/aarch64.cc @@ -1084,7 +1084,7 @@ pure_scalable_type_info::analyze_array (const_tree type) /* An array of unknown, flexible or variable length will be passed and returned by reference whatever we do. */ - tree nelts_minus_one = array_type_nelts (type); + tree nelts_minus_one = array_type_nelts_minus_one (type); if (!tree_fits_uhwi_p (nelts_minus_one)) return DOESNT_MATTER; diff --git a/gcc/config/i386/i386.cc b/gcc/config/i386/i386.cc index 546c964d2a4..c6407843fc5 100644 --- a/gcc/config/i386/i386.cc +++ b/gcc/config/i386/i386.cc @@ -24393,7 +24393,7 @@ ix86_canonical_va_list_type (tree type) return ms_va_list_type_node; if ((TREE_CODE (type) == ARRAY_TYPE - && integer_zerop (array_type_nelts (type))) + && integer_zerop (array_type_nelts_minus_one (type))) || POINTER_TYPE_P (type)) { tree elem_type = TREE_TYPE (type); diff --git a/gcc/cp/decl.cc b/gcc/cp/decl.cc index 6458e96bded..98133894c48 100644 --- a/gcc/cp/decl.cc +++ b/gcc/cp/decl.cc @@ -6908,7 +6908,7 @@ reshape_init_array (tree type, reshape_iter *d, tree first_initializer_p, gcc_assert (TREE_CODE (type) == ARRAY_TYPE); if (TYPE_DOMAIN (type)) - max_index = array_type_nelts (type); + max_index = array_type_nelts_minus_one (type); return reshape_init_array_1 (TREE_TYPE (type), max_index, d, first_initializer_p, complain); diff --git a/gcc/cp/init.cc b/gcc/cp/init.cc index 20373d26988..493e64691cd 100644 --- a/gcc/cp/init.cc +++ b/gcc/cp/init.cc @@ -263,7 +263,7 @@ build_zero_init_1 (tree type, tree nelts, bool static_storage_p, else if (TYPE_DOMAIN (type) == NULL_TREE) return NULL_TREE; else - max_index = array_type_nelts (type); + max_index = array_type_nelts_minus_one (type); /* If we have an error_mark here, we should just return error mark as we don't know the size of the array yet. */ @@ -474,7 +474,7 @@ build_value_init_noctor (tree type, tsubst_flags_t complain) vec *v = NULL; /* Iterate over the array elements, building initializations. */ - tree max_index = array_type_nelts (type); + tree max_index = array_type_nelts_minus_one (type); /* If we have an error_mark here, we should just return error mark as we don't know the size of the array yet. */ @@ -4519,7 +4519,7 @@ build_vec_init (tree base, tree maxindex, tree init, : location_of (base)); if (TREE_CODE (atype) == ARRAY_TYPE && TYPE_DOMAIN (atype)) - maxindex = array_type_nelts (atype); + maxindex = array_type_nelts_minus_one (atype); if (maxindex == NULL_TREE || maxindex == error_mark_node) return error_mark_node; @@ -5178,7 +5178,7 @@ build_delete (location_t loc, tree otype, tree addr, error_at (loc, "unknown array size in delete"); return error_mark_node; } - return build_vec_delete (loc, addr, array_type_nelts (type), + return build_vec_delete (loc, addr, array_type_nelts_minus_one (type), auto_delete, use_global_delete, complain); } diff --git a/gcc/cp/lambda.cc b/gcc/cp/lambda.cc index 0770417810e..065113bc122 100644 --- a/gcc/cp/lambda.cc +++ b/gcc/cp/lambda.cc @@ -556,7 +556,8 @@ add_capture (tree lambda, tree id, tree orig_init, bool by_reference_p, integer_zero_node, tf_warning_or_error); initializer = build_constructor_va (init_list_type_node, 2, NULL_TREE, build_address (elt), - NULL_TREE, array_type_nelts (type)); + NULL_TREE, + array_type_nelts_minus_one (type)); type = vla_capture_type (type); } else if (!dependent_type_p (type) diff --git a/gcc/cp/tree.cc b/gcc/cp/tree.cc index 31ecbb1ac79..040136c70ab 100644 --- a/gcc/cp/tree.cc +++ b/gcc/cp/tree.cc @@ -3088,7 +3088,7 @@ array_type_nelts_top (tree type) { return fold_build2_loc (input_location, PLUS_EXPR, sizetype, - array_type_nelts (type), + array_type_nelts_minus_one (type), size_one_node); } diff --git a/gcc/expr.cc b/gcc/expr.cc index 320be8b17a1..803da754be1 100644 --- a/gcc/expr.cc +++ b/gcc/expr.cc @@ -6991,14 +6991,14 @@ count_type_elements (const_tree type, bool for_ctor_p) { case ARRAY_TYPE: { - tree nelts; + tree nelts_minus_one; - nelts = array_type_nelts (type); - if (nelts && tree_fits_uhwi_p (nelts)) + nelts_minus_one = array_type_nelts_minus_one (type); + if (nelts_minus_one && tree_fits_uhwi_p (nelts_minus_one)) { unsigned HOST_WIDE_INT n; - n = tree_to_uhwi (nelts) + 1; + n = tree_to_uhwi (nelts_minus_one) + 1; if (n == 0 || for_ctor_p) return n; else diff --git a/gcc/fortran/trans-array.cc b/gcc/fortran/trans-array.cc index 8c35926436d..22ac3c1a5f3 100644 --- a/gcc/fortran/trans-array.cc +++ b/gcc/fortran/trans-array.cc @@ -9640,7 +9640,7 @@ structure_alloc_comps (gfc_symbol * der_type, tree decl, tree dest, else { /* Otherwise use the TYPE_DOMAIN information. */ - tmp = array_type_nelts (decl_type); + tmp = array_type_nelts_minus_one (decl_type); tmp = fold_convert (gfc_array_index_type, tmp); } diff --git a/gcc/fortran/trans-openmp.cc b/gcc/fortran/trans-openmp.cc index df1bf144e23..14cd2f9fad7 100644 --- a/gcc/fortran/trans-openmp.cc +++ b/gcc/fortran/trans-openmp.cc @@ -582,7 +582,7 @@ gfc_walk_alloc_comps (tree decl, tree dest, tree var, tem = size_binop (MINUS_EXPR, tem, size_one_node); } else - tem = array_type_nelts (type); + tem = array_type_nelts_minus_one (type); tem = fold_convert (gfc_array_index_type, tem); } @@ -1309,7 +1309,7 @@ gfc_omp_clause_linear_ctor (tree clause, tree dest, tree src, tree add) nelems = size_binop (MINUS_EXPR, nelems, size_one_node); } else - nelems = array_type_nelts (type); + nelems = array_type_nelts_minus_one (type); nelems = fold_convert (gfc_array_index_type, nelems); gfc_omp_linear_clause_add_loop (&block, dest, src, add, nelems); diff --git a/gcc/rust/backend/rust-tree.cc b/gcc/rust/backend/rust-tree.cc index cdb79095da8..8d32e5203ae 100644 --- a/gcc/rust/backend/rust-tree.cc +++ b/gcc/rust/backend/rust-tree.cc @@ -869,7 +869,7 @@ tree array_type_nelts_top (tree type) { return fold_build2_loc (input_location, PLUS_EXPR, sizetype, - array_type_nelts (type), size_one_node); + array_type_nelts_minus_one (type), size_one_node); } // forked from gcc/cp/tree.cc builtin_valid_in_constant_expr_p diff --git a/gcc/tree.cc b/gcc/tree.cc index b14cfbe7929..7439777f307 100644 --- a/gcc/tree.cc +++ b/gcc/tree.cc @@ -3698,7 +3698,7 @@ int_byte_position (const_tree field) ARRAY_TYPE) minus one. This counts only elements of the top array. */ tree -array_type_nelts (const_tree type) +array_type_nelts_minus_one (const_tree type) { tree index_type, min, max; @@ -14789,7 +14789,7 @@ is_empty_type (const_tree type) return true; } else if (TREE_CODE (type) == ARRAY_TYPE) - return (integer_minus_onep (array_type_nelts (type)) + return (integer_minus_onep (array_type_nelts_minus_one (type)) || TYPE_DOMAIN (type) == NULL_TREE || is_empty_type (TREE_TYPE (type))); return false; diff --git a/gcc/tree.h b/gcc/tree.h index 93aa7d22d6f..4e29544a36c 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -4921,7 +4921,7 @@ extern tree build_method_type_directly (tree, tree, tree); extern tree build_method_type (tree, tree); extern tree build_offset_type (tree, tree); extern tree build_complex_type (tree, bool named = false); -extern tree array_type_nelts (const_tree); +extern tree array_type_nelts_minus_one (const_tree); extern tree value_member (tree, tree); extern tree purpose_member (const_tree, tree); From patchwork Sat Aug 31 14:56:48 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Alejandro Colomar X-Patchwork-Id: 1979329 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@legolas.ozlabs.org Authentication-Results: legolas.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=kernel.org header.i=@kernel.org header.a=rsa-sha256 header.s=k20201202 header.b=ShPpS8vA; dkim-atps=neutral Authentication-Results: legolas.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=2620:52:3:1:0:246e:9693:128c; helo=server2.sourceware.org; envelope-from=gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=patchwork.ozlabs.org) Received: from server2.sourceware.org (server2.sourceware.org [IPv6:2620:52:3:1:0:246e:9693:128c]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (secp384r1) server-digest SHA384) (No client certificate requested) by legolas.ozlabs.org (Postfix) with ESMTPS id 4WwymK0y2tz1yfK for ; Sun, 1 Sep 2024 00:57:21 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id ED9E2385020B for ; Sat, 31 Aug 2024 14:57:18 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from dfw.source.kernel.org (dfw.source.kernel.org [IPv6:2604:1380:4641:c500::1]) by sourceware.org (Postfix) with ESMTPS id 86661385C6C2 for ; Sat, 31 Aug 2024 14:56:57 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 86661385C6C2 Authentication-Results: sourceware.org; dmarc=pass (p=quarantine dis=none) header.from=kernel.org Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=kernel.org ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 86661385C6C2 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=2604:1380:4641:c500::1 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1725116219; cv=none; b=jKm5aGRmMsnY8mUSmXRzcCFSk9hmJNlD/4Q3etjvA+igWXsXohInlaCwpJOOIZb931pdfgHWY4yKEkrV2dGgq7iJRSzGGV86NxEPinyypnLeqyzU9qm5tR+F4qI6gznNH4MsCMVUf0H1qKNOddf/rrMwUCawKA+PEfIbY23UlHE= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1725116219; c=relaxed/simple; bh=CDaxm+SnEGt++TUzwZk66AUHfO4h2f81FTZnSjoKKOk=; h=DKIM-Signature:Date:From:To:Subject:Message-ID:MIME-Version; b=ldmbW8QMVUPbpsUDNTvrJUC9Gn0wU64dqIguEIF1RSmHy+qp458uTdwEDz+Uzi59FWjLW2GRq6vwvsbtPM3ws81jKEESj0O+j+aBz0iOraeK0LKfBzOArAYLZZv+T6pZvgepYtzdZPmOh5bvkDbZp0VxuJMdby/fE8s+CW5f3xo= ARC-Authentication-Results: i=1; server2.sourceware.org Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by dfw.source.kernel.org (Postfix) with ESMTP id 38D255C3F85; Sat, 31 Aug 2024 14:56:53 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id E6263C4CEC0; Sat, 31 Aug 2024 14:56:49 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1725116216; bh=CDaxm+SnEGt++TUzwZk66AUHfO4h2f81FTZnSjoKKOk=; h=Date:From:To:Cc:Subject:References:In-Reply-To:From; b=ShPpS8vAp0o+qeOCNfFsDpOyiOuraaRbUNCoX7xUeBQP96IFdpBLELbJED9ZKInwT duCDjTTs4D51WTQnG+n4+pLSzqDC/ontce38ufJUYd1rBAgzvWW8K0m8fx5/WlJxCm N3j0/kJezPA9eyNqKfDDAN3Gd0FGGqgOj+6jyTtx1iuVfexWGasVbrTJEC5MmOFWnr zKRri2a5h3Uc7x6+8dxUC22GcX3UBIIpfDTvwbEZE8aUmK2ogjsK4dI3UvYE0V8dUD 9CTu/cbStOrP+83jEbJbtlX9aa64oVzb+DRuS/nghP/3K/2YTJMPpNoxF/w0OGNz+S 3iX9A0LcxdN3w== Date: Sat, 31 Aug 2024 16:56:48 +0200 From: Alejandro Colomar To: gcc-patches@gcc.gnu.org Cc: Alejandro Colomar , Joseph Myers , Gabriel Ravier , Jakub Jelinek , Kees Cook , Qing Zhao , Jens Gustedt , David Brown , Florian Weimer , Andreas Schwab , Timm Baeder , Daniel Plakosh , "A. Jiang" , Eugene Zelenko , Aaron Ballman , Paul Koning , Daniel Lundin , Nikolaos Strimpas , JeanHeyd Meneide , Fernando Borretti , Jonathan Protzenko , Chris Bazley , Ville Voutilainen , Alex Celeste , Jakub =?utf-8?q?=C5=81ukasiewicz?= , Douglas McIlroy , Jason Merrill , Xavier Del Campo Romero , Martin Uecker , Siddhesh Poyarekar , DJ Delorie , Carlos O'Donell , Stephen Coady , ganandan@redhat.com, mnewsome@redhat.com Subject: [PATCH v12 3/4] Merge definitions of array_type_nelts_top() Message-ID: <03de2d67bb1951546d0b69fa626dd3824e36da90.1725115144.git.alx@kernel.org> X-Mailer: git-send-email 2.45.2 References: MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: X-Spam-Status: No, score=-10.0 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, 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~incoming=patchwork.ozlabs.org@gcc.gnu.org There were two identical definitions, and none of them are available where they are needed for implementing __nelementsof__. Merge them, and provide the single definition in gcc/tree.{h,cc}, where it's available for __nelementsof__, which will be added in the following commit. gcc/ChangeLog: * tree.h (array_type_nelts_top) * tree.cc (array_type_nelts_top): Define function (moved from gcc/cp/). gcc/cp/ChangeLog: * cp-tree.h (array_type_nelts_top) * tree.cc (array_type_nelts_top): Remove function (move to gcc/). gcc/rust/ChangeLog: * backend/rust-tree.h (array_type_nelts_top) * backend/rust-tree.cc (array_type_nelts_top): Remove function. Signed-off-by: Alejandro Colomar --- gcc/cp/cp-tree.h | 1 - gcc/cp/tree.cc | 13 ------------- gcc/rust/backend/rust-tree.cc | 13 ------------- gcc/rust/backend/rust-tree.h | 2 -- gcc/tree.cc | 13 +++++++++++++ gcc/tree.h | 1 + 6 files changed, 14 insertions(+), 29 deletions(-) diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index 2eeb5e3e8b1..6913175c3ce 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -8108,7 +8108,6 @@ extern tree build_exception_variant (tree, tree); extern void fixup_deferred_exception_variants (tree, tree); extern tree bind_template_template_parm (tree, tree); extern tree array_type_nelts_total (tree); -extern tree array_type_nelts_top (tree); extern bool array_of_unknown_bound_p (const_tree); extern tree break_out_target_exprs (tree, bool = false); extern tree build_ctor_subob_ref (tree, tree, tree); diff --git a/gcc/cp/tree.cc b/gcc/cp/tree.cc index 040136c70ab..7d179491476 100644 --- a/gcc/cp/tree.cc +++ b/gcc/cp/tree.cc @@ -3079,19 +3079,6 @@ cxx_print_statistics (void) depth_reached); } -/* Return, as an INTEGER_CST node, the number of elements for TYPE - (which is an ARRAY_TYPE). This counts only elements of the top - array. */ - -tree -array_type_nelts_top (tree type) -{ - return fold_build2_loc (input_location, - PLUS_EXPR, sizetype, - array_type_nelts_minus_one (type), - size_one_node); -} - /* Return, as an INTEGER_CST node, the number of elements for TYPE (which is an ARRAY_TYPE). This one is a recursive count of all ARRAY_TYPEs that are clumped together. */ diff --git a/gcc/rust/backend/rust-tree.cc b/gcc/rust/backend/rust-tree.cc index 8d32e5203ae..3dc6b076711 100644 --- a/gcc/rust/backend/rust-tree.cc +++ b/gcc/rust/backend/rust-tree.cc @@ -859,19 +859,6 @@ is_empty_class (tree type) return CLASSTYPE_EMPTY_P (type); } -// forked from gcc/cp/tree.cc array_type_nelts_top - -/* Return, as an INTEGER_CST node, the number of elements for TYPE - (which is an ARRAY_TYPE). This counts only elements of the top - array. */ - -tree -array_type_nelts_top (tree type) -{ - return fold_build2_loc (input_location, PLUS_EXPR, sizetype, - array_type_nelts_minus_one (type), size_one_node); -} - // forked from gcc/cp/tree.cc builtin_valid_in_constant_expr_p /* Test whether DECL is a builtin that may appear in a diff --git a/gcc/rust/backend/rust-tree.h b/gcc/rust/backend/rust-tree.h index 26c8b653ac6..e597c3ab81d 100644 --- a/gcc/rust/backend/rust-tree.h +++ b/gcc/rust/backend/rust-tree.h @@ -2993,8 +2993,6 @@ extern location_t rs_expr_location (const_tree); extern int is_empty_class (tree type); -extern tree array_type_nelts_top (tree); - extern bool is_really_empty_class (tree, bool); diff --git a/gcc/tree.cc b/gcc/tree.cc index 7439777f307..d0a7156d982 100644 --- a/gcc/tree.cc +++ b/gcc/tree.cc @@ -3729,6 +3729,19 @@ array_type_nelts_minus_one (const_tree type) ? max : fold_build2 (MINUS_EXPR, TREE_TYPE (max), max, min)); } + +/* Return, as an INTEGER_CST node, the number of elements for TYPE + (which is an ARRAY_TYPE). This counts only elements of the top + array. */ + +tree +array_type_nelts_top (tree type) +{ + return fold_build2_loc (input_location, + PLUS_EXPR, sizetype, + array_type_nelts_minus_one (type), + size_one_node); +} /* If arg is static -- a reference to an object in static storage -- then return the object. This is not the same as the C meaning of `static'. diff --git a/gcc/tree.h b/gcc/tree.h index 4e29544a36c..372f4dd71da 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -4922,6 +4922,7 @@ extern tree build_method_type (tree, tree); extern tree build_offset_type (tree, tree); extern tree build_complex_type (tree, bool named = false); extern tree array_type_nelts_minus_one (const_tree); +extern tree array_type_nelts_top (tree); extern tree value_member (tree, tree); extern tree purpose_member (const_tree, tree); From patchwork Sat Aug 31 14:56:57 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Alejandro Colomar X-Patchwork-Id: 1979330 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@legolas.ozlabs.org Authentication-Results: legolas.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=kernel.org header.i=@kernel.org header.a=rsa-sha256 header.s=k20201202 header.b=ET4CT1lt; dkim-atps=neutral Authentication-Results: legolas.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=2620:52:3:1:0:246e:9693:128c; helo=server2.sourceware.org; envelope-from=gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=patchwork.ozlabs.org) Received: from server2.sourceware.org (server2.sourceware.org [IPv6:2620:52:3:1:0:246e:9693:128c]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (secp384r1) server-digest SHA384) (No client certificate requested) by legolas.ozlabs.org (Postfix) with ESMTPS id 4Wwymg1rJkz1yfK for ; Sun, 1 Sep 2024 00:57:39 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 1D3FA3865C24 for ; Sat, 31 Aug 2024 14:57:37 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from dfw.source.kernel.org (dfw.source.kernel.org [139.178.84.217]) by sourceware.org (Postfix) with ESMTPS id 699EB385EC2D for ; Sat, 31 Aug 2024 14:57:08 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 699EB385EC2D Authentication-Results: sourceware.org; dmarc=pass (p=quarantine dis=none) header.from=kernel.org Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=kernel.org ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 699EB385EC2D Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=139.178.84.217 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1725116233; cv=none; b=Gx0wPI2/WJEcyCZSQPsFVutALNIK1wzYDA7qdHb6O6R264bPkDYiUBjGd+z/qHUXSb/tR4xh1ljBPZvCIOMGwN4SW95tbP268C1a7loKYw/Ovp5rKyV2Sr8isOSMwsSTmgIdOyChS34qosSbbwycN6aZWcfm3/3EIU+B7ay2BiE= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1725116233; c=relaxed/simple; bh=vPjcBEPGndl9Xz/rigYyodqoDwEnpe8VHEVAYNUFo8w=; h=DKIM-Signature:Date:From:To:Subject:Message-ID:MIME-Version; b=JB1swtMJF7knJV+0a8a3rrFMwcPvMq7nvYoJB1NeweVrhrDW2bu1fJG42n+zFAe3QQ8crIpxyJ1Rz6sC2Y5Y8qHxD9oc7Z8bQ2XJKCqd1uF0/WkojrsU6RXsRK4dVSzhon8tFyrGU1eGI30p43GcqcH6AsiAodvsvuM3AxGINaA= ARC-Authentication-Results: i=1; server2.sourceware.org Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by dfw.source.kernel.org (Postfix) with ESMTP id B59AB5C3F98; Sat, 31 Aug 2024 14:57:02 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 4C4C3C4CEC0; Sat, 31 Aug 2024 14:56:59 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1725116225; bh=vPjcBEPGndl9Xz/rigYyodqoDwEnpe8VHEVAYNUFo8w=; h=Date:From:To:Cc:Subject:References:In-Reply-To:From; b=ET4CT1ltHvav8uuIBqcMKeHR7GAm641462t0bhKnGCj/QtSoVxVo9vtc4Ku6iLubT zy2XKod1yKIEsO/GNFLrpEKPU7rPSTl6f4Ay2PBw5hDXJoi4FuEphImkSP4PUv9tdB hT7qwiecYm4nWJ+ayCjuFdxuBH5VQzHijilSwhoVb/tm0omzfTZgpa3JieReEW9887 3+n27JcJJHBOyiR34BWo7NeCYgIl1FhIwgLXQSUeNOyVmY+Ks7yoerOV4qgBoLChPG aL56a2QDuBE+9EngBMdFkZGsyCRphCglxa4LuZi8Ri6jFCT+y7WCjsgHUxA8FSfECz bWCBPV774KM4Q== Date: Sat, 31 Aug 2024 16:56:57 +0200 From: Alejandro Colomar To: gcc-patches@gcc.gnu.org Cc: Alejandro Colomar , Joseph Myers , Gabriel Ravier , Jakub Jelinek , Kees Cook , Qing Zhao , Jens Gustedt , David Brown , Florian Weimer , Andreas Schwab , Timm Baeder , Daniel Plakosh , "A. Jiang" , Eugene Zelenko , Aaron Ballman , Paul Koning , Daniel Lundin , Nikolaos Strimpas , JeanHeyd Meneide , Fernando Borretti , Jonathan Protzenko , Chris Bazley , Ville Voutilainen , Alex Celeste , Jakub =?utf-8?q?=C5=81ukasiewicz?= , Douglas McIlroy , Jason Merrill , Xavier Del Campo Romero , Martin Uecker , Siddhesh Poyarekar , DJ Delorie , Carlos O'Donell , Stephen Coady , ganandan@redhat.com, mnewsome@redhat.com Subject: [PATCH v12 4/4] c: Add __nelementsof__ operator Message-ID: <4373c48205d4ba06305a2248df55a6744310de2e.1725115144.git.alx@kernel.org> X-Mailer: git-send-email 2.45.2 References: MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: X-Spam-Status: No, score=-10.0 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, KAM_SHORT, 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~incoming=patchwork.ozlabs.org@gcc.gnu.org This operator is similar to sizeof but can only be applied to an array, and returns its number of elements. FUTURE DIRECTIONS: - We should make it work with array parameters to functions, and somehow magically return the number of elements of the array, regardless of it being really a pointer. - Fix support for [0]. gcc/ChangeLog: * doc/extend.texi: Document __nelementsof__ operator. * target.h (enum type_context_kind): Add __nelementsof__ operator. gcc/c-family/ChangeLog: * c-common.h * c-common.def: * c-common.cc (c_nelementsof_type): Add __nelementsof__ operator. gcc/c/ChangeLog: * c-tree.h (c_expr_nelementsof_expr, c_expr_nelementsof_type) * c-decl.cc (start_struct, finish_struct) (start_enum, finish_enum) * c-parser.cc (c_parser_sizeof_expression) (c_parser_nelementsof_expression) (c_parser_sizeof_or_nelementsof_expression) (c_parser_unary_expression) * c-typeck.cc (build_external_ref) (record_maybe_used_decl, pop_maybe_used) (is_top_array_vla) (c_expr_nelementsof_expr, c_expr_nelementsof_type): Add __nelementsof__operator. gcc/cp/ChangeLog: * operators.def: Add __nelementsof__ operator. gcc/testsuite/ChangeLog: * gcc.dg/nelementsof-compile.c * gcc.dg/nelementsof-vla.c * gcc.dg/nelementsof.c: Add tests for __nelementsof__ operator. Link: Link: Link: Cc: Joseph Myers Cc: Gabriel Ravier Cc: Jakub Jelinek Cc: Kees Cook Cc: Qing Zhao Cc: Jens Gustedt Cc: David Brown Cc: Florian Weimer Cc: Andreas Schwab Cc: Timm Baeder Cc: Daniel Plakosh Cc: "A. Jiang" Cc: Eugene Zelenko Cc: Aaron Ballman Cc: Paul Koning Cc: Daniel Lundin Cc: Nikolaos Strimpas Cc: JeanHeyd Meneide Cc: Fernando Borretti Cc: Jonathan Protzenko Cc: Chris Bazley Cc: Ville Voutilainen Cc: Alex Celeste Cc: Jakub Łukasiewicz Cc: Douglas McIlroy Cc: Jason Merrill Suggested-by: Xavier Del Campo Romero Co-authored-by: Martin Uecker Signed-off-by: Alejandro Colomar --- gcc/c-family/c-common.cc | 26 ++++ gcc/c-family/c-common.def | 3 + gcc/c-family/c-common.h | 2 + gcc/c/c-decl.cc | 22 ++- gcc/c/c-parser.cc | 62 +++++++-- gcc/c/c-tree.h | 4 + gcc/c/c-typeck.cc | 118 +++++++++++++++- gcc/cp/operators.def | 1 + gcc/doc/extend.texi | 30 +++++ gcc/target.h | 3 + gcc/testsuite/gcc.dg/nelementsof-compile.c | 115 ++++++++++++++++ gcc/testsuite/gcc.dg/nelementsof-vla.c | 46 +++++++ gcc/testsuite/gcc.dg/nelementsof.c | 150 +++++++++++++++++++++ 13 files changed, 558 insertions(+), 24 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/nelementsof-compile.c create mode 100644 gcc/testsuite/gcc.dg/nelementsof-vla.c create mode 100644 gcc/testsuite/gcc.dg/nelementsof.c diff --git a/gcc/c-family/c-common.cc b/gcc/c-family/c-common.cc index e7e371fd26f..188bb9b65ef 100644 --- a/gcc/c-family/c-common.cc +++ b/gcc/c-family/c-common.cc @@ -465,6 +465,7 @@ const struct c_common_resword c_common_reswords[] = { "__inline", RID_INLINE, 0 }, { "__inline__", RID_INLINE, 0 }, { "__label__", RID_LABEL, 0 }, + { "__nelementsof__", RID_NELEMENTSOF, 0 }, { "__null", RID_NULL, 0 }, { "__real", RID_REALPART, 0 }, { "__real__", RID_REALPART, 0 }, @@ -4070,6 +4071,31 @@ c_alignof_expr (location_t loc, tree expr) return fold_convert_loc (loc, size_type_node, t); } + +/* Implement the lementsof keyword: + Return the number of elements of an array. */ + +tree +c_nelementsof_type (location_t loc, tree type) +{ + enum tree_code type_code; + + type_code = TREE_CODE (type); + if (type_code != ARRAY_TYPE) + { + error_at (loc, "invalid application of % to type %qT", type); + return error_mark_node; + } + if (!COMPLETE_TYPE_P (type)) + { + error_at (loc, + "invalid application of % to incomplete type %qT", + type); + return error_mark_node; + } + + return array_type_nelts_top (type); +} /* Handle C and C++ default attributes. */ diff --git a/gcc/c-family/c-common.def b/gcc/c-family/c-common.def index 5de96e5d4a8..12ee0d2adb3 100644 --- a/gcc/c-family/c-common.def +++ b/gcc/c-family/c-common.def @@ -50,6 +50,9 @@ DEFTREECODE (EXCESS_PRECISION_EXPR, "excess_precision_expr", tcc_expression, 1) number. */ DEFTREECODE (USERDEF_LITERAL, "userdef_literal", tcc_exceptional, 3) +/* Represents a 'nelementsof' expression. */ +DEFTREECODE (NELEMENTSOF_EXPR, "nelementsof_expr", tcc_expression, 1) + /* Represents a 'sizeof' expression during C++ template expansion, or for the purpose of -Wsizeof-pointer-memaccess warning. */ DEFTREECODE (SIZEOF_EXPR, "sizeof_expr", tcc_expression, 1) diff --git a/gcc/c-family/c-common.h b/gcc/c-family/c-common.h index d3827573a36..66b705d42e1 100644 --- a/gcc/c-family/c-common.h +++ b/gcc/c-family/c-common.h @@ -105,6 +105,7 @@ enum rid /* C extensions */ RID_ASM, RID_TYPEOF, RID_TYPEOF_UNQUAL, RID_ALIGNOF, RID_ATTRIBUTE, + RID_NELEMENTSOF, RID_VA_ARG, RID_EXTENSION, RID_IMAGPART, RID_REALPART, RID_LABEL, RID_CHOOSE_EXPR, RID_TYPES_COMPATIBLE_P, RID_BUILTIN_COMPLEX, RID_BUILTIN_SHUFFLE, @@ -887,6 +888,7 @@ extern tree c_common_truthvalue_conversion (location_t, tree); extern void c_apply_type_quals_to_decl (int, tree); extern tree c_sizeof_or_alignof_type (location_t, tree, bool, bool, int); extern tree c_alignof_expr (location_t, tree); +extern tree c_nelementsof_type (location_t, tree); /* Print an error message for invalid operands to arith operation CODE. NOP_EXPR is used as a special case (see truthvalue_conversion). */ extern void binary_op_error (rich_location *, enum tree_code, tree, tree); diff --git a/gcc/c/c-decl.cc b/gcc/c/c-decl.cc index c73d3107efb..e4385293ee1 100644 --- a/gcc/c/c-decl.cc +++ b/gcc/c/c-decl.cc @@ -8992,12 +8992,17 @@ start_struct (location_t loc, enum tree_code code, tree name, within a statement expr used within sizeof, et. al. This is not terribly serious as C++ doesn't permit statement exprs within sizeof anyhow. */ - if (warn_cxx_compat && (in_sizeof || in_typeof || in_alignof)) + if (warn_cxx_compat + && (in_sizeof || in_typeof || in_alignof || in_nelementsof)) warning_at (loc, OPT_Wc___compat, "defining type in %qs expression is invalid in C++", (in_sizeof ? "sizeof" - : (in_typeof ? "typeof" : "alignof"))); + : (in_typeof + ? "typeof" + : (in_alignof + ? "alignof" + : "nelementsof")))); if (in_underspecified_init) error_at (loc, "%qT defined in underspecified object initializer", ref); @@ -9957,7 +9962,7 @@ finish_struct (location_t loc, tree t, tree fieldlist, tree attributes, struct_types. */ if (warn_cxx_compat && struct_parse_info != NULL - && !in_sizeof && !in_typeof && !in_alignof) + && !in_sizeof && !in_typeof && !in_alignof && !in_nelementsof) struct_parse_info->struct_types.safe_push (t); } @@ -10131,12 +10136,17 @@ start_enum (location_t loc, struct c_enum_contents *the_enum, tree name, /* FIXME: This will issue a warning for a use of a type defined within sizeof in a statement expr. This is not terribly serious as C++ doesn't permit statement exprs within sizeof anyhow. */ - if (warn_cxx_compat && (in_sizeof || in_typeof || in_alignof)) + if (warn_cxx_compat + && (in_sizeof || in_typeof || in_alignof || in_nelementsof)) warning_at (loc, OPT_Wc___compat, "defining type in %qs expression is invalid in C++", (in_sizeof ? "sizeof" - : (in_typeof ? "typeof" : "alignof"))); + : (in_typeof + ? "typeof" + : (in_alignof + ? "alignof" + : "nelementsof")))); if (in_underspecified_init) error_at (loc, "%qT defined in underspecified object initializer", @@ -10330,7 +10340,7 @@ finish_enum (tree enumtype, tree values, tree attributes) struct_types. */ if (warn_cxx_compat && struct_parse_info != NULL - && !in_sizeof && !in_typeof && !in_alignof) + && !in_sizeof && !in_typeof && !in_alignof && !in_nelementsof) struct_parse_info->struct_types.safe_push (enumtype); /* Check for consistency with previous definition */ diff --git a/gcc/c/c-parser.cc b/gcc/c/c-parser.cc index aff5af17430..24a01e08baf 100644 --- a/gcc/c/c-parser.cc +++ b/gcc/c/c-parser.cc @@ -74,7 +74,17 @@ along with GCC; see the file COPYING3. If not see #include "bitmap.h" #include "analyzer/analyzer-language.h" #include "toplev.h" + +#define c_parser_sizeof_expression(parser) \ +( \ + c_parser_sizeof_or_nelementsof_expression (parser, RID_SIZEOF) \ +) +#define c_parser_nelementsof_expression(parser) \ +( \ + c_parser_sizeof_or_nelementsof_expression (parser, RID_NELEMENTSOF) \ +) + /* We need to walk over decls with incomplete struct/union/enum types after parsing the whole translation unit. In finish_decl(), if the decl is static, has incomplete @@ -1694,7 +1704,8 @@ static struct c_expr c_parser_binary_expression (c_parser *, struct c_expr *, tree); static struct c_expr c_parser_cast_expression (c_parser *, struct c_expr *); static struct c_expr c_parser_unary_expression (c_parser *); -static struct c_expr c_parser_sizeof_expression (c_parser *); +static struct c_expr c_parser_sizeof_or_nelementsof_expression (c_parser *, + enum rid); static struct c_expr c_parser_alignof_expression (c_parser *); static struct c_expr c_parser_postfix_expression (c_parser *); static struct c_expr c_parser_postfix_expression_after_paren_type (c_parser *, @@ -9910,6 +9921,8 @@ c_parser_unary_expression (c_parser *parser) case CPP_KEYWORD: switch (c_parser_peek_token (parser)->keyword) { + case RID_NELEMENTSOF: + return c_parser_nelementsof_expression (parser); case RID_SIZEOF: return c_parser_sizeof_expression (parser); case RID_ALIGNOF: @@ -9949,12 +9962,13 @@ c_parser_unary_expression (c_parser *parser) /* Parse a sizeof expression. */ static struct c_expr -c_parser_sizeof_expression (c_parser *parser) +c_parser_sizeof_or_nelementsof_expression (c_parser *parser, enum rid rid) { + const char *op_name = (rid == RID_NELEMENTSOF) ? "nelementsof" : "sizeof"; struct c_expr expr; struct c_expr result; location_t expr_loc; - gcc_assert (c_parser_next_token_is_keyword (parser, RID_SIZEOF)); + gcc_assert (c_parser_next_token_is_keyword (parser, rid)); location_t start; location_t finish = UNKNOWN_LOCATION; @@ -9963,7 +9977,10 @@ c_parser_sizeof_expression (c_parser *parser) c_parser_consume_token (parser); c_inhibit_evaluation_warnings++; - in_sizeof++; + if (rid == RID_NELEMENTSOF) + in_nelementsof++; + else + in_sizeof++; if (c_parser_next_token_is (parser, CPP_OPEN_PAREN) && c_token_starts_compound_literal (c_parser_peek_2nd_token (parser))) { @@ -9982,7 +9999,10 @@ c_parser_sizeof_expression (c_parser *parser) { struct c_expr ret; c_inhibit_evaluation_warnings--; - in_sizeof--; + if (rid == RID_NELEMENTSOF) + in_nelementsof--; + else + in_sizeof--; ret.set_error (); ret.original_code = ERROR_MARK; ret.original_type = NULL; @@ -9994,31 +10014,45 @@ c_parser_sizeof_expression (c_parser *parser) type_name, expr_loc); finish = expr.get_finish (); - goto sizeof_expr; + goto Xof_expr; } /* sizeof ( type-name ). */ if (scspecs) - error_at (expr_loc, "storage class specifier in %"); + error_at (expr_loc, "storage class specifier in %qs", op_name); if (type_name->specs->alignas_p) error_at (type_name->specs->locations[cdw_alignas], - "alignment specified for type name in %"); + "alignment specified for type name in %qs", op_name); c_inhibit_evaluation_warnings--; - in_sizeof--; - result = c_expr_sizeof_type (expr_loc, type_name); + if (rid == RID_NELEMENTSOF) + { + in_nelementsof--; + result = c_expr_nelementsof_type (expr_loc, type_name); + } + else + { + in_sizeof--; + result = c_expr_sizeof_type (expr_loc, type_name); + } } else { expr_loc = c_parser_peek_token (parser)->location; expr = c_parser_unary_expression (parser); finish = expr.get_finish (); - sizeof_expr: + Xof_expr: c_inhibit_evaluation_warnings--; - in_sizeof--; + if (rid == RID_NELEMENTSOF) + in_nelementsof--; + else + in_sizeof--; mark_exp_read (expr.value); if (TREE_CODE (expr.value) == COMPONENT_REF && DECL_C_BIT_FIELD (TREE_OPERAND (expr.value, 1))) - error_at (expr_loc, "% applied to a bit-field"); - result = c_expr_sizeof_expr (expr_loc, expr); + error_at (expr_loc, "%qs applied to a bit-field", op_name); + if (rid == RID_NELEMENTSOF) + result = c_expr_nelementsof_expr (expr_loc, expr); + else + result = c_expr_sizeof_expr (expr_loc, expr); } if (finish == UNKNOWN_LOCATION) finish = start; diff --git a/gcc/c/c-tree.h b/gcc/c/c-tree.h index 57befb94c08..4ea45661bc9 100644 --- a/gcc/c/c-tree.h +++ b/gcc/c/c-tree.h @@ -736,6 +736,7 @@ extern int c_type_dwarf_attribute (const_tree, int); /* in c-typeck.cc */ extern int in_alignof; extern int in_sizeof; +extern int in_nelementsof; extern int in_typeof; extern bool c_in_omp_for; extern bool c_omp_array_section_p; @@ -786,6 +787,9 @@ extern tree build_external_ref (location_t, tree, bool, tree *); extern void pop_maybe_used (bool); extern struct c_expr c_expr_sizeof_expr (location_t, struct c_expr); extern struct c_expr c_expr_sizeof_type (location_t, struct c_type_name *); +extern struct c_expr c_expr_nelementsof_expr (location_t, struct c_expr); +extern struct c_expr c_expr_nelementsof_type (location_t loc, + struct c_type_name *); extern struct c_expr parser_build_unary_op (location_t, enum tree_code, struct c_expr); extern struct c_expr parser_build_binary_op (location_t, diff --git a/gcc/c/c-typeck.cc b/gcc/c/c-typeck.cc index 094e41fa202..651e5c15b87 100644 --- a/gcc/c/c-typeck.cc +++ b/gcc/c/c-typeck.cc @@ -71,6 +71,9 @@ int in_alignof; /* The level of nesting inside "sizeof". */ int in_sizeof; +/* The level of nesting inside "nelementsof". */ +int in_nelementsof; + /* The level of nesting inside "typeof". */ int in_typeof; @@ -3255,7 +3258,7 @@ build_external_ref (location_t loc, tree id, bool fun, tree *type) if (TREE_CODE (ref) == FUNCTION_DECL && !in_alignof) { - if (!in_sizeof && !in_typeof) + if (!in_sizeof && !in_typeof && !in_nelementsof) C_DECL_USED (ref) = 1; else if (DECL_INITIAL (ref) == NULL_TREE && DECL_EXTERNAL (ref) @@ -3311,7 +3314,7 @@ struct maybe_used_decl { /* The decl. */ tree decl; - /* The level seen at (in_sizeof + in_typeof). */ + /* The level seen at (in_sizeof + in_typeof + in_nelementsof). */ int level; /* The next one at this level or above, or NULL. */ struct maybe_used_decl *next; @@ -3329,7 +3332,7 @@ record_maybe_used_decl (tree decl) { struct maybe_used_decl *t = XOBNEW (&parser_obstack, struct maybe_used_decl); t->decl = decl; - t->level = in_sizeof + in_typeof; + t->level = in_sizeof + in_typeof + in_nelementsof; t->next = maybe_used_decls; maybe_used_decls = t; } @@ -3343,7 +3346,7 @@ void pop_maybe_used (bool used) { struct maybe_used_decl *p = maybe_used_decls; - int cur_level = in_sizeof + in_typeof; + int cur_level = in_sizeof + in_typeof + in_nelementsof; while (p && p->level > cur_level) { if (used) @@ -3453,6 +3456,113 @@ c_expr_sizeof_type (location_t loc, struct c_type_name *t) return ret; } +static bool +is_top_array_vla (tree type) +{ + bool zero, star, var; + tree d; + + if (TREE_CODE (type) != ARRAY_TYPE) + return false; + if (!COMPLETE_TYPE_P (type)) + return false; + + d = TYPE_DOMAIN (type); + zero = !TYPE_MAX_VALUE (d); + star = (zero && C_TYPE_VARIABLE_SIZE (type)); + if (star) + return true; + if (zero) + return false; + + var = (TREE_CODE (TYPE_MIN_VALUE (d)) != INTEGER_CST + || TREE_CODE (TYPE_MAX_VALUE (d)) != INTEGER_CST); + return var; +} + +/* Return the result of nelementsof applied to EXPR. */ + +struct c_expr +c_expr_nelementsof_expr (location_t loc, struct c_expr expr) +{ + struct c_expr ret; + if (expr.value == error_mark_node) + { + ret.value = error_mark_node; + ret.original_code = ERROR_MARK; + ret.original_type = NULL; + ret.m_decimal = 0; + pop_maybe_used (false); + } + else + { + bool expr_const_operands = true; + + tree folded_expr = c_fully_fold (expr.value, require_constant_value, + &expr_const_operands); + ret.value = c_nelementsof_type (loc, TREE_TYPE (folded_expr)); + c_last_sizeof_arg = expr.value; + c_last_sizeof_loc = loc; + ret.original_code = NELEMENTSOF_EXPR; + ret.original_type = NULL; + ret.m_decimal = 0; + if (is_top_array_vla (TREE_TYPE (folded_expr))) + { + /* nelementsof is evaluated when given a vla. */ + ret.value = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (ret.value), + folded_expr, ret.value); + C_MAYBE_CONST_EXPR_NON_CONST (ret.value) = !expr_const_operands; + SET_EXPR_LOCATION (ret.value, loc); + } + pop_maybe_used (is_top_array_vla (TREE_TYPE (folded_expr))); + } + return ret; +} + +/* Return the result of nelementsof applied to T, a structure for the type + name passed to nelementsof (rather than the type itself). LOC is the + location of the original expression. */ + +struct c_expr +c_expr_nelementsof_type (location_t loc, struct c_type_name *t) +{ + tree type; + struct c_expr ret; + tree type_expr = NULL_TREE; + bool type_expr_const = true; + type = groktypename (t, &type_expr, &type_expr_const); + ret.value = c_nelementsof_type (loc, type); + c_last_sizeof_arg = type; + c_last_sizeof_loc = loc; + ret.original_code = NELEMENTSOF_EXPR; + ret.original_type = NULL; + ret.m_decimal = 0; + if (type == error_mark_node) + { + ret.value = error_mark_node; + ret.original_code = ERROR_MARK; + } + else + if ((type_expr || TREE_CODE (ret.value) == INTEGER_CST) + && is_top_array_vla (type)) + { + /* If the type is a [*] array, it is a VLA but is represented as + having a size of zero. In such a case we must ensure that + the result of nelementsof does not get folded to a constant by + c_fully_fold, because if the length is evaluated the result is + not constant and so constraints on zero or negative size + arrays must not be applied when this nelementsof call is inside + another array declarator. */ + if (!type_expr) + type_expr = integer_zero_node; + ret.value = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (ret.value), + type_expr, ret.value); + C_MAYBE_CONST_EXPR_NON_CONST (ret.value) = !type_expr_const; + } + pop_maybe_used (type != error_mark_node ? is_top_array_vla (type) : false); + return ret; +} + /* Build a function call to function FUNCTION with parameters PARAMS. The function call is at LOC. PARAMS is a list--a chain of TREE_LIST nodes--in which the diff --git a/gcc/cp/operators.def b/gcc/cp/operators.def index d8878923602..7f1d24779c8 100644 --- a/gcc/cp/operators.def +++ b/gcc/cp/operators.def @@ -91,6 +91,7 @@ DEF_OPERATOR ("co_await", CO_AWAIT_EXPR, "aw", OVL_OP_FLAG_UNARY) /* These are extensions. */ DEF_OPERATOR ("alignof", ALIGNOF_EXPR, "az", OVL_OP_FLAG_UNARY) +DEF_OPERATOR ("__nelementsof__", NELEMENTSOF_EXPR, "lz", OVL_OP_FLAG_UNARY) DEF_OPERATOR ("__imag__", IMAGPART_EXPR, "v18__imag__", OVL_OP_FLAG_UNARY) DEF_OPERATOR ("__real__", REALPART_EXPR, "v18__real__", OVL_OP_FLAG_UNARY) diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi index 5845bcedf6e..3057d39f873 100644 --- a/gcc/doc/extend.texi +++ b/gcc/doc/extend.texi @@ -10544,6 +10544,36 @@ If the operand of the @code{__alignof__} expression is a function, the expression evaluates to the alignment of the function which may be specified by attribute @code{aligned} (@pxref{Common Function Attributes}). +@node nelementsof +@section Determining the Number of Elements of Arrays +@cindex nelementsof +@cindex number of elements + +The keyword @code{__elemetsf__} determines the length of an array operand, +that is, the number of elements in the array. +Its syntax is similar to @code{sizeof}. +The operand must be +a parenthesized complete array type name +or an expression of such a type. +For example: + +@smallexample +int a[n]; +__elemetsf__ (a); // returns n +__elemetsf__ (int [7][3]); // returns 7 +@end smallexample + +The result of this operator is an integer constant expression, +unless the top-level array is a variable-length array. +The operand is only evaluated +if the top-level array is a variable-length array. +For example: + +@smallexample +__elemetsf__ (int [7][n++]); // integer constant expression +__elemetsf__ (int [n++][7]); // run-time value; n++ is evaluated +@end smallexample + @node Inline @section An Inline Function is As Fast As a Macro @cindex inline functions diff --git a/gcc/target.h b/gcc/target.h index 837651d273a..09245d70c1f 100644 --- a/gcc/target.h +++ b/gcc/target.h @@ -245,6 +245,9 @@ enum type_context_kind { /* Directly measuring the alignment of T. */ TCTX_ALIGNOF, + /* Directly measuring the number of elements of array T. */ + TCTX_NELEMENTSOF, + /* Creating objects of type T with static storage duration. */ TCTX_STATIC_STORAGE, diff --git a/gcc/testsuite/gcc.dg/nelementsof-compile.c b/gcc/testsuite/gcc.dg/nelementsof-compile.c new file mode 100644 index 00000000000..211b63fa7b5 --- /dev/null +++ b/gcc/testsuite/gcc.dg/nelementsof-compile.c @@ -0,0 +1,115 @@ +/* { dg-do compile } */ +/* { dg-options "-Wno-declaration-after-statement -Wno-pedantic -Wno-vla" } */ + +extern int x[]; + +static int w[] = {1, 2, 3}; + +static int z[0]; +static int y[__nelementsof__(z)]; + +void +automatic(void) +{ + __nelementsof__ (w); +} + +void +incomplete (int p[]) +{ + __nelementsof__ (x); /* { dg-error "incomplete" } */ + + /* We want to support the following one in the future, + but for now it should fail. */ + __nelementsof__ (p); /* { dg-error "invalid" } */ +} + +void +fam (void) +{ + struct { + int x; + int fam[]; + } s; + + __nelementsof__ (s.fam); /* { dg-error "incomplete" } */ +} + +void fix_fix (int i, char (*a)[3][5], int (*x)[__nelementsof__ (*a)]); +void fix_var (int i, char (*a)[3][i], int (*x)[__nelementsof__ (*a)]); +void fix_uns (int i, char (*a)[3][*], int (*x)[__nelementsof__ (*a)]); + +void +func (void) +{ + int i3[3]; + int i5[5]; + char c35[3][5]; + + fix_fix (5, &c35, &i3); + fix_fix (5, &c35, &i5); /* { dg-error "incompatible-pointer-types" } */ + + fix_var (5, &c35, &i3); + fix_var (5, &c35, &i5); /* { dg-error "incompatible-pointer-types" } */ + + fix_uns (5, &c35, &i3); + fix_uns (5, &c35, &i5); /* { dg-error "incompatible-pointer-types" } */ +} + +void +non_arr(void) +{ + int x; + int *p; + struct s { + int x[3]; + } s; + + __nelementsof__ (x); /* { dg-error "invalid" } */ + __nelementsof__ (int); /* { dg-error "invalid" } */ + __nelementsof__ (s); /* { dg-error "invalid" } */ + __nelementsof__ (struct s); /* { dg-error "invalid" } */ + __nelementsof__ (&x); /* { dg-error "invalid" } */ + __nelementsof__ (p); /* { dg-error "invalid" } */ + __nelementsof__ (int *); /* { dg-error "invalid" } */ + __nelementsof__ (&s.x); /* { dg-error "invalid" } */ + __nelementsof__ (int (*)[3]); /* { dg-error "invalid" } */ +} + +static int f1(); +static int f2(); /* { dg-warning "never defined" } */ +int a[10][10]; +int n; + +void +syms(void) +{ + int b[n][n]; + + __nelementsof__ (a[f1()]); + __nelementsof__ (b[f2()]); +} + +void +no_parens(void) +{ + __nelementsof__ a; + __nelementsof__ *a; + __nelementsof__ (int [3]) {}; + + __nelementsof__ int [3]; /* { dg-error "expected expression before" } */ +} + +void +const_expr(void) +{ + int n = 7; + + _Static_assert (__nelementsof__ (int [3][n]) == 3); + _Static_assert (__nelementsof__ (int [n][3]) == 7); /* { dg-error "not constant" } */ + _Static_assert (__nelementsof__ (int [0][3]) == 0); + _Static_assert (__nelementsof__ (int [0]) == 0); + + /* FIXME: nelementsof(int [0][n]) should result in a constant expression. */ + _Static_assert (__nelementsof__ (int [0][n]) == 0); /* { dg-error "not constant" } */ +} diff --git a/gcc/testsuite/gcc.dg/nelementsof-vla.c b/gcc/testsuite/gcc.dg/nelementsof-vla.c new file mode 100644 index 00000000000..0cd4dfd37fa --- /dev/null +++ b/gcc/testsuite/gcc.dg/nelementsof-vla.c @@ -0,0 +1,46 @@ +/* { dg-do compile } */ +/* { dg-options "-Wno-pedantic -Wvla-parameter" } */ + +void fix_fix (int i, + char (*a)[3][5], + int (*x)[__nelementsof__ (*a)]); +void fix_var (int i, + char (*a)[3][i], /* dg-warn "variable" */ + int (*x)[__nelementsof__ (*a)]); +void fix_uns (int i, + char (*a)[3][*], + int (*x)[__nelementsof__ (*a)]); + +void zro_fix (int i, + char (*a)[0][5], + int (*x)[__nelementsof__ (*a)]); +void zro_var (int i, + char (*a)[0][i], /* dg-warn "variable" */ + int (*x)[__nelementsof__ (*a)]); +void zro_uns (int i, + char (*a)[0][*], + int (*x)[__nelementsof__ (*a)]); + +void var_fix (int i, + char (*a)[i][5], /* dg-warn "variable" */ + int (*x)[__nelementsof__ (*a)]); /* dg-warn "variable" */ +void var_var (int i, + char (*a)[i][i], /* dg-warn "variable" */ + int (*x)[__nelementsof__ (*a)]); /* dg-warn "variable" */ +void var_uns (int i, + char (*a)[i][*], /* dg-warn "variable" */ + int (*x)[__nelementsof__ (*a)]); /* dg-warn "variable" */ + +void uns_fix (int i, + char (*a)[*][5], + int (*x)[__nelementsof__ (*a)]); +void uns_var (int i, + char (*a)[*][i], /* dg-warn "variable" */ + int (*x)[__nelementsof__ (*a)]); +void uns_uns (int i, + char (*a)[*][*], + int (*x)[__nelementsof__ (*a)]); + +// Can't test due to bug: +//static int z2[0]; +//static int y2[__nelementsof__(z2)]; diff --git a/gcc/testsuite/gcc.dg/nelementsof.c b/gcc/testsuite/gcc.dg/nelementsof.c new file mode 100644 index 00000000000..292311e2822 --- /dev/null +++ b/gcc/testsuite/gcc.dg/nelementsof.c @@ -0,0 +1,150 @@ +/* { dg-do run } */ +/* { dg-options "-Wno-declaration-after-statement -Wno-pedantic -Wno-vla" } */ + +#undef NDEBUG +#include + +void +array (void) +{ + short a[7]; + + static_assert (__nelementsof__ (a) == 7); + static_assert (__nelementsof__ (long [0]) == 0); + static_assert (__nelementsof__ (unsigned [99]) == 99); +} + +void +automatic(void) +{ + int a[] = {1, 2, 3}; + int z[] = {}; + + static_assert (__nelementsof__ (a) == 3); + static_assert (__nelementsof__ (z) == 0); +} + +void +vla (void) +{ + unsigned n; + + n = 99; + assert (__nelementsof__ (short [n - 10]) == 99 - 10); + + int v[n / 2]; + assert (__nelementsof__ (v) == 99 / 2); + + n = 0; + int z[n]; + assert (__nelementsof__ (z) == 0); +} + +void +member (void) +{ + struct { + int a[8]; + } s; + + static_assert (__nelementsof__ (s.a) == 8); +} + +void +vla_eval (void) +{ + int i; + + i = 7; + assert (__nelementsof__ (struct {int x;}[i++]) == 7); + assert (i == 7 + 1); + + int v[i]; + int (*p)[i]; + p = &v; + assert (__nelementsof__ (*p++) == i); + assert (p - 1 == &v); +} + +void +inner_vla_noeval (void) +{ + int i; + + i = 3; + static_assert (__nelementsof__ (struct {int x[i++];}[3]) == 3); + assert (i == 3); +} + +void +array_noeval (void) +{ + long a[5]; + long (*p)[__nelementsof__ (a)]; + + p = &a; + static_assert (__nelementsof__ (*p++) == 5); + assert (p == &a); +} + +void +matrix_zero (void) +{ + int i; + + static_assert (__nelementsof__ (int [0][4]) == 0); + i = 3; + assert (__nelementsof__ (int [0][i]) == 0); +} + +void +matrix_fixed (void) +{ + int i; + + static_assert (__nelementsof__ (int [7][4]) == 7); + i = 3; + static_assert (__nelementsof__ (int [7][i]) == 7); +} + +void +matrix_vla (void) +{ + int i, j; + + i = 7; + assert (__nelementsof__ (int [i++][4]) == 7); + assert (i == 7 + 1); + + i = 9; + j = 3; + assert (__nelementsof__ (int [i++][j]) == 9); + assert (i == 9 + 1); +} + +void +no_parens(void) +{ + int n = 3; + int a[7]; + int v[n]; + + static_assert (__nelementsof__ a == 7); + assert (__nelementsof__ v == 3); +} + +int +main (void) +{ + array (); + automatic (); + vla (); + member (); + vla_eval (); + inner_vla_noeval (); + array_noeval (); + matrix_zero (); + matrix_fixed (); + matrix_vla (); + no_parens (); +}