From patchwork Tue Sep 10 21:35:50 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Nathan Sidwell X-Patchwork-Id: 1160566 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (mailfrom) smtp.mailfrom=gcc.gnu.org (client-ip=209.132.180.131; helo=sourceware.org; envelope-from=gcc-patches-return-508806-incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=acm.org Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.b="aeygZ8dE"; dkim=fail reason="signature verification failed" (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.b="m93nNtR4"; dkim-atps=neutral Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 46Sdd42NJtz9sCJ for ; Wed, 11 Sep 2019 07:36:06 +1000 (AEST) DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:to :from:subject:message-id:date:mime-version:content-type; q=dns; s=default; b=bGw2dpcOSWJUAAWlNmb9mM9Pio/PfU7AzKaD+7JNQolhDx6h0n To0ZoFwFBm7msFSClOBSnhafL9c+Pflj352RYgJkQOpNdaIeFlR2eweJ4g2l34w6 UTKC1zVWMBon0HxWy007sEFiOQ7WGKRfRaf0dRSXZ0Zqal1GGS5n5q4+8= 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:to :from:subject:message-id:date:mime-version:content-type; s= default; bh=umzUq+yYbAl5dILvcF58V0HND1M=; b=aeygZ8dE89+YAnw50QxL +S1LjeH94NmeRoVWulTLoLEKnvJviunQw3m8F1BnnCOAMv6TeMoV+2UnqbArdHdN xT5yMhJT4cJBpZPLZvWDLeCENrOARiVBUVYOIj9eQaHuqOVAK1Ld2vm2JVwV+vUP C1+rvUKAMFwQZuUbXTNzzto= Received: (qmail 119632 invoked by alias); 10 Sep 2019 21:35:57 -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 119623 invoked by uid 89); 10 Sep 2019 21:35:57 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-11.1 required=5.0 tests=BAYES_00, FREEMAIL_FROM, GIT_PATCH_2, GIT_PATCH_3, KAM_ASCII_DIVIDERS, RCVD_IN_DNSWL_NONE, SPF_PASS, UPPERCASE_50_75 autolearn=ham version=3.3.1 spammy=H*r:500, Statements, sk:argumen X-HELO: mail-qk1-f193.google.com Received: from mail-qk1-f193.google.com (HELO mail-qk1-f193.google.com) (209.85.222.193) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Tue, 10 Sep 2019 21:35:55 +0000 Received: by mail-qk1-f193.google.com with SMTP id x5so18654254qkh.5 for ; Tue, 10 Sep 2019 14:35:54 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=sender:to:from:subject:message-id:date:user-agent:mime-version :content-language; bh=weXHGQkgCXmYFJRaGJO4GpX9qQa2X/1MXUZoW2C/F6o=; b=m93nNtR4a8ITFPTz4PJtGuuwlvWd2qP4Z4x1P7cNF2wWwkMjSDUkCX7n/lrxmdrl+1 geNruQLL3VZLAGo0ipxdGVrN5b9oXVCpmLXUkVPUFfBW7MC8MyjEkNPvRjVCBKWvcEfJ YeBO8Y9Pd9BhrB5VHPTk1m5lKFLak3NDM8qHHbCFaFkK69KaoZIRjJHaLjjJkrXIPP9s avTRjOSC0yXQCSTbf1KOIEGVduynGAMGaPPdCyIMKCYW/49FNuLh0XuQdZ5UpppWgfG5 gJLaOSPEsd6IJQvoKxtFnPGya7Ii/xiiyo5IpZsWzYZRlFX+onhZtfgWdQi6fkwz5jNN Ts4A== Received: from ?IPv6:2620:10d:c0a3:1407:ad91:fd0:3e01:cf0f? ([2620:10d:c091:500::1:719d]) by smtp.googlemail.com with ESMTPSA id x5sm8562556qkn.102.2019.09.10.14.35.51 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Tue, 10 Sep 2019 14:35:52 -0700 (PDT) To: GCC Patches From: Nathan Sidwell Subject: [PATCH] some tree struct marking Message-ID: Date: Tue, 10 Sep 2019 17:35:50 -0400 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Thunderbird/60.8.0 MIME-Version: 1.0 We were (still) not correctly marking the C++ tree structs. This patch fixes that and 1) adds MARK_TS_TYPE_NON_COMMON, because we needed it. 2) sorts the order of marking nodes, so it's a little easier to figure where to put new ones. 3) reformats & sorts the common tree_node_structure_for_code to be a little clearer in what it's doing. (these switch statements seem a fine exception to the usual formatting rules) I'll commit to trunk shortly, as the non-c++ bits are sufficiently obvious. nathan 2019-09-10 Nathan Sidwell gcc/ * tree.h (MARK_TS_TYPE_NON_COMMON): New. * tree.c (tree_node_structure_for_code): Reformat and alphabetize. gcc/cp/ * c-objcp-common.c (cp-objcp-common.c): Alphababetize and correctly mark all C++ nodes. * decl.c (cp_tree_node_structure): Alphabetize. Index: gcc/cp/cp-objcp-common.c =================================================================== --- gcc/cp/cp-objcp-common.c (revision 275596) +++ gcc/cp/cp-objcp-common.c (working copy) @@ -366,102 +366,111 @@ void cp_common_init_ts (void) { - MARK_TS_DECL_NON_COMMON (USING_DECL); - MARK_TS_DECL_COMMON (TEMPLATE_DECL); - MARK_TS_DECL_COMMON (WILDCARD_DECL); + /* With type. */ + MARK_TS_TYPED (PTRMEM_CST); + MARK_TS_TYPED (LAMBDA_EXPR); + MARK_TS_TYPED (TYPE_ARGUMENT_PACK); - MARK_TS_COMMON (TEMPLATE_TEMPLATE_PARM); - MARK_TS_COMMON (TEMPLATE_TYPE_PARM); - MARK_TS_COMMON (TEMPLATE_PARM_INDEX); + /* Random new trees. */ + MARK_TS_COMMON (BASELINK); + MARK_TS_COMMON (DECLTYPE_TYPE); MARK_TS_COMMON (OVERLOAD); + MARK_TS_COMMON (TEMPLATE_PARM_INDEX); MARK_TS_COMMON (TYPENAME_TYPE); MARK_TS_COMMON (TYPEOF_TYPE); - MARK_TS_COMMON (UNDERLYING_TYPE); - MARK_TS_COMMON (BASELINK); - MARK_TS_COMMON (TYPE_PACK_EXPANSION); - MARK_TS_COMMON (TYPE_ARGUMENT_PACK); - MARK_TS_COMMON (DECLTYPE_TYPE); - MARK_TS_COMMON (BOUND_TEMPLATE_TEMPLATE_PARM); MARK_TS_COMMON (UNBOUND_CLASS_TEMPLATE); + MARK_TS_COMMON (UNDERLYING_TYPE); - MARK_TS_TYPED (SWITCH_STMT); - MARK_TS_TYPED (IF_STMT); - MARK_TS_TYPED (FOR_STMT); - MARK_TS_TYPED (RANGE_FOR_STMT); - MARK_TS_TYPED (EH_SPEC_BLOCK); - MARK_TS_TYPED (CLEANUP_STMT); - MARK_TS_TYPED (SCOPE_REF); - MARK_TS_TYPED (TRY_BLOCK); - MARK_TS_TYPED (HANDLER); - MARK_TS_TYPED (TYPE_ARGUMENT_PACK); - MARK_TS_TYPED (NOEXCEPT_EXPR); - MARK_TS_TYPED (WHILE_STMT); - MARK_TS_TYPED (BREAK_STMT); - MARK_TS_TYPED (DO_STMT); - MARK_TS_TYPED (CONTINUE_STMT); - MARK_TS_TYPED (PTRMEM_CST); - MARK_TS_TYPED (USING_STMT); - MARK_TS_TYPED (OMP_DEPOBJ); + /* New decls. */ + MARK_TS_DECL_COMMON (TEMPLATE_DECL); + MARK_TS_DECL_COMMON (WILDCARD_DECL); + + MARK_TS_DECL_NON_COMMON (USING_DECL); + /* New Types. */ + MARK_TS_TYPE_NON_COMMON (BOUND_TEMPLATE_TEMPLATE_PARM); + MARK_TS_TYPE_NON_COMMON (TEMPLATE_TEMPLATE_PARM); + MARK_TS_TYPE_NON_COMMON (TEMPLATE_TYPE_PARM); + MARK_TS_TYPE_NON_COMMON (TYPE_ARGUMENT_PACK); + MARK_TS_TYPE_NON_COMMON (TYPE_PACK_EXPANSION); + + /* Statements. */ + MARK_TS_EXP (BREAK_STMT); + MARK_TS_EXP (CLEANUP_STMT); + MARK_TS_EXP (CONTINUE_STMT); + MARK_TS_EXP (DO_STMT); + MARK_TS_EXP (EH_SPEC_BLOCK); + MARK_TS_EXP (FOR_STMT); + MARK_TS_EXP (HANDLER); + MARK_TS_EXP (IF_STMT); + MARK_TS_EXP (OMP_DEPOBJ); + MARK_TS_EXP (RANGE_FOR_STMT); + MARK_TS_EXP (SWITCH_STMT); + MARK_TS_EXP (TRY_BLOCK); + MARK_TS_EXP (USING_STMT); + MARK_TS_EXP (WHILE_STMT); + + /* Random expressions. */ + MARK_TS_EXP (ADDRESSOF_EXPR); MARK_TS_EXP (AGGR_INIT_EXPR); + MARK_TS_EXP (ALIGNOF_EXPR); + MARK_TS_EXP (ARROW_EXPR); + MARK_TS_EXP (AT_ENCODE_EXPR); + MARK_TS_EXP (CAST_EXPR); + MARK_TS_EXP (CONST_CAST_EXPR); MARK_TS_EXP (CTOR_INITIALIZER); - MARK_TS_EXP (EXPR_STMT); - MARK_TS_EXP (TAG_DEFN); + MARK_TS_EXP (DELETE_EXPR); + MARK_TS_EXP (DOTSTAR_EXPR); + MARK_TS_EXP (DYNAMIC_CAST_EXPR); MARK_TS_EXP (EMPTY_CLASS_EXPR); + MARK_TS_EXP (EXPR_STMT); + MARK_TS_EXP (IMPLICIT_CONV_EXPR); + MARK_TS_EXP (MEMBER_REF); MARK_TS_EXP (MODOP_EXPR); - MARK_TS_EXP (THROW_EXPR); - MARK_TS_EXP (CAST_EXPR); - MARK_TS_EXP (TYPE_EXPR); + MARK_TS_EXP (MUST_NOT_THROW_EXPR); + MARK_TS_EXP (NEW_EXPR); + MARK_TS_EXP (NOEXCEPT_EXPR); + MARK_TS_EXP (NON_DEPENDENT_EXPR); + MARK_TS_EXP (OFFSETOF_EXPR); + MARK_TS_EXP (OFFSET_REF); + MARK_TS_EXP (PSEUDO_DTOR_EXPR); MARK_TS_EXP (REINTERPRET_CAST_EXPR); - MARK_TS_EXP (CONST_CAST_EXPR); + MARK_TS_EXP (SCOPE_REF); MARK_TS_EXP (STATIC_CAST_EXPR); - MARK_TS_EXP (DYNAMIC_CAST_EXPR); - MARK_TS_EXP (IMPLICIT_CONV_EXPR); + MARK_TS_EXP (STMT_EXPR); + MARK_TS_EXP (TAG_DEFN); MARK_TS_EXP (TEMPLATE_ID_EXPR); - MARK_TS_EXP (ARROW_EXPR); - MARK_TS_EXP (UNARY_PLUS_EXPR); + MARK_TS_EXP (THROW_EXPR); MARK_TS_EXP (TRAIT_EXPR); - - MARK_TS_EXP (NON_DEPENDENT_EXPR); - MARK_TS_EXP (NEW_EXPR); - MARK_TS_EXP (VEC_NEW_EXPR); - MARK_TS_EXP (MEMBER_REF); - MARK_TS_EXP (DOTSTAR_EXPR); - MARK_TS_EXP (DELETE_EXPR); - MARK_TS_EXP (VEC_DELETE_EXPR); - MARK_TS_EXP (PSEUDO_DTOR_EXPR); MARK_TS_EXP (TYPEID_EXPR); - MARK_TS_EXP (MUST_NOT_THROW_EXPR); - MARK_TS_EXP (STMT_EXPR); - MARK_TS_EXP (OFFSET_REF); - MARK_TS_EXP (OFFSETOF_EXPR); - MARK_TS_EXP (ADDRESSOF_EXPR); + MARK_TS_EXP (TYPE_EXPR); + MARK_TS_EXP (UNARY_PLUS_EXPR); + MARK_TS_EXP (VEC_DELETE_EXPR); MARK_TS_EXP (VEC_INIT_EXPR); - MARK_TS_EXP (LAMBDA_EXPR); - - MARK_TS_EXP (ALIGNOF_EXPR); - MARK_TS_EXP (AT_ENCODE_EXPR); + MARK_TS_EXP (VEC_NEW_EXPR); - MARK_TS_EXP (NONTYPE_ARGUMENT_PACK); + /* Fold expressions. */ + MARK_TS_EXP (BINARY_LEFT_FOLD_EXPR); + MARK_TS_EXP (BINARY_RIGHT_FOLD_EXPR); MARK_TS_EXP (EXPR_PACK_EXPANSION); + MARK_TS_EXP (NONTYPE_ARGUMENT_PACK); MARK_TS_EXP (UNARY_LEFT_FOLD_EXPR); MARK_TS_EXP (UNARY_RIGHT_FOLD_EXPR); - MARK_TS_EXP (BINARY_LEFT_FOLD_EXPR); - MARK_TS_EXP (BINARY_RIGHT_FOLD_EXPR); - MARK_TS_EXP (REQUIRES_EXPR); - MARK_TS_EXP (SIMPLE_REQ); - MARK_TS_EXP (TYPE_REQ); - MARK_TS_EXP (COMPOUND_REQ); - MARK_TS_EXP (NESTED_REQ); - MARK_TS_EXP (PRED_CONSTR); + /* Constraints. */ MARK_TS_EXP (CHECK_CONSTR); - MARK_TS_EXP (EXPR_CONSTR); - MARK_TS_EXP (TYPE_CONSTR); - MARK_TS_EXP (ICONV_CONSTR); + MARK_TS_EXP (COMPOUND_REQ); + MARK_TS_EXP (CONJ_CONSTR); MARK_TS_EXP (DEDUCT_CONSTR); + MARK_TS_EXP (DISJ_CONSTR); MARK_TS_EXP (EXCEPT_CONSTR); + MARK_TS_EXP (EXPR_CONSTR); + MARK_TS_EXP (ICONV_CONSTR); + MARK_TS_EXP (NESTED_REQ); MARK_TS_EXP (PARM_CONSTR); - MARK_TS_EXP (CONJ_CONSTR); - MARK_TS_EXP (DISJ_CONSTR); + MARK_TS_EXP (PRED_CONSTR); + MARK_TS_EXP (REQUIRES_EXPR); + MARK_TS_EXP (SIMPLE_REQ); + MARK_TS_EXP (TYPE_CONSTR); + MARK_TS_EXP (TYPE_REQ); c_common_init_ts (); Index: gcc/cp/decl.c =================================================================== --- gcc/cp/decl.c (revision 275596) +++ gcc/cp/decl.c (working copy) @@ -16828,18 +16828,18 @@ cp_tree_node_structure (union lang_tree_ switch (TREE_CODE (&t->generic)) { - case DEFERRED_PARSE: return TS_CP_DEFERRED_PARSE; + case ARGUMENT_PACK_SELECT: return TS_CP_ARGUMENT_PACK_SELECT; + case BASELINK: return TS_CP_BASELINK; + case CONSTRAINT_INFO: return TS_CP_CONSTRAINT_INFO; case DEFERRED_NOEXCEPT: return TS_CP_DEFERRED_NOEXCEPT; + case DEFERRED_PARSE: return TS_CP_DEFERRED_PARSE; case IDENTIFIER_NODE: return TS_CP_IDENTIFIER; + case LAMBDA_EXPR: return TS_CP_LAMBDA_EXPR; case OVERLOAD: return TS_CP_OVERLOAD; - case TEMPLATE_PARM_INDEX: return TS_CP_TPI; case PTRMEM_CST: return TS_CP_PTRMEM; - case BASELINK: return TS_CP_BASELINK; - case TEMPLATE_DECL: return TS_CP_TEMPLATE_DECL; case STATIC_ASSERT: return TS_CP_STATIC_ASSERT; - case ARGUMENT_PACK_SELECT: return TS_CP_ARGUMENT_PACK_SELECT; - case TRAIT_EXPR: return TS_CP_TRAIT_EXPR; - case LAMBDA_EXPR: return TS_CP_LAMBDA_EXPR; + case TEMPLATE_DECL: return TS_CP_TEMPLATE_DECL; case TEMPLATE_INFO: return TS_CP_TEMPLATE_INFO; - case CONSTRAINT_INFO: return TS_CP_CONSTRAINT_INFO; + case TEMPLATE_PARM_INDEX: return TS_CP_TPI; + case TRAIT_EXPR: return TS_CP_TRAIT_EXPR; case USERDEF_LITERAL: return TS_CP_USERDEF_LITERAL; default: return TS_CP_GENERIC; Index: gcc/tree.c =================================================================== --- gcc/tree.c (revision 275596) +++ gcc/tree.c (working copy) @@ -456,69 +456,59 @@ tree_node_structure_for_code (enum tree_ { case tcc_declaration: - { - switch (code) - { - case FIELD_DECL: - return TS_FIELD_DECL; - case PARM_DECL: - return TS_PARM_DECL; - case VAR_DECL: - return TS_VAR_DECL; - case LABEL_DECL: - return TS_LABEL_DECL; - case RESULT_DECL: - return TS_RESULT_DECL; - case DEBUG_EXPR_DECL: - return TS_DECL_WRTL; - case CONST_DECL: - return TS_CONST_DECL; - case TYPE_DECL: - return TS_TYPE_DECL; - case FUNCTION_DECL: - return TS_FUNCTION_DECL; - case TRANSLATION_UNIT_DECL: - return TS_TRANSLATION_UNIT_DECL; - default: - return TS_DECL_NON_COMMON; - } - } - case tcc_type: - return TS_TYPE_NON_COMMON; - case tcc_reference: - case tcc_comparison: - case tcc_unary: + switch (code) + { + case CONST_DECL: return TS_CONST_DECL; + case DEBUG_EXPR_DECL: return TS_DECL_WRTL; + case FIELD_DECL: return TS_FIELD_DECL; + case FUNCTION_DECL: return TS_FUNCTION_DECL; + case LABEL_DECL: return TS_LABEL_DECL; + case PARM_DECL: return TS_PARM_DECL; + case RESULT_DECL: return TS_RESULT_DECL; + case TRANSLATION_UNIT_DECL: return TS_TRANSLATION_UNIT_DECL; + case TYPE_DECL: return TS_TYPE_DECL; + case VAR_DECL: return TS_VAR_DECL; + default: return TS_DECL_NON_COMMON; + } + + case tcc_type: return TS_TYPE_NON_COMMON; + case tcc_binary: + case tcc_comparison: case tcc_expression: + case tcc_reference: case tcc_statement: - case tcc_vl_exp: - return TS_EXP; + case tcc_unary: + case tcc_vl_exp: return TS_EXP; + default: /* tcc_constant and tcc_exceptional */ break; } + switch (code) { /* tcc_constant cases. */ - case VOID_CST: return TS_TYPED; + case COMPLEX_CST: return TS_COMPLEX; + case FIXED_CST: return TS_FIXED_CST; case INTEGER_CST: return TS_INT_CST; case POLY_INT_CST: return TS_POLY_INT_CST; case REAL_CST: return TS_REAL_CST; - case FIXED_CST: return TS_FIXED_CST; - case COMPLEX_CST: return TS_COMPLEX; - case VECTOR_CST: return TS_VECTOR; case STRING_CST: return TS_STRING; + case VECTOR_CST: return TS_VECTOR; + case VOID_CST: return TS_TYPED; + /* tcc_exceptional cases. */ - case ERROR_MARK: return TS_COMMON; - case IDENTIFIER_NODE: return TS_IDENTIFIER; - case TREE_LIST: return TS_LIST; - case TREE_VEC: return TS_VEC; - case SSA_NAME: return TS_SSA_NAME; - case PLACEHOLDER_EXPR: return TS_COMMON; - case STATEMENT_LIST: return TS_STATEMENT_LIST; case BLOCK: return TS_BLOCK; case CONSTRUCTOR: return TS_CONSTRUCTOR; - case TREE_BINFO: return TS_BINFO; + case ERROR_MARK: return TS_COMMON; + case IDENTIFIER_NODE: return TS_IDENTIFIER; case OMP_CLAUSE: return TS_OMP_CLAUSE; case OPTIMIZATION_NODE: return TS_OPTIMIZATION; + case PLACEHOLDER_EXPR: return TS_COMMON; + case SSA_NAME: return TS_SSA_NAME; + case STATEMENT_LIST: return TS_STATEMENT_LIST; case TARGET_OPTION_NODE: return TS_TARGET_OPTION; + case TREE_BINFO: return TS_BINFO; + case TREE_LIST: return TS_LIST; + case TREE_VEC: return TS_VEC; default: Index: gcc/tree.h =================================================================== --- gcc/tree.h (revision 275596) +++ gcc/tree.h (working copy) @@ -95,4 +95,8 @@ as_internal_fn (combined_fn code) tree_contains_struct[C][TS_TYPE_WITH_LANG_SPECIFIC] = true) +#define MARK_TS_TYPE_NON_COMMON(C) \ + (MARK_TS_TYPE_WITH_LANG_SPECIFIC (C), \ + tree_contains_struct[C][TS_TYPE_NON_COMMON] = true) \ + #define MARK_TS_DECL_MINIMAL(C) \ (MARK_TS_COMMON (C), \