OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

alias.c (find_base_decl): Remove unreachable case '3' block. 

2004-09-17  Jeffrey D. Oldham  <oldham@codesourcery.com>
	    Zack Weinberg  <zack@codesourcery.com>

	* alias.c (find_base_decl): Remove unreachable case '3' block.
	* expr.c (safe_from_p): Abort if passed a type.
	* tree-gimple.c (recalculate_side_effects): Abort if passed
	anything other than an expression.
	* tree-ssa-pre.c (phi_translate): Return expr immediately if
	is_gimple_min_invariant is true for it.  Reorder cases for clarity.
	Abort on un-handled tree classes.
	(valid_in_set): Likewise.
	* tree.c (tree_code_class_strings): New static data.

	* tree.h (enum tree_code_class): New.
	(tree_code_class_strings): Declare.
	(TREE_CODE_CLASS_STRING, EXCEPTIONAL_CLASS_P, CONSTANT_CLASS_P)
	(REFERENCE_CLASS_P, COMPARISON_CLASS_P, UNARY_CLASS_P, BINARY_CLASS_P)
	(STATEMENT_CLASS_P, EXPRESSION_CLASS_P, IS_TYPE_OR_DECL_P): New macros.
	(TYPE_P, DECL_P, IS_NON_TYPE_CODE_CLASS, IS_EXPR_CODE_CLASS)
	(checking macros, EXPR_LOCATION, SET_EXPR_LOCATION, EXPR_LOCUS): Update.

	* tree.def, c-common.def, objc/objc-tree.def: Use
	tree_code_class enumeration constants instead of code letters.

	* alias.c, builtins.c, c-common.c, c-format.c, c-lang.c, c-pragma.c
	* c-typeck.c, cgraphunit.c, convert.c, dbxout.c, dwarf2out.c
	* emit-rtl.c expr.c, fold-const.c, gimplify.c, lambda-code.c
	* langhooks.c, langhooks.h, predict.c, print-tree.c, reload1.c, stmt.c
	* tree-browser.c, tree-cfg.c, tree-chrec.c, tree-complex.c, tree-dfa.c
	* tree-dump.c, tree-eh.c, tree-gimple.c, tree-inline.c, tree-nested.c
	* tree-outof-ssa.c, tree-pretty-print.c, tree-sra.c, tree-ssa-ccp.c
	* tree-ssa-dce.c, tree-ssa-dom.c, tree-ssa-forwprop.c, tree-ssa-live.c
	* tree-ssa-loop-im.c, tree-ssa-loop-ivopts.c, tree-ssa-operands.c
	* tree-ssa-phiopt.c, tree-ssa-pre.c, tree-ssa-propagate.c
	* tree-ssa.c, tree-ssanames.c, tree-tailcall.c, tree.c, varasm.c
	* config/sol2-c.c, config/arm/arm.c, config/i386/winnt.c
	* config/pa/pa.c, config/pa/pa.h, config/sh/sh.c, objc/objc-lang.c
	Update to match.

	* LANGUAGES: Add note about change.

ada:
	* ada-tree.def: Use tree_code_class enumeration constants
	instead of code letters.
	* ada-tree.h, decl.c, misc.c, trans.c, utils.c, utils2.c:
	Update for new tree-class enumeration constants.

cp:
	* cp-tree.def: Use tree_code_class enumeration constants
	instead of code letters.
	* call.c, class.c, cp-gimplify.c, cp-lang.c, cxx-pretty-print.c
	* mangle.c, pt.c, semantics.c, tree.c, typeck.c:
	Update for new tree-class enumeration constants.

fortran:
	* f95-lang.c, trans-expr.c, trans.c: Update for new tree-class
	enumeration constants.

java:
	* java-tree.def: Use tree_code_class enumeration constants
	instead of code letters.
	* java-gimplify.c, jcf-write.c, lang.c, parse.y: Update for
	new tree-class enumeration constants.

treelang:
	* treetree.c: Update for new tree-class enumeration constants.

From-SVN: r87675
This commit is contained in:
Jeffrey D. Oldham 2004-09-17 21:55:02 +00:00 committed by Zack Weinberg
parent ade2298233
commit 6615c44615
97 changed files with 1212 additions and 1038 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

63
gcc/ChangeLog
View File

@ -1,3 +1,44 @@
2004-09-17 Jeffrey D. Oldham <oldham@codesourcery.com>
Zack Weinberg <zack@codesourcery.com>
* alias.c (find_base_decl): Remove unreachable case '3' block.
* expr.c (safe_from_p): Abort if passed a type.
* tree-gimple.c (recalculate_side_effects): Abort if passed
anything other than an expression.
* tree-ssa-pre.c (phi_translate): Return expr immediately if
is_gimple_min_invariant is true for it. Reorder cases for clarity.
Abort on un-handled tree classes.
(valid_in_set): Likewise.
* tree.c (tree_code_class_strings): New static data.
* tree.h (enum tree_code_class): New.
(tree_code_class_strings): Declare.
(TREE_CODE_CLASS_STRING, EXCEPTIONAL_CLASS_P, CONSTANT_CLASS_P)
(REFERENCE_CLASS_P, COMPARISON_CLASS_P, UNARY_CLASS_P, BINARY_CLASS_P)
(STATEMENT_CLASS_P, EXPRESSION_CLASS_P, IS_TYPE_OR_DECL_P): New macros.
(TYPE_P, DECL_P, IS_NON_TYPE_CODE_CLASS, IS_EXPR_CODE_CLASS)
(checking macros, EXPR_LOCATION, SET_EXPR_LOCATION, EXPR_LOCUS): Update.
* tree.def, c-common.def, objc/objc-tree.def: Use
tree_code_class enumeration constants instead of code letters.
* alias.c, builtins.c, c-common.c, c-format.c, c-lang.c, c-pragma.c
* c-typeck.c, cgraphunit.c, convert.c, dbxout.c, dwarf2out.c
* emit-rtl.c expr.c, fold-const.c, gimplify.c, lambda-code.c
* langhooks.c, langhooks.h, predict.c, print-tree.c, reload1.c, stmt.c
* tree-browser.c, tree-cfg.c, tree-chrec.c, tree-complex.c, tree-dfa.c
* tree-dump.c, tree-eh.c, tree-gimple.c, tree-inline.c, tree-nested.c
* tree-outof-ssa.c, tree-pretty-print.c, tree-sra.c, tree-ssa-ccp.c
* tree-ssa-dce.c, tree-ssa-dom.c, tree-ssa-forwprop.c, tree-ssa-live.c
* tree-ssa-loop-im.c, tree-ssa-loop-ivopts.c, tree-ssa-operands.c
* tree-ssa-phiopt.c, tree-ssa-pre.c, tree-ssa-propagate.c
* tree-ssa.c, tree-ssanames.c, tree-tailcall.c, tree.c, varasm.c
* config/sol2-c.c, config/arm/arm.c, config/i386/winnt.c
* config/pa/pa.c, config/pa/pa.h, config/sh/sh.c, objc/objc-lang.c
Update to match.
* LANGUAGES: Add note about change.
2004-09-17 Diego Novillo <dnovillo@redhat.com>
PR tree-optimization/17319
@ -33,7 +74,7 @@
(dbxout_init): Include lang number in N_SO stab.
* dbxout.h (N_SO_AS, N_SO_C, N_SO_ANSI_C, N_SO_CC, N_SO_FORTRAN,
N_SO_PASCAL, N_SO_FORTRAN90, N_SO_OBJC, N_SO_OBJCPLUS): New #define.
2004-09-17 Diego Novillo <dnovillo@redhat.com>
PR tree-optimization/17273
@ -63,7 +104,7 @@
2004-09-17 Sylvain Pion <Sylvain.Pion@sophia.inria.fr>
* doc/extend.texi: Fix duplicated word.
* doc/extend.texi: Fix duplicated word.
2004-09-17 Toon Moene <toon@moene.indiv.nluug.nl>
@ -115,7 +156,7 @@
2004-09-17 Steven Bosscher <stevenb@suse.de>
PR tree-optimization/17513
PR tree-optimization/17513
* cfgexpand.c (construct_init_block): Clear EDGE_EXECUTABLE
for successors of the entry block.
@ -208,11 +249,11 @@
2004-09-16 Andrew MacLeod <amacleod@redhat.com>
PR tree-optimization/17517
* tree-ssa-copyrename.c (copy_rename_partition_coalesce): Don't
* tree-ssa-copyrename.c (copy_rename_partition_coalesce): Don't
coalesce same-root variables without checking for abnormal PHI usage.
2004-09-16 Daniel Berlin <dberlin@dberlin.org>
* cfgloop.h (duplicate_loop): Add prototype.
* cfgloopmanip.c (duplicate_loop): Make non-static.
* lambda-code.c (perfect_nestify): Factor out test whether
@ -229,7 +270,7 @@
loop invariant as well.
(perfect_nestify): new function.
(gcc_loop_to_lambda_loop): New parameters to track lower bounds,
upper bounds, and steps.
upper bounds, and steps.
Set outerinductionvar properly.
(gcc_loopnest_to_lambda_loopnest): Add loops and need_perfect
parameters.
@ -254,9 +295,9 @@
2004-09-16 Sebastian Pop <pop@cri.ensmp.fr>
* tree-loop-linear.c (gather_interchange_stats): Add more comments.
Gather also strides of accessed data. Pass in the data references
Gather also strides of accessed data. Pass in the data references
array.
(try_interchange_loops): Add a new heuristic for handling the temporal
(try_interchange_loops): Add a new heuristic for handling the temporal
locality. Pass in the data references array.
(linear_transform_loops): Pass the data references array to
try_interchange_loops.
@ -369,7 +410,7 @@
* Makefile.in (tree-ssa-dom.o): Depend on tree-ssa-propagate.h.
* tree-ssa-dom.c (cprop_into_stmt): Recompute TREE_INVARIANT
after propagating into an ADDR_EXPR.
after propagating into an ADDR_EXPR.
2004-09-15 Andrew Pinski <apinski@apple.com>
@ -587,7 +628,7 @@
2004-09-14 Jeff Law <law@redhat.com>
* tree-ssa-dom.c (stmts_to_rescan): Move from a block-local
to a global varray.
to a global varray.
(tree_ssa_dominator_optimize): Allocate stmts_to_rescan.
(dom_opt_initialize_block_local_data): No longer test state
of stmts_to_rescan.
@ -824,7 +865,7 @@
PR tree-optimization/17400
* tree-ssa-copyrename.c (copy_rename_partition_coalesce): Don't
coalesce partitions when one occurs in an abnormal PHI.
2004-09-13 Andrew Pinski <apinski@apple.com>
* config/rs6000/darwin.h (ASM_OUTPUT_COMMON): Change variable size's

12
gcc/LANGUAGES
View File

@ -6,6 +6,18 @@ time as we can formally start documenting the interface this file will
serve as a repository for information on these interface and any incompatable
changes we've made.
2004-09-09:
In an effort to decrease execution time, single char tree code
classes were changed to enumerated values.
Old way:
DEFTREECODE (CLASS_METHOD_DECL, "class_method_decl", 'd', 0)
New way:
DEFTREECODE (CLASS_METHOD_DECL, "class_method_decl", tcc_declaration, 0)
2001-02-26:
A DECL_INITIAL of NULL_TREE or error_mark_node in a VAR_DECL is no longer
taken to signify a tentative definition which should not be emitted until

30
gcc/ada/ChangeLog
View File

@ -1,3 +1,11 @@
2004-09-17 Jeffrey D. Oldham <oldham@codesourcery.com>
Zack Weinberg <zack@codesourcery.com>
* ada-tree.def: Use tree_code_class enumeration constants
instead of code letters.
* ada-tree.h, decl.c, misc.c, trans.c, utils.c, utils2.c:
Update for new tree-class enumeration constants.
2004-09-17 Vincent Celier <celier@gnat.com>
* prj-attr-pm.ads, prj-attr-pm.adb: New files, to split some private
@ -456,7 +464,7 @@
2004-08-25 Nathan Sidwell <nathan@codesourcery.com>
Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
* ada-tree.h (TYPE_RM_SIZE_INT): Use TYPE_LANG_SLOT_1.
2004-08-25 Nathan Sidwell <nathan@codesourcery.com>
@ -465,7 +473,7 @@
* trans.c (Exception_Handler_to_gnu_sjlj, gnat_to_gnu): Likewise.
* utils.c (init_gigi_decls): Likewise.
* utils2.c (build_call_raise, build_allocator): Likewise.
2004-08-24 Nathan Sidwell <nathan@codesourcery.com>
* utils.c (gnat_init_decl_processing): Adjust
@ -589,7 +597,7 @@
GNAT.Sockets.Thin.Is_Socket_In_Set to account for new specification
and test explicitly for non-zero return value.
* g-socthi-vms.ads, g-socthi-mingw.ads, g-socthi-vxworks.ads:
* g-socthi-vms.ads, g-socthi-mingw.ads, g-socthi-vxworks.ads:
(Is_Socket_In_Set): Declare imported function as returning C.int, to
avoid using a derived boolean type.
@ -1264,7 +1272,7 @@
(gnat_to_gnu, case N_Compilation_Unit): Just handle nested case here.
(add_stmt): Force walking of sizes and DECL_INITIAL for DECL_EXPR.
(mark_visited): Don't mark dummy type.
(tree_transform <N_Procedure_Call_Statement>): Unless this is an In
(tree_transform <N_Procedure_Call_Statement>): Unless this is an In
parameter, we must remove any LJM building from GNU_NAME.
(gnat_to_gnu, case N_String_Literal): Fill in indices in CONSTRUCTOR.
(pos_to_constructor): Use int_const_binop.
@ -1471,7 +1479,7 @@
(gnat_to_gnu): If statement and not in procedure, go into elab proc.
Delete calls to add_decl_expr; add arg to create_*_decl.
(gnat_to_gnu, case N_Loop): Recalculate side effects on COND_EXPR.
(gnat_to_gnu, case N_Subprogram_Body): Move some code to
(gnat_to_gnu, case N_Subprogram_Body): Move some code to
begin_subprog_body and call it.
Don't push and pop ggc context.
(gnat_to_gnu, case N_Compilation_Unit): Rework to support elab proc.
@ -1497,7 +1505,7 @@
(function_nesting_depth): Deleted.
(begin_subprog_body): Delete obsolete code.
* utils2.c (build_call_alloc_dealloc): Add new arg to create_var_decl.
2004-06-28 Robert Dewar <dewar@gnat.com>
* mlib-tgt-tru64.adb, mlib-tgt-aix.adb, mlib-tgt-irix.adb,
@ -1629,8 +1637,8 @@
Lib_Address and Relocatable.
(Default_DLL_Address): Removed.
* mlib-tgt-tru64.adb, mlib-tgt-aix.adb, mlib-tgt-irix.adb,
mlib-tgt-hpux.adb, mlib-tgt-linux.adb, mlib-tgt-solaris.adb,
* mlib-tgt-tru64.adb, mlib-tgt-aix.adb, mlib-tgt-irix.adb,
mlib-tgt-hpux.adb, mlib-tgt-linux.adb, mlib-tgt-solaris.adb,
mlib-tgt-vms-alpha.adb, mlib-tgt-vms-ia64.adb, mlib-tgt-vxworks.adb:
(Build_Dynamic_Library): Remove parameter Lib_Address and Relocatable.
(Default_DLL_Address): Removed.
@ -1827,7 +1835,7 @@
(Compile_Sources.Compile): Add switch -gnatez as the last option
(Display): Never display -gnatez
* Makefile.generic:
* Makefile.generic:
When using $(MAIN_OBJECT), always use $(OBJ_DIR)/$(MAIN_OBJECT)
* gnatcmd.adb (Check_Project): New function
@ -2402,7 +2410,7 @@
opt.adb, par.adb, opt.ads, par-ch11.adb, par-ch3.adb, par-ch4.adb,
par-ch5.adb, par-ch6.adb, par-ch8.adb, par-ch9.adb, par-prag.adb,
par-util.adb, scng.adb, sem_aggr.adb, sem_attr.adb, sem_cat.adb,
sem_ch10.adb, sem_ch10.adb, sem_ch11.adb, sem_ch12.adb, sem_ch2.adb,
sem_ch10.adb, sem_ch10.adb, sem_ch11.adb, sem_ch12.adb, sem_ch2.adb,
sem_ch3.adb, sem_ch3.ads, sem_ch4.adb, sem_ch5.adb, sem_ch6.adb,
sem_ch7.adb, sem_ch8.adb, sem_ch9.adb, sem_eval.adb, sem_prag.adb,
sem_res.adb, sem_type.adb, sem_util.adb, sinfo.ads, snames.adb,
@ -3027,7 +3035,7 @@
Renaming of target specific files for clarity
* Makefile.in: Rename GNAT target specific files.
* Makefile.in: Rename GNAT target specific files.
* 31soccon.ads, 31soliop.ads 35soccon.ads, 3asoccon.ads,
3bsoccon.ads, 3gsoccon.ads, 3hsoccon.ads, 3psoccon.ads,

23
gcc/ada/ada-tree.def
View File

@ -6,7 +6,7 @@
* *
* Specification *
* *
* Copyright (C) 1992-2003 Free Software Foundation, Inc. *
* Copyright (C) 1992-2004 Free Software Foundation, Inc. *
* *
* GNAT is free software; you can redistribute it and/or modify it under *
* terms of the GNU General Public License as published by the Free Soft- *
@ -28,23 +28,24 @@
to GCC. TREE_TYPE is the type of the fat pointer and TYPE_OBJECT_RECORD_TYPE
is the type of a record containing the template and data. */
DEFTREECODE (UNCONSTRAINED_ARRAY_TYPE, "unconstrained_array_type", 't', 0)
DEFTREECODE (UNCONSTRAINED_ARRAY_TYPE, "unconstrained_array_type", tcc_type, 0)
/* A reference to an unconstrained array. This node only exists as an
intermediate node during the translation of a GNAT tree to a GCC tree;
it is never passed to GCC. The only field used is operand 0, which
is the fat pointer object. */
DEFTREECODE (UNCONSTRAINED_ARRAY_REF, "unconstrained_array_ref", 'r', 1)
DEFTREECODE (UNCONSTRAINED_ARRAY_REF, "unconstrained_array_ref",
tcc_reference, 1)
/* An expression that returns an RTL suitable for its type. Operand 0
is an expression to be evaluated for side effects only. */
DEFTREECODE (NULL_EXPR, "null_expr", 'e', 1)
DEFTREECODE (NULL_EXPR, "null_expr", tcc_expression, 1)
/* Same as ADDR_EXPR, except that if the operand represents a bit field,
return the address of the byte containing the bit. This is used
for the 'Address attribute and never shows up in the tree. */
DEFTREECODE (ATTR_ADDR_EXPR, "attr_addr_expr", 'r', 1)
DEFTREECODE (ATTR_ADDR_EXPR, "attr_addr_expr", tcc_reference, 1)
/* Here are the tree codes for the statement types known to Ada. These
must be at the end of this file to allow IS_ADA_STMT to work. */
@ -53,32 +54,32 @@ DEFTREECODE (ATTR_ADDR_EXPR, "attr_addr_expr", 'r', 1)
makes this tree node, whose operand is a statement. The latter inserts
the actual statements into this node. Gimplification consists of
just returning the inner statement. */
DEFTREECODE (STMT_STMT, "stmt_stmt", 's', 1)
DEFTREECODE (STMT_STMT, "stmt_stmt", tcc_statement, 1)
/* A loop. LOOP_STMT_TOP_COND and LOOP_STMT_BOT_COND are the tests to exit a
loop at the top and bottom, respectively. LOOP_STMT_UPDATE is the statement
to update the loop iterator at the continue point. LOOP_STMT_BODY are the
statements in the body of the loop. LOOP_STMT_LABEL points to the LABEL_DECL
of the end label of the loop. */
DEFTREECODE (LOOP_STMT, "loop_stmt", 's', 5)
DEFTREECODE (LOOP_STMT, "loop_stmt", tcc_statement, 5)
/* Conditionally exit a loop. EXIT_STMT_COND is the condition, which, if
true, will cause the loop to be exited. If no condition is specified,
the loop is unconditionally exited. EXIT_STMT_LABEL is the end label
corresponding to the loop to exit. */
DEFTREECODE (EXIT_STMT, "exit_stmt", 's', 2)
DEFTREECODE (EXIT_STMT, "exit_stmt", tcc_statement, 2)
/* A exception region. REGION_STMT_BODY is the statement to be executed
inside the region. REGION_STMT_HANDLE is a statement that represents
the exception handlers (usually a BLOCK_STMT of HANDLE_STMTs).
REGION_STMT_BLOCK is the BLOCK node for the declarative region, if any. */
DEFTREECODE (REGION_STMT, "region_stmt", 's', 3)
DEFTREECODE (REGION_STMT, "region_stmt", tcc_statement, 3)
/* An exception handler. HANDLER_STMT_ARG is the value to pass to
expand_start_catch, HANDLER_STMT_LIST is the list of statements for the
handler itself, and HANDLER_STMT_BLOCK is the BLOCK node for this
binding. */
DEFTREECODE (HANDLER_STMT, "handler_stmt", 's', 3)
DEFTREECODE (HANDLER_STMT, "handler_stmt", tcc_statement, 3)
/* A statement that emits a USE for its single operand. */
DEFTREECODE (USE_STMT, "use_expr", 's', 1)
DEFTREECODE (USE_STMT, "use_expr", tcc_statement, 1)

2
gcc/ada/ada-tree.h
View File

@ -273,7 +273,7 @@ struct lang_type GTY(()) {tree t; };
/* Define fields and macros for statements.
Start by defining which tree codes are used for statements. */
#define IS_STMT(NODE) (TREE_CODE_CLASS (TREE_CODE (NODE)) == 's')
#define IS_STMT(NODE) (STATEMENT_CLASS_P (NODE))
#define IS_ADA_STMT(NODE) (IS_STMT (NODE) \
&& TREE_CODE (NODE) >= STMT_STMT)

7
gcc/ada/decl.c
View File

@ -761,7 +761,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
just use that declaration or reference as this entity unless
the latter has to be materialized. */
else if ((DECL_P (gnu_expr)
|| TREE_CODE_CLASS (TREE_CODE (gnu_expr)) == 'r')
|| (REFERENCE_CLASS_P (gnu_expr) == tcc_reference))
&& !Materialize_Entity (gnat_entity)
&& (!global_bindings_p ()
|| (staticp (gnu_expr)
@ -4553,7 +4553,7 @@ elaborate_expression_1 (Node_Id gnat_expr, Entity_Id gnat_entity,
rely here on the fact that an expression cannot contain both the
discriminant and some other variable. */
expr_variable = (TREE_CODE_CLASS (TREE_CODE (gnu_expr)) != 'c'
expr_variable = (!CONSTANT_CLASS_P (gnu_expr)
&& !(TREE_CODE (gnu_inner_expr) == VAR_DECL
&& TREE_READONLY (gnu_inner_expr))
&& !CONTAINS_PLACEHOLDER_P (gnu_expr));
@ -5565,8 +5565,7 @@ annotate_value (tree gnu_size)
return No_Uint;
/* See if we've already saved the value for this node. */
if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (gnu_size)))
&& TREE_COMPLEXITY (gnu_size))
if (EXPR_P (gnu_size) && TREE_COMPLEXITY (gnu_size))
return (Node_Ref_Or_Val) TREE_COMPLEXITY (gnu_size);
/* If we do not return inside this switch, TCODE will be set to the

4
gcc/ada/misc.c
View File

@ -173,9 +173,9 @@ const struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
#define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
const char tree_code_type[] = {
const enum tree_code_class tree_code_type[] = {
#include "tree.def"
'x',
tcc_exceptional,
#include "ada-tree.def"
};
#undef DEFTREECODE

24
gcc/ada/trans.c
View File

@ -3219,7 +3219,7 @@ gnat_to_gnu (Node_Id gnat_node)
/* If this is a comparison operator, convert any references to
an unconstrained array value into a reference to the
actual array. */
if (TREE_CODE_CLASS (code) == '<')
if (TREE_CODE_CLASS (code) == tcc_comparison)
{
gnu_lhs = maybe_unconstrained_array (gnu_lhs);
gnu_rhs = maybe_unconstrained_array (gnu_rhs);
@ -4035,7 +4035,7 @@ gnat_to_gnu (Node_Id gnat_node)
/* Set the location information into the result. If we're supposed to
return something of void_type, it means we have something we're
elaborating for effect, so just return. */
if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (gnu_result))))
if (EXPR_P (gnu_result))
annotate_with_node (gnu_result, gnat_node);
if (TREE_CODE (gnu_result_type) == VOID_TYPE)
@ -5712,13 +5712,13 @@ gnat_stabilize_reference_1 (tree e, bool force)
switch (TREE_CODE_CLASS (code))
{
case 'x':
case 't':
case 'd':
case '<':
case 's':
case 'e':
case 'r':
case tcc_exceptional:
case tcc_type:
case tcc_declaration:
case tcc_comparison:
case tcc_statement:
case tcc_expression:
case tcc_reference:
/* If this is a COMPONENT_REF of a fat pointer, save the entire
fat pointer. This may be more efficient, but will also allow
us to more easily find the match for the PLACEHOLDER_EXPR. */
@ -5734,12 +5734,12 @@ gnat_stabilize_reference_1 (tree e, bool force)
return e;
break;
case 'c':
case tcc_constant:
/* Constants need no processing. In fact, we should never reach
here. */
return e;
case '2':
case tcc_binary:
/* Recursively stabilize each operand. */
result = build2 (code, type,
gnat_stabilize_reference_1 (TREE_OPERAND (e, 0), force),
@ -5747,7 +5747,7 @@ gnat_stabilize_reference_1 (tree e, bool force)
force));
break;
case '1':
case tcc_unary:
/* Recursively stabilize each operand. */
result = build1 (code, type,
gnat_stabilize_reference_1 (TREE_OPERAND (e, 0),

20
gcc/ada/utils.c
View File

@ -2009,11 +2009,11 @@ max_size (tree exp, bool max_p)
switch (TREE_CODE_CLASS (code))
{
case 'd':
case 'c':
case tcc_declaration:
case tcc_constant:
return exp;
case 'x':
case tcc_exceptional:
if (code == TREE_LIST)
return tree_cons (TREE_PURPOSE (exp),
max_size (TREE_VALUE (exp), max_p),
@ -2021,7 +2021,7 @@ max_size (tree exp, bool max_p)
? max_size (TREE_CHAIN (exp), max_p) : NULL_TREE);
break;
case 'r':
case tcc_reference:
/* If this contains a PLACEHOLDER_EXPR, it is the thing we want to
modify. Otherwise, we treat it like a variable. */
if (!CONTAINS_PLACEHOLDER_P (exp))
@ -2031,12 +2031,12 @@ max_size (tree exp, bool max_p)
return
max_size (max_p ? TYPE_MAX_VALUE (type) : TYPE_MIN_VALUE (type), true);
case '<':
case tcc_comparison:
return max_p ? size_one_node : size_zero_node;
case '1':
case '2':
case 'e':
case tcc_unary:
case tcc_binary:
case tcc_expression:
switch (TREE_CODE_LENGTH (code))
{
case 1:
@ -2087,6 +2087,10 @@ max_size (tree exp, bool max_p)
return build3 (CALL_EXPR, type, TREE_OPERAND (exp, 0),
max_size (TREE_OPERAND (exp, 1), max_p), NULL);
}
/* Other tree classes cannot happen. */
default:
break;
}
abort ();

7
gcc/ada/utils2.c
View File

@ -290,17 +290,18 @@ contains_null_expr (tree exp)
switch (TREE_CODE_CLASS (TREE_CODE (exp)))
{
case '1':
case tcc_unary:
return contains_null_expr (TREE_OPERAND (exp, 0));
case '<': case '2':
case tcc_comparison:
case tcc_binary:
tem = contains_null_expr (TREE_OPERAND (exp, 0));
if (tem)
return tem;
return contains_null_expr (TREE_OPERAND (exp, 1));
case 'e':
case tcc_expression:
switch (TREE_CODE (exp))
{
case SAVE_EXPR:

23
gcc/alias.c
View File

@ -342,13 +342,13 @@ objects_must_conflict_p (tree t1, tree t2)
static tree
find_base_decl (tree t)
{
tree d0, d1, d2;
tree d0, d1;
if (t == 0 || t == error_mark_node || ! POINTER_TYPE_P (TREE_TYPE (t)))
return 0;
/* If this is a declaration, return it. */
if (TREE_CODE_CLASS (TREE_CODE (t)) == 'd')
if (DECL_P (t))
return t;
/* Handle general expressions. It would be nice to deal with
@ -356,10 +356,10 @@ find_base_decl (tree t)
same, then `a->f' and `b->f' are also the same. */
switch (TREE_CODE_CLASS (TREE_CODE (t)))
{
case '1':
case tcc_unary:
return find_base_decl (TREE_OPERAND (t, 0));
case '2':
case tcc_binary:
/* Return 0 if found in neither or both are the same. */
d0 = find_base_decl (TREE_OPERAND (t, 0));
d1 = find_base_decl (TREE_OPERAND (t, 1));
@ -372,21 +372,6 @@ find_base_decl (tree t)
else
return 0;
case '3':
d0 = find_base_decl (TREE_OPERAND (t, 0));
d1 = find_base_decl (TREE_OPERAND (t, 1));
d2 = find_base_decl (TREE_OPERAND (t, 2));
/* Set any nonzero values from the last, then from the first. */
if (d1 == 0) d1 = d2;
if (d0 == 0) d0 = d1;
if (d1 == 0) d1 = d0;
if (d2 == 0) d2 = d1;
/* At this point all are nonzero or all are zero. If all three are the
same, return it. Otherwise, return zero. */
return (d0 == d1 && d1 == d2) ? d0 : 0;
default:
return 0;
}

6
gcc/builtins.c
View File

@ -248,7 +248,7 @@ get_pointer_alignment (tree exp, unsigned int max_align)
else if (DECL_P (exp))
align = DECL_ALIGN (exp);
#ifdef CONSTANT_ALIGNMENT
else if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'c')
else if (CONSTANT_CLASS_P (exp))
align = CONSTANT_ALIGNMENT (exp, align);
#endif
return MIN (align, max_align);
@ -6205,7 +6205,7 @@ fold_builtin_constant_p (tree arglist)
STRIP_NOPS (arglist);
/* If we know this is a constant, emit the constant of one. */
if (TREE_CODE_CLASS (TREE_CODE (arglist)) == 'c'
if (CONSTANT_CLASS_P (arglist)
|| (TREE_CODE (arglist) == CONSTRUCTOR
&& TREE_CONSTANT (arglist))
|| (TREE_CODE (arglist) == ADDR_EXPR
@ -8513,7 +8513,7 @@ fold_builtin (tree exp, bool ignore)
if (exp)
{
/* ??? Don't clobber shared nodes such as integer_zero_node. */
if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'c')
if (CONSTANT_CLASS_P (exp))
exp = build1 (NOP_EXPR, TREE_TYPE (exp), exp);
TREE_NO_WARNING (exp) = 1;
}

59
gcc/c-common.c
View File

@ -1196,7 +1196,7 @@ verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
{
struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
enum tree_code code;
char cl;
enum tree_code_class cl;
/* X may be NULL if it is the operand of an empty statement expression
({ }). */
@ -1345,39 +1345,32 @@ verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
return;
}
default:
break;
}
if (cl == '1')
{
if (first_rtl_op (code) == 0)
return;
x = TREE_OPERAND (x, 0);
writer = 0;
goto restart;
}
switch (cl)
{
case 'r':
case '<':
case '2':
case 'e':
case 's':
case 'x':
{
int lp;
int max = first_rtl_op (TREE_CODE (x));
for (lp = 0; lp < max; lp++)
{
tmp_before = tmp_nosp = 0;
verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, NULL_TREE);
merge_tlist (&tmp_nosp, tmp_before, 0);
add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
}
break;
}
/* For other expressions, simply recurse on their operands.
Manual tail recursion for unary expressions.
Other non-expressions need not be processed. */
if (cl == tcc_unary)
{
if (first_rtl_op (code) == 0)
return;
x = TREE_OPERAND (x, 0);
writer = 0;
goto restart;
}
else if (IS_EXPR_CODE_CLASS (cl))
{
int lp;
int max = first_rtl_op (TREE_CODE (x));
for (lp = 0; lp < max; lp++)
{
tmp_before = tmp_nosp = 0;
verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, 0);
merge_tlist (&tmp_nosp, tmp_before, 0);
add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
}
}
return;
}
}

24
gcc/c-common.def
View File

@ -25,46 +25,46 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
/* Tree nodes relevant to both C and C++. These were originally in
cp-tree.def in the cp subdir. */
DEFTREECODE (SIZEOF_EXPR, "sizeof_expr", '1', 1)
DEFTREECODE (ARROW_EXPR, "arrow_expr", 'e', 1)
DEFTREECODE (ALIGNOF_EXPR, "alignof_expr", '1', 1)
DEFTREECODE (SIZEOF_EXPR, "sizeof_expr", tcc_unary, 1)
DEFTREECODE (ARROW_EXPR, "arrow_expr", tcc_expression, 1)
DEFTREECODE (ALIGNOF_EXPR, "alignof_expr", tcc_unary, 1)
/* Used to represent an expression statement. Use `EXPR_STMT_EXPR' to
obtain the expression. */
DEFTREECODE (EXPR_STMT, "expr_stmt", 'e', 1)
DEFTREECODE (EXPR_STMT, "expr_stmt", tcc_expression, 1)
/* Used to represent a `for' statement. The operands are
FOR_INIT_STMT, FOR_COND, FOR_EXPR, and FOR_BODY, respectively. */
DEFTREECODE (FOR_STMT, "for_stmt", 'e', 4)
DEFTREECODE (FOR_STMT, "for_stmt", tcc_expression, 4)
/* Used to represent a 'while' statement. The operands are WHILE_COND
and WHILE_BODY, respectively. */
DEFTREECODE (WHILE_STMT, "while_stmt", 'e', 2)
DEFTREECODE (WHILE_STMT, "while_stmt", tcc_expression, 2)
/* Used to represent a 'do' statement. The operands are DO_BODY and
DO_COND, respectively. */
DEFTREECODE (DO_STMT, "do_stmt", 'e', 2)
DEFTREECODE (DO_STMT, "do_stmt", tcc_expression, 2)
/* Used to represent a 'break' statement. */
DEFTREECODE (BREAK_STMT, "break_stmt", 'e', 0)
DEFTREECODE (BREAK_STMT, "break_stmt", tcc_expression, 0)
/* Used to represent a 'continue' statement. */
DEFTREECODE (CONTINUE_STMT, "continue_stmt", 'e', 0)
DEFTREECODE (CONTINUE_STMT, "continue_stmt", tcc_expression, 0)
/* Used to represent a 'switch' statement. The operands are
SWITCH_COND, SWITCH_BODY and SWITCH_TYPE, respectively. */
DEFTREECODE (SWITCH_STMT, "switch_stmt", 'e', 3)
DEFTREECODE (SWITCH_STMT, "switch_stmt", tcc_expression, 3)
/* A STMT_EXPR represents a statement-expression. The
STMT_EXPR_STMT is the statement given by the expression. */
DEFTREECODE (STMT_EXPR, "stmt_expr", 'e', 1)
DEFTREECODE (STMT_EXPR, "stmt_expr", tcc_expression, 1)
/* A COMPOUND_LITERAL_EXPR represents a C99 compound literal. The
COMPOUND_LITERAL_EXPR_DECL_STMT is the a DECL_STMT containing the decl
for the anonymous object represented by the COMPOUND_LITERAL;
the DECL_INITIAL of that decl is the CONSTRUCTOR that initializes
the compound literal. */
DEFTREECODE (COMPOUND_LITERAL_EXPR, "compound_literal_expr", 'e', 1)
DEFTREECODE (COMPOUND_LITERAL_EXPR, "compound_literal_expr", tcc_expression, 1)
/*
Local variables:

2
gcc/c-format.c
View File

@ -2094,7 +2094,7 @@ check_format_types (format_wanted_type *types, const char *format_start,
&& i == 0
&& (TYPE_READONLY (cur_type)
|| (cur_param != 0
&& (TREE_CODE_CLASS (TREE_CODE (cur_param)) == 'c'
&& (CONSTANT_CLASS_P (cur_param)
|| (DECL_P (cur_param)
&& TREE_READONLY (cur_param))))))
warning ("writing into constant object (arg %d)", arg_num);

4
gcc/c-lang.c
View File

@ -54,9 +54,9 @@ const struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
#define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
const char tree_code_type[] = {
const enum tree_code_class tree_code_type[] = {
#include "tree.def"
'x',
tcc_exceptional,
#include "c-common.def"
};
#undef DEFTREECODE

2
gcc/c-pragma.c
View File

@ -316,7 +316,7 @@ handle_pragma_weak (cpp_reader * ARG_UNUSED (dummy))
warning ("junk at end of #pragma weak");
decl = identifier_global_value (name);
if (decl && TREE_CODE_CLASS (TREE_CODE (decl)) == 'd')
if (decl && DECL_P (decl))
{
apply_pragma_weak (decl, value);
if (value)

43
gcc/c-typeck.c
View File

@ -744,18 +744,24 @@ same_translation_unit_p (tree t1, tree t2)
while (t1 && TREE_CODE (t1) != TRANSLATION_UNIT_DECL)
switch (TREE_CODE_CLASS (TREE_CODE (t1)))
{
case 'd': t1 = DECL_CONTEXT (t1); break;
case 't': t1 = TYPE_CONTEXT (t1); break;
case 'x': t1 = BLOCK_SUPERCONTEXT (t1); break; /* assume block */
case tcc_declaration:
t1 = DECL_CONTEXT (t1); break;
case tcc_type:
t1 = TYPE_CONTEXT (t1); break;
case tcc_exceptional:
t1 = BLOCK_SUPERCONTEXT (t1); break; /* assume block */
default: gcc_unreachable ();
}
while (t2 && TREE_CODE (t2) != TRANSLATION_UNIT_DECL)
switch (TREE_CODE_CLASS (TREE_CODE (t2)))
{
case 'd': t2 = DECL_CONTEXT (t2); break;
case 't': t2 = TYPE_CONTEXT (t2); break;
case 'x': t2 = BLOCK_SUPERCONTEXT (t2); break; /* assume block */
case tcc_declaration:
t2 = DECL_CONTEXT (t2); break;
case tcc_type:
t2 = TYPE_CONTEXT (t2); break;
case tcc_exceptional:
t2 = BLOCK_SUPERCONTEXT (t2); break; /* assume block */
default: gcc_unreachable ();
}
@ -1200,7 +1206,7 @@ default_function_array_conversion (tree exp)
int volatilep = 0;
int lvalue_array_p;
if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'r' || DECL_P (exp))
if (REFERENCE_CLASS_P (exp) || DECL_P (exp))
{
constp = TREE_READONLY (exp);
volatilep = TREE_THIS_VOLATILE (exp);
@ -2232,7 +2238,8 @@ parser_build_binary_op (enum tree_code code, struct c_expr arg1,
|| code2 == PLUS_EXPR || code2 == MINUS_EXPR)
warning ("suggest parentheses around arithmetic in operand of |");
/* Check cases like x|y==z */
if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
if (TREE_CODE_CLASS (code1) == tcc_comparison
|| TREE_CODE_CLASS (code2) == tcc_comparison)
warning ("suggest parentheses around comparison in operand of |");
}
@ -2244,7 +2251,8 @@ parser_build_binary_op (enum tree_code code, struct c_expr arg1,
|| code2 == PLUS_EXPR || code2 == MINUS_EXPR)
warning ("suggest parentheses around arithmetic in operand of ^");
/* Check cases like x^y==z */
if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
if (TREE_CODE_CLASS (code1) == tcc_comparison
|| TREE_CODE_CLASS (code2) == tcc_comparison)
warning ("suggest parentheses around comparison in operand of ^");
}
@ -2254,13 +2262,14 @@ parser_build_binary_op (enum tree_code code, struct c_expr arg1,
|| code2 == PLUS_EXPR || code2 == MINUS_EXPR)
warning ("suggest parentheses around + or - in operand of &");
/* Check cases like x&y==z */
if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
if (TREE_CODE_CLASS (code1) == tcc_comparison
|| TREE_CODE_CLASS (code2) == tcc_comparison)
warning ("suggest parentheses around comparison in operand of &");
}
/* Similarly, check for cases like 1<=i<=10 that are probably errors. */
if (TREE_CODE_CLASS (code) == '<'
&& (TREE_CODE_CLASS (code1) == '<'
|| TREE_CODE_CLASS (code2) == '<'))
if (TREE_CODE_CLASS (code) == tcc_comparison
&& (TREE_CODE_CLASS (code1) == tcc_comparison
|| TREE_CODE_CLASS (code2) == tcc_comparison))
warning ("comparisons like X<=Y<=Z do not have their mathematical meaning");
}
@ -2604,7 +2613,7 @@ build_unary_op (enum tree_code code, tree xarg, int flag)
to which the address will point. Note that you can't get a
restricted pointer by taking the address of something, so we
only have to deal with `const' and `volatile' here. */
if ((DECL_P (arg) || TREE_CODE_CLASS (TREE_CODE (arg)) == 'r')
if ((DECL_P (arg) || REFERENCE_CLASS_P (arg))
&& (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg)))
argtype = c_build_type_variant (argtype,
TREE_READONLY (arg),
@ -3208,7 +3217,7 @@ build_c_cast (tree type, tree expr)
else
TREE_OVERFLOW (value) = 0;
if (TREE_CODE_CLASS (TREE_CODE (ovalue)) == 'c')
if (CONSTANT_CLASS_P (ovalue))
/* Similarly, constant_overflow cannot have become
cleared. */
TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
@ -6396,7 +6405,7 @@ c_finish_return (tree retval)
case ADDR_EXPR:
inner = TREE_OPERAND (inner, 0);
while (TREE_CODE_CLASS (TREE_CODE (inner)) == 'r'
while (REFERENCE_CLASS_P (inner)
&& TREE_CODE (inner) != INDIRECT_REF)
inner = TREE_OPERAND (inner, 0);
@ -6744,7 +6753,7 @@ c_process_expr_stmt (tree expr)
/* If the expression is not of a type to which we cannot assign a line
number, wrap the thing in a no-op NOP_EXPR. */
if (DECL_P (expr) || TREE_CODE_CLASS (TREE_CODE (expr)) == 'c')
if (DECL_P (expr) || CONSTANT_CLASS_P (expr))
expr = build1 (NOP_EXPR, TREE_TYPE (expr), expr);
if (EXPR_P (expr))

14
gcc/cgraphunit.c
View File

@ -671,7 +671,7 @@ record_call_1 (tree *tp, int *walk_subtrees, void *data)
default:
/* Save some cycles by not walking types and declaration as we
won't find anything useful there anyway. */
if (DECL_P (*tp) || TYPE_P (*tp))
if (IS_TYPE_OR_DECL_P (*tp))
{
*walk_subtrees = 0;
break;
@ -740,7 +740,7 @@ verify_cgraph_node_1 (tree *tp, int *walk_subtrees, void *data)
/* Save some cycles by not walking types and declaration as we
won't find anything useful there anyway. */
if (DECL_P (*tp) || TYPE_P (*tp))
if (IS_TYPE_OR_DECL_P (*tp))
*walk_subtrees = 0;
return NULL_TREE;
@ -2225,18 +2225,18 @@ scan_for_static_refs (tree *tp,
check_lhs_var (fn, TREE_OPERAND (t, 0));
/* Next check the operands on the rhs to see if they are ok. */
switch (TREE_CODE_CLASS (TREE_CODE (rhs))) {
case '2':
case tcc_binary:
check_rhs_var (fn, TREE_OPERAND (rhs, 0));
check_rhs_var (fn, TREE_OPERAND (rhs, 1));
break;
case '1':
case 'r':
case tcc_unary:
case tcc_reference:
check_rhs_var (fn, TREE_OPERAND (rhs, 0));
break;
case 'd':
case tcc_declaration:
check_rhs_var (fn, rhs);
break;
case 'e':
case tcc_expression:
switch (TREE_CODE (rhs)) {
case ADDR_EXPR:
check_rhs_var (fn, rhs);

2
gcc/config/arm/arm.c
View File

@ -13788,7 +13788,7 @@ arm_encode_section_info (tree decl, rtx rtl, int first)
/* If we are referencing a function that is weak then encode a long call
flag in the function name, otherwise if the function is static or
or known to be defined in this file then encode a short call flag. */
if (first && TREE_CODE_CLASS (TREE_CODE (decl)) == 'd')
if (first && DECL_P (decl))
{
if (TREE_CODE (decl) == FUNCTION_DECL && DECL_WEAK (decl))
arm_encode_call_attribute (decl, LONG_CALL_FLAG_CHAR);

3
gcc/config/i386/winnt.c
View File

@ -99,8 +99,7 @@ associated_type (tree decl)
t = TYPE_MAIN_VARIANT
(TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
}
else if (DECL_CONTEXT (decl)
&& TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (decl))) == 't')
else if (DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl)))
t = DECL_CONTEXT (decl);
return t;

3
gcc/config/pa/pa.c
View File

@ -9342,8 +9342,7 @@ pa_select_section (tree exp, int reloc,
else
readonly_data_section ();
}
else if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'c'
&& !reloc)
else if (CONSTANT_CLASS_P (exp) && !reloc)
readonly_data_section ();
else if (TARGET_SOM
&& TREE_CODE (exp) == VAR_DECL

2
gcc/config/pa/pa.h
View File

@ -1770,7 +1770,7 @@ forget_section (void) \
&& TREE_READONLY (DECL) && ! TREE_SIDE_EFFECTS (DECL) \
&& (! DECL_INITIAL (DECL) || ! reloc_needed (DECL_INITIAL (DECL))) \
&& !flag_pic) \
|| (TREE_CODE_CLASS (TREE_CODE (DECL)) == 'c'))
|| CONSTANT_CLASS_P (DECL))
#define FUNCTION_NAME_P(NAME) (*(NAME) == '@')

2
gcc/config/sh/sh.c
View File

@ -7065,7 +7065,7 @@ sh_insert_attributes (tree node, tree *attributes)
return;
/* We are only interested in fields. */
if (TREE_CODE_CLASS (TREE_CODE (node)) != 'd')
if (!DECL_P (node))
return;
/* Add a 'handle_interrupt' attribute. */

6
gcc/config/sol2-c.c
View File

@ -113,7 +113,7 @@ solaris_pragma_align (cpp_reader *pfile ATTRIBUTE_UNUSED)
while (1)
{
tree decl = identifier_global_value (t);
if (decl && TREE_CODE_CLASS (TREE_CODE (decl)) == 'd')
if (decl && DECL_P (decl))
warning ("%<#pragma align%> must appear before the declaration of "
"%D, ignoring", decl);
else
@ -168,7 +168,7 @@ solaris_pragma_init (cpp_reader *pfile ATTRIBUTE_UNUSED)
while (1)
{
tree decl = identifier_global_value (t);
if (decl && TREE_CODE_CLASS (TREE_CODE (decl)) == 'd')
if (decl && DECL_P (decl))
{
tree init_list = build_tree_list (get_identifier ("init"),
NULL);
@ -226,7 +226,7 @@ solaris_pragma_fini (cpp_reader *pfile ATTRIBUTE_UNUSED)
while (1)
{
tree decl = identifier_global_value (t);
if (decl && TREE_CODE_CLASS (TREE_CODE (decl)) == 'd')
if (decl && DECL_P (decl))
{
tree fini_list = build_tree_list (get_identifier ("fini"),
NULL);

2
gcc/convert.c
View File

@ -401,7 +401,7 @@ convert_to_integer (tree type, tree expr)
we must also change the types of the operands to maintain type
correctness. */
if (TREE_CODE_CLASS (ex_form) == '<')
if (TREE_CODE_CLASS (ex_form) == tcc_comparison)
{
expr = copy_node (expr);
TREE_TYPE (expr) = type;

17
gcc/cp/ChangeLog
View File

@ -1,3 +1,12 @@
2004-09-17 Jeffrey D. Oldham <oldham@codesourcery.com>
Zack Weinberg <zack@codesourcery.com>
* cp-tree.def: Use tree_code_class enumeration constants
instead of code letters.
* call.c, class.c, cp-gimplify.c, cp-lang.c, cxx-pretty-print.c
* mangle.c, pt.c, semantics.c, tree.c, typeck.c:
Update for new tree-class enumeration constants.
2004-09-16 Mark Mitchell <mark@codesourcery.com>
PR c++/16002
@ -16,7 +25,7 @@
2004-09-16 Andrew MacLeod <amacleod@redhat.com>
* error.c (dump_decl): Make sure there is lang_specific info before
* error.c (dump_decl): Make sure there is lang_specific info before
checking for DTOR and CTOR decls.
2004-09-16 Nathan Sidwell <nathan@codesourcery.com>
@ -106,9 +115,9 @@
2004-09-11 Richard Henderson <rth@redhat.com>
PR c++/17404
* pt.c (cur_stmt_expr): Move from tsubst_expr.
(tsubst_expr) <case STMT_EXPR>: Move ...
(tsubst_copy_and_build): ... here.
* pt.c (cur_stmt_expr): Move from tsubst_expr.
(tsubst_expr) <case STMT_EXPR>: Move ...
(tsubst_copy_and_build): ... here.
2004-09-10 Zack Weinberg <zack@codesourcery.com>

2
gcc/cp/call.c
View File

@ -5867,7 +5867,7 @@ joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn)
/* If we have two pseudo-candidates for conversions to the same type,
or two candidates for the same function, arbitrarily pick one. */
if (cand1->fn == cand2->fn
&& (TYPE_P (cand1->fn) || DECL_P (cand1->fn)))
&& (IS_TYPE_OR_DECL_P (cand1->fn)))
return 1;
/* a viable function F1

4
gcc/cp/class.c
View File

@ -6272,11 +6272,11 @@ get_enclosing_class (tree type)
{
switch (TREE_CODE_CLASS (TREE_CODE (node)))
{
case 'd':
case tcc_declaration:
node = DECL_CONTEXT (node);
break;
case 't':
case tcc_type:
if (node != type)
return node;
node = TYPE_CONTEXT (node);

2
gcc/cp/cp-gimplify.c
View File

@ -303,7 +303,7 @@ cp_genericize_r (tree *stmt_p, int *walk_subtrees, void *data)
&& is_invisiref_parm (TREE_OPERAND (stmt, 0)))
/* Don't dereference an invisiref RESULT_DECL inside a RETURN_EXPR. */
*walk_subtrees = 0;
else if (DECL_P (stmt) || TYPE_P (stmt))
else if (IS_TYPE_OR_DECL_P (stmt))
*walk_subtrees = 0;
/* Due to the way voidify_wrapper_expr is written, we don't get a chance

6
gcc/cp/cp-lang.c
View File

@ -57,11 +57,11 @@ const struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
#define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
const char tree_code_type[] = {
const enum tree_code_class tree_code_type[] = {
#include "tree.def"
'x',
tcc_exceptional,
#include "c-common.def"
'x',
tcc_exceptional,
#include "cp-tree.def"
};
#undef DEFTREECODE

95
gcc/cp/cp-tree.def
View File

@ -42,56 +42,56 @@ Boston, MA 02111-1307, USA. */
2. An expression of the form `x.*p'. In this case, operand 0 will
be an expression corresponding to `x' and operand 1 will be an
expression with pointer-to-member type. */
DEFTREECODE (OFFSET_REF, "offset_ref", 'r', 2)
DEFTREECODE (OFFSET_REF, "offset_ref", tcc_reference, 2)
/* A pointer-to-member constant. For a pointer-to-member constant
`X::Y' The PTRMEM_CST_CLASS is the RECORD_TYPE for `X' and the
PTRMEM_CST_MEMBER is the _DECL for `Y'. */
DEFTREECODE (PTRMEM_CST, "ptrmem_cst", 'c', 0)
DEFTREECODE (PTRMEM_CST, "ptrmem_cst", tcc_constant, 0)
/* For NEW_EXPR, operand 0 is the placement list.
Operand 1 is the new-declarator.
Operand 2 is the number of elements in the array.
Operand 3 is the initializer. */
DEFTREECODE (NEW_EXPR, "nw_expr", 'e', 4)
DEFTREECODE (VEC_NEW_EXPR, "vec_nw_expr", 'e', 3)
DEFTREECODE (NEW_EXPR, "nw_expr", tcc_expression, 4)
DEFTREECODE (VEC_NEW_EXPR, "vec_nw_expr", tcc_expression, 3)
/* For DELETE_EXPR, operand 0 is the store to be destroyed.
Operand 1 is the value to pass to the destroying function
saying whether the store should be deallocated as well. */
DEFTREECODE (DELETE_EXPR, "dl_expr", 'e', 2)
DEFTREECODE (VEC_DELETE_EXPR, "vec_dl_expr", 'e', 2)
DEFTREECODE (DELETE_EXPR, "dl_expr", tcc_expression, 2)
DEFTREECODE (VEC_DELETE_EXPR, "vec_dl_expr", tcc_expression, 2)
/* Value is reference to particular overloaded class method.
Operand 0 is the class, operand 1 is the field
The COMPLEXITY field holds the class level (usually 0). */
DEFTREECODE (SCOPE_REF, "scope_ref", 'r', 2)
DEFTREECODE (SCOPE_REF, "scope_ref", tcc_reference, 2)
/* When composing an object with a member, this is the result.
Operand 0 is the object. Operand 1 is the member (usually
a dereferenced pointer to member). */
DEFTREECODE (MEMBER_REF, "member_ref", 'r', 2)
DEFTREECODE (MEMBER_REF, "member_ref", tcc_reference, 2)
/* Type conversion operator in C++. TREE_TYPE is type that this
operator converts to. Operand is expression to be converted. */
DEFTREECODE (TYPE_EXPR, "type_expr", 'e', 1)
DEFTREECODE (TYPE_EXPR, "type_expr", tcc_expression, 1)
/* For AGGR_INIT_EXPR, operand 0 is function which performs initialization,
operand 1 is argument list to initialization function,
and operand 2 is the slot which was allocated for this expression. */
DEFTREECODE (AGGR_INIT_EXPR, "aggr_init_expr", 'e', 3)
DEFTREECODE (AGGR_INIT_EXPR, "aggr_init_expr", tcc_expression, 3)
/* A throw expression. operand 0 is the expression, if there was one,
else it is NULL_TREE. */
DEFTREECODE (THROW_EXPR, "throw_expr", 'e', 1)
DEFTREECODE (THROW_EXPR, "throw_expr", tcc_expression, 1)
/* An empty class object. The TREE_TYPE gives the class type. We use
these to avoid actually creating instances of the empty classes. */
DEFTREECODE (EMPTY_CLASS_EXPR, "empty_class_expr", 'e', 0)
DEFTREECODE (EMPTY_CLASS_EXPR, "empty_class_expr", tcc_expression, 0)
/* A DECL which is really just a placeholder for an expression. Used to
implement non-class scope anonymous unions. */
DEFTREECODE (ALIAS_DECL, "alias_decl", 'd', 0)
DEFTREECODE (ALIAS_DECL, "alias_decl", tcc_declaration, 0)
/* A reference to a member function or member functions from a base
class. BASELINK_FUNCTIONS gives the FUNCTION_DECL,
@ -105,7 +105,7 @@ DEFTREECODE (ALIAS_DECL, "alias_decl", 'd', 0)
the type of the expression. This type is either a FUNCTION_TYPE,
METHOD_TYPE, or `unknown_type_node' indicating that the function is
overloaded. */
DEFTREECODE (BASELINK, "baselink", 'x', 0)
DEFTREECODE (BASELINK, "baselink", tcc_exceptional, 0)
/* Template definition. The following fields have the specified uses,
although there are other macros in cp-tree.h that should be used for
@ -122,7 +122,7 @@ DEFTREECODE (BASELINK, "baselink", 'x', 0)
DECL_TEMPLATE_RESULT decl for object to be created
(e.g., FUNCTION_DECL with tmpl parms used)
*/
DEFTREECODE (TEMPLATE_DECL, "template_decl", 'd', 0)
DEFTREECODE (TEMPLATE_DECL, "template_decl", tcc_declaration, 0)
/* Index into a template parameter list. The TEMPLATE_PARM_IDX gives
the index (from 0) of the parameter, while the TEMPLATE_PARM_LEVEL
@ -157,11 +157,11 @@ DEFTREECODE (TEMPLATE_DECL, "template_decl", 'd', 0)
The LEVEL is the level of the parameter when we are worrying about
the types of things; the ORIG_LEVEL is the level when we are
worrying about instantiating things. */
DEFTREECODE (TEMPLATE_PARM_INDEX, "template_parm_index", 'x', 0)
DEFTREECODE (TEMPLATE_PARM_INDEX, "template_parm_index", tcc_exceptional, 0)
/* Index into a template parameter list. This parameter must be a type.
The type.value field will be a TEMPLATE_PARM_INDEX. */
DEFTREECODE (TEMPLATE_TYPE_PARM, "template_type_parm", 't', 0)
DEFTREECODE (TEMPLATE_TYPE_PARM, "template_type_parm", tcc_type, 0)
/* Index into a template parameter list for template template parameters.
This parameter must be a type. The TYPE_FIELDS value will be a
@ -170,13 +170,14 @@ DEFTREECODE (TEMPLATE_TYPE_PARM, "template_type_parm", 't', 0)
It is used without template arguments like TT in C<TT>,
TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO is NULL_TREE
and TYPE_NAME is a TEMPLATE_DECL. */
DEFTREECODE (TEMPLATE_TEMPLATE_PARM, "template_template_parm", 't', 0)
DEFTREECODE (TEMPLATE_TEMPLATE_PARM, "template_template_parm", tcc_type, 0)
/* Like TEMPLATE_TEMPLATE_PARM it is used with bound template arguments
like TT<int>.
In this case, TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO contains the
template name and its bound arguments. TYPE_NAME is a TYPE_DECL. */
DEFTREECODE (BOUND_TEMPLATE_TEMPLATE_PARM, "bound_template_template_parm", 't', 0)
DEFTREECODE (BOUND_TEMPLATE_TEMPLATE_PARM, "bound_template_template_parm",
tcc_type, 0)
/* A type designated by `typename T::t'. TYPE_CONTEXT is `T',
TYPE_NAME is an IDENTIFIER_NODE for `t'. If the type was named via
@ -184,51 +185,51 @@ DEFTREECODE (BOUND_TEMPLATE_TEMPLATE_PARM, "bound_template_template_parm", 't',
If TREE_TYPE is present, this type was generated by the implicit
typename extension, and the TREE_TYPE is a _TYPE from a baseclass
of `T'. */
DEFTREECODE (TYPENAME_TYPE, "typename_type", 't', 0)
DEFTREECODE (TYPENAME_TYPE, "typename_type", tcc_type, 0)
/* For template template argument of the form `T::template C'.
TYPE_CONTEXT is `T', the template parameter dependent object.
TYPE_NAME is an IDENTIFIER_NODE for `C', the member class template. */
DEFTREECODE (UNBOUND_CLASS_TEMPLATE, "unbound_class_template", 't', 0)
DEFTREECODE (UNBOUND_CLASS_TEMPLATE, "unbound_class_template", tcc_type, 0)
/* A type designated by `__typeof (expr)'. TYPEOF_TYPE_EXPR is the
expression in question. */
DEFTREECODE (TYPEOF_TYPE, "typeof_type", 't', 0)
DEFTREECODE (TYPEOF_TYPE, "typeof_type", tcc_type, 0)
/* A using declaration. DECL_INITIAL contains the specified scope.
This is not an alias, but is later expanded into multiple aliases.
The decl will have a NULL_TYPE iff the scope is a dependent scope,
otherwise it will have a void type. */
DEFTREECODE (USING_DECL, "using_decl", 'd', 0)
DEFTREECODE (USING_DECL, "using_decl", tcc_declaration, 0)
/* A using directive. The operand is USING_STMT_NAMESPACE. */
DEFTREECODE (USING_STMT, "using_directive", 'e', 1)
DEFTREECODE (USING_STMT, "using_directive", tcc_expression, 1)
/* An un-parsed default argument. Looks like an IDENTIFIER_NODE. */
DEFTREECODE (DEFAULT_ARG, "default_arg", 'x', 0)
DEFTREECODE (DEFAULT_ARG, "default_arg", tcc_exceptional, 0)
/* A template-id, like foo<int>. The first operand is the template.
The second is NULL if there are no explicit arguments, or a
TREE_VEC of arguments. The template will be a FUNCTION_DECL,
TEMPLATE_DECL, or an OVERLOAD. If the template-id refers to a
member template, the template may be an IDENTIFIER_NODE. */
DEFTREECODE (TEMPLATE_ID_EXPR, "template_id_expr", 'e', 2)
DEFTREECODE (TEMPLATE_ID_EXPR, "template_id_expr", tcc_expression, 2)
/* A list-like node for chaining overloading candidates. TREE_TYPE is
the original name, and the parameter is the FUNCTION_DECL. */
DEFTREECODE (OVERLOAD, "overload", 'x', 0)
DEFTREECODE (OVERLOAD, "overload", tcc_exceptional, 0)
/* A whole bunch of tree codes for the initial, superficial parsing of
templates. */
DEFTREECODE (MODOP_EXPR, "modop_expr", 'e', 3)
DEFTREECODE (CAST_EXPR, "cast_expr", '1', 1)
DEFTREECODE (REINTERPRET_CAST_EXPR, "reinterpret_cast_expr", '1', 1)
DEFTREECODE (CONST_CAST_EXPR, "const_cast_expr", '1', 1)
DEFTREECODE (STATIC_CAST_EXPR, "static_cast_expr", '1', 1)
DEFTREECODE (DYNAMIC_CAST_EXPR, "dynamic_cast_expr", '1', 1)
DEFTREECODE (DOTSTAR_EXPR, "dotstar_expr", 'e', 2)
DEFTREECODE (TYPEID_EXPR, "typeid_expr", 'e', 1)
DEFTREECODE (PSEUDO_DTOR_EXPR, "pseudo_dtor_expr", 'e', 3)
DEFTREECODE (MODOP_EXPR, "modop_expr", tcc_expression, 3)
DEFTREECODE (CAST_EXPR, "cast_expr", tcc_unary, 1)
DEFTREECODE (REINTERPRET_CAST_EXPR, "reinterpret_cast_expr", tcc_unary, 1)
DEFTREECODE (CONST_CAST_EXPR, "const_cast_expr", tcc_unary, 1)
DEFTREECODE (STATIC_CAST_EXPR, "static_cast_expr", tcc_unary, 1)
DEFTREECODE (DYNAMIC_CAST_EXPR, "dynamic_cast_expr", tcc_unary, 1)
DEFTREECODE (DOTSTAR_EXPR, "dotstar_expr", tcc_expression, 2)
DEFTREECODE (TYPEID_EXPR, "typeid_expr", tcc_expression, 1)
DEFTREECODE (PSEUDO_DTOR_EXPR, "pseudo_dtor_expr", tcc_expression, 3)
/* A placeholder for an expression that is not type-dependent, but
does occur in a template. When an expression that is not
@ -239,38 +240,38 @@ DEFTREECODE (PSEUDO_DTOR_EXPR, "pseudo_dtor_expr", 'e', 3)
that situation, we create a NON_DEPENDENT_EXPR to take the place of
the original expression. The expression is the only operand -- it
is only needed for diagnostics. */
DEFTREECODE (NON_DEPENDENT_EXPR, "non_dependent_expr", 'e', 1)
DEFTREECODE (NON_DEPENDENT_EXPR, "non_dependent_expr", tcc_expression, 1)
/* CTOR_INITIALIZER is a placeholder in template code for a call to
setup_vtbl_pointer (and appears in all functions, not just ctors). */
DEFTREECODE (CTOR_INITIALIZER, "ctor_initializer", 'e', 1)
DEFTREECODE (CTOR_INITIALIZER, "ctor_initializer", tcc_expression, 1)
DEFTREECODE (TRY_BLOCK, "try_block", 'e', 2)
DEFTREECODE (TRY_BLOCK, "try_block", tcc_expression, 2)
DEFTREECODE (EH_SPEC_BLOCK, "eh_spec_block", 'e', 2)
DEFTREECODE (EH_SPEC_BLOCK, "eh_spec_block", tcc_expression, 2)
/* A HANDLER wraps a catch handler for the HANDLER_TYPE. If this is
CATCH_ALL_TYPE, then the handler catches all types. The declaration of
the catch variable is in HANDLER_PARMS, and the body block in
HANDLER_BODY. */
DEFTREECODE (HANDLER, "handler", 'e', 2)
DEFTREECODE (HANDLER, "handler", tcc_expression, 2)
/* A MUST_NOT_THROW_EXPR wraps an expression that may not
throw, and must call terminate if it does. */
DEFTREECODE (MUST_NOT_THROW_EXPR, "must_not_throw_expr", 'e', 1)
DEFTREECODE (MUST_NOT_THROW_EXPR, "must_not_throw_expr", tcc_expression, 1)
/* A CLEANUP_STMT marks the point at which a declaration is fully
constructed. The CLEANUP_EXPR is run on behalf of CLEANUP_DECL
when CLEANUP_BODY completes. */
DEFTREECODE (CLEANUP_STMT, "cleanup_stmt", 'e', 3)
DEFTREECODE (CLEANUP_STMT, "cleanup_stmt", tcc_expression, 3)
/* Represents an 'if' statement. The operands are IF_COND,
THEN_CLAUSE, and ELSE_CLAUSE, respectively. */
/* ??? It is currently still necessary to distinguish between IF_STMT
and COND_EXPR for the benefit of templates. */
DEFTREECODE (IF_STMT, "if_stmt", 'e', 3)
DEFTREECODE (IF_STMT, "if_stmt", tcc_expression, 3)
DEFTREECODE (TAG_DEFN, "tag_defn", 'e', 0)
DEFTREECODE (TAG_DEFN, "tag_defn", tcc_expression, 0)
/* Template instantiation level node.
@ -280,10 +281,10 @@ DEFTREECODE (TAG_DEFN, "tag_defn", 'e', 0)
A stack of template instantiation nodes is kept through the TREE_CHAIN
fields of these nodes. */
DEFTREECODE (TINST_LEVEL, "TINST_LEVEL", 'x', 0)
DEFTREECODE (TINST_LEVEL, "TINST_LEVEL", tcc_exceptional, 0)
/* Represents an 'offsetof' expression during template expansion. */
DEFTREECODE (OFFSETOF_EXPR, "offsetof_expr", 'e', 1)
DEFTREECODE (OFFSETOF_EXPR, "offsetof_expr", tcc_expression, 1)
/*
Local variables:

5
gcc/cp/cxx-pretty-print.c
View File

@ -1154,7 +1154,8 @@ static void
pp_cxx_parameter_declaration_clause (cxx_pretty_printer *pp, tree t)
{
tree args = TYPE_P (t) ? NULL : FUNCTION_FIRST_USER_PARM (t);
tree types = TYPE_P (t) ? TYPE_ARG_TYPES (t) : FUNCTION_FIRST_USER_PARMTYPE (t);
tree types =
TYPE_P (t) ? TYPE_ARG_TYPES (t) : FUNCTION_FIRST_USER_PARMTYPE (t);
const bool abstract = args == NULL
|| pp_c_base (pp)->flags & pp_c_flag_abstract;
bool first = true;
@ -1441,7 +1442,7 @@ pp_cxx_template_argument_list (cxx_pretty_printer *pp, tree t)
if (i != 0)
pp_cxx_separate_with (pp, ',');
if (TYPE_P (arg) || (TREE_CODE (arg) == TEMPLATE_DECL
&& TYPE_P (DECL_TEMPLATE_RESULT (arg))))
&& TYPE_P (DECL_TEMPLATE_RESULT (arg))))
pp_cxx_type_id (pp, arg);
else
pp_cxx_expression (pp, arg);

4
gcc/cp/mangle.c
View File

@ -1997,7 +1997,7 @@ write_expression (tree expr)
|| code == TEMPLATE_PARM_INDEX)
write_template_param (expr);
/* Handle literals. */
else if (TREE_CODE_CLASS (code) == 'c'
else if (TREE_CODE_CLASS (code) == tcc_constant
|| (abi_version_at_least (2) && code == CONST_DECL))
write_template_arg_literal (expr);
else if (DECL_P (expr))
@ -2260,7 +2260,7 @@ write_template_arg (tree node)
else if (code == TEMPLATE_DECL)
/* A template appearing as a template arg is a template template arg. */
write_template_template_arg (node);
else if ((TREE_CODE_CLASS (code) == 'c' && code != PTRMEM_CST)
else if ((TREE_CODE_CLASS (code) == tcc_constant && code != PTRMEM_CST)
|| (abi_version_at_least (2) && code == CONST_DECL))
write_template_arg_literal (node);
else if (DECL_P (node))

27
gcc/cp/pt.c
View File

@ -4891,7 +4891,7 @@ uses_template_parms (tree t)
|| TREE_CODE (t) == TEMPLATE_PARM_INDEX
|| TREE_CODE (t) == OVERLOAD
|| TREE_CODE (t) == BASELINK
|| TREE_CODE_CLASS (TREE_CODE (t)) == 'c')
|| CONSTANT_CLASS_P (t))
dependent_p = (type_dependent_expression_p (t)
|| value_dependent_expression_p (t));
else
@ -10109,7 +10109,7 @@ unify (tree tparms, tree targs, tree parm, tree arg, int strict)
return 1;
default:
gcc_assert (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (parm))));
gcc_assert (EXPR_P (parm));
/* We must be looking at an expression. This can happen with
something like:
@ -11586,9 +11586,9 @@ dependent_type_p_r (tree type)
A type is dependent if it is:
-- a template parameter. Template template parameters are
types for us (since TYPE_P holds true for them) so we
handle them here. */
-- a template parameter. Template template parameters are types
for us (since TYPE_P holds true for them) so we handle
them here. */
if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
|| TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM)
return true;
@ -11819,20 +11819,20 @@ value_dependent_expression_p (tree expression)
|| value_dependent_expression_p (TREE_OPERAND (expression, 1)));
/* A constant expression is value-dependent if any subexpression is
value-dependent. */
if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (expression))))
if (EXPR_P (expression))
{
switch (TREE_CODE_CLASS (TREE_CODE (expression)))
{
case '1':
case tcc_unary:
return (value_dependent_expression_p
(TREE_OPERAND (expression, 0)));
case '<':
case '2':
case tcc_comparison:
case tcc_binary:
return ((value_dependent_expression_p
(TREE_OPERAND (expression, 0)))
|| (value_dependent_expression_p
(TREE_OPERAND (expression, 1))));
case 'e':
case tcc_expression:
{
int i;
for (i = 0; i < first_rtl_op (TREE_CODE (expression)); ++i)
@ -11846,6 +11846,13 @@ value_dependent_expression_p (tree expression)
return true;
return false;
}
case tcc_reference:
case tcc_statement:
/* These cannot be value dependent. */
return false;
default:
gcc_unreachable ();
}
}

2
gcc/cp/semantics.c
View File

@ -1239,7 +1239,7 @@ finish_mem_initializers (tree mem_inits)
tree
finish_parenthesized_expr (tree expr)
{
if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (expr))))
if (EXPR_P (expr))
/* This inhibits warnings in c_common_truthvalue_conversion. */
TREE_NO_WARNING (expr) = 1;

21
gcc/cp/tree.c
View File

@ -1,6 +1,6 @@
/* Language-dependent node constructors for parse phase of GNU compiler.
Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
Hacked by Michael Tiemann (tiemann@cygnus.com)
This file is part of GCC.
@ -1554,12 +1554,12 @@ cp_tree_equal (tree t1, tree t2)
switch (TREE_CODE_CLASS (code1))
{
case '1':
case '2':
case '<':
case 'e':
case 'r':
case 's':
case tcc_unary:
case tcc_binary:
case tcc_comparison:
case tcc_expression:
case tcc_reference:
case tcc_statement:
{
int i;
@ -1570,11 +1570,12 @@ cp_tree_equal (tree t1, tree t2)
return true;
}
case 't':
case tcc_type:
return same_type_p (t1, t2);
default:
gcc_unreachable ();
}
gcc_unreachable ();
/* We can get here with --disable-checking. */
return false;
}

2
gcc/cp/typeck.c
View File

@ -4956,7 +4956,7 @@ build_c_cast (tree type, tree expr)
{
TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
if (TREE_CODE_CLASS (TREE_CODE (ovalue)) == 'c')
if (CONSTANT_CLASS_P (ovalue))
TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
}
}

8
gcc/dbxout.c
View File

@ -1318,7 +1318,7 @@ dbxout_type (tree type, int full)
|| TREE_CODE (type) == QUAL_UNION_TYPE
|| TREE_CODE (type) == ENUMERAL_TYPE)
&& TYPE_STUB_DECL (type)
&& TREE_CODE_CLASS (TREE_CODE (TYPE_STUB_DECL (type))) == 'd'
&& DECL_P (TYPE_STUB_DECL (type))
&& ! DECL_IGNORED_P (TYPE_STUB_DECL (type)))
debug_queue_symbol (TYPE_STUB_DECL (type));
else if (TYPE_NAME (type)
@ -2179,19 +2179,19 @@ dbxout_symbol (tree decl, int local ATTRIBUTE_UNUSED)
|| TREE_CODE (t) == ENUMERAL_TYPE)
&& TYPE_STUB_DECL (t)
&& TYPE_STUB_DECL (t) != decl
&& TREE_CODE_CLASS (TREE_CODE (TYPE_STUB_DECL (t))) == 'd'
&& DECL_P (TYPE_STUB_DECL (t))
&& ! DECL_IGNORED_P (TYPE_STUB_DECL (t)))
{
debug_queue_symbol (TYPE_STUB_DECL (t));
if (TYPE_NAME (t)
&& TYPE_NAME (t) != TYPE_STUB_DECL (t)
&& TYPE_NAME (t) != decl
&& TREE_CODE_CLASS (TREE_CODE (TYPE_NAME (t))) == 'd')
&& DECL_P (TYPE_NAME (t)))
debug_queue_symbol (TYPE_NAME (t));
}
else if (TYPE_NAME (t)
&& TYPE_NAME (t) != decl
&& TREE_CODE_CLASS (TREE_CODE (TYPE_NAME (t))) == 'd')
&& DECL_P (TYPE_NAME (t)))
debug_queue_symbol (TYPE_NAME (t));
}

7
gcc/dwarf2out.c
View File

@ -10918,7 +10918,7 @@ gen_formal_parameter_die (tree node, dw_die_ref context_die)
switch (TREE_CODE_CLASS (TREE_CODE (node)))
{
case 'd':
case tcc_declaration:
origin = decl_ultimate_origin (node);
if (origin != NULL)
add_abstract_origin_attribute (parm_die, origin);
@ -10939,7 +10939,7 @@ gen_formal_parameter_die (tree node, dw_die_ref context_die)
break;
case 't':
case tcc_type:
/* We were called with some kind of a ..._TYPE node. */
add_type_attribute (parm_die, node, 0, 0, context_die);
break;
@ -12417,7 +12417,8 @@ force_type_die (tree type)
static dw_die_ref
setup_namespace_context (tree thing, dw_die_ref context_die)
{
tree context = DECL_P (thing) ? DECL_CONTEXT (thing) : TYPE_CONTEXT (thing);
tree context = (DECL_P (thing)
? DECL_CONTEXT (thing) : TYPE_CONTEXT (thing));
if (context && TREE_CODE (context) == NAMESPACE_DECL)
/* Force out the namespace. */
context_die = force_decl_die (context);

2
gcc/emit-rtl.c
View File

@ -1592,7 +1592,7 @@ set_mem_attributes_minus_bitpos (rtx ref, tree t, int objectp,
}
/* If this is a constant, we know the alignment. */
else if (TREE_CODE_CLASS (TREE_CODE (t)) == 'c')
else if (CONSTANT_CLASS_P (t))
{
align = TYPE_ALIGN (type);
#ifdef CONSTANT_ALIGNMENT

34
gcc/expr.c
View File

@ -3527,7 +3527,7 @@ expand_assignment (tree to, tree from, int want_value)
src = from;
STRIP_NOPS (src);
if (TREE_CODE (TREE_TYPE (src)) != INTEGER_TYPE
|| TREE_CODE_CLASS (TREE_CODE (src)) != '2')
|| !BINARY_CLASS_P (src))
break;
op0 = TREE_OPERAND (src, 0);
@ -5755,14 +5755,14 @@ safe_from_p (rtx x, tree exp, int top_p)
/* Now look at our tree code and possibly recurse. */
switch (TREE_CODE_CLASS (TREE_CODE (exp)))
{
case 'd':
case tcc_declaration:
exp_rtl = DECL_RTL_IF_SET (exp);
break;
case 'c':
case tcc_constant:
return 1;
case 'x':
case tcc_exceptional:
if (TREE_CODE (exp) == TREE_LIST)
{
while (1)
@ -5781,7 +5781,7 @@ safe_from_p (rtx x, tree exp, int top_p)
else
return 0;
case 's':
case tcc_statement:
/* The only case we look at here is the DECL_INITIAL inside a
DECL_EXPR. */
return (TREE_CODE (exp) != DECL_EXPR
@ -5789,17 +5789,17 @@ safe_from_p (rtx x, tree exp, int top_p)
|| !DECL_INITIAL (DECL_EXPR_DECL (exp))
|| safe_from_p (x, DECL_INITIAL (DECL_EXPR_DECL (exp)), 0));
case '2':
case '<':
case tcc_binary:
case tcc_comparison:
if (!safe_from_p (x, TREE_OPERAND (exp, 1), 0))
return 0;
/* Fall through. */
case '1':
case tcc_unary:
return safe_from_p (x, TREE_OPERAND (exp, 0), 0);
case 'e':
case 'r':
case tcc_expression:
case tcc_reference:
/* Now do code-specific tests. EXP_RTL is set to any rtx we find in
the expression. If it is set, we conflict iff we are that rtx or
both are in memory. Otherwise, we check all operands of the
@ -5872,6 +5872,11 @@ safe_from_p (rtx x, tree exp, int top_p)
>= (unsigned int) LAST_AND_UNUSED_TREE_CODE
&& !lang_hooks.safe_from_p (x, exp))
return 0;
break;
case tcc_type:
/* Should never get a type here. */
gcc_unreachable ();
}
/* If we have an rtl, find any enclosed object. Then see if we conflict
@ -6068,7 +6073,7 @@ expand_expr_addr_expr_1 (tree exp, rtx target, enum machine_mode tmode,
generating ADDR_EXPR of something that isn't an LVALUE. The only
exception here is STRING_CST. */
if (TREE_CODE (exp) == CONSTRUCTOR
|| TREE_CODE_CLASS (TREE_CODE (exp)) == 'c')
|| CONSTANT_CLASS_P (exp))
return XEXP (output_constant_def (exp, 0), 0);
/* Everything must be something allowed by is_gimple_addressable. */
@ -6400,12 +6405,13 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode,
return const0_rtx;
}
if (TREE_CODE_CLASS (code) == '1' || code == COMPONENT_REF
|| code == INDIRECT_REF)
if (TREE_CODE_CLASS (code) == tcc_unary
|| code == COMPONENT_REF || code == INDIRECT_REF)
return expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode,
modifier);
else if (TREE_CODE_CLASS (code) == '2' || TREE_CODE_CLASS (code) == '<'
else if (TREE_CODE_CLASS (code) == tcc_binary
|| TREE_CODE_CLASS (code) == tcc_comparison
|| code == ARRAY_REF || code == ARRAY_RANGE_REF)
{
expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, modifier);

167
gcc/fold-const.c
View File

@ -2281,7 +2281,7 @@ combine_comparisons (enum tree_code code, enum tree_code lcode,
static int
truth_value_p (enum tree_code code)
{
return (TREE_CODE_CLASS (code) == '<'
return (TREE_CODE_CLASS (code) == tcc_comparison
|| code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR
|| code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR
|| code == TRUTH_XOR_EXPR || code == TRUTH_NOT_EXPR);
@ -2420,7 +2420,7 @@ operand_equal_p (tree arg0, tree arg1, unsigned int flags)
switch (TREE_CODE_CLASS (TREE_CODE (arg0)))
{
case '1':
case tcc_unary:
/* Two conversions are equal only if signedness and modes match. */
switch (TREE_CODE (arg0))
{
@ -2441,8 +2441,8 @@ operand_equal_p (tree arg0, tree arg1, unsigned int flags)
return operand_equal_p (TREE_OPERAND (arg0, 0),
TREE_OPERAND (arg1, 0), flags);
case '<':
case '2':
case tcc_comparison:
case tcc_binary:
if (operand_equal_p (TREE_OPERAND (arg0, 0),
TREE_OPERAND (arg1, 0), flags)
&& operand_equal_p (TREE_OPERAND (arg0, 1),
@ -2456,7 +2456,7 @@ operand_equal_p (tree arg0, tree arg1, unsigned int flags)
&& operand_equal_p (TREE_OPERAND (arg0, 1),
TREE_OPERAND (arg1, 0), flags));
case 'r':
case tcc_reference:
/* If either of the pointer (or reference) expressions we are
dereferencing contain a side effect, these cannot be equal. */
if (TREE_SIDE_EFFECTS (arg0)
@ -2503,7 +2503,7 @@ operand_equal_p (tree arg0, tree arg1, unsigned int flags)
return 0;
}
case 'e':
case tcc_expression:
switch (TREE_CODE (arg0))
{
case ADDR_EXPR:
@ -2570,7 +2570,7 @@ operand_equal_p (tree arg0, tree arg1, unsigned int flags)
return 0;
}
case 'd':
case tcc_declaration:
/* Consider __builtin_sqrt equal to sqrt. */
return (TREE_CODE (arg0) == FUNCTION_DECL
&& DECL_BUILT_IN (arg0) && DECL_BUILT_IN (arg1)
@ -2652,17 +2652,17 @@ static int
twoval_comparison_p (tree arg, tree *cval1, tree *cval2, int *save_p)
{
enum tree_code code = TREE_CODE (arg);
char class = TREE_CODE_CLASS (code);
enum tree_code_class class = TREE_CODE_CLASS (code);
/* We can handle some of the 'e' cases here. */
if (class == 'e' && code == TRUTH_NOT_EXPR)
class = '1';
else if (class == 'e'
/* We can handle some of the tcc_expression cases here. */
if (class == tcc_expression && code == TRUTH_NOT_EXPR)
class = tcc_unary;
else if (class == tcc_expression
&& (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR
|| code == COMPOUND_EXPR))
class = '2';
class = tcc_binary;
else if (class == 'e' && code == SAVE_EXPR
else if (class == tcc_expression && code == SAVE_EXPR
&& ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg, 0)))
{
/* If we've already found a CVAL1 or CVAL2, this expression is
@ -2670,24 +2670,24 @@ twoval_comparison_p (tree arg, tree *cval1, tree *cval2, int *save_p)
if (*cval1 || *cval2)
return 0;
class = '1';
class = tcc_unary;
*save_p = 1;
}
switch (class)
{
case '1':
case tcc_unary:
return twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p);
case '2':
case tcc_binary:
return (twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p)
&& twoval_comparison_p (TREE_OPERAND (arg, 1),
cval1, cval2, save_p));
case 'c':
case tcc_constant:
return 1;
case 'e':
case tcc_expression:
if (code == COND_EXPR)
return (twoval_comparison_p (TREE_OPERAND (arg, 0),
cval1, cval2, save_p)
@ -2697,7 +2697,7 @@ twoval_comparison_p (tree arg, tree *cval1, tree *cval2, int *save_p)
cval1, cval2, save_p));
return 0;
case '<':
case tcc_comparison:
/* First see if we can handle the first operand, then the second. For
the second operand, we know *CVAL1 can't be zero. It must be that
one side of the comparison is each of the values; test for the
@ -2745,30 +2745,30 @@ eval_subst (tree arg, tree old0, tree new0, tree old1, tree new1)
{
tree type = TREE_TYPE (arg);
enum tree_code code = TREE_CODE (arg);
char class = TREE_CODE_CLASS (code);
enum tree_code_class class = TREE_CODE_CLASS (code);
/* We can handle some of the 'e' cases here. */
if (class == 'e' && code == TRUTH_NOT_EXPR)
class = '1';
else if (class == 'e'
/* We can handle some of the tcc_expression cases here. */
if (class == tcc_expression && code == TRUTH_NOT_EXPR)
class = tcc_unary;
else if (class == tcc_expression
&& (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
class = '2';
class = tcc_binary;
switch (class)
{
case '1':
case tcc_unary:
return fold (build1 (code, type,
eval_subst (TREE_OPERAND (arg, 0),
old0, new0, old1, new1)));
case '2':
case tcc_binary:
return fold (build2 (code, type,
eval_subst (TREE_OPERAND (arg, 0),
old0, new0, old1, new1),
eval_subst (TREE_OPERAND (arg, 1),
old0, new0, old1, new1)));
case 'e':
case tcc_expression:
switch (code)
{
case SAVE_EXPR:
@ -2790,7 +2790,7 @@ eval_subst (tree arg, tree old0, tree new0, tree old1, tree new1)
}
/* Fall through - ??? */
case '<':
case tcc_comparison:
{
tree arg0 = TREE_OPERAND (arg, 0);
tree arg1 = TREE_OPERAND (arg, 1);
@ -2890,7 +2890,7 @@ invert_truthvalue (tree arg)
floating-point non-equality comparisons, in which case we just
enclose a TRUTH_NOT_EXPR around what we have. */
if (TREE_CODE_CLASS (code) == '<')
if (TREE_CODE_CLASS (code) == tcc_comparison)
{
tree op_type = TREE_TYPE (TREE_OPERAND (arg, 0));
if (FLOAT_TYPE_P (op_type)
@ -3413,7 +3413,7 @@ simple_operand_p (tree exp)
== TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))))
exp = TREE_OPERAND (exp, 0);
return (TREE_CODE_CLASS (TREE_CODE (exp)) == 'c'
return (CONSTANT_CLASS_P (exp)
|| (DECL_P (exp)
&& ! TREE_ADDRESSABLE (exp)
&& ! TREE_THIS_VOLATILE (exp)
@ -3484,7 +3484,7 @@ range_binop (enum tree_code code, tree type, tree arg0, int upper0_p,
return TREE_CODE (tem) == INTEGER_CST ? tem : 0;
}
if (TREE_CODE_CLASS (code) != '<')
if (TREE_CODE_CLASS (code) != tcc_comparison)
return 0;
/* Set SGN[01] to -1 if ARG[01] is a lower bound, 1 for upper, and 0
@ -3555,13 +3555,13 @@ make_range (tree exp, int *pin_p, tree *plow, tree *phigh)
{
if (first_rtl_op (code) > 0)
arg0 = TREE_OPERAND (exp, 0);
if (TREE_CODE_CLASS (code) == '<'
|| TREE_CODE_CLASS (code) == '1'
|| TREE_CODE_CLASS (code) == '2')
if (TREE_CODE_CLASS (code) == tcc_comparison
|| TREE_CODE_CLASS (code) == tcc_unary
|| TREE_CODE_CLASS (code) == tcc_binary)
arg0_type = TREE_TYPE (arg0);
if (TREE_CODE_CLASS (code) == '2'
|| TREE_CODE_CLASS (code) == '<'
|| (TREE_CODE_CLASS (code) == 'e'
if (TREE_CODE_CLASS (code) == tcc_binary
|| TREE_CODE_CLASS (code) == tcc_comparison
|| (TREE_CODE_CLASS (code) == tcc_expression
&& TREE_CODE_LENGTH (code) > 1))
arg1 = TREE_OPERAND (exp, 1);
}
@ -4192,7 +4192,7 @@ fold_cond_expr_with_comparison (tree type, tree arg0, tree arg1, tree arg2)
tem = fold (build1 (ABS_EXPR, TREE_TYPE (arg1), arg1));
return negate_expr (fold_convert (type, tem));
default:
gcc_assert (TREE_CODE_CLASS (comp_code) == '<');
gcc_assert (TREE_CODE_CLASS (comp_code) == tcc_comparison);
break;
}
@ -4296,7 +4296,7 @@ fold_cond_expr_with_comparison (tree type, tree arg0, tree arg1, tree arg2)
return pedantic_non_lvalue (fold_convert (type, arg1));
break;
default:
gcc_assert (TREE_CODE_CLASS (comp_code) == '<');
gcc_assert (TREE_CODE_CLASS (comp_code) == tcc_comparison);
break;
}
}
@ -4569,7 +4569,8 @@ fold_truthop (enum tree_code code, tree truth_type, tree lhs, tree rhs)
rcode = NE_EXPR;
}
if (TREE_CODE_CLASS (lcode) != '<' || TREE_CODE_CLASS (rcode) != '<')
if (TREE_CODE_CLASS (lcode) != tcc_comparison
|| TREE_CODE_CLASS (rcode) != tcc_comparison)
return 0;
ll_arg = TREE_OPERAND (lhs, 0);
@ -5073,10 +5074,10 @@ extract_muldiv_1 (tree t, tree c, enum tree_code code, tree wide_type)
if (integer_zerop (c))
return NULL_TREE;
if (TREE_CODE_CLASS (tcode) == '1')
if (TREE_CODE_CLASS (tcode) == tcc_unary)
op0 = TREE_OPERAND (t, 0);
if (TREE_CODE_CLASS (tcode) == '2')
if (TREE_CODE_CLASS (tcode) == tcc_binary)
op0 = TREE_OPERAND (t, 0), op1 = TREE_OPERAND (t, 1);
/* Note that we need not handle conditional operations here since fold
@ -5094,10 +5095,10 @@ extract_muldiv_1 (tree t, tree c, enum tree_code code, tree wide_type)
case CONVERT_EXPR: case NON_LVALUE_EXPR: case NOP_EXPR:
/* If op0 is an expression ... */
if ((TREE_CODE_CLASS (TREE_CODE (op0)) == '<'
|| TREE_CODE_CLASS (TREE_CODE (op0)) == '1'
|| TREE_CODE_CLASS (TREE_CODE (op0)) == '2'
|| TREE_CODE_CLASS (TREE_CODE (op0)) == 'e')
if ((COMPARISON_CLASS_P (op0)
|| UNARY_CLASS_P (op0)
|| BINARY_CLASS_P (op0)
|| EXPRESSION_CLASS_P (op0))
/* ... and is unsigned, and its type is smaller than ctype,
then we cannot pass through as widening. */
&& ((TYPE_UNSIGNED (TREE_TYPE (op0))
@ -5990,14 +5991,14 @@ fold (tree expr)
tree tem;
tree arg0 = NULL_TREE, arg1 = NULL_TREE;
enum tree_code code = TREE_CODE (t);
int kind = TREE_CODE_CLASS (code);
enum tree_code_class kind = TREE_CODE_CLASS (code);
/* WINS will be nonzero when the switch is done
if all operands are constant. */
int wins = 1;
/* Return right away if a constant. */
if (kind == 'c')
if (kind == tcc_constant)
return t;
if (code == NOP_EXPR || code == FLOAT_EXPR || code == CONVERT_EXPR)
@ -6046,7 +6047,7 @@ fold (tree expr)
of the arguments so that their form can be studied. In any
cases, the appropriate type conversions should be put back in
the tree that will get out of the constant folder. */
if (kind == '<')
if (kind == tcc_comparison)
STRIP_SIGN_NOPS (op);
else
STRIP_NOPS (op);
@ -6118,7 +6119,7 @@ fold (tree expr)
return tem;
}
if (TREE_CODE_CLASS (code) == '1')
if (TREE_CODE_CLASS (code) == tcc_unary)
{
if (TREE_CODE (arg0) == COMPOUND_EXPR)
return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
@ -6165,7 +6166,7 @@ fold (tree expr)
TREE_OPERAND (TREE_OPERAND (tem, 2), 0)));
return tem;
}
else if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<')
else if (COMPARISON_CLASS_P (arg0))
{
if (TREE_CODE (type) == BOOLEAN_TYPE)
{
@ -6181,16 +6182,16 @@ fold (tree expr)
integer_zero_node))));
}
}
else if (TREE_CODE_CLASS (code) == '<'
else if (TREE_CODE_CLASS (code) == tcc_comparison
&& TREE_CODE (arg0) == COMPOUND_EXPR)
return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
fold (build2 (code, type, TREE_OPERAND (arg0, 1), arg1)));
else if (TREE_CODE_CLASS (code) == '<'
else if (TREE_CODE_CLASS (code) == tcc_comparison
&& TREE_CODE (arg1) == COMPOUND_EXPR)
return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
fold (build2 (code, type, arg0, TREE_OPERAND (arg1, 1))));
else if (TREE_CODE_CLASS (code) == '2'
|| TREE_CODE_CLASS (code) == '<')
else if (TREE_CODE_CLASS (code) == tcc_binary
|| TREE_CODE_CLASS (code) == tcc_comparison)
{
if (TREE_CODE (arg0) == COMPOUND_EXPR)
return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
@ -6202,8 +6203,7 @@ fold (tree expr)
fold (build2 (code, type,
arg0, TREE_OPERAND (arg1, 1))));
if (TREE_CODE (arg0) == COND_EXPR
|| TREE_CODE_CLASS (TREE_CODE (arg0)) == '<')
if (TREE_CODE (arg0) == COND_EXPR || COMPARISON_CLASS_P (arg0))
{
tem = fold_binary_op_with_conditional_arg (code, type, arg0, arg1,
/*cond_first_p=*/1);
@ -6211,8 +6211,7 @@ fold (tree expr)
return tem;
}
if (TREE_CODE (arg1) == COND_EXPR
|| TREE_CODE_CLASS (TREE_CODE (arg1)) == '<')
if (TREE_CODE (arg1) == COND_EXPR || COMPARISON_CLASS_P (arg1))
{
tem = fold_binary_op_with_conditional_arg (code, type, arg1, arg0,
/*cond_first_p=*/0);
@ -6382,7 +6381,7 @@ fold (tree expr)
/* Convert (T1)((T2)X op Y) into (T1)X op Y, for pointer types T1 and
T2 being pointers to types of the same size. */
if (POINTER_TYPE_P (TREE_TYPE (t))
&& TREE_CODE_CLASS (TREE_CODE (arg0)) == '2'
&& BINARY_CLASS_P (arg0)
&& TREE_CODE (TREE_OPERAND (arg0, 0)) == NOP_EXPR
&& POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (arg0, 0))))
{
@ -8772,7 +8771,7 @@ fold (tree expr)
for reasons given above each one.
Also try swapping the arguments and inverting the conditional. */
if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
if (COMPARISON_CLASS_P (arg0)
&& operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
arg1, TREE_OPERAND (arg0, 1))
&& !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg1))))
@ -8784,14 +8783,14 @@ fold (tree expr)
return tem;
}
if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
if (COMPARISON_CLASS_P (arg0)
&& operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
TREE_OPERAND (t, 2),
TREE_OPERAND (arg0, 1))
&& !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (t, 2)))))
{
tem = invert_truthvalue (arg0);
if (TREE_CODE_CLASS (TREE_CODE (tem)) == '<')
if (COMPARISON_CLASS_P (tem))
{
tem = fold_cond_expr_with_comparison (type, tem,
TREE_OPERAND (t, 2),
@ -9055,14 +9054,15 @@ fold_checksum_tree (tree expr, struct md5_ctx *ctx, htab_t ht)
return;
*slot = expr;
code = TREE_CODE (expr);
if (TREE_CODE_CLASS (code) == 'd' && DECL_ASSEMBLER_NAME_SET_P (expr))
if (TREE_CODE_CLASS (code) == tcc_declaration
&& DECL_ASSEMBLER_NAME_SET_P (expr))
{
/* Allow DECL_ASSEMBLER_NAME to be modified. */
memcpy (buf, expr, tree_size (expr));
expr = (tree) buf;
SET_DECL_ASSEMBLER_NAME (expr, NULL);
}
else if (TREE_CODE_CLASS (code) == 't'
else if (TREE_CODE_CLASS (code) == tcc_type
&& (TYPE_POINTER_TO (expr) || TYPE_REFERENCE_TO (expr)
|| TYPE_CACHED_VALUES_P (expr)))
{
@ -9076,11 +9076,12 @@ fold_checksum_tree (tree expr, struct md5_ctx *ctx, htab_t ht)
}
md5_process_bytes (expr, tree_size (expr), ctx);
fold_checksum_tree (TREE_TYPE (expr), ctx, ht);
if (TREE_CODE_CLASS (code) != 't' && TREE_CODE_CLASS (code) != 'd')
if (TREE_CODE_CLASS (code) != tcc_type
&& TREE_CODE_CLASS (code) != tcc_declaration)
fold_checksum_tree (TREE_CHAIN (expr), ctx, ht);
switch (TREE_CODE_CLASS (code))
{
case 'c':
case tcc_constant:
switch (code)
{
case STRING_CST:
@ -9098,7 +9099,7 @@ fold_checksum_tree (tree expr, struct md5_ctx *ctx, htab_t ht)
break;
}
break;
case 'x':
case tcc_exceptional:
switch (code)
{
case TREE_LIST:
@ -9113,17 +9114,17 @@ fold_checksum_tree (tree expr, struct md5_ctx *ctx, htab_t ht)
break;
}
break;
case 'e':
case 'r':
case '<':
case '1':
case '2':
case 's':
case tcc_expression:
case tcc_reference:
case tcc_comparison:
case tcc_unary:
case tcc_binary:
case tcc_statement:
len = first_rtl_op (code);
for (i = 0; i < len; ++i)
fold_checksum_tree (TREE_OPERAND (expr, i), ctx, ht);
break;
case 'd':
case tcc_declaration:
fold_checksum_tree (DECL_SIZE (expr), ctx, ht);
fold_checksum_tree (DECL_SIZE_UNIT (expr), ctx, ht);
fold_checksum_tree (DECL_NAME (expr), ctx, ht);
@ -9136,7 +9137,7 @@ fold_checksum_tree (tree expr, struct md5_ctx *ctx, htab_t ht)
fold_checksum_tree (DECL_ATTRIBUTES (expr), ctx, ht);
fold_checksum_tree (DECL_VINDEX (expr), ctx, ht);
break;
case 't':
case tcc_type:
if (TREE_CODE (expr) == ENUMERAL_TYPE)
fold_checksum_tree (TYPE_VALUES (expr), ctx, ht);
fold_checksum_tree (TYPE_SIZE (expr), ctx, ht);
@ -9630,7 +9631,7 @@ tree_expr_nonzero_p (tree t)
return !DECL_WEAK (base);
/* Constants are never weak. */
if (TREE_CODE_CLASS (TREE_CODE (base)) == 'c')
if (CONSTANT_CLASS_P (base))
return true;
return false;
@ -10554,12 +10555,12 @@ fold_ignored_result (tree t)
for (;;)
switch (TREE_CODE_CLASS (TREE_CODE (t)))
{
case '1':
case tcc_unary:
t = TREE_OPERAND (t, 0);
break;
case '2':
case '<':
case tcc_binary:
case tcc_comparison:
if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)))
t = TREE_OPERAND (t, 0);
else if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 0)))
@ -10568,7 +10569,7 @@ fold_ignored_result (tree t)
return t;
break;
case 'e':
case tcc_expression:
switch (TREE_CODE (t))
{
case COMPOUND_EXPR:

136
gcc/fortran/ChangeLog
View File

@ -1,3 +1,9 @@
2004-09-17 Jeffrey D. Oldham <oldham@codesourcery.com>
Zack Weinberg <zack@codesourcery.com>
* f95-lang.c, trans-expr.c, trans.c: Update for new tree-class
enumeration constants.
2004-09-17 Paul Brook <paul@codesourcery.com>
* gfortran.h (struct gfc_linebuf): Don't use C99 empty arrays.
@ -312,30 +318,30 @@
2004-08-26 Richard Henderson <rth@redhat.com>
* arith.c: Include system.h, not real system headers.
(MPZ_NULL, MPF_NULL, DEF_GFC_INTEGER_KIND, DEF_GFC_LOGICAL_KIND,
DEF_GFC_REAL_KIND, GFC_SP_KIND, GFC_SP_PREC, GFC_SP_EMIN, GFC_SP_EMAX,
GFC_DP_KIND, GFC_DP_PREC, GFC_DP_EMIN, GFC_DP_EMAX, GFC_QP_KIND,
GFC_QP_PREC, GFC_QP_EMIN, GFC_QP_EMAX): Remove.
(gfc_integer_kinds, gfc_logical_kinds, gfc_real_kinds,
gfc_index_integer_kind, gfc_default_integer_kind,
gfc_default_real_kind,gfc_default_double_kind,
gfc_default_character_kind, gfc_default_logical_kind,
gfc_default_complex_kind, validate_integer, validate_real,
validate_logical, validate_character,
gfc_validate_kind): Move to trans-types.c.
(gfc_set_model_kind): Use gfc_validate_kind.
(gfc_set_model): Just copy the current precision to default.
(gfc_arith_init_1): Use mpfr precision 128 for integer setup.
* f95-lang.c (gfc_init_decl_processing): Invoke gfc_init_kinds.
* gfortran.h: Update file commentary.
* trans-types.c (MAX_INT_KINDS, MAX_REAL_KINDS): New.
(gfc_default_integer_kind_1, gfc_default_real_kind_1,
gfc_default_double_kind_1, gfc_default_character_kind_1,
gfc_default_logical_kind_1, gfc_default_complex_kind_1): New.
(gfc_init_kinds): New.
(gfc_init_types): Don't set gfc_index_integer_kind here.
* trans-types.h (gfc_init_kinds): Declare.
* arith.c: Include system.h, not real system headers.
(MPZ_NULL, MPF_NULL, DEF_GFC_INTEGER_KIND, DEF_GFC_LOGICAL_KIND,
DEF_GFC_REAL_KIND, GFC_SP_KIND, GFC_SP_PREC, GFC_SP_EMIN, GFC_SP_EMAX,
GFC_DP_KIND, GFC_DP_PREC, GFC_DP_EMIN, GFC_DP_EMAX, GFC_QP_KIND,
GFC_QP_PREC, GFC_QP_EMIN, GFC_QP_EMAX): Remove.
(gfc_integer_kinds, gfc_logical_kinds, gfc_real_kinds,
gfc_index_integer_kind, gfc_default_integer_kind,
gfc_default_real_kind,gfc_default_double_kind,
gfc_default_character_kind, gfc_default_logical_kind,
gfc_default_complex_kind, validate_integer, validate_real,
validate_logical, validate_character,
gfc_validate_kind): Move to trans-types.c.
(gfc_set_model_kind): Use gfc_validate_kind.
(gfc_set_model): Just copy the current precision to default.
(gfc_arith_init_1): Use mpfr precision 128 for integer setup.
* f95-lang.c (gfc_init_decl_processing): Invoke gfc_init_kinds.
* gfortran.h: Update file commentary.
* trans-types.c (MAX_INT_KINDS, MAX_REAL_KINDS): New.
(gfc_default_integer_kind_1, gfc_default_real_kind_1,
gfc_default_double_kind_1, gfc_default_character_kind_1,
gfc_default_logical_kind_1, gfc_default_complex_kind_1): New.
(gfc_init_kinds): New.
(gfc_init_types): Don't set gfc_index_integer_kind here.
* trans-types.h (gfc_init_kinds): Declare.
* doc/invoke.texi: Clarify DOUBLE PRECISION behaviour wrt -r8.
2004-08-26 Tobias Schlueter <tobias.schlueter@physik.uni-muenchen.de>
@ -422,7 +428,7 @@
build.
* trans-array.c (gfc_conv_descriptor_data,
gfc_conv_descriptor_offset, gfc_conv_descriptor_dimension,
gfc_conv_descriptor_stride, gfc_conv_descriptor_lbound,
gfc_conv_descriptor_stride, gfc_conv_descriptor_lbound,
gfc_conv_descriptor_ubound, gfc_trans_allocate_array_storage,
gfc_trans_allocate_temp_array,
gfc_trans_array_constructor_subarray,
@ -480,7 +486,7 @@
2004-08-25 Tobias Schlueter <tobias.schlueter@physik.uni-muenchen.de>
* trans-const.c (gfc_conv_mpz_to_tree): Change call to
* trans-const.c (gfc_conv_mpz_to_tree): Change call to
build_int_cst to build_int_cst_wide in accordance to Nathan's
previous patch.
@ -503,7 +509,7 @@
2004-08-24 Tobias Schlueter <tobias.schlueter@physik.uni-muenchen.de>
* trans-decl.c, trans-types.c: Add and remove blank lines as
* trans-decl.c, trans-types.c: Add and remove blank lines as
required.
2004-08-24 Richard Henderson <rth@redhat.com>
@ -512,9 +518,9 @@
2004-08-24 Tobias Schlueter <tobias.schlueter@physik.uni-muenchen.de>
* resolve.c (merge_argument_lists): Revert unintentionally
* resolve.c (merge_argument_lists): Revert unintentionally
committed change.
2004-08-24 Tobias Schlueter <tobias.schlueter@physik.uni-muenchen.de>
* trans-decl.c (build_function_decl): Fix spelling in comment.
@ -545,15 +551,15 @@
2004-08-22 Richard Henderson <rth@redhat.com>
PR 13465
* data.c (find_con_by_offset): Search ordered list; handle
elements with repeat counts.
(gfc_assign_data_value_range): New.
* gfortran.h (struct gfc_data_value): Make repeat unsigned.
(gfc_assign_data_value_range): Declare.
* match.c (top_val_list): Extract repeat count into a temporary.
* resolve.c (values): Make left unsigned.
(next_data_value): Don't decrement left.
(check_data_variable): Use gfc_assign_data_value_range.
* data.c (find_con_by_offset): Search ordered list; handle
elements with repeat counts.
(gfc_assign_data_value_range): New.
* gfortran.h (struct gfc_data_value): Make repeat unsigned.
(gfc_assign_data_value_range): Declare.
* match.c (top_val_list): Extract repeat count into a temporary.
* resolve.c (values): Make left unsigned.
(next_data_value): Don't decrement left.
(check_data_variable): Use gfc_assign_data_value_range.
2004-08-22 Tobias Schlueter <tobias.schlueter@physik.uni-muenchen.de>
@ -1416,7 +1422,7 @@
unused variables if they're use associated.
2004-06-14 Tobias Schlueter <tobias.schlueter@physik.uni-muenchen.de>
Andrew Vaught <andyv@firstinter.net>
Andrew Vaught <andyv@firstinter.net>
PR fortran/14928
* gfortran.h (gfc_check_f): Add new field f3ml.
@ -1769,7 +1775,7 @@
2004-05-17 Steve Kargl <kargls@comcast.net>
* arith.c (gfc_real2complex): Range checking wrong part of complex
number.
number.
2004-05-16 Paul Brook <paul@codesourcery.com>
@ -1911,15 +1917,15 @@
2004-05-14 Tobias Schlueter <tobias.schlueter@physik.uni-muenchen.de>
PR fortran/14066
PR fortran/14066
* match.c (gfc_match_do): Allow infinite loops with
label-do-stmt. Do not enforce space after comma.
2004-05-14 Tobias Schlueter <tobias.schlueter@physik.uni-muenchen.de>
PR fortran/15051
PR fortran/15051
* parse.c (parse_interface): Allow empty INTERFACE, remove
seen_body.
seen_body.
2004-05-14 Tobias Schlueter <tobias.schlueter@physik.uni-muenchen.de>
@ -1941,7 +1947,7 @@
PR fortran/14568
* trans-decl.c (generate_local_decl): Don't warn for unused
variables which are in common blocks.
variables which are in common blocks.
2004-05-13 Diego Novillo <dnovillo@redhat.com>
@ -2166,9 +2172,9 @@
2004-03-24 Bud Davis <bdavis9659@comcast.net>
PR 14055
PR 14055
* arith.c (gfc_convert_integer,gfc_convert_real): Removed leading '+'
before conversion by gmp library call.
before conversion by gmp library call.
2004-03-24 Bud Davis <bdavis9659@comcast.net>
@ -3103,8 +3109,8 @@
* lang-options.h: Remove.
2003-07-23 Arnaud Desitter <arnaud.desitter@geography.oxford.ac.uk>
* iresolve.c (g95_resolve_transpose): Proper variable in switch.
* simplify.c (g95_simplify_nearest): Fix typo and use a correct test
* iresolve.c (g95_resolve_transpose): Proper variable in switch.
* simplify.c (g95_simplify_nearest): Fix typo and use a correct test
on kind.
2003-07-22 Steven Bosscher <steven@gcc.gnu.org>
@ -3749,21 +3755,21 @@
2003-04-10 Canqun Yang <canqun@yahoo.com.cn>
* trans-stmt.c (g95_trans_forall): Implement WHERE inside FORALL.
(g95_trans_forall_body): New function.
* trans-stmt.c (g95_trans_forall): Implement WHERE inside FORALL.
(g95_trans_forall_body): New function.
2003-04-10 Canqun Yang <canqun@yahoo.com.cn>
* resolve.c (resove_where): New function.
(resolve_where_shape): New function.
(resolve_code): Add call to 'resolve_where'
* trans-stmt.c (g95_trans_where): Modified.
(g95_trans_where_2): New function.
(g95_trans_where_assign): New function.
(g95_evaluate_where_mask): New function.
(g95_add_to_stmt_list): New function.
(g95_get_temp_expr): New function.
* trans.h (where_stmt_list): New structure.
* resolve.c (resove_where): New function.
(resolve_where_shape): New function.
(resolve_code): Add call to 'resolve_where'
* trans-stmt.c (g95_trans_where): Modified.
(g95_trans_where_2): New function.
(g95_trans_where_assign): New function.
(g95_evaluate_where_mask): New function.
(g95_add_to_stmt_list): New function.
(g95_get_temp_expr): New function.
* trans.h (where_stmt_list): New structure.
2003-04-10 Paul Brook <paul@nowt.org>
@ -3851,7 +3857,7 @@
* arith.c (validate_logical), g95.h, options.c (g95_init_options):
Remove option l1.
* g95.h, intrinsic.c(g95_get_intrinsic_sub_symbol): Add const.
* g95.h, intrinsic.c(g95_get_intrinsic_sub_symbol): Add const.
* iresolve.c(g95_resolve_cpu_time, g95_resolve_random_number): Add
const.
* lang-options.h: Remove -finline-repack-arrays. Add -fg77-calls.
@ -4092,7 +4098,7 @@
2003-02-05 Toon Moene <toon@moene.indiv.nluug.nl>
* lang-options.h: Fix warning involving C90 concatenated
strings.
strings.
2003-02-06 Steven Bosscher <s.bosscher@student.tudelft.nl>
Arnaud Desitter <arnaud.desitter@geography.oxford.ac.uk>
@ -4178,7 +4184,7 @@
2003-01-28 Steven Bosscher <s.bosscher@student.tudelft.n>
* Make-lang.in: Don't build with broken tree-ssa-pre.
* Make-lang.in: Don't build with broken tree-ssa-pre.
2003-01-28 Steven Bosscher <s.bosscher@student.tudelft.nl>
@ -4515,7 +4521,7 @@
2003-01-10 Steven Bosscher <s.bosscher@student.tudelft.nl>
* dump-parse-tree.c (g95_show_namespace): Fixed another
* dump-parse-tree.c (g95_show_namespace): Fixed another
typo. Sorry, it's Friday...
2003-01-10 Steven Bosscher <s.bosscher@student.tudelft.nl>
@ -5018,7 +5024,7 @@
2002-09-01 Toon Moene <toon@moene.indiv.nluug.nl>
* g95_conv_mpz_to_tree: Free storage pointed to by q,
not by buff.
not by buff.
2002-08-30 Paul Brook <paul@nowt.org>

4
gcc/fortran/f95-lang.c
View File

@ -153,7 +153,7 @@ const struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
#define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
const char tree_code_type[] = {
const enum tree_code_class tree_code_type[] = {
#include "tree.def"
};
#undef DEFTREECODE
@ -221,7 +221,7 @@ gfc_truthvalue_conversion (tree expr)
case BOOLEAN_TYPE:
if (TREE_TYPE (expr) == boolean_type_node)
return expr;
else if (TREE_CODE_CLASS (TREE_CODE (expr)) == '<')
else if (COMPARISON_CLASS_P (expr))
{
TREE_TYPE (expr) = boolean_type_node;
return expr;

2
gcc/fortran/trans-expr.c
View File

@ -107,7 +107,7 @@ gfc_make_safe_expr (gfc_se * se)
{
tree var;
if (TREE_CODE_CLASS (TREE_CODE (se->expr)) == 'c')
if (CONSTANT_CLASS_P (se->expr))
return;
/* We need a temporary for this result. */

2
gcc/fortran/trans.c
View File

@ -127,7 +127,7 @@ gfc_evaluate_now (tree expr, stmtblock_t * pblock)
{
tree var;
if (TREE_CODE_CLASS (TREE_CODE (expr)) == 'c')
if (CONSTANT_CLASS_P (expr))
return expr;
var = gfc_create_var (TREE_TYPE (expr), NULL);

28
gcc/gimplify.c
View File

@ -562,9 +562,7 @@ should_carry_locus_p (tree stmt)
static void
annotate_one_with_locus (tree t, location_t locus)
{
if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (t)))
&& ! EXPR_HAS_LOCATION (t)
&& should_carry_locus_p (t))
if (EXPR_P (t) && ! EXPR_HAS_LOCATION (t) && should_carry_locus_p (t))
SET_EXPR_LOCATION (t, locus);
}
@ -599,9 +597,9 @@ mostly_copy_tree_r (tree *tp, int *walk_subtrees, void *data)
{
enum tree_code code = TREE_CODE (*tp);
/* Don't unshare types, decls, constants and SAVE_EXPR nodes. */
if (TREE_CODE_CLASS (code) == 't'
|| TREE_CODE_CLASS (code) == 'd'
|| TREE_CODE_CLASS (code) == 'c'
if (TREE_CODE_CLASS (code) == tcc_type
|| TREE_CODE_CLASS (code) == tcc_declaration
|| TREE_CODE_CLASS (code) == tcc_constant
|| code == SAVE_EXPR || code == TARGET_EXPR
/* We can't do anything sensible with a BLOCK used as an expression,
but we also can't abort when we see it because of non-expression
@ -637,9 +635,9 @@ copy_if_shared_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
types and the bounds of types. Mark them as visited so we properly
unmark their subtrees on the unmark pass. If we've already seen them,
don't look down further. */
if (TREE_CODE_CLASS (code) == 't'
|| TREE_CODE_CLASS (code) == 'd'
|| TREE_CODE_CLASS (code) == 'c')
if (TREE_CODE_CLASS (code) == tcc_type
|| TREE_CODE_CLASS (code) == tcc_declaration
|| TREE_CODE_CLASS (code) == tcc_constant)
{
if (TREE_VISITED (t))
*walk_subtrees = 0;
@ -2319,7 +2317,7 @@ gimplify_init_ctor_preeval_1 (tree *tp, int *walk_subtrees, void *xdata)
&& alias_sets_conflict_p (data->lhs_alias_set, get_alias_set (t)))
return t;
if (DECL_P (t) || TYPE_P (t))
if (IS_TYPE_OR_DECL_P (t))
*walk_subtrees = 0;
return NULL;
}
@ -3872,7 +3870,7 @@ gimplify_expr (tree *expr_p, tree *pre_p, tree *post_p,
default:
switch (TREE_CODE_CLASS (TREE_CODE (*expr_p)))
{
case '<':
case tcc_comparison:
/* If this is a comparison of objects of aggregate type,
handle it specially (by converting to a call to
memcmp). It would be nice to only have to do this
@ -3886,12 +3884,12 @@ gimplify_expr (tree *expr_p, tree *pre_p, tree *post_p,
/* If *EXPR_P does not need to be special-cased, handle it
according to its class. */
case '1':
case tcc_unary:
ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
post_p, is_gimple_val, fb_rvalue);
break;
case '2':
case tcc_binary:
expr_2:
{
enum gimplify_status r0, r1;
@ -3905,8 +3903,8 @@ gimplify_expr (tree *expr_p, tree *pre_p, tree *post_p,
break;
}
case 'd':
case 'c':
case tcc_declaration:
case tcc_constant:
ret = GS_ALL_DONE;
goto dont_recalculate;

14
gcc/java/ChangeLog
View File

@ -1,3 +1,11 @@
2004-09-17 Jeffrey D. Oldham <oldham@codesourcery.com>
Zack Weinberg <zack@codesourcery.com>
* java-tree.def: Use tree_code_class enumeration constants
instead of code letters.
* java-gimplify.c, jcf-write.c, lang.c, parse.y: Update for
new tree-class enumeration constants.
2004-09-13 Tom Tromey <tromey@redhat.com>
PR java/17216:
@ -131,7 +139,7 @@
* class.c (build_utf8_ref, build_static_field_ref,
make_field_value, make_method_value, get_dispatch_table,
make_class_data, emit_symbol_table, emit_catch_table): Likewise.
* constants.c (get_tag_node, build_ref_from_constant_pool,
* constants.c (get_tag_node, build_ref_from_constant_pool,
build_constants_constructor): Likewise.
* decl.c (java_init_decl_processing): Likewise.
* expr.c (build_java_array_length_access, build_newarray,
@ -627,7 +635,7 @@
set_nested_class_simple_name_value.
2004-06-22 Andrew Haley <aph@redhat.com>
Ranjit Mathew <rmathew@hotmail.com>
Ranjit Mathew <rmathew@hotmail.com>
Fixes PR java/16113.
* decl.c (force_poplevels): Remove call to expand_end_bindings.
@ -699,7 +707,7 @@
of unordered conditionals. Add comment.
2004-05-29 Ranjit Mathew <rmathew@hotmail.com>
Per Bothner <per@bothner.com>
Per Bothner <per@bothner.com>
* java-tree.h (DECL_LOCAL_FINAL_IUD): New macro to test if a
local variable was initialised upon declaration.

3
gcc/java/java-gimplify.c
View File

@ -141,7 +141,8 @@ java_gimplify_expr (tree *expr_p, tree *pre_p ATTRIBUTE_UNUSED,
Parameter lists, maybe? Or perhaps that's unnecessary because
the front end already generates SAVE_EXPRs. */
if (TREE_CODE_CLASS (code) == '2' || TREE_CODE_CLASS (code) == '<')
if (TREE_CODE_CLASS (code) == tcc_binary
|| TREE_CODE_CLASS (code) == tcc_comparison)
{
enum gimplify_status stat
= gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,

44
gcc/java/java-tree.def
View File

@ -1,33 +1,34 @@
/* Shift right, logical. */
DEFTREECODE (URSHIFT_EXPR, "urshift_expr", '2', 2)
DEFTREECODE (URSHIFT_EXPR, "urshift_expr", tcc_binary, 2)
/* Return -1, 0, 1 depending on whether the first argument is
less, equal, or greater to the second argument. */
DEFTREECODE (COMPARE_EXPR, "compare_expr", '2', 2)
DEFTREECODE (COMPARE_EXPR, "compare_expr", tcc_binary, 2)
/* Same as COMPARE_EXPR, but if either value is NaN, the result is -1. */
DEFTREECODE (COMPARE_L_EXPR, "compare_l_expr", '2', 2)
DEFTREECODE (COMPARE_L_EXPR, "compare_l_expr", tcc_binary, 2)
/* Same as COMPARE_EXPR, but if either value is NaN, the result is 1. */
DEFTREECODE (COMPARE_G_EXPR, "compare_g_expr", '2', 2)
DEFTREECODE (COMPARE_G_EXPR, "compare_g_expr", tcc_binary, 2)
/* Unary plus. Operand 0 is the expression the unary plus is applied
to */
DEFTREECODE (UNARY_PLUS_EXPR, "unary_plus_expr", '1', 1)
DEFTREECODE (UNARY_PLUS_EXPR, "unary_plus_expr", tcc_unary, 1)
/* New array creation expression.
Operand 0 is the array base type.
Operand 1 is the list of dimension expressions.
Operand 2 is the number of other dimensions of unspecified range.
Once patched, the node will bear the type of the created array. */
DEFTREECODE (NEW_ARRAY_EXPR, "new_array_expr", 'e', 3)
DEFTREECODE (NEW_ARRAY_EXPR, "new_array_expr", tcc_expression, 3)
/* New anonymous array creation expression.
Operand 0 is the base type of the anonymous array.
Operand 1 is the signature of the dimensions this array contains.
Operand 2 is the anonymous array initializer.
Once patched, the node will bear the type of the created array. */
DEFTREECODE (NEW_ANONYMOUS_ARRAY_EXPR, "new_anonymous_array", 'e', 3)
DEFTREECODE (NEW_ANONYMOUS_ARRAY_EXPR, "new_anonymous_array",
tcc_expression, 3)
/* New class creation expression.
Operand 0 is the name of the class to be created
@ -35,68 +36,69 @@ DEFTREECODE (NEW_ANONYMOUS_ARRAY_EXPR, "new_anonymous_array", 'e', 3)
There is no operand 2. That slot is used for the
CALL_EXPR_RTL macro (see preexpand_calls).
The type should be the one of the created class. */
DEFTREECODE (NEW_CLASS_EXPR, "new_class_expr", 'e', 3)
DEFTREECODE (NEW_CLASS_EXPR, "new_class_expr", tcc_expression, 3)
/* Defines `this' as an expression. */
DEFTREECODE (THIS_EXPR, "this", '1', 0)
DEFTREECODE (THIS_EXPR, "this", tcc_unary, 0)
/* Case statement expression.
Operand 1 is the case value. */
DEFTREECODE (CASE_EXPR, "case", 'e', 1)
DEFTREECODE (CASE_EXPR, "case", tcc_expression, 1)
/* Default statement expression. */
DEFTREECODE (DEFAULT_EXPR, "default", 'e', 0)
DEFTREECODE (DEFAULT_EXPR, "default", tcc_expression, 0)
/* Try expression
Operand 0 is the tried block,
Operand 1 contains chained catch nodes. */
DEFTREECODE (TRY_EXPR, "try-catch", 'e', 2)
DEFTREECODE (TRY_EXPR, "try-catch", tcc_expression, 2)
/* Catch clause.
Operand 0 is the catch clause block, which contains the declaration of
the catch clause parameter. */
DEFTREECODE (JAVA_CATCH_EXPR, "catch", '1', 1)
DEFTREECODE (JAVA_CATCH_EXPR, "catch", tcc_unary, 1)
/* Synchronized statement.
Operand 0 is the expression on which we wish to synchronize,
Operand 1 is the synchronized expression block. */
DEFTREECODE (SYNCHRONIZED_EXPR, "synchronized", 'e', 2)
DEFTREECODE (SYNCHRONIZED_EXPR, "synchronized", tcc_expression, 2)
/* Throw statement.
Operand 0 is the throw expression. */
DEFTREECODE (THROW_EXPR, "throw", '1', 1)
DEFTREECODE (THROW_EXPR, "throw", tcc_unary, 1)
/* Conditional operator.
Operand 0 is the condition expression
Operand 1 is the then-value
Operand 2 is the else-value. */
DEFTREECODE (CONDITIONAL_EXPR, "?:", 'e', 3)
DEFTREECODE (CONDITIONAL_EXPR, "?:", tcc_expression, 3)
/* instanceof operator.
Operand 0 is the expression that is getting tested
Operand 1 is the class used for the test. */
DEFTREECODE (INSTANCEOF_EXPR, "instanceof", 'e', 2)
DEFTREECODE (INSTANCEOF_EXPR, "instanceof", tcc_expression, 2)
/* Array initializers.
Operand 0 is the (sub) array target to initialize, left to NULL_TREE
when the node is created.
Operand 1 is a CONSTRUCTOR node. */
DEFTREECODE (NEW_ARRAY_INIT, "new_array_init", '1', 1)
DEFTREECODE (NEW_ARRAY_INIT, "new_array_init", tcc_unary, 1)
/* Class literal.
Operand 0 is the name of the class we're trying to build a
reference from. */
DEFTREECODE (CLASS_LITERAL, "class_literal", '1', 1)
DEFTREECODE (CLASS_LITERAL, "class_literal", tcc_unary, 1)
/* The Java object within the exception object from the runtime. */
DEFTREECODE (JAVA_EXC_OBJ_EXPR, "java_exc_obj_expr", 'e', 0)
DEFTREECODE (JAVA_EXC_OBJ_EXPR, "java_exc_obj_expr", tcc_expression, 0)
/* Annotates a tree node (usually an expression) with source location
information: a file name (EXPR_WFL_FILENAME); a line number
(EXPR_WFL_LINENO); and column number (EXPR_WFL_COLNO). It is
expanded as the contained node (EXPR_WFL_NODE); a line note should
be emitted first if EXPR_WFL_EMIT_LINE_NOTE. */
DEFTREECODE (EXPR_WITH_FILE_LOCATION, "expr_with_file_location", 'e', 3)
DEFTREECODE (EXPR_WITH_FILE_LOCATION, "expr_with_file_location",
tcc_expression, 3)
/*
Local variables:

3
gcc/java/jcf-write.c
View File

@ -2036,8 +2036,7 @@ generate_bytecode_insns (tree exp, int target, struct jcf_partial *state)
/* If the rhs is a binary expression and the left operand is
`==' to the lhs then we have an OP= expression. In this
case we must do some special processing. */
if (TREE_CODE_CLASS (TREE_CODE (rhs)) == '2'
&& lhs == TREE_OPERAND (rhs, 0))
if (BINARY_CLASS_P (rhs) && lhs == TREE_OPERAND (rhs, 0))
{
if (TREE_CODE (lhs) == COMPONENT_REF)
{

10
gcc/java/lang.c
View File

@ -78,9 +78,9 @@ static void java_clear_binding_stack (void);
#define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
const char tree_code_type[] = {
const enum tree_code_class tree_code_type[] = {
#include "tree.def"
'x',
tcc_exceptional,
#include "java-tree.def"
};
#undef DEFTREECODE
@ -430,8 +430,7 @@ put_decl_node (tree node)
node = TREE_TYPE (node);
was_pointer = 1;
}
if (TREE_CODE_CLASS (TREE_CODE (node)) == 'd'
&& DECL_NAME (node) != NULL_TREE)
if (DECL_P (node) && DECL_NAME (node) != NULL_TREE)
{
if (TREE_CODE (node) == FUNCTION_DECL)
{
@ -464,8 +463,7 @@ put_decl_node (tree node)
else
put_decl_node (DECL_NAME (node));
}
else if (TREE_CODE_CLASS (TREE_CODE (node)) == 't'
&& TYPE_NAME (node) != NULL_TREE)
else if (TYPE_P (node) && TYPE_NAME (node) != NULL_TREE)
{
if (TREE_CODE (node) == RECORD_TYPE && TYPE_ARRAY_P (node))
{

10
gcc/java/parse.y
View File

@ -1687,7 +1687,7 @@ do_statement:
for_statement:
for_begin SC_TK expression SC_TK for_update CP_TK statement
{
if (TREE_CODE_CLASS (TREE_CODE ($3)) == 'c')
if (CONSTANT_CLASS_P ($3))
$3 = build_wfl_node ($3);
$$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);
}
@ -3126,7 +3126,7 @@ find_expr_with_wfl (tree node)
{
while (node)
{
char code;
enum tree_code_class code;
tree to_return;
switch (TREE_CODE (node))
@ -3152,7 +3152,8 @@ find_expr_with_wfl (tree node)
default:
code = TREE_CODE_CLASS (TREE_CODE (node));
if (((code == '1') || (code == '2') || (code == 'e'))
if (((code == tcc_unary) || (code == tcc_binary)
|| (code == tcc_expression))
&& EXPR_WFL_LINECOL (node))
return node;
return NULL_TREE;
@ -14895,8 +14896,7 @@ finish_for_loop (int location, tree condition, tree update, tree body)
{
/* Try to detect constraint violations. These would be
programming errors somewhere. */
if (! IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (up2)))
|| TREE_CODE (up2) == LOOP_EXPR)
if (! EXPR_P (up2) || TREE_CODE (up2) == LOOP_EXPR)
abort ();
SUPPRESS_UNREACHABLE_ERROR (up2) = 1;
}

2
gcc/lambda-code.c
View File

@ -1420,7 +1420,7 @@ find_induction_var_from_exit_cond (struct loop *loop)
if (TREE_CODE (expr) != COND_EXPR)
return NULL_TREE;
test = TREE_OPERAND (expr, 0);
if (TREE_CODE_CLASS (TREE_CODE (test)) != '<')
if (!COMPARISON_CLASS_P (test))
return NULL_TREE;
/* This is a guess. We say that for a <,!=,<= b, a is the induction
variable.

6
gcc/langhooks.c
View File

@ -422,7 +422,7 @@ lhd_tree_dump_type_quals (tree t)
tree
lhd_expr_size (tree exp)
{
if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'd'
if (DECL_P (exp)
&& DECL_SIZE_UNIT (exp) != 0)
return DECL_SIZE_UNIT (exp);
else
@ -439,8 +439,8 @@ lhd_gimplify_expr (tree *expr_p ATTRIBUTE_UNUSED, tree *pre_p ATTRIBUTE_UNUSED,
}
/* lang_hooks.tree_size: Determine the size of a tree with code C,
which is a language-specific tree code in category 'x'. The
default expects never to be called. */
which is a language-specific tree code in category tcc_constant or
tcc_exceptional. The default expects never to be called. */
size_t
lhd_tree_size (enum tree_code c ATTRIBUTE_UNUSED)
{

15
gcc/langhooks.h
View File

@ -205,9 +205,10 @@ struct lang_hooks
identifier nodes long enough for the language-specific slots. */
size_t identifier_size;
/* Determines the size of any language-specific 'x' or 'c' nodes.
Since it is called from make_node, the only information available
is the tree code. Expected to abort on unrecognized codes. */
/* Determines the size of any language-specific tcc_constant or
tcc_exceptional nodes. Since it is called from make_node, the
only information available is the tree code. Expected to abort
on unrecognized codes. */
size_t (*tree_size) (enum tree_code);
/* The first callback made to the front end, for simple
@ -338,12 +339,12 @@ struct lang_hooks
this hook. It should output to stderr. */
void (*print_statistics) (void);
/* Called by print_tree when there is a tree of class 'x' that it
doesn't know how to display. */
/* Called by print_tree when there is a tree of class tcc_exceptional
that it doesn't know how to display. */
lang_print_tree_hook print_xnode;
/* Called to print language-dependent parts of a class 'd', class
't', and IDENTIFIER_NODE nodes. */
/* Called to print language-dependent parts of tcc_decl, tcc_type,
and IDENTIFIER_NODE nodes. */
lang_print_tree_hook print_decl;
lang_print_tree_hook print_type;
lang_print_tree_hook print_identifier;

6
gcc/objc/objc-lang.c
View File

@ -54,11 +54,11 @@ const struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
#define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
const char tree_code_type[] = {
const enum tree_code_class tree_code_type[] = {
#include "tree.def"
'x',
tcc_exceptional,
#include "c-common.def"
'x',
tcc_exceptional,
#include "objc-tree.def"
};
#undef DEFTREECODE

24
gcc/objc/objc-tree.def
View File

@ -1,7 +1,7 @@
/* This file contains the definitions and documentation for the
additional tree codes used in the Objective C front end (see tree.def
for the standard codes).
Copyright (C) 1990, 1997, 1998, 1999, 2000, 2001, 2003
Copyright (C) 1990, 1997, 1998, 1999, 2000, 2001, 2003, 2004
Free Software Foundation, Inc.
This file is part of GCC.
@ -23,20 +23,22 @@ Boston, MA 02111-1307, USA. */
/* Objective-C types. */
DEFTREECODE (CLASS_INTERFACE_TYPE, "class_interface_type", 't', 0)
DEFTREECODE (CLASS_IMPLEMENTATION_TYPE, "class_implementation_type", 't', 0)
DEFTREECODE (CATEGORY_INTERFACE_TYPE, "category_interface_type", 't', 0)
DEFTREECODE (CATEGORY_IMPLEMENTATION_TYPE,"category_implementation_type", 't', 0)
DEFTREECODE (PROTOCOL_INTERFACE_TYPE, "protocol_interface_type", 't', 0)
DEFTREECODE (CLASS_INTERFACE_TYPE, "class_interface_type", tcc_type, 0)
DEFTREECODE (CLASS_IMPLEMENTATION_TYPE, "class_implementation_type",
tcc_type, 0)
DEFTREECODE (CATEGORY_INTERFACE_TYPE, "category_interface_type", tcc_type, 0)
DEFTREECODE (CATEGORY_IMPLEMENTATION_TYPE,"category_implementation_type",
tcc_type, 0)
DEFTREECODE (PROTOCOL_INTERFACE_TYPE, "protocol_interface_type", tcc_type, 0)
/* Objective-C decls. */
DEFTREECODE (KEYWORD_DECL, "keyword_decl", 'd', 0)
DEFTREECODE (INSTANCE_METHOD_DECL, "instance_method_decl", 'd', 0)
DEFTREECODE (CLASS_METHOD_DECL, "class_method_decl", 'd', 0)
DEFTREECODE (KEYWORD_DECL, "keyword_decl", tcc_declaration, 0)
DEFTREECODE (INSTANCE_METHOD_DECL, "instance_method_decl", tcc_declaration, 0)
DEFTREECODE (CLASS_METHOD_DECL, "class_method_decl", tcc_declaration, 0)
/* Objective-C expressions. */
DEFTREECODE (MESSAGE_SEND_EXPR, "message_send_expr", 'e', 3)
DEFTREECODE (CLASS_REFERENCE_EXPR, "class_reference_expr", 'e', 1)
DEFTREECODE (MESSAGE_SEND_EXPR, "message_send_expr", tcc_expression, 3)
DEFTREECODE (CLASS_REFERENCE_EXPR, "class_reference_expr", tcc_expression, 1)
/*
Local variables:

2
gcc/predict.c
View File

@ -1048,7 +1048,7 @@ tree_predict_by_opcode (basic_block bb)
if (then_edge->flags & EDGE_TRUE_VALUE)
break;
cond = TREE_OPERAND (stmt, 0);
if (TREE_CODE_CLASS (TREE_CODE (cond)) != '<')
if (!COMPARISON_CLASS_P (cond))
return;
op0 = TREE_OPERAND (cond, 0);
type = TREE_TYPE (op0);

36
gcc/print-tree.c
View File

@ -61,7 +61,7 @@ debug_tree (tree node)
void
print_node_brief (FILE *file, const char *prefix, tree node, int indent)
{
char class;
enum tree_code_class class;
if (node == 0)
return;
@ -75,12 +75,12 @@ print_node_brief (FILE *file, const char *prefix, tree node, int indent)
fprintf (file, "%s <%s " HOST_PTR_PRINTF,
prefix, tree_code_name[(int) TREE_CODE (node)], (char *) node);
if (class == 'd')
if (class == tcc_declaration)
{
if (DECL_NAME (node))
fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node)));
}
else if (class == 't')
else if (class == tcc_type)
{
if (TYPE_NAME (node))
{
@ -156,7 +156,7 @@ print_node (FILE *file, const char *prefix, tree node, int indent)
int hash;
struct bucket *b;
enum machine_mode mode;
char class;
enum tree_code_class class;
int len;
int first_rtl;
int i;
@ -177,7 +177,7 @@ print_node (FILE *file, const char *prefix, tree node, int indent)
return;
}
if (indent > 8 && (class == 't' || class == 'd'))
if (indent > 8 && (class == tcc_type || class == tcc_declaration))
{
print_node_brief (file, prefix, node, indent);
return;
@ -214,12 +214,12 @@ print_node (FILE *file, const char *prefix, tree node, int indent)
prefix, tree_code_name[(int) TREE_CODE (node)], (void *) node);
/* Print the name, if any. */
if (class == 'd')
if (class == tcc_declaration)
{
if (DECL_NAME (node))
fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node)));
}
else if (class == 't')
else if (class == tcc_type)
{
if (TYPE_NAME (node))
{
@ -296,7 +296,7 @@ print_node (FILE *file, const char *prefix, tree node, int indent)
switch (TREE_CODE_CLASS (TREE_CODE (node)))
{
case 'd':
case tcc_declaration:
mode = DECL_MODE (node);
if (DECL_UNSIGNED (node))
@ -461,7 +461,7 @@ print_node (FILE *file, const char *prefix, tree node, int indent)
print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4);
break;
case 't':
case tcc_type:
if (TYPE_UNSIGNED (node))
fputs (" unsigned", file);
@ -573,12 +573,12 @@ print_node (FILE *file, const char *prefix, tree node, int indent)
print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4);
break;
case 'e':
case '<':
case '1':
case '2':
case 'r':
case 's':
case tcc_expression:
case tcc_comparison:
case tcc_unary:
case tcc_binary:
case tcc_reference:
case tcc_statement:
if (TREE_CODE (node) == BIT_FIELD_REF && BIT_FIELD_REF_UNSIGNED (node))
fputs (" unsigned", file);
if (TREE_CODE (node) == BIND_EXPR)
@ -619,8 +619,8 @@ print_node (FILE *file, const char *prefix, tree node, int indent)
print_node (file, "chain", TREE_CHAIN (node), indent + 4);
break;
case 'c':
case 'x':
case tcc_constant:
case tcc_exceptional:
switch (TREE_CODE (node))
{
case INTEGER_CST:
@ -765,7 +765,7 @@ print_node (FILE *file, const char *prefix, tree node, int indent)
break;
default:
if (TREE_CODE_CLASS (TREE_CODE (node)) == 'x')
if (EXCEPTIONAL_CLASS_P (node))
lang_hooks.print_xnode (file, node, indent);
break;
}

2
gcc/reload1.c
View File

@ -2032,7 +2032,7 @@ alter_reg (int i, int from_reg)
/* If we have a decl for the original register, set it for the
memory. If this is a shared MEM, make a copy. */
if (REG_EXPR (regno_reg_rtx[i])
&& TREE_CODE_CLASS (TREE_CODE (REG_EXPR (regno_reg_rtx[i]))) == 'd')
&& DECL_P (REG_EXPR (regno_reg_rtx[i])))
{
rtx decl = DECL_RTL_IF_SET (REG_EXPR (regno_reg_rtx[i]));

6
gcc/stmt.c
View File

@ -1471,16 +1471,14 @@ warn_if_unused_value (tree exp, location_t locus)
default:
/* Referencing a volatile value is a side effect, so don't warn. */
if ((DECL_P (exp)
|| TREE_CODE_CLASS (TREE_CODE (exp)) == 'r')
if ((DECL_P (exp) || REFERENCE_CLASS_P (exp))
&& TREE_THIS_VOLATILE (exp))
return 0;
/* If this is an expression which has no operands, there is no value
to be unused. There are no such language-independent codes,
but front ends may define such. */
if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'e'
&& TREE_CODE_LENGTH (TREE_CODE (exp)) == 0)
if (EXPRESSION_CLASS_P (exp) && TREE_CODE_LENGTH (TREE_CODE (exp)) == 0)
return 0;
maybe_warn:

46
gcc/tree-browser.c
View File

@ -1,5 +1,5 @@
/* Tree browser.
Copyright (C) 2002, 2003 Free Software Foundation, Inc.
Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
Contributed by Sebastian Pop <s.pop@laposte.net>
This file is part of GCC.
@ -262,14 +262,14 @@ browse_tree (tree begin)
break;
case TB_REFERENCE_TO_THIS:
if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 't')
if (head && TYPE_P (head))
TB_SET_HEAD (TYPE_REFERENCE_TO (head));
else
TB_WF;
break;
case TB_POINTER_TO_THIS:
if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 't')
if (head && TYPE_P (head))
TB_SET_HEAD (TYPE_POINTER_TO (head));
else
TB_WF;
@ -338,28 +338,28 @@ browse_tree (tree begin)
break;
case TB_INITIAL:
if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 'd')
if (head && DECL_P (head))
TB_SET_HEAD (DECL_INITIAL (head));
else
TB_WF;
break;
case TB_RESULT:
if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 'd')
if (head && DECL_P (head))
TB_SET_HEAD (DECL_RESULT_FLD (head));
else
TB_WF;
break;
case TB_ARGUMENTS:
if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 'd')
if (head && DECL_P (head))
TB_SET_HEAD (DECL_ARGUMENTS (head));
else
TB_WF;
break;
case TB_ABSTRACT_ORIGIN:
if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 'd')
if (head && DECL_P (head))
TB_SET_HEAD (DECL_ABSTRACT_ORIGIN (head));
else if (head && TREE_CODE (head) == BLOCK)
TB_SET_HEAD (BLOCK_ABSTRACT_ORIGIN (head));
@ -368,18 +368,18 @@ browse_tree (tree begin)
break;
case TB_ATTRIBUTES:
if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 'd')
if (head && DECL_P (head))
TB_SET_HEAD (DECL_ATTRIBUTES (head));
else if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 't')
else if (head && TYPE_P (head))
TB_SET_HEAD (TYPE_ATTRIBUTES (head));
else
TB_WF;
break;
case TB_CONTEXT:
if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 'd')
if (head && DECL_P (head))
TB_SET_HEAD (DECL_CONTEXT (head));
else if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 't'
else if (head && TYPE_P (head)
&& TYPE_CONTEXT (head))
TB_SET_HEAD (TYPE_CONTEXT (head));
else
@ -401,18 +401,18 @@ browse_tree (tree begin)
break;
case TB_UNIT_SIZE:
if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 'd')
if (head && DECL_P (head))
TB_SET_HEAD (DECL_SIZE_UNIT (head));
else if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 't')
else if (head && TYPE_P (head))
TB_SET_HEAD (TYPE_SIZE_UNIT (head));
else
TB_WF;
break;
case TB_SIZE:
if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 'd')
if (head && DECL_P (head))
TB_SET_HEAD (DECL_SIZE (head));
else if (head && TREE_CODE_CLASS (TREE_CODE (head)) == 't')
else if (head && TYPE_P (head))
TB_SET_HEAD (TYPE_SIZE (head));
else
TB_WF;
@ -441,32 +441,28 @@ browse_tree (tree begin)
break;
case TB_CHILD_0:
if (head && IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (head)))
&& TREE_OPERAND (head, 0))
if (head && EXPR_P (head) && TREE_OPERAND (head, 0))
TB_SET_HEAD (TREE_OPERAND (head, 0));
else
TB_WF;
break;
case TB_CHILD_1:
if (head && IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (head)))
&& TREE_OPERAND (head, 1))
if (head && EXPR_P (head) && TREE_OPERAND (head, 1))
TB_SET_HEAD (TREE_OPERAND (head, 1));
else
TB_WF;
break;
case TB_CHILD_2:
if (head && IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (head)))
&& TREE_OPERAND (head, 2))
if (head && EXPR_P (head) && TREE_OPERAND (head, 2))
TB_SET_HEAD (TREE_OPERAND (head, 2));
else
TB_WF;
break;
case TB_CHILD_3:
if (head && IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (head)))
&& TREE_OPERAND (head, 3))
if (head && EXPR_P (head) && TREE_OPERAND (head, 3))
TB_SET_HEAD (TREE_OPERAND (head, 3));
else
TB_WF;
@ -751,7 +747,7 @@ store_child_info (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
node = *tp;
/* 'node' is the parent of 'TREE_OPERAND (node, *)'. */
if (TREE_CODE_CLASS (TREE_CODE (node)) == 'e')
if (EXPRESSION_CLASS_P (node))
{
#define STORE_CHILD(N) do { \
@ -808,7 +804,7 @@ TB_parent_eq (const void *p1, const void *p2)
if (p1 == NULL || p2 == NULL)
return 0;
if (TREE_CODE_CLASS(TREE_CODE(parent)) == 'e')
if (EXPRESSION_CLASS_P (parent))
{
#define TEST_CHILD(N) do { \

15
gcc/tree-cfg.c
View File

@ -2004,7 +2004,7 @@ find_taken_edge (basic_block bb, tree val)
SSA_NAME, we can always determine its truth value (except when
doing floating point comparisons that may involve NaNs). */
if (val
&& TREE_CODE_CLASS (TREE_CODE (val)) == '<'
&& COMPARISON_CLASS_P (val)
&& TREE_OPERAND (val, 0) == TREE_OPERAND (val, 1)
&& TREE_CODE (TREE_OPERAND (val, 0)) == SSA_NAME
&& (TREE_CODE (TREE_TYPE (TREE_OPERAND (val, 0))) != REAL_TYPE
@ -3085,8 +3085,8 @@ verify_expr (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
We check for constants explicitly since they are not considered
gimple invariants if they overflowed. */
#define CHECK_OP(N, MSG) \
do { if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (t, N))) != 'c' \
&& !is_gimple_val (TREE_OPERAND (t, N))) \
do { if (!CONSTANT_CLASS_P (TREE_OPERAND (t, N)) \
&& !is_gimple_val (TREE_OPERAND (t, N))) \
{ error (MSG); return TREE_OPERAND (t, N); }} while (0)
switch (TREE_CODE (t))
@ -3187,8 +3187,7 @@ verify_expr (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
t = TREE_OPERAND (t, 0);
}
if (TREE_CODE_CLASS (TREE_CODE (t)) != 'c'
&& !is_gimple_lvalue (t))
if (!CONSTANT_CLASS_P (t) && !is_gimple_lvalue (t))
{
error ("Invalid reference prefix.");
return t;
@ -3298,10 +3297,10 @@ verify_stmt (tree stmt, bool last_in_block)
static bool
tree_node_can_be_shared (tree t)
{
if (TYPE_P (t) || DECL_P (t)
if (IS_TYPE_OR_DECL_P (t)
/* We check for constants explicitly since they are not considered
gimple invariants if they overflowed. */
|| TREE_CODE_CLASS (TREE_CODE (t)) == 'c'
|| CONSTANT_CLASS_P (t)
|| is_gimple_min_invariant (t)
|| TREE_CODE (t) == SSA_NAME)
return true;
@ -3309,7 +3308,7 @@ tree_node_can_be_shared (tree t)
while (((TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
/* We check for constants explicitly since they are not considered
gimple invariants if they overflowed. */
&& (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (t, 1))) == 'c'
&& (CONSTANT_CLASS_P (TREE_OPERAND (t, 1))
|| is_gimple_min_invariant (TREE_OPERAND (t, 1))))
|| (TREE_CODE (t) == COMPONENT_REF
|| TREE_CODE (t) == REALPART_EXPR

2
gcc/tree-chrec.c
View File

@ -932,7 +932,7 @@ chrec_convert (tree type,
/* Don't propagate overflows. */
TREE_OVERFLOW (res) = 0;
if (TREE_CODE_CLASS (TREE_CODE (res)) == 'c')
if (CONSTANT_CLASS_P (res))
TREE_CONSTANT_OVERFLOW (res) = 0;
return res;
}

8
gcc/tree-complex.c
View File

@ -425,7 +425,7 @@ expand_complex_operations_1 (block_stmt_iterator *bsi)
ar = extract_component (bsi, ac, 0);
ai = extract_component (bsi, ac, 1);
if (TREE_CODE_CLASS (code) == '1')
if (TREE_CODE_CLASS (code) == tcc_unary)
bc = br = bi = NULL;
else
{
@ -776,8 +776,8 @@ expand_vector_operations_1 (block_stmt_iterator *bsi)
return;
code = TREE_CODE (rhs);
if (TREE_CODE_CLASS (code) != '1'
&& TREE_CODE_CLASS (code) != '2')
if (TREE_CODE_CLASS (code) != tcc_unary
&& TREE_CODE_CLASS (code) != tcc_binary)
return;
if (code == NOP_EXPR || code == VIEW_CONVERT_EXPR)
@ -872,7 +872,7 @@ expand_vector_operations_1 (block_stmt_iterator *bsi)
break;
}
if (TREE_CODE_CLASS (code) == '1')
if (TREE_CODE_CLASS (code) == tcc_unary)
*p_rhs = expand_vector_piecewise (bsi, do_unop, type, compute_type,
TREE_OPERAND (rhs, 0),
NULL_TREE, code);

4
gcc/tree-dfa.c
View File

@ -847,9 +847,7 @@ find_vars_r (tree *tp, int *walk_subtrees, void *data)
/* Type, _DECL and constant nodes have no interesting children.
Ignore them. */
else if (DECL_P (*tp)
|| TYPE_P (*tp)
|| TREE_CODE_CLASS (TREE_CODE (*tp)) == 'c')
else if (IS_TYPE_OR_DECL_P (*tp) || CONSTANT_CLASS_P (*tp))
*walk_subtrees = 0;
return NULL_TREE;

18
gcc/tree-dump.c
View File

@ -216,7 +216,7 @@ dequeue_and_dump (dump_info_p di)
tree t;
unsigned int index;
enum tree_code code;
char code_class;
enum tree_code_class code_class;
const char* code_name;
/* Get the next node from the queue. */
@ -292,19 +292,19 @@ dequeue_and_dump (dump_info_p di)
switch (code_class)
{
case '1':
case tcc_unary:
dump_child ("op 0", TREE_OPERAND (t, 0));
break;
case '2':
case '<':
case tcc_binary:
case tcc_comparison:
dump_child ("op 0", TREE_OPERAND (t, 0));
dump_child ("op 1", TREE_OPERAND (t, 1));
break;
case 'e':
case 'r':
case 's':
case tcc_expression:
case tcc_reference:
case tcc_statement:
/* These nodes are handled explicitly below. */
break;
@ -346,7 +346,7 @@ dequeue_and_dump (dump_info_p di)
if (TREE_CHAIN (t) && !dump_flag (di, TDF_SLIM, NULL))
dump_child ("chan", TREE_CHAIN (t));
}
else if (code_class == 't')
else if (code_class == tcc_type)
{
/* All types have qualifiers. */
int quals = lang_hooks.tree_dump.type_quals (t);
@ -373,7 +373,7 @@ dequeue_and_dump (dump_info_p di)
/* All types have alignments. */
dump_int (di, "algn", TYPE_ALIGN (t));
}
else if (code_class == 'c')
else if (code_class == tcc_constant)
/* All constants can have types. */
queue_and_dump_type (di, t);

8
gcc/tree-eh.c
View File

@ -1,5 +1,5 @@
/* Exception handling semantics and decomposition for trees.
Copyright (C) 2003 Free Software Foundation, Inc.
Copyright (C) 2003, 2004 Free Software Foundation, Inc.
This file is part of GCC.
@ -1719,9 +1719,9 @@ tree_could_trap_p (tree expr)
bool honor_trapv = false;
tree t, base, idx;
if (TREE_CODE_CLASS (code) == '<'
|| TREE_CODE_CLASS (code) == '1'
|| TREE_CODE_CLASS (code) == '2')
if (TREE_CODE_CLASS (code) == tcc_comparison
|| TREE_CODE_CLASS (code) == tcc_unary
|| TREE_CODE_CLASS (code) == tcc_binary)
{
t = TREE_TYPE (expr);
fp_operation = FLOAT_TYPE_P (t);

23
gcc/tree-gimple.c
View File

@ -201,9 +201,9 @@ is_gimple_formal_tmp_rhs (tree t)
switch (TREE_CODE_CLASS (code))
{
case '1':
case '2':
case '<':
case tcc_unary:
case tcc_binary:
case tcc_comparison:
return true;
default:
@ -312,8 +312,7 @@ is_gimple_lvalue (tree t)
bool
is_gimple_condexpr (tree t)
{
return (is_gimple_val (t)
|| TREE_CODE_CLASS (TREE_CODE (t)) == '<');
return (is_gimple_val (t) || COMPARISON_CLASS_P (t));
}
/* Return true if T is something whose address can be taken. */
@ -579,7 +578,7 @@ recalculate_side_effects (tree t)
switch (TREE_CODE_CLASS (code))
{
case 'e':
case tcc_expression:
switch (code)
{
case INIT_EXPR:
@ -598,10 +597,10 @@ recalculate_side_effects (tree t)
}
/* Fall through. */
case '<': /* a comparison expression */
case '1': /* a unary arithmetic expression */
case '2': /* a binary arithmetic expression */
case 'r': /* a reference */
case tcc_comparison: /* a comparison expression */
case tcc_unary: /* a unary arithmetic expression */
case tcc_binary: /* a binary arithmetic expression */
case tcc_reference: /* a reference */
TREE_SIDE_EFFECTS (t) = TREE_THIS_VOLATILE (t);
for (i = 0; i < fro; ++i)
{
@ -610,5 +609,9 @@ recalculate_side_effects (tree t)
TREE_SIDE_EFFECTS (t) = 1;
}
break;
default:
/* Can never be used with non-expressions. */
gcc_unreachable ();
}
}

11
gcc/tree-inline.c
View File

@ -1159,7 +1159,7 @@ estimate_num_insns_1 (tree *tp, int *walk_subtrees, void *data)
int *count = data;
tree x = *tp;
if (TYPE_P (x) || DECL_P (x))
if (IS_TYPE_OR_DECL_P (x))
{
*walk_subtrees = 0;
return NULL;
@ -1167,8 +1167,7 @@ estimate_num_insns_1 (tree *tp, int *walk_subtrees, void *data)
/* Assume that constants and references counts nothing. These should
be majorized by amount of operations among them we count later
and are common target of CSE and similar optimizations. */
else if (TREE_CODE_CLASS (TREE_CODE (x)) == 'c'
|| TREE_CODE_CLASS (TREE_CODE (x)) == 'r')
else if (CONSTANT_CLASS_P (x) || REFERENCE_CLASS_P (x))
return NULL;
switch (TREE_CODE (x))
@ -2258,7 +2257,7 @@ copy_tree_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
/* We make copies of most nodes. */
if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code))
|| TREE_CODE_CLASS (code) == 'c'
|| TREE_CODE_CLASS (code) == tcc_constant
|| code == TREE_LIST
|| code == TREE_VEC
|| code == TYPE_DECL)
@ -2288,9 +2287,9 @@ copy_tree_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
BIND_EXPR_BLOCK (*tp) = NULL_TREE;
}
else if (TREE_CODE_CLASS (code) == 't')
else if (TREE_CODE_CLASS (code) == tcc_type)
*walk_subtrees = 0;
else if (TREE_CODE_CLASS (code) == 'd')
else if (TREE_CODE_CLASS (code) == tcc_declaration)
*walk_subtrees = 0;
else
gcc_assert (code != STATEMENT_LIST);

6
gcc/tree-nested.c
View File

@ -831,7 +831,7 @@ convert_nonlocal_reference (tree *tp, int *walk_subtrees, void *data)
break;
default:
if (!DECL_P (t) && !TYPE_P (t))
if (!IS_TYPE_OR_DECL_P (t))
{
*walk_subtrees = 1;
wi->val_only = true;
@ -945,7 +945,7 @@ convert_local_reference (tree *tp, int *walk_subtrees, void *data)
break;
default:
if (!DECL_P (t) && !TYPE_P (t))
if (!IS_TYPE_OR_DECL_P (t))
{
*walk_subtrees = 1;
wi->val_only = true;
@ -1124,7 +1124,7 @@ convert_tramp_reference (tree *tp, int *walk_subtrees, void *data)
break;
default:
if (!DECL_P (t) && !TYPE_P (t))
if (!IS_TYPE_OR_DECL_P (t))
*walk_subtrees = 1;
break;
}

2
gcc/tree-outof-ssa.c
View File

@ -1750,7 +1750,7 @@ discover_nonconstant_array_refs_r (tree * tp, int *walk_subtrees,
{
tree t = *tp;
if (TYPE_P (t) || DECL_P (t))
if (IS_TYPE_OR_DECL_P (t))
*walk_subtrees = 0;
else if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
{

14
gcc/tree-pretty-print.c
View File

@ -1,5 +1,5 @@
/* Pretty formatting of GENERIC trees in C syntax.
Copyright (C) 2001, 2002, 2003 Free Software Foundation, Inc.
Copyright (C) 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>
This file is part of GCC.
@ -70,7 +70,7 @@ do_niy (pretty_printer *buffer, tree node)
pp_string (buffer, "<<< Unknown tree: ");
pp_string (buffer, tree_code_name[(int) TREE_CODE (node)]);
if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (node))))
if (EXPR_P (node))
{
len = first_rtl_op (TREE_CODE (node));
for (i = 0; i < len; ++i)
@ -303,7 +303,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
case CHAR_TYPE:
{
unsigned int quals = TYPE_QUALS (node);
char class;
enum tree_code_class class;
if (quals & TYPE_QUAL_CONST)
pp_string (buffer, "const ");
@ -314,14 +314,14 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
class = TREE_CODE_CLASS (TREE_CODE (node));
if (class == 'd')
if (class == tcc_declaration)
{
if (DECL_NAME (node))
dump_decl_name (buffer, node, flags);
else
pp_string (buffer, "<unnamed type decl>");
}
else if (class == 't')
else if (class == tcc_type)
{
if (TYPE_NAME (node))
{
@ -1330,9 +1330,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
case GOTO_EXPR:
op0 = GOTO_DESTINATION (node);
if (TREE_CODE (op0) != SSA_NAME
&& DECL_P (op0)
&& DECL_NAME (op0))
if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0))
{
const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
if (strcmp (name, "break") == 0

4
gcc/tree-sra.c
View File

@ -1553,7 +1553,7 @@ find_new_referenced_vars_1 (tree *tp, int *walk_subtrees,
if (TREE_CODE (t) == VAR_DECL && !var_ann (t))
add_referenced_tmp_var (t);
if (DECL_P (t) || TYPE_P (t))
if (IS_TYPE_OR_DECL_P (t))
*walk_subtrees = 0;
return NULL;
@ -1903,7 +1903,7 @@ mark_notrap (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
TREE_THIS_NOTRAP (t) = 1;
*walk_subtrees = 0;
}
else if (DECL_P (t) || TYPE_P (t))
else if (IS_TYPE_OR_DECL_P (t))
*walk_subtrees = 0;
return NULL;

2
gcc/tree-ssa-alias.c
View File

@ -1790,7 +1790,7 @@ add_pointed_to_var (struct alias_info *ai, tree ptr, tree value)
gcc_assert (TREE_CODE (value) == ADDR_EXPR);
pt_var = TREE_OPERAND (value, 0);
if (TREE_CODE_CLASS (TREE_CODE (pt_var)) == 'r')
if (REFERENCE_CLASS_P (pt_var))
pt_var = get_base_address (pt_var);
if (pt_var && SSA_VAR_P (pt_var))

11
gcc/tree-ssa-ccp.c
View File

@ -787,7 +787,7 @@ ccp_fold (tree stmt)
{
tree rhs = get_rhs (stmt);
enum tree_code code = TREE_CODE (rhs);
int kind = TREE_CODE_CLASS (code);
enum tree_code_class kind = TREE_CODE_CLASS (code);
tree retval = NULL_TREE;
vuse_optype vuses;
@ -805,7 +805,7 @@ ccp_fold (tree stmt)
/* Unary operators. Note that we know the single operand must
be a constant. So this should almost always return a
simplified RHS. */
if (kind == '1')
if (kind == tcc_unary)
{
/* Handle unary operators which can appear in GIMPLE form. */
tree op0 = TREE_OPERAND (rhs, 0);
@ -845,8 +845,8 @@ ccp_fold (tree stmt)
/* Binary and comparison operators. We know one or both of the
operands are constants. */
else if (kind == '2'
|| kind == '<'
else if (kind == tcc_binary
|| kind == tcc_comparison
|| code == TRUTH_AND_EXPR
|| code == TRUTH_OR_EXPR
|| code == TRUTH_XOR_EXPR)
@ -2035,7 +2035,8 @@ fold_stmt (tree *stmt_p)
if (TREE_CODE (callee) == OBJ_TYPE_REF
&& lang_hooks.fold_obj_type_ref
&& TREE_CODE (OBJ_TYPE_REF_OBJECT (callee)) == ADDR_EXPR
&& DECL_P (TREE_OPERAND (OBJ_TYPE_REF_OBJECT (callee), 0)))
&& DECL_P (TREE_OPERAND
(OBJ_TYPE_REF_OBJECT (callee), 0)))
{
tree t;

2
gcc/tree-ssa-dce.c
View File

@ -402,7 +402,7 @@ mark_stmt_if_obviously_necessary (tree stmt, bool aggressive)
a global variable. Otherwise, we check if the base variable
is a global. */
lhs = TREE_OPERAND (stmt, 0);
if (TREE_CODE_CLASS (TREE_CODE (lhs)) == 'r')
if (REFERENCE_CLASS_P (lhs))
lhs = get_base_address (lhs);
if (lhs == NULL_TREE)

24
gcc/tree-ssa-dom.c
View File

@ -616,7 +616,7 @@ thread_across_edge (struct dom_walk_data *walk_data, edge e)
else
cond = SWITCH_COND (stmt);
if (TREE_CODE_CLASS (TREE_CODE (cond)) == '<')
if (COMPARISON_CLASS_P (cond))
{
tree dummy_cond, op0, op1;
enum tree_code cond_code;
@ -776,8 +776,7 @@ initialize_hash_element (tree expr, tree lhs, struct expr_hash_elt *element)
For the former case, we have no annotation and we want to hash the
conditional expression. In the latter case we have an annotation and
we want to record the expression the statement evaluates. */
if (TREE_CODE_CLASS (TREE_CODE (expr)) == '<'
|| TREE_CODE (expr) == TRUTH_NOT_EXPR)
if (COMPARISON_CLASS_P (expr) || TREE_CODE (expr) == TRUTH_NOT_EXPR)
{
element->ann = NULL;
element->rhs = expr;
@ -932,7 +931,7 @@ dom_opt_finalize_block (struct dom_walk_data *walk_data, basic_block bb)
}
else if ((last = last_stmt (bb))
&& TREE_CODE (last) == COND_EXPR
&& (TREE_CODE_CLASS (TREE_CODE (COND_EXPR_COND (last))) == '<'
&& (COMPARISON_CLASS_P (COND_EXPR_COND (last))
|| TREE_CODE (COND_EXPR_COND (last)) == SSA_NAME)
&& bb->succ
&& (bb->succ->flags & EDGE_ABNORMAL) == 0
@ -949,7 +948,7 @@ dom_opt_finalize_block (struct dom_walk_data *walk_data, basic_block bb)
cond = COND_EXPR_COND (last);
cond_code = TREE_CODE (cond);
if (TREE_CODE_CLASS (cond_code) == '<')
if (TREE_CODE_CLASS (cond_code) == tcc_comparison)
inverted = invert_truthvalue (cond);
/* If the THEN arm is the end of a dominator tree or has PHI nodes,
@ -965,7 +964,7 @@ dom_opt_finalize_block (struct dom_walk_data *walk_data, basic_block bb)
VARRAY_PUSH_TREE (const_and_copies_stack, NULL_TREE);
/* Record any equivalences created by following this edge. */
if (TREE_CODE_CLASS (cond_code) == '<')
if (TREE_CODE_CLASS (cond_code) == tcc_comparison)
{
record_cond (cond, boolean_true_node);
record_dominating_conditions (cond);
@ -989,7 +988,7 @@ dom_opt_finalize_block (struct dom_walk_data *walk_data, basic_block bb)
|| phi_nodes (false_edge->dest))
{
/* Record any equivalences created by following this edge. */
if (TREE_CODE_CLASS (cond_code) == '<')
if (TREE_CODE_CLASS (cond_code) == tcc_comparison)
{
record_cond (cond, boolean_false_node);
record_cond (inverted, boolean_true_node);
@ -1699,10 +1698,9 @@ simplify_rhs_and_lookup_avail_expr (struct dom_walk_data *walk_data,
/* If the result is a suitable looking gimple expression,
then use it instead of the original for STMT. */
if (TREE_CODE (t) == SSA_NAME
|| (TREE_CODE_CLASS (TREE_CODE (t)) == '1'
|| (UNARY_CLASS_P (t)
&& TREE_CODE (TREE_OPERAND (t, 0)) == SSA_NAME)
|| ((TREE_CODE_CLASS (TREE_CODE (t)) == '2'
|| TREE_CODE_CLASS (TREE_CODE (t)) == '<')
|| ((BINARY_CLASS_P (t) || COMPARISON_CLASS_P (t))
&& TREE_CODE (TREE_OPERAND (t, 0)) == SSA_NAME
&& is_gimple_val (TREE_OPERAND (t, 1))))
result = update_rhs_and_lookup_avail_expr (stmt, t, insert);
@ -1920,7 +1918,7 @@ simplify_cond_and_lookup_avail_expr (tree stmt,
{
tree cond = COND_EXPR_COND (stmt);
if (TREE_CODE_CLASS (TREE_CODE (cond)) == '<')
if (COMPARISON_CLASS_P (cond))
{
tree op0 = TREE_OPERAND (cond, 0);
tree op1 = TREE_OPERAND (cond, 1);
@ -3023,7 +3021,7 @@ record_range (tree cond, basic_block bb, varray_type *vrp_variables_p)
{
/* We explicitly ignore NE_EXPRs. They rarely allow for meaningful
range optimizations and significantly complicate the implementation. */
if (TREE_CODE_CLASS (TREE_CODE (cond)) == '<'
if (COMPARISON_CLASS_P (cond)
&& TREE_CODE (cond) != NE_EXPR
&& TREE_CODE (TREE_TYPE (TREE_OPERAND (cond, 1))) == INTEGER_TYPE)
{
@ -3091,7 +3089,7 @@ get_eq_expr_value (tree if_stmt,
/* If we have a comparison expression, then record its result into
the available expression table. */
if (TREE_CODE_CLASS (TREE_CODE (cond)) == '<')
if (COMPARISON_CLASS_P (cond))
{
tree op0 = TREE_OPERAND (cond, 0);
tree op1 = TREE_OPERAND (cond, 1);

10
gcc/tree-ssa-forwprop.c
View File

@ -172,7 +172,7 @@ record_single_argument_cond_exprs (varray_type cond_worklist,
if (cond_code == SSA_NAME
|| ((cond_code == EQ_EXPR || cond_code == NE_EXPR)
&& TREE_CODE (TREE_OPERAND (cond, 0)) == SSA_NAME
&& TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (cond, 1))) == 'c'
&& CONSTANT_CLASS_P (TREE_OPERAND (cond, 1))
&& INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (cond, 1)))))
{
tree def;
@ -209,7 +209,7 @@ record_single_argument_cond_exprs (varray_type cond_worklist,
/* The first operand must be an SSA_NAME and the second
operand must be a constant. */
if (TREE_CODE (op0) != SSA_NAME
|| TREE_CODE_CLASS (TREE_CODE (op1)) != 'c'
|| !CONSTANT_CLASS_P (op1)
|| !INTEGRAL_TYPE_P (TREE_TYPE (op1)))
continue;
}
@ -223,7 +223,7 @@ record_single_argument_cond_exprs (varray_type cond_worklist,
/* If TEST_VAR is set from a relational operation
between two SSA_NAMEs or a combination of an SSA_NAME
and a constant, then it is interesting. */
if (TREE_CODE_CLASS (TREE_CODE (def_rhs)) == '<')
if (COMPARISON_CLASS_P (def_rhs))
{
tree op0 = TREE_OPERAND (def_rhs, 0);
tree op1 = TREE_OPERAND (def_rhs, 1);
@ -364,7 +364,7 @@ substitute_single_use_vars (varray_type *cond_worklist,
new_cond = build (cond_code, boolean_type_node, op0, t);
}
/* If the variable is defined by a conditional expression... */
else if (TREE_CODE_CLASS (def_rhs_code) == '<')
else if (TREE_CODE_CLASS (def_rhs_code) == tcc_comparison)
{
/* TEST_VAR was set from a relational operator. */
tree op0 = TREE_OPERAND (def_rhs, 0);
@ -382,7 +382,7 @@ substitute_single_use_vars (varray_type *cond_worklist,
/* If we did not get a simple relational expression or
bare SSA_NAME, then we can not optimize this case. */
if (TREE_CODE_CLASS (TREE_CODE (new_cond)) != '<'
if (!COMPARISON_CLASS_P (new_cond)
&& TREE_CODE (new_cond) != SSA_NAME)
continue;
}

4
gcc/tree-ssa-live.c
View File

@ -1,5 +1,5 @@
/* Liveness for SSA trees.
Copyright (C) 2003 Free Software Foundation, Inc.
Copyright (C) 2003, 2004 Free Software Foundation, Inc.
Contributed by Andrew MacLeod <amacleod@redhat.com>
This file is part of GCC.
@ -297,7 +297,7 @@ mark_all_vars_used_1 (tree *tp, int *walk_subtrees,
if (TREE_CODE (t) == VAR_DECL)
set_is_used (t);
if (DECL_P (t) || TYPE_P (t))
if (IS_TYPE_OR_DECL_P (t))
*walk_subtrees = 0;
return NULL;

22
gcc/tree-ssa-loop-im.c
View File

@ -1,5 +1,5 @@
/* Loop invariant motion.
Copyright (C) 2003 Free Software Foundation, Inc.
Copyright (C) 2003, 2004 Free Software Foundation, Inc.
This file is part of GCC.
@ -256,7 +256,7 @@ outermost_invariant_loop (tree def, struct loop *loop)
static struct loop *
outermost_invariant_loop_expr (tree expr, struct loop *loop)
{
char class = TREE_CODE_CLASS (TREE_CODE (expr));
enum tree_code_class class = TREE_CODE_CLASS (TREE_CODE (expr));
unsigned i, nops;
struct loop *max_loop = superloop_at_depth (loop, 1), *aloop;
@ -265,10 +265,10 @@ outermost_invariant_loop_expr (tree expr, struct loop *loop)
|| is_gimple_min_invariant (expr))
return outermost_invariant_loop (expr, loop);
if (class != '1'
&& class != '2'
&& class != 'e'
&& class != '<')
if (class != tcc_unary
&& class != tcc_binary
&& class != tcc_expression
&& class != tcc_comparison)
return NULL;
nops = first_rtl_op (TREE_CODE (expr));
@ -714,7 +714,7 @@ may_move_till (tree ref, tree *index, void *data)
static void
force_move_till_expr (tree expr, struct loop *orig_loop, struct loop *loop)
{
char class = TREE_CODE_CLASS (TREE_CODE (expr));
enum tree_code_class class = TREE_CODE_CLASS (TREE_CODE (expr));
unsigned i, nops;
if (TREE_CODE (expr) == SSA_NAME)
@ -727,10 +727,10 @@ force_move_till_expr (tree expr, struct loop *orig_loop, struct loop *loop)
return;
}
if (class != '1'
&& class != '2'
&& class != 'e'
&& class != '<')
if (class != tcc_unary
&& class != tcc_binary
&& class != tcc_expression
&& class != tcc_comparison)
return;
nops = first_rtl_op (TREE_CODE (expr));

19
gcc/tree-ssa-loop-ivopts.c
View File

@ -1,5 +1,5 @@
/* Induction variable optimizations.
Copyright (C) 2003 Free Software Foundation, Inc.
Copyright (C) 2003, 2004 Free Software Foundation, Inc.
This file is part of GCC.
@ -721,7 +721,7 @@ static bool
contains_abnormal_ssa_name_p (tree expr)
{
enum tree_code code = TREE_CODE (expr);
char class = TREE_CODE_CLASS (code);
enum tree_code_class class = TREE_CODE_CLASS (code);
if (code == SSA_NAME)
return SSA_NAME_OCCURS_IN_ABNORMAL_PHI (expr) != 0;
@ -737,13 +737,13 @@ contains_abnormal_ssa_name_p (tree expr)
switch (class)
{
case '2':
case '<':
case tcc_binary:
case tcc_comparison:
if (contains_abnormal_ssa_name_p (TREE_OPERAND (expr, 1)))
return true;
/* Fallthru. */
case '1':
case tcc_unary:
if (contains_abnormal_ssa_name_p (TREE_OPERAND (expr, 0)))
return true;
@ -1347,21 +1347,20 @@ find_interesting_uses_stmt (struct ivopts_data *data, tree stmt)
switch (TREE_CODE_CLASS (TREE_CODE (rhs)))
{
case '<':
case tcc_comparison:
find_interesting_uses_cond (data, stmt, &TREE_OPERAND (stmt, 1));
return;
case 'r':
case tcc_reference:
find_interesting_uses_address (data, stmt, &TREE_OPERAND (stmt, 1));
if (TREE_CODE_CLASS (TREE_CODE (lhs)) == 'r')
if (REFERENCE_CLASS_P (lhs))
find_interesting_uses_address (data, stmt, &TREE_OPERAND (stmt, 0));
return;
default: ;
}
/* Handle memory = gimple_val. */
if (TREE_CODE_CLASS (TREE_CODE (lhs)) == 'r'
if (REFERENCE_CLASS_P (lhs)
&& is_gimple_val (rhs))
{
find_interesting_uses_address (data, stmt, &TREE_OPERAND (stmt, 0));

10
gcc/tree-ssa-operands.c
View File

@ -1,5 +1,5 @@
/* SSA operands management for trees.
Copyright (C) 2003 Free Software Foundation, Inc.
Copyright (C) 2003, 2004 Free Software Foundation, Inc.
This file is part of GCC.
@ -967,7 +967,7 @@ static void
get_expr_operands (tree stmt, tree *expr_p, int flags)
{
enum tree_code code;
char class;
enum tree_code_class class;
tree expr = *expr_p;
if (expr == NULL || expr == error_mark_node)
@ -1170,11 +1170,11 @@ get_expr_operands (tree stmt, tree *expr_p, int flags)
return;
default:
if (class == '1')
if (class == tcc_unary)
goto do_unary;
if (class == '2' || class == '<')
if (class == tcc_binary || class == tcc_comparison)
goto do_binary;
if (class == 'c' || class == 't')
if (class == tcc_constant || class == tcc_type)
return;
}

2
gcc/tree-ssa-phiopt.c
View File

@ -341,7 +341,7 @@ conditional_replacement (basic_block bb, tree phi, tree arg0, tree arg1)
if (old_result)
{
tree new1;
if (TREE_CODE_CLASS (TREE_CODE (old_result)) != '<')
if (!COMPARISON_CLASS_P (old_result))
return false;
new1 = build (TREE_CODE (old_result), TREE_TYPE (result),

99
gcc/tree-ssa-pre.c
View File

@ -848,15 +848,21 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
if (expr == NULL)
return NULL;
if (is_gimple_min_invariant (expr))
return expr;
/* Phi translations of a given expression don't change, */
phitrans = phi_trans_lookup (expr, pred);
if (phitrans)
return phitrans;
switch (TREE_CODE_CLASS (TREE_CODE (expr)))
{
case '2':
case tcc_reference:
/* XXX: Until we have PRE of loads working, none will be ANTIC. */
return NULL;
case tcc_binary:
{
tree oldop1 = TREE_OPERAND (expr, 0);
tree oldop2 = TREE_OPERAND (expr, 1);
@ -884,13 +890,9 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
phi_trans_add (oldexpr, newexpr, pred);
}
}
break;
/* XXX: Until we have PRE of loads working, none will be ANTIC.
*/
case 'r':
return NULL;
break;
case '1':
return expr;
case tcc_unary:
{
tree oldop1 = TREE_OPERAND (expr, 0);
tree newop1;
@ -911,10 +913,9 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
phi_trans_add (oldexpr, newexpr, pred);
}
}
break;
case 'd':
gcc_unreachable ();
case 'x':
return expr;
case tcc_exceptional:
{
tree phi = NULL;
int i;
@ -934,9 +935,11 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
return PHI_ARG_DEF (phi, i);
}
}
break;
return expr;
default:
gcc_unreachable ();
}
return expr;
}
static void
@ -1046,34 +1049,31 @@ valid_in_set (value_set_t set, tree expr)
{
switch (TREE_CODE_CLASS (TREE_CODE (expr)))
{
case '2':
case tcc_binary:
{
tree op1 = TREE_OPERAND (expr, 0);
tree op2 = TREE_OPERAND (expr, 1);
return set_contains_value (set, op1) && set_contains_value (set, op2);
}
break;
case '1':
case tcc_unary:
{
tree op1 = TREE_OPERAND (expr, 0);
return set_contains_value (set, op1);
}
break;
/* XXX: Until PRE of loads works, no reference nodes are ANTIC.
*/
case 'r':
{
return false;
}
case 'x':
{
gcc_assert (TREE_CODE (expr) == SSA_NAME);
return true;
}
case 'c':
gcc_unreachable ();
}
return false;
case tcc_reference:
/* XXX: Until PRE of loads works, no reference nodes are ANTIC. */
return false;
case tcc_exceptional:
gcc_assert (TREE_CODE (expr) == SSA_NAME);
return true;
default:
/* No other cases should be encountered. */
gcc_unreachable ();
}
}
/* Clean the set of expressions that are no longer valid in SET. This
@ -1291,9 +1291,9 @@ find_or_generate_expression (basic_block block, tree expr, tree stmts)
if (genop == NULL)
{
genop = VALUE_HANDLE_EXPR_SET (expr)->head->expr;
gcc_assert (TREE_CODE_CLASS (TREE_CODE (genop)) == '1'
|| TREE_CODE_CLASS (TREE_CODE (genop)) == '2'
|| TREE_CODE_CLASS (TREE_CODE (genop)) == 'r');
gcc_assert (UNARY_CLASS_P (genop)
|| BINARY_CLASS_P (genop)
|| REFERENCE_CLASS_P (genop));
genop = create_expression_by_pieces (block, genop, stmts);
}
return genop;
@ -1323,7 +1323,7 @@ create_expression_by_pieces (basic_block block, tree expr, tree stmts)
switch (TREE_CODE_CLASS (TREE_CODE (expr)))
{
case '2':
case tcc_binary:
{
tree_stmt_iterator tsi;
tree genop1, genop2;
@ -1345,7 +1345,7 @@ create_expression_by_pieces (basic_block block, tree expr, tree stmts)
pre_stats.insertions++;
break;
}
case '1':
case tcc_unary:
{
tree_stmt_iterator tsi;
tree genop1;
@ -1423,8 +1423,8 @@ insert_aux (basic_block block)
node;
node = node->next)
{
if (TREE_CODE_CLASS (TREE_CODE (node->expr)) == '2'
|| TREE_CODE_CLASS (TREE_CODE (node->expr)) == '1')
if (BINARY_CLASS_P (node->expr)
|| UNARY_CLASS_P (node->expr))
{
tree *avail;
tree val;
@ -1528,8 +1528,8 @@ insert_aux (basic_block block)
tree builtexpr;
bprime = pred->src;
eprime = avail[bprime->index];
if (TREE_CODE_CLASS (TREE_CODE (eprime)) == '2'
|| TREE_CODE_CLASS (TREE_CODE (eprime)) == '1')
if (BINARY_CLASS_P (eprime)
|| UNARY_CLASS_P (eprime))
{
builtexpr = create_expression_by_pieces (bprime,
eprime,
@ -1668,13 +1668,13 @@ create_value_expr_from (tree expr, basic_block block, vuse_optype vuses)
enum tree_code code = TREE_CODE (expr);
tree vexpr;
gcc_assert (TREE_CODE_CLASS (code) == '1'
|| TREE_CODE_CLASS (code) == '2'
|| TREE_CODE_CLASS (code) == 'r');
gcc_assert (TREE_CODE_CLASS (code) == tcc_unary
|| TREE_CODE_CLASS (code) == tcc_binary
|| TREE_CODE_CLASS (code) == tcc_reference);
if (TREE_CODE_CLASS (code) == '1')
if (TREE_CODE_CLASS (code) == tcc_unary)
vexpr = pool_alloc (unary_node_pool);
else if (TREE_CODE_CLASS (code) == 'r')
else if (TREE_CODE_CLASS (code) == tcc_reference)
vexpr = pool_alloc (reference_node_pool);
else
vexpr = pool_alloc (binary_node_pool);
@ -1791,8 +1791,7 @@ compute_avail (basic_block block)
value_insert_into_set (EXP_GEN (block), rhs);
continue;
}
else if (TREE_CODE_CLASS (TREE_CODE (rhs)) == '1'
|| TREE_CODE_CLASS (TREE_CODE (rhs)) == '2'
else if (UNARY_CLASS_P (rhs) || BINARY_CLASS_P (rhs)
|| TREE_CODE (rhs) == INDIRECT_REF)
{
/* For binary, unary, and reference expressions,

4
gcc/tree-ssa-propagate.c
View File

@ -564,13 +564,13 @@ set_rhs (tree *stmt_p, tree expr)
ssa_op_iter iter;
/* Verify the constant folded result is valid gimple. */
if (TREE_CODE_CLASS (code) == '2')
if (TREE_CODE_CLASS (code) == tcc_binary)
{
if (!is_gimple_val (TREE_OPERAND (expr, 0))
|| !is_gimple_val (TREE_OPERAND (expr, 1)))
return false;
}
else if (TREE_CODE_CLASS (code) == '1')
else if (TREE_CODE_CLASS (code) == tcc_unary)
{
if (!is_gimple_val (TREE_OPERAND (expr, 0)))
return false;

2
gcc/tree-ssa.c
View File

@ -1296,7 +1296,7 @@ warn_uninitialized_var (tree *tp, int *walk_subtrees, void *data)
warn_uninit (t, "%H'%D' is used uninitialized in this function", locus);
*walk_subtrees = 0;
}
else if (DECL_P (t) || TYPE_P (t))
else if (IS_TYPE_OR_DECL_P (t))
*walk_subtrees = 0;
return NULL_TREE;

6
gcc/tree-ssanames.c
View File

@ -1,5 +1,5 @@
/* Generic routines for manipulating SSA_NAME expressions
Copyright (C) 2003 Free Software Foundation, Inc.
Copyright (C) 2003, 2004 Free Software Foundation, Inc.
This file is part of GCC.
@ -184,9 +184,7 @@ make_ssa_name (tree var, tree stmt)
gcc_assert (DECL_P (var)
|| TREE_CODE (var) == INDIRECT_REF);
gcc_assert (!stmt
|| IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (stmt)))
|| TREE_CODE (stmt) == PHI_NODE);
gcc_assert (!stmt || EXPR_P (stmt) || TREE_CODE (stmt) == PHI_NODE);
/* If our free list has an element, then use it. Also reuse the
SSA version number of the element on the free list which helps

4
gcc/tree-tailcall.c
View File

@ -1,5 +1,5 @@
/* Tail call optimization on trees.
Copyright (C) 2003 Free Software Foundation, Inc.
Copyright (C) 2003, 2004 Free Software Foundation, Inc.
This file is part of GCC.
@ -279,7 +279,7 @@ process_assignment (tree ass, tree stmt, block_stmt_iterator call, tree *m,
return true;
}
if (TREE_CODE_CLASS (code) != '2')
if (TREE_CODE_CLASS (code) != tcc_binary)
return false;
/* Accumulator optimizations will reverse the order of operations.

242
gcc/tree.c
View File

@ -50,6 +50,23 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
#include "tree-flow.h"
#include "params.h"
/* Each tree code class has an associated string representation.
These must correspond to the tree_code_class entries. */
const char* tree_code_class_strings[] =
{
"exceptional",
"constant",
"type",
"declaration",
"reference",
"comparison",
"unary",
"binary",
"statement",
"expression",
};
/* obstack.[ch] explicitly declined to prototype this. */
extern int _obstack_allocated_p (struct obstack *h, void *obj);
@ -155,22 +172,22 @@ tree_code_size (enum tree_code code)
switch (TREE_CODE_CLASS (code))
{
case 'd': /* A decl node */
case tcc_declaration: /* A decl node */
return sizeof (struct tree_decl);
case 't': /* a type node */
case tcc_type: /* a type node */
return sizeof (struct tree_type);
case 'r': /* a reference */
case 'e': /* an expression */
case 's': /* an expression with side effects */
case '<': /* a comparison expression */
case '1': /* a unary arithmetic expression */
case '2': /* a binary arithmetic expression */
case tcc_reference: /* a reference */
case tcc_expression: /* an expression */
case tcc_statement: /* an expression with side effects */
case tcc_comparison: /* a comparison expression */
case tcc_unary: /* a unary arithmetic expression */
case tcc_binary: /* a binary arithmetic expression */
return (sizeof (struct tree_exp)
+ (TREE_CODE_LENGTH (code) - 1) * sizeof (char *));
case 'c': /* a constant */
case tcc_constant: /* a constant */
switch (code)
{
case INTEGER_CST: return sizeof (struct tree_int_cst);
@ -182,7 +199,7 @@ tree_code_size (enum tree_code code)
return lang_hooks.tree_size (code);
}
case 'x': /* something random, like an identifier. */
case tcc_exceptional: /* something random, like an identifier. */
switch (code)
{
case IDENTIFIER_NODE: return lang_hooks.identifier_size;
@ -240,41 +257,41 @@ tree
make_node_stat (enum tree_code code MEM_STAT_DECL)
{
tree t;
int type = TREE_CODE_CLASS (code);
enum tree_code_class type = TREE_CODE_CLASS (code);
size_t length = tree_code_size (code);
#ifdef GATHER_STATISTICS
tree_node_kind kind;
switch (type)
{
case 'd': /* A decl node */
case tcc_declaration: /* A decl node */
kind = d_kind;
break;
case 't': /* a type node */
case tcc_type: /* a type node */
kind = t_kind;
break;
case 's': /* an expression with side effects */
case tcc_statement: /* an expression with side effects */
kind = s_kind;
break;
case 'r': /* a reference */
case tcc_reference: /* a reference */
kind = r_kind;
break;
case 'e': /* an expression */
case '<': /* a comparison expression */
case '1': /* a unary arithmetic expression */
case '2': /* a binary arithmetic expression */
case tcc_expression: /* an expression */
case tcc_comparison: /* a comparison expression */
case tcc_unary: /* a unary arithmetic expression */
case tcc_binary: /* a binary arithmetic expression */
kind = e_kind;
break;
case 'c': /* a constant */
case tcc_constant: /* a constant */
kind = c_kind;
break;
case 'x': /* something random, like an identifier. */
case tcc_exceptional: /* something random, like an identifier. */
if (code == IDENTIFIER_NODE)
kind = id_kind;
else if (code == TREE_VEC)
@ -290,9 +307,6 @@ make_node_stat (enum tree_code code MEM_STAT_DECL)
else
kind = x_kind;
break;
default:
gcc_unreachable ();
}
tree_node_counts[(int) kind]++;
@ -307,11 +321,11 @@ make_node_stat (enum tree_code code MEM_STAT_DECL)
switch (type)
{
case 's':
case tcc_statement:
TREE_SIDE_EFFECTS (t) = 1;
break;
case 'd':
case tcc_declaration:
if (code != FUNCTION_DECL)
DECL_ALIGN (t) = 1;
DECL_USER_ALIGN (t) = 0;
@ -323,7 +337,7 @@ make_node_stat (enum tree_code code MEM_STAT_DECL)
DECL_POINTER_ALIAS_SET (t) = -1;
break;
case 't':
case tcc_type:
TYPE_UID (t) = next_type_uid++;
TYPE_ALIGN (t) = char_type_node ? TYPE_ALIGN (char_type_node) : 0;
TYPE_USER_ALIGN (t) = 0;
@ -337,12 +351,12 @@ make_node_stat (enum tree_code code MEM_STAT_DECL)
TYPE_ALIAS_SET (t) = -1;
break;
case 'c':
case tcc_constant:
TREE_CONSTANT (t) = 1;
TREE_INVARIANT (t) = 1;
break;
case 'e':
case tcc_expression:
switch (code)
{
case INIT_EXPR:
@ -361,6 +375,10 @@ make_node_stat (enum tree_code code MEM_STAT_DECL)
break;
}
break;
default:
/* Other classes need no special treatment. */
break;
}
return t;
@ -387,9 +405,9 @@ copy_node_stat (tree node MEM_STAT_DECL)
TREE_VISITED (t) = 0;
t->common.ann = 0;
if (TREE_CODE_CLASS (code) == 'd')
if (TREE_CODE_CLASS (code) == tcc_declaration)
DECL_UID (t) = next_decl_uid++;
else if (TREE_CODE_CLASS (code) == 't')
else if (TREE_CODE_CLASS (code) == tcc_type)
{
TYPE_UID (t) = next_type_uid++;
/* The following is so that the debug code for
@ -1566,9 +1584,9 @@ skip_simple_arithmetic (tree expr)
inner = expr;
while (1)
{
if (TREE_CODE_CLASS (TREE_CODE (inner)) == '1')
if (UNARY_CLASS_P (inner))
inner = TREE_OPERAND (inner, 0);
else if (TREE_CODE_CLASS (TREE_CODE (inner)) == '2')
else if (BINARY_CLASS_P (inner))
{
if (TREE_INVARIANT (TREE_OPERAND (inner, 1)))
inner = TREE_OPERAND (inner, 0);
@ -1606,22 +1624,29 @@ tree_node_structure (tree t)
switch (TREE_CODE_CLASS (code))
{
case 'd': return TS_DECL;
case 't': return TS_TYPE;
case 'r': case '<': case '1': case '2': case 'e': case 's':
case tcc_declaration:
return TS_DECL;
case tcc_type:
return TS_TYPE;
case tcc_reference:
case tcc_comparison:
case tcc_unary:
case tcc_binary:
case tcc_expression:
case tcc_statement:
return TS_EXP;
default: /* 'c' and 'x' */
default: /* tcc_constant and tcc_exceptional */
break;
}
switch (code)
{
/* 'c' cases. */
/* tcc_constant cases. */
case INTEGER_CST: return TS_INT_CST;
case REAL_CST: return TS_REAL_CST;
case COMPLEX_CST: return TS_COMPLEX;
case VECTOR_CST: return TS_VECTOR;
case STRING_CST: return TS_STRING;
/* 'x' cases. */
/* tcc_exceptional cases. */
case ERROR_MARK: return TS_COMMON;
case IDENTIFIER_NODE: return TS_IDENTIFIER;
case TREE_LIST: return TS_LIST;
@ -1656,22 +1681,23 @@ contains_placeholder_p (tree exp)
switch (TREE_CODE_CLASS (code))
{
case 'r':
case tcc_reference:
/* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
position computations since they will be converted into a
WITH_RECORD_EXPR involving the reference, which will assume
here will be valid. */
return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
case 'x':
case tcc_exceptional:
if (code == TREE_LIST)
return (CONTAINS_PLACEHOLDER_P (TREE_VALUE (exp))
|| CONTAINS_PLACEHOLDER_P (TREE_CHAIN (exp)));
break;
case '1':
case '2': case '<':
case 'e':
case tcc_unary:
case tcc_binary:
case tcc_comparison:
case tcc_expression:
switch (code)
{
case COMPOUND_EXPR:
@ -1823,7 +1849,7 @@ substitute_in_expr (tree exp, tree f, tree r)
/* If this expression is getting a value from a PLACEHOLDER_EXPR
and it is the right field, replace it with R. */
for (inner = TREE_OPERAND (exp, 0);
TREE_CODE_CLASS (TREE_CODE (inner)) == 'r';
REFERENCE_CLASS_P (inner);
inner = TREE_OPERAND (inner, 0))
;
if (TREE_CODE (inner) == PLACEHOLDER_EXPR
@ -1844,16 +1870,16 @@ substitute_in_expr (tree exp, tree f, tree r)
else
switch (TREE_CODE_CLASS (code))
{
case 'c':
case 'd':
case tcc_constant:
case tcc_declaration:
return exp;
case 'x':
case '1':
case '2':
case '<':
case 'e':
case 'r':
case tcc_exceptional:
case tcc_unary:
case tcc_binary:
case tcc_comparison:
case tcc_expression:
case tcc_reference:
switch (first_rtl_op (code))
{
case 0:
@ -1922,10 +1948,10 @@ substitute_placeholder_in_expr (tree exp, tree obj)
elt = ((TREE_CODE (elt) == COMPOUND_EXPR
|| TREE_CODE (elt) == COND_EXPR)
? TREE_OPERAND (elt, 1)
: (TREE_CODE_CLASS (TREE_CODE (elt)) == 'r'
|| TREE_CODE_CLASS (TREE_CODE (elt)) == '1'
|| TREE_CODE_CLASS (TREE_CODE (elt)) == '2'
|| TREE_CODE_CLASS (TREE_CODE (elt)) == 'e')
: (REFERENCE_CLASS_P (elt)
|| UNARY_CLASS_P (elt)
|| BINARY_CLASS_P (elt)
|| EXPRESSION_CLASS_P (elt))
? TREE_OPERAND (elt, 0) : 0))
if (TYPE_MAIN_VARIANT (TREE_TYPE (elt)) == need_type)
return elt;
@ -1934,10 +1960,10 @@ substitute_placeholder_in_expr (tree exp, tree obj)
elt = ((TREE_CODE (elt) == COMPOUND_EXPR
|| TREE_CODE (elt) == COND_EXPR)
? TREE_OPERAND (elt, 1)
: (TREE_CODE_CLASS (TREE_CODE (elt)) == 'r'
|| TREE_CODE_CLASS (TREE_CODE (elt)) == '1'
|| TREE_CODE_CLASS (TREE_CODE (elt)) == '2'
|| TREE_CODE_CLASS (TREE_CODE (elt)) == 'e')
: (REFERENCE_CLASS_P (elt)
|| UNARY_CLASS_P (elt)
|| BINARY_CLASS_P (elt)
|| EXPRESSION_CLASS_P (elt))
? TREE_OPERAND (elt, 0) : 0))
if (POINTER_TYPE_P (TREE_TYPE (elt))
&& (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt)))
@ -1963,17 +1989,17 @@ substitute_placeholder_in_expr (tree exp, tree obj)
else
switch (TREE_CODE_CLASS (code))
{
case 'c':
case 'd':
case tcc_constant:
case tcc_declaration:
return exp;
case 'x':
case '1':
case '2':
case '<':
case 'e':
case 'r':
case 's':
case tcc_exceptional:
case tcc_unary:
case tcc_binary:
case tcc_comparison:
case tcc_expression:
case tcc_reference:
case tcc_statement:
switch (first_rtl_op (code))
{
case 0:
@ -2145,13 +2171,13 @@ stabilize_reference_1 (tree e)
switch (TREE_CODE_CLASS (code))
{
case 'x':
case 't':
case 'd':
case '<':
case 's':
case 'e':
case 'r':
case tcc_exceptional:
case tcc_type:
case tcc_declaration:
case tcc_comparison:
case tcc_statement:
case tcc_expression:
case tcc_reference:
/* If the expression has side-effects, then encase it in a SAVE_EXPR
so that it will only be evaluated once. */
/* The reference (r) and comparison (<) classes could be handled as
@ -2160,12 +2186,12 @@ stabilize_reference_1 (tree e)
return save_expr (e);
return e;
case 'c':
case tcc_constant:
/* Constants need no processing. In fact, we should never reach
here. */
return e;
case '2':
case tcc_binary:
/* Division is slow and tends to be compiled with jumps,
especially the division by powers of 2 that is often
found inside of an array reference. So do it just once. */
@ -2179,7 +2205,7 @@ stabilize_reference_1 (tree e)
stabilize_reference_1 (TREE_OPERAND (e, 1)));
break;
case '1':
case tcc_unary:
/* Recursively stabilize each operand. */
result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)));
break;
@ -2271,7 +2297,7 @@ do { tree _node = (NODE); \
else
ti = tc = false;
}
else if (TREE_CODE_CLASS (TREE_CODE (node)) == 'c')
else if (CONSTANT_CLASS_P (node))
;
else
{
@ -2319,10 +2345,10 @@ build1_stat (enum tree_code code, tree type, tree node MEM_STAT_DECL)
#ifdef GATHER_STATISTICS
switch (TREE_CODE_CLASS (code))
{
case 's': /* an expression with side effects */
case tcc_statement: /* an expression with side effects */
kind = s_kind;
break;
case 'r': /* a reference */
case tcc_reference: /* a reference */
kind = r_kind;
break;
default:
@ -2357,7 +2383,7 @@ build1_stat (enum tree_code code, tree type, tree node MEM_STAT_DECL)
TREE_READONLY (t) = TREE_READONLY (node);
}
if (TREE_CODE_CLASS (code) == 's')
if (TREE_CODE_CLASS (code) == tcc_statement)
TREE_SIDE_EFFECTS (t) = 1;
else switch (code)
{
@ -2386,12 +2412,15 @@ build1_stat (enum tree_code code, tree type, tree node MEM_STAT_DECL)
break;
default:
if (TREE_CODE_CLASS (code) == '1' && node && !TYPE_P (node)
if (TREE_CODE_CLASS (code) == tcc_unary
&& node && !TYPE_P (node)
&& TREE_CONSTANT (node))
TREE_CONSTANT (t) = 1;
if (TREE_CODE_CLASS (code) == '1' && node && TREE_INVARIANT (node))
if (TREE_CODE_CLASS (code) == tcc_unary
&& node && TREE_INVARIANT (node))
TREE_INVARIANT (t) = 1;
if (TREE_CODE_CLASS (code) == 'r' && node && TREE_THIS_VOLATILE (node))
if (TREE_CODE_CLASS (code) == tcc_reference
&& node && TREE_THIS_VOLATILE (node))
TREE_THIS_VOLATILE (t) = 1;
break;
}
@ -2435,8 +2464,8 @@ build2_stat (enum tree_code code, tree tt, tree arg0, tree arg1 MEM_STAT_DECL)
/* Expressions without side effects may be constant if their
arguments are as well. */
constant = (TREE_CODE_CLASS (code) == '<'
|| TREE_CODE_CLASS (code) == '2');
constant = (TREE_CODE_CLASS (code) == tcc_comparison
|| TREE_CODE_CLASS (code) == tcc_binary);
read_only = 1;
side_effects = TREE_SIDE_EFFECTS (t);
invariant = constant;
@ -2449,7 +2478,8 @@ build2_stat (enum tree_code code, tree tt, tree arg0, tree arg1 MEM_STAT_DECL)
TREE_INVARIANT (t) = invariant;
TREE_SIDE_EFFECTS (t) = side_effects;
TREE_THIS_VOLATILE (t)
= TREE_CODE_CLASS (code) == 'r' && arg0 && TREE_THIS_VOLATILE (arg0);
= (TREE_CODE_CLASS (code) == tcc_reference
&& arg0 && TREE_THIS_VOLATILE (arg0));
return t;
}
@ -2497,7 +2527,8 @@ build3_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
TREE_SIDE_EFFECTS (t) = side_effects;
TREE_THIS_VOLATILE (t)
= TREE_CODE_CLASS (code) == 'r' && arg0 && TREE_THIS_VOLATILE (arg0);
= (TREE_CODE_CLASS (code) == tcc_reference
&& arg0 && TREE_THIS_VOLATILE (arg0));
return t;
}
@ -2526,7 +2557,8 @@ build4_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
TREE_SIDE_EFFECTS (t) = side_effects;
TREE_THIS_VOLATILE (t)
= TREE_CODE_CLASS (code) == 'r' && arg0 && TREE_THIS_VOLATILE (arg0);
= (TREE_CODE_CLASS (code) == tcc_reference
&& arg0 && TREE_THIS_VOLATILE (arg0));
return t;
}
@ -3829,12 +3861,12 @@ simple_cst_equal (tree t1, tree t2)
switch (TREE_CODE_CLASS (code1))
{
case '1':
case '2':
case '<':
case 'e':
case 'r':
case 's':
case tcc_unary:
case tcc_binary:
case tcc_comparison:
case tcc_expression:
case tcc_reference:
case tcc_statement:
cmp = 1;
for (i = 0; i < TREE_CODE_LENGTH (code1); i++)
{
@ -3976,7 +4008,7 @@ iterative_hash_expr (tree t, hashval_t val)
default:
class = TREE_CODE_CLASS (code);
if (class == 'd')
if (class == tcc_declaration)
{
/* Decls we can just compare by pointer. */
val = iterative_hash_pointer (t, val);
@ -4774,7 +4806,8 @@ find_var_from_fn (tree *tp, int *walk_subtrees, void *data)
if (TYPE_P (*tp))
*walk_subtrees = 0;
else if (DECL_P (*tp) && lang_hooks.tree_inlining.auto_var_in_fn_p (*tp, fn))
else if (DECL_P (*tp)
&& lang_hooks.tree_inlining.auto_var_in_fn_p (*tp, fn))
return *tp;
return NULL_TREE;
@ -5312,12 +5345,13 @@ tree_not_check_failed (const tree node, const char *file,
code, given in CL. */
void
tree_class_check_failed (const tree node, int cl, const char *file,
int line, const char *function)
tree_class_check_failed (const tree node, const enum tree_code_class cl,
const char *file, int line, const char *function)
{
internal_error
("tree check: expected class %qc, have %qc (%s) in %s, at %s:%d",
cl, TREE_CODE_CLASS (TREE_CODE (node)),
("tree check: expected class %qs, have %qs (%s) in %s, at %s:%d",
TREE_CODE_CLASS_STRING (cl),
TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
}

332
gcc/tree.def
View File

@ -21,49 +21,37 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA. */
/* The third argument can be:
'x' for an exceptional code (fits no category).
't' for a type object code.
'c' for codes for constants.
'd' for codes for declarations (also serving as variable refs).
'r' for codes for references to storage.
'<' for codes for comparison expressions.
'1' for codes for unary arithmetic expressions.
'2' for codes for binary arithmetic expressions.
's' for codes for "statement" expressions, which have side-effects,
but usually no interesting value.
'e' for codes for other kinds of expressions. */
/* For `r', `e', `<', `1', `2', and `s' nodes, which use struct
tree_exp, the 4th element is the number of argument slots to
allocate. This determines the size of the tree node object.
Other nodes use different structures, and the size is determined
by the tree_union member structure; the 4th element should be
zero. Languages that define language-specific 'x' or 'c' codes
must define the tree_size langhook to say how big they are. */
/* For tcc_references, tcc_expression, tcc_comparison, tcc_unary,
tcc_binary, and tcc_statement nodes, which use struct tree_exp, the
4th element is the number of argument slots to allocate. This
determines the size of the tree node object. Other nodes use
different structures, and the size is determined by the tree_union
member structure; the 4th element should be zero. Languages that
define language-specific tcc_exceptional or tcc_constant codes must
define the tree_size langhook to say how big they are. */
/* Any erroneous construct is parsed into a node of this type.
This type of node is accepted without complaint in all contexts
by later parsing activities, to avoid multiple error messages
for one error.
No fields in these nodes are used except the TREE_CODE. */
DEFTREECODE (ERROR_MARK, "error_mark", 'x', 0)
DEFTREECODE (ERROR_MARK, "error_mark", tcc_exceptional, 0)
/* Used to represent a name (such as, in the DECL_NAME of a decl node).
Internally it looks like a STRING_CST node.
There is only one IDENTIFIER_NODE ever made for any particular name.
Use `get_identifier' to get it (or create it, the first time). */
DEFTREECODE (IDENTIFIER_NODE, "identifier_node", 'x', 0)
DEFTREECODE (IDENTIFIER_NODE, "identifier_node", tcc_exceptional, 0)
/* Has the TREE_VALUE and TREE_PURPOSE fields. */
/* These nodes are made into lists by chaining through the
TREE_CHAIN field. The elements of the list live in the
TREE_VALUE fields, while TREE_PURPOSE fields are occasionally
used as well to get the effect of Lisp association lists. */
DEFTREECODE (TREE_LIST, "tree_list", 'x', 0)
DEFTREECODE (TREE_LIST, "tree_list", tcc_exceptional, 0)
/* These nodes contain an array of tree nodes. */
DEFTREECODE (TREE_VEC, "tree_vec", 'x', 0)
DEFTREECODE (TREE_VEC, "tree_vec", tcc_exceptional, 0)
/* A symbol binding block. These are arranged in a tree,
where the BLOCK_SUBBLOCKS field contains a chain of subblocks
@ -85,7 +73,7 @@ DEFTREECODE (TREE_VEC, "tree_vec", 'x', 0)
instance of an inline function).
TREE_ASM_WRITTEN is nonzero if the block was actually referenced
in the generated assembly. */
DEFTREECODE (BLOCK, "block", 'x', 0)
DEFTREECODE (BLOCK, "block", tcc_exceptional, 0)
/* Each data type is represented by a tree node whose code is one of
the following: */
@ -130,7 +118,8 @@ DEFTREECODE (BLOCK, "block", 'x', 0)
ENUMERAL_TYPE, RECORD_TYPE, UNION_TYPE, and QUAL_UNION_TYPE nodes;
see below. */
DEFTREECODE (VOID_TYPE, "void_type", 't', 0) /* The void type in C */
DEFTREECODE (VOID_TYPE, "void_type", tcc_type, 0)
/* The void type in C */
/* Integer types in all languages, including char in C.
Also used for sub-ranges of other discrete types.
@ -140,20 +129,20 @@ DEFTREECODE (VOID_TYPE, "void_type", 't', 0) /* The void type in C */
of this will point at the supertype (another INTEGER_TYPE,
or an ENUMERAL_TYPE, CHAR_TYPE, or BOOLEAN_TYPE).
Otherwise, the TREE_TYPE is zero. */
DEFTREECODE (INTEGER_TYPE, "integer_type", 't', 0)
DEFTREECODE (INTEGER_TYPE, "integer_type", tcc_type, 0)
/* C's float and double. Different floating types are distinguished
by machine mode and by the TYPE_SIZE and the TYPE_PRECISION. */
DEFTREECODE (REAL_TYPE, "real_type", 't', 0)
DEFTREECODE (REAL_TYPE, "real_type", tcc_type, 0)
/* Complex number types. The TREE_TYPE field is the data type
of the real and imaginary parts. */
DEFTREECODE (COMPLEX_TYPE, "complex_type", 't', 0)
DEFTREECODE (COMPLEX_TYPE, "complex_type", tcc_type, 0)
/* Vector types. The TREE_TYPE field is the data type of the vector
elements. The TYPE_PRECISION field is the number of subparts of
the vector. */
DEFTREECODE (VECTOR_TYPE, "vector_type", 't', 0)
DEFTREECODE (VECTOR_TYPE, "vector_type", tcc_type, 0)
/* C enums. The type node looks just like an INTEGER_TYPE node.
The symbols for the values of the enum type are defined by
@ -166,39 +155,39 @@ DEFTREECODE (VECTOR_TYPE, "vector_type", 't', 0)
fields are filled in.
RECORD_TYPE, UNION_TYPE, and QUAL_UNION_TYPE forward refs are
treated similarly. */
DEFTREECODE (ENUMERAL_TYPE, "enumeral_type", 't', 0)
DEFTREECODE (ENUMERAL_TYPE, "enumeral_type", tcc_type, 0)
/* Pascal's boolean type (true or false are the only values);
no special fields needed. */
DEFTREECODE (BOOLEAN_TYPE, "boolean_type", 't', 0)
DEFTREECODE (BOOLEAN_TYPE, "boolean_type", tcc_type, 0)
/* CHAR in Pascal; not used in C.
No special fields needed. */
DEFTREECODE (CHAR_TYPE, "char_type", 't', 0)
DEFTREECODE (CHAR_TYPE, "char_type", tcc_type, 0)
/* All pointer-to-x types have code POINTER_TYPE.
The TREE_TYPE points to the node for the type pointed to. */
DEFTREECODE (POINTER_TYPE, "pointer_type", 't', 0)
DEFTREECODE (POINTER_TYPE, "pointer_type", tcc_type, 0)
/* An offset is a pointer relative to an object.
The TREE_TYPE field is the type of the object at the offset.
The TYPE_OFFSET_BASETYPE points to the node for the type of object
that the offset is relative to. */
DEFTREECODE (OFFSET_TYPE, "offset_type", 't', 0)
DEFTREECODE (OFFSET_TYPE, "offset_type", tcc_type, 0)
/* A reference is like a pointer except that it is coerced
automatically to the value it points to. Used in C++. */
DEFTREECODE (REFERENCE_TYPE, "reference_type", 't', 0)
DEFTREECODE (REFERENCE_TYPE, "reference_type", tcc_type, 0)
/* METHOD_TYPE is the type of a function which takes an extra first
argument for "self", which is not present in the declared argument list.
The TREE_TYPE is the return type of the method. The TYPE_METHOD_BASETYPE
is the type of "self". TYPE_ARG_TYPES is the real argument list, which
includes the hidden argument for "self". */
DEFTREECODE (METHOD_TYPE, "method_type", 't', 0)
DEFTREECODE (METHOD_TYPE, "method_type", tcc_type, 0)
/* Used for Pascal; details not determined right now. */
DEFTREECODE (FILE_TYPE, "file_type", 't', 0)
DEFTREECODE (FILE_TYPE, "file_type", tcc_type, 0)
/* Types of arrays. Special fields:
TREE_TYPE Type of an array element.
@ -209,13 +198,13 @@ DEFTREECODE (FILE_TYPE, "file_type", 't', 0)
TYPE_STRING_FLAG indicates a string (in contrast to an array of chars)
in languages (such as Chill) that make a distinction. */
/* Array types in C or Pascal */
DEFTREECODE (ARRAY_TYPE, "array_type", 't', 0)
DEFTREECODE (ARRAY_TYPE, "array_type", tcc_type, 0)
/* Types of sets for Pascal. Special fields are the same as
in an array type. The target type is always a boolean type.
Used for both bitstrings and powersets in Chill;
TYPE_STRING_FLAG indicates a bitstring. */
DEFTREECODE (SET_TYPE, "set_type", 't', 0)
DEFTREECODE (SET_TYPE, "set_type", tcc_type, 0)
/* Struct in C, or record in Pascal. */
/* Special fields:
@ -225,19 +214,19 @@ DEFTREECODE (SET_TYPE, "set_type", 't', 0)
A few may need to be added for Pascal. */
/* See the comment above, before ENUMERAL_TYPE, for how
forward references to struct tags are handled in C. */
DEFTREECODE (RECORD_TYPE, "record_type", 't', 0)
DEFTREECODE (RECORD_TYPE, "record_type", tcc_type, 0)
/* Union in C. Like a struct, except that the offsets of the fields
will all be zero. */
/* See the comment above, before ENUMERAL_TYPE, for how
forward references to union tags are handled in C. */
DEFTREECODE (UNION_TYPE, "union_type", 't', 0) /* C union type */
DEFTREECODE (UNION_TYPE, "union_type", tcc_type, 0) /* C union type */
/* Similar to UNION_TYPE, except that the expressions in DECL_QUALIFIER
in each FIELD_DECL determine what the union contains. The first
field whose DECL_QUALIFIER expression is true is deemed to occupy
the union. */
DEFTREECODE (QUAL_UNION_TYPE, "qual_union_type", 't', 0)
DEFTREECODE (QUAL_UNION_TYPE, "qual_union_type", tcc_type, 0)
/* Type of functions. Special fields:
TREE_TYPE type of value returned.
@ -245,13 +234,13 @@ DEFTREECODE (QUAL_UNION_TYPE, "qual_union_type", 't', 0)
this list is made of TREE_LIST nodes.
Types of "Procedures" in languages where they are different from functions
have code FUNCTION_TYPE also, but then TREE_TYPE is zero or void type. */
DEFTREECODE (FUNCTION_TYPE, "function_type", 't', 0)
DEFTREECODE (FUNCTION_TYPE, "function_type", tcc_type, 0)
/* This is a language-specific kind of type.
Its meaning is defined by the language front end.
layout_type does not know how to lay this out,
so the front-end must do so manually. */
DEFTREECODE (LANG_TYPE, "lang_type", 't', 0)
DEFTREECODE (LANG_TYPE, "lang_type", tcc_type, 0)
/* Expressions */
@ -265,20 +254,20 @@ DEFTREECODE (LANG_TYPE, "lang_type", 't', 0)
TREE_CONSTANT_OVERFLOW already set, it is known to be unique.
INTEGER_CST nodes are created for the integral types, for pointer
types and for vector and float types in some circumstances. */
DEFTREECODE (INTEGER_CST, "integer_cst", 'c', 0)
DEFTREECODE (INTEGER_CST, "integer_cst", tcc_constant, 0)
/* Contents are in TREE_REAL_CST field. */
DEFTREECODE (REAL_CST, "real_cst", 'c', 0)
DEFTREECODE (REAL_CST, "real_cst", tcc_constant, 0)
/* Contents are in TREE_REALPART and TREE_IMAGPART fields,
whose contents are other constant nodes. */
DEFTREECODE (COMPLEX_CST, "complex_cst", 'c', 0)
DEFTREECODE (COMPLEX_CST, "complex_cst", tcc_constant, 0)
/* Contents are in TREE_VECTOR_CST_ELTS field. */
DEFTREECODE (VECTOR_CST, "vector_cst", 'c', 0)
DEFTREECODE (VECTOR_CST, "vector_cst", tcc_constant, 0)
/* Contents are TREE_STRING_LENGTH and TREE_STRING_POINTER fields. */
DEFTREECODE (STRING_CST, "string_cst", 'c', 0)
DEFTREECODE (STRING_CST, "string_cst", tcc_constant, 0)
/* Declarations. All references to names are represented as ..._DECL
nodes. The decls in one binding context are chained through the
@ -338,22 +327,23 @@ DEFTREECODE (STRING_CST, "string_cst", 'c', 0)
of a decl (i.e. one which is nested within an abstract instance of a
inline function. */
DEFTREECODE (FUNCTION_DECL, "function_decl", 'd', 0)
DEFTREECODE (LABEL_DECL, "label_decl", 'd', 0)
DEFTREECODE (CONST_DECL, "const_decl", 'd', 0)
DEFTREECODE (TYPE_DECL, "type_decl", 'd', 0)
DEFTREECODE (VAR_DECL, "var_decl", 'd', 0)
DEFTREECODE (PARM_DECL, "parm_decl", 'd', 0)
DEFTREECODE (RESULT_DECL, "result_decl", 'd', 0)
DEFTREECODE (FIELD_DECL, "field_decl", 'd', 0)
DEFTREECODE (FUNCTION_DECL, "function_decl", tcc_declaration, 0)
DEFTREECODE (LABEL_DECL, "label_decl", tcc_declaration, 0)
DEFTREECODE (CONST_DECL, "const_decl", tcc_declaration, 0)
DEFTREECODE (TYPE_DECL, "type_decl", tcc_declaration, 0)
DEFTREECODE (VAR_DECL, "var_decl", tcc_declaration, 0)
DEFTREECODE (PARM_DECL, "parm_decl", tcc_declaration, 0)
DEFTREECODE (RESULT_DECL, "result_decl", tcc_declaration, 0)
DEFTREECODE (FIELD_DECL, "field_decl", tcc_declaration, 0)
/* A namespace declaration. Namespaces appear in DECL_CONTEXT of other
_DECLs, providing a hierarchy of names. */
DEFTREECODE (NAMESPACE_DECL, "namespace_decl", 'd', 0)
DEFTREECODE (NAMESPACE_DECL, "namespace_decl", tcc_declaration, 0)
/* A translation unit. This is not technically a declaration, since it
can't be looked up, but it's close enough. */
DEFTREECODE (TRANSLATION_UNIT_DECL, "translation_unit_decl", 'd', 0)
DEFTREECODE (TRANSLATION_UNIT_DECL, "translation_unit_decl",\
tcc_declaration, 0)
/* References to storage. */
@ -362,7 +352,7 @@ DEFTREECODE (TRANSLATION_UNIT_DECL, "translation_unit_decl", 'd', 0)
Operand 1 is the field (a node of type FIELD_DECL).
Operand 2, if present, is the value of DECL_FIELD_OFFSET, measured
in units of DECL_OFFSET_ALIGN / BITS_PER_UNIT. */
DEFTREECODE (COMPONENT_REF, "component_ref", 'r', 3)
DEFTREECODE (COMPONENT_REF, "component_ref", tcc_reference, 3)
/* Reference to a group of bits within an object. Similar to COMPONENT_REF
except the position is given explicitly rather than via a FIELD_DECL.
@ -371,22 +361,22 @@ DEFTREECODE (COMPONENT_REF, "component_ref", 'r', 3)
operand 2 is a tree giving the position of the first referenced bit.
The field can be either a signed or unsigned field;
BIT_FIELD_REF_UNSIGNED says which. */
DEFTREECODE (BIT_FIELD_REF, "bit_field_ref", 'r', 3)
DEFTREECODE (BIT_FIELD_REF, "bit_field_ref", tcc_reference, 3)
/* C unary `*' or Pascal `^'. One operand, an expression for a pointer. */
DEFTREECODE (INDIRECT_REF, "indirect_ref", 'r', 1)
DEFTREECODE (INDIRECT_REF, "indirect_ref", tcc_reference, 1)
/* Array indexing.
Operand 0 is the array; operand 1 is a (single) array index.
Operand 2, if present, is a copy of TYPE_MIN_VALUE of the index.
Operand 3, if present, is the element size, measured in units of
the alignment of the element type. */
DEFTREECODE (ARRAY_REF, "array_ref", 'r', 4)
DEFTREECODE (ARRAY_REF, "array_ref", tcc_reference, 4)
/* Likewise, except that the result is a range ("slice") of the array. The
starting index of the resulting array is taken from operand 1 and the size
of the range is taken from the type of the expression. */
DEFTREECODE (ARRAY_RANGE_REF, "array_range_ref", 'r', 4)
DEFTREECODE (ARRAY_RANGE_REF, "array_range_ref", tcc_reference, 4)
/* Used to represent lookup of runtime type dependent data. Often this is
a reference to a vtable, but it needn't be. Operands are:
@ -398,13 +388,13 @@ DEFTREECODE (ARRAY_RANGE_REF, "array_range_ref", 'r', 4)
reference to something simpler, usually to the address of a DECL.
Never touched by the middle-end. Good choices would be either an
identifier or a vtable index. */
DEFTREECODE (OBJ_TYPE_REF, "obj_type_ref", 'e', 3)
DEFTREECODE (OBJ_TYPE_REF, "obj_type_ref", tcc_expression, 3)
/* The exception object from the runtime. */
DEFTREECODE (EXC_PTR_EXPR, "exc_ptr_expr", 'e', 0)
DEFTREECODE (EXC_PTR_EXPR, "exc_ptr_expr", tcc_expression, 0)
/* The filter object from the runtime. */
DEFTREECODE (FILTER_EXPR, "filter_expr", 'e', 0)
DEFTREECODE (FILTER_EXPR, "filter_expr", tcc_expression, 0)
/* Constructor: return an aggregate value made from specified components.
In C, this is used only for structure and array initializers.
@ -426,7 +416,7 @@ DEFTREECODE (FILTER_EXPR, "filter_expr", 'e', 0)
The TREE_VALUE specifies a value (index) in the set that is true.
If TREE_PURPOSE is non-NULL, it specifies the lower limit of a
range of true values. Elements not listed are false (not in the set). */
DEFTREECODE (CONSTRUCTOR, "constructor", 'e', 1)
DEFTREECODE (CONSTRUCTOR, "constructor", tcc_expression, 1)
/* The expression types are mostly straightforward, with the fourth argument
of DEFTREECODE saying how many operands there are.
@ -436,14 +426,14 @@ DEFTREECODE (CONSTRUCTOR, "constructor", 'e', 1)
/* Contains two expressions to compute, one followed by the other.
the first value is ignored. The second one's value is used. The
type of the first expression need not agree with the other types. */
DEFTREECODE (COMPOUND_EXPR, "compound_expr", 'e', 2)
DEFTREECODE (COMPOUND_EXPR, "compound_expr", tcc_expression, 2)
/* Assignment expression. Operand 0 is the what to set; 1, the new value. */
DEFTREECODE (MODIFY_EXPR, "modify_expr", 'e', 2)
DEFTREECODE (MODIFY_EXPR, "modify_expr", tcc_expression, 2)
/* Initialization expression. Operand 0 is the variable to initialize;
Operand 1 is the initializer. */
DEFTREECODE (INIT_EXPR, "init_expr", 'e', 2)
DEFTREECODE (INIT_EXPR, "init_expr", tcc_expression, 2)
/* For TARGET_EXPR, operand 0 is the target of an initialization,
operand 1 is the initializer for the target, which may be void
@ -451,7 +441,7 @@ DEFTREECODE (INIT_EXPR, "init_expr", 'e', 2)
operand 2 is the cleanup for this node, if any.
operand 3 is the saved initializer after this node has been
expanded once; this is so we can re-expand the tree later. */
DEFTREECODE (TARGET_EXPR, "target_expr", 'e', 4)
DEFTREECODE (TARGET_EXPR, "target_expr", tcc_expression, 4)
/* Conditional expression ( ... ? ... : ... in C).
Operand 0 is the condition.
@ -461,7 +451,7 @@ DEFTREECODE (TARGET_EXPR, "target_expr", 'e', 4)
Operand 1 must have the same type as the entire expression, unless
it unconditionally throws an exception, in which case it should
have VOID_TYPE. The same constraints apply to operand 2. */
DEFTREECODE (COND_EXPR, "cond_expr", 'e', 3)
DEFTREECODE (COND_EXPR, "cond_expr", tcc_expression, 3)
/* Declare local variables, including making RTL and allocating space.
BIND_EXPR_VARS is a chain of VAR_DECL nodes for the variables.
@ -484,25 +474,25 @@ DEFTREECODE (COND_EXPR, "cond_expr", 'e', 3)
In order for the BIND_EXPR to be known at all, the code that creates it
must also install it as a subblock in the tree of BLOCK
nodes for the function. */
DEFTREECODE (BIND_EXPR, "bind_expr", 'e', 3)
DEFTREECODE (BIND_EXPR, "bind_expr", tcc_expression, 3)
/* A labeled block. Operand 0 is the label that will be generated to
mark the end of the block.
Operand 1 is the labeled block body. */
DEFTREECODE (LABELED_BLOCK_EXPR, "labeled_block_expr", 'e', 2)
DEFTREECODE (LABELED_BLOCK_EXPR, "labeled_block_expr", tcc_expression, 2)
/* Function call. Operand 0 is the function.
Operand 1 is the argument list, a list of expressions
made out of a chain of TREE_LIST nodes.
Operand 2 is the static chain argument, or NULL. */
DEFTREECODE (CALL_EXPR, "call_expr", 'e', 3)
DEFTREECODE (CALL_EXPR, "call_expr", tcc_expression, 3)
/* Specify a value to compute along with its corresponding cleanup.
Operand 0 is the cleanup expression.
The cleanup is executed by the first enclosing CLEANUP_POINT_EXPR,
which must exist. This differs from TRY_CATCH_EXPR in that operand 1
is always evaluated when cleanups are run. */
DEFTREECODE (WITH_CLEANUP_EXPR, "with_cleanup_expr", 'e', 1)
DEFTREECODE (WITH_CLEANUP_EXPR, "with_cleanup_expr", tcc_expression, 1)
/* Specify a cleanup point.
Operand 0 is an expression that may have cleanups. If it does, those
@ -519,7 +509,7 @@ DEFTREECODE (WITH_CLEANUP_EXPR, "with_cleanup_expr", 'e', 1)
As a consequence, the operand of a CLEANUP_POINT_EXPR must not have
BLKmode, because it will not be forced out of memory. */
DEFTREECODE (CLEANUP_POINT_EXPR, "cleanup_point_expr", 'e', 1)
DEFTREECODE (CLEANUP_POINT_EXPR, "cleanup_point_expr", tcc_expression, 1)
/* The following two codes are used in languages that have types where
some field in an object of the type contains a value that is used in
@ -571,62 +561,62 @@ DEFTREECODE (CLEANUP_POINT_EXPR, "cleanup_point_expr", 'e', 1)
/* Denotes a record to later be substituted before evaluating this expression.
The type of this expression is used to find the record to replace it. */
DEFTREECODE (PLACEHOLDER_EXPR, "placeholder_expr", 'x', 0)
DEFTREECODE (PLACEHOLDER_EXPR, "placeholder_expr", tcc_exceptional, 0)
/* Simple arithmetic. */
DEFTREECODE (PLUS_EXPR, "plus_expr", '2', 2)
DEFTREECODE (MINUS_EXPR, "minus_expr", '2', 2)
DEFTREECODE (MULT_EXPR, "mult_expr", '2', 2)
DEFTREECODE (PLUS_EXPR, "plus_expr", tcc_binary, 2)
DEFTREECODE (MINUS_EXPR, "minus_expr", tcc_binary, 2)
DEFTREECODE (MULT_EXPR, "mult_expr", tcc_binary, 2)
/* Division for integer result that rounds the quotient toward zero. */
DEFTREECODE (TRUNC_DIV_EXPR, "trunc_div_expr", '2', 2)
DEFTREECODE (TRUNC_DIV_EXPR, "trunc_div_expr", tcc_binary, 2)
/* Division for integer result that rounds the quotient toward infinity. */
DEFTREECODE (CEIL_DIV_EXPR, "ceil_div_expr", '2', 2)
DEFTREECODE (CEIL_DIV_EXPR, "ceil_div_expr", tcc_binary, 2)
/* Division for integer result that rounds toward minus infinity. */
DEFTREECODE (FLOOR_DIV_EXPR, "floor_div_expr", '2', 2)
DEFTREECODE (FLOOR_DIV_EXPR, "floor_div_expr", tcc_binary, 2)
/* Division for integer result that rounds toward nearest integer. */
DEFTREECODE (ROUND_DIV_EXPR, "round_div_expr", '2', 2)
DEFTREECODE (ROUND_DIV_EXPR, "round_div_expr", tcc_binary, 2)
/* Four kinds of remainder that go with the four kinds of division. */
DEFTREECODE (TRUNC_MOD_EXPR, "trunc_mod_expr", '2', 2)
DEFTREECODE (CEIL_MOD_EXPR, "ceil_mod_expr", '2', 2)
DEFTREECODE (FLOOR_MOD_EXPR, "floor_mod_expr", '2', 2)
DEFTREECODE (ROUND_MOD_EXPR, "round_mod_expr", '2', 2)
DEFTREECODE (TRUNC_MOD_EXPR, "trunc_mod_expr", tcc_binary, 2)
DEFTREECODE (CEIL_MOD_EXPR, "ceil_mod_expr", tcc_binary, 2)
DEFTREECODE (FLOOR_MOD_EXPR, "floor_mod_expr", tcc_binary, 2)
DEFTREECODE (ROUND_MOD_EXPR, "round_mod_expr", tcc_binary, 2)
/* Division for real result. */
DEFTREECODE (RDIV_EXPR, "rdiv_expr", '2', 2)
DEFTREECODE (RDIV_EXPR, "rdiv_expr", tcc_binary, 2)
/* Division which is not supposed to need rounding.
Used for pointer subtraction in C. */
DEFTREECODE (EXACT_DIV_EXPR, "exact_div_expr", '2', 2)
DEFTREECODE (EXACT_DIV_EXPR, "exact_div_expr", tcc_binary, 2)
/* Conversion of real to fixed point: four ways to round,
like the four ways to divide.
CONVERT_EXPR can also be used to convert a real to an integer,
and that is what is used in languages that do not have ways of
specifying which of these is wanted. Maybe these are not needed. */
DEFTREECODE (FIX_TRUNC_EXPR, "fix_trunc_expr", '1', 1)
DEFTREECODE (FIX_CEIL_EXPR, "fix_ceil_expr", '1', 1)
DEFTREECODE (FIX_FLOOR_EXPR, "fix_floor_expr", '1', 1)
DEFTREECODE (FIX_ROUND_EXPR, "fix_round_expr", '1', 1)
DEFTREECODE (FIX_TRUNC_EXPR, "fix_trunc_expr", tcc_unary, 1)
DEFTREECODE (FIX_CEIL_EXPR, "fix_ceil_expr", tcc_unary, 1)
DEFTREECODE (FIX_FLOOR_EXPR, "fix_floor_expr", tcc_unary, 1)
DEFTREECODE (FIX_ROUND_EXPR, "fix_round_expr", tcc_unary, 1)
/* Conversion of an integer to a real. */
DEFTREECODE (FLOAT_EXPR, "float_expr", '1', 1)
DEFTREECODE (FLOAT_EXPR, "float_expr", tcc_unary, 1)
/* Unary negation. */
DEFTREECODE (NEGATE_EXPR, "negate_expr", '1', 1)
DEFTREECODE (NEGATE_EXPR, "negate_expr", tcc_unary, 1)
DEFTREECODE (MIN_EXPR, "min_expr", '2', 2)
DEFTREECODE (MAX_EXPR, "max_expr", '2', 2)
DEFTREECODE (MIN_EXPR, "min_expr", tcc_binary, 2)
DEFTREECODE (MAX_EXPR, "max_expr", tcc_binary, 2)
/* Represents the absolute value of the operand.
An ABS_EXPR must have either an INTEGER_TYPE or a REAL_TYPE. The
operand of the ABS_EXPR must have the same type. */
DEFTREECODE (ABS_EXPR, "abs_expr", '1', 1)
DEFTREECODE (ABS_EXPR, "abs_expr", tcc_unary, 1)
/* Shift operations for shift and rotate.
Shift means logical shift if done on an
@ -635,16 +625,16 @@ DEFTREECODE (ABS_EXPR, "abs_expr", '1', 1)
shift by; it need not be the same type as the first operand and result.
Note that the result is undefined if the second operand is larger
than the first operand's type size. */
DEFTREECODE (LSHIFT_EXPR, "lshift_expr", '2', 2)
DEFTREECODE (RSHIFT_EXPR, "rshift_expr", '2', 2)
DEFTREECODE (LROTATE_EXPR, "lrotate_expr", '2', 2)
DEFTREECODE (RROTATE_EXPR, "rrotate_expr", '2', 2)
DEFTREECODE (LSHIFT_EXPR, "lshift_expr", tcc_binary, 2)
DEFTREECODE (RSHIFT_EXPR, "rshift_expr", tcc_binary, 2)
DEFTREECODE (LROTATE_EXPR, "lrotate_expr", tcc_binary, 2)
DEFTREECODE (RROTATE_EXPR, "rrotate_expr", tcc_binary, 2)
/* Bitwise operations. Operands have same mode as result. */
DEFTREECODE (BIT_IOR_EXPR, "bit_ior_expr", '2', 2)
DEFTREECODE (BIT_XOR_EXPR, "bit_xor_expr", '2', 2)
DEFTREECODE (BIT_AND_EXPR, "bit_and_expr", '2', 2)
DEFTREECODE (BIT_NOT_EXPR, "bit_not_expr", '1', 1)
DEFTREECODE (BIT_IOR_EXPR, "bit_ior_expr", tcc_binary, 2)
DEFTREECODE (BIT_XOR_EXPR, "bit_xor_expr", tcc_binary, 2)
DEFTREECODE (BIT_AND_EXPR, "bit_and_expr", tcc_binary, 2)
DEFTREECODE (BIT_NOT_EXPR, "bit_not_expr", tcc_unary, 1)
/* ANDIF and ORIF allow the second operand not to be computed if the
value of the expression is determined from the first operand. AND,
@ -655,12 +645,12 @@ DEFTREECODE (BIT_NOT_EXPR, "bit_not_expr", '1', 1)
an INTEGER_TYPE VAR_DECL as its argument; instead, a NE_EXPR will be
used to compare the VAR_DECL to zero, thereby obtaining a node with
value zero or one. */
DEFTREECODE (TRUTH_ANDIF_EXPR, "truth_andif_expr", 'e', 2)
DEFTREECODE (TRUTH_ORIF_EXPR, "truth_orif_expr", 'e', 2)
DEFTREECODE (TRUTH_AND_EXPR, "truth_and_expr", 'e', 2)
DEFTREECODE (TRUTH_OR_EXPR, "truth_or_expr", 'e', 2)
DEFTREECODE (TRUTH_XOR_EXPR, "truth_xor_expr", 'e', 2)
DEFTREECODE (TRUTH_NOT_EXPR, "truth_not_expr", 'e', 1)
DEFTREECODE (TRUTH_ANDIF_EXPR, "truth_andif_expr", tcc_expression, 2)
DEFTREECODE (TRUTH_ORIF_EXPR, "truth_orif_expr", tcc_expression, 2)
DEFTREECODE (TRUTH_AND_EXPR, "truth_and_expr", tcc_expression, 2)
DEFTREECODE (TRUTH_OR_EXPR, "truth_or_expr", tcc_expression, 2)
DEFTREECODE (TRUTH_XOR_EXPR, "truth_xor_expr", tcc_expression, 2)
DEFTREECODE (TRUTH_NOT_EXPR, "truth_not_expr", tcc_expression, 1)
/* Relational operators.
`EQ_EXPR' and `NE_EXPR' are allowed for any types.
@ -668,39 +658,39 @@ DEFTREECODE (TRUTH_NOT_EXPR, "truth_not_expr", 'e', 1)
or real types.
In all cases the operands will have the same type,
and the value is always the type used by the language for booleans. */
DEFTREECODE (LT_EXPR, "lt_expr", '<', 2)
DEFTREECODE (LE_EXPR, "le_expr", '<', 2)
DEFTREECODE (GT_EXPR, "gt_expr", '<', 2)
DEFTREECODE (GE_EXPR, "ge_expr", '<', 2)
DEFTREECODE (EQ_EXPR, "eq_expr", '<', 2)
DEFTREECODE (NE_EXPR, "ne_expr", '<', 2)
DEFTREECODE (LT_EXPR, "lt_expr", tcc_comparison, 2)
DEFTREECODE (LE_EXPR, "le_expr", tcc_comparison, 2)
DEFTREECODE (GT_EXPR, "gt_expr", tcc_comparison, 2)
DEFTREECODE (GE_EXPR, "ge_expr", tcc_comparison, 2)
DEFTREECODE (EQ_EXPR, "eq_expr", tcc_comparison, 2)
DEFTREECODE (NE_EXPR, "ne_expr", tcc_comparison, 2)
/* Additional relational operators for floating point unordered. */
DEFTREECODE (UNORDERED_EXPR, "unordered_expr", '<', 2)
DEFTREECODE (ORDERED_EXPR, "ordered_expr", '<', 2)
DEFTREECODE (UNORDERED_EXPR, "unordered_expr", tcc_comparison, 2)
DEFTREECODE (ORDERED_EXPR, "ordered_expr", tcc_comparison, 2)
/* These are equivalent to unordered or ... */
DEFTREECODE (UNLT_EXPR, "unlt_expr", '<', 2)
DEFTREECODE (UNLE_EXPR, "unle_expr", '<', 2)
DEFTREECODE (UNGT_EXPR, "ungt_expr", '<', 2)
DEFTREECODE (UNGE_EXPR, "unge_expr", '<', 2)
DEFTREECODE (UNEQ_EXPR, "uneq_expr", '<', 2)
DEFTREECODE (UNLT_EXPR, "unlt_expr", tcc_comparison, 2)
DEFTREECODE (UNLE_EXPR, "unle_expr", tcc_comparison, 2)
DEFTREECODE (UNGT_EXPR, "ungt_expr", tcc_comparison, 2)
DEFTREECODE (UNGE_EXPR, "unge_expr", tcc_comparison, 2)
DEFTREECODE (UNEQ_EXPR, "uneq_expr", tcc_comparison, 2)
/* This is the reverse of uneq_expr. */
DEFTREECODE (LTGT_EXPR, "ltgt_expr", '<', 2)
DEFTREECODE (LTGT_EXPR, "ltgt_expr", tcc_comparison, 2)
DEFTREECODE (RANGE_EXPR, "range_expr", '2', 2)
DEFTREECODE (RANGE_EXPR, "range_expr", tcc_binary, 2)
/* Represents a conversion of type of a value.
All conversions, including implicit ones, must be
represented by CONVERT_EXPR or NOP_EXPR nodes. */
DEFTREECODE (CONVERT_EXPR, "convert_expr", '1', 1)
DEFTREECODE (CONVERT_EXPR, "convert_expr", tcc_unary, 1)
/* Represents a conversion expected to require no code to be generated. */
DEFTREECODE (NOP_EXPR, "nop_expr", '1', 1)
DEFTREECODE (NOP_EXPR, "nop_expr", tcc_unary, 1)
/* Value is same as argument, but guaranteed not an lvalue. */
DEFTREECODE (NON_LVALUE_EXPR, "non_lvalue_expr", '1', 1)
DEFTREECODE (NON_LVALUE_EXPR, "non_lvalue_expr", tcc_unary, 1)
/* Represents viewing something of one type as being of a second type.
This corresponds to an "Unchecked Conversion" in Ada and roughly to
@ -712,91 +702,91 @@ DEFTREECODE (NON_LVALUE_EXPR, "non_lvalue_expr", '1', 1)
case no actual data motion may occur. TREE_ADDRESSABLE will be set in
this case and GCC must abort if it could not do the operation without
generating insns. */
DEFTREECODE (VIEW_CONVERT_EXPR, "view_convert_expr", 'r', 1)
DEFTREECODE (VIEW_CONVERT_EXPR, "view_convert_expr", tcc_reference, 1)
/* Represents something we computed once and will use multiple times.
First operand is that expression. After it is evaluated once, it
will be replaced by the temporary variable that holds the value. */
DEFTREECODE (SAVE_EXPR, "save_expr", 'e', 1)
DEFTREECODE (SAVE_EXPR, "save_expr", tcc_expression, 1)
/* & in C. Value is the address at which the operand's value resides.
Operand may have any mode. Result mode is Pmode. */
DEFTREECODE (ADDR_EXPR, "addr_expr", 'e', 1)
DEFTREECODE (ADDR_EXPR, "addr_expr", tcc_expression, 1)
/* Operand0 is a function constant; result is part N of a function
descriptor of type ptr_mode. */
DEFTREECODE (FDESC_EXPR, "fdesc_expr", 'e', 2)
DEFTREECODE (FDESC_EXPR, "fdesc_expr", tcc_expression, 2)
/* Given two real or integer operands of the same type,
returns a complex value of the corresponding complex type. */
DEFTREECODE (COMPLEX_EXPR, "complex_expr", '2', 2)
DEFTREECODE (COMPLEX_EXPR, "complex_expr", tcc_binary, 2)
/* Complex conjugate of operand. Used only on complex types. */
DEFTREECODE (CONJ_EXPR, "conj_expr", '1', 1)
DEFTREECODE (CONJ_EXPR, "conj_expr", tcc_unary, 1)
/* Used only on an operand of complex type, these return
a value of the corresponding component type. */
DEFTREECODE (REALPART_EXPR, "realpart_expr", 'r', 1)
DEFTREECODE (IMAGPART_EXPR, "imagpart_expr", 'r', 1)
DEFTREECODE (REALPART_EXPR, "realpart_expr", tcc_reference, 1)
DEFTREECODE (IMAGPART_EXPR, "imagpart_expr", tcc_reference, 1)
/* Nodes for ++ and -- in C.
The second arg is how much to increment or decrement by.
For a pointer, it would be the size of the object pointed to. */
DEFTREECODE (PREDECREMENT_EXPR, "predecrement_expr", 'e', 2)
DEFTREECODE (PREINCREMENT_EXPR, "preincrement_expr", 'e', 2)
DEFTREECODE (POSTDECREMENT_EXPR, "postdecrement_expr", 'e', 2)
DEFTREECODE (POSTINCREMENT_EXPR, "postincrement_expr", 'e', 2)
DEFTREECODE (PREDECREMENT_EXPR, "predecrement_expr", tcc_expression, 2)
DEFTREECODE (PREINCREMENT_EXPR, "preincrement_expr", tcc_expression, 2)
DEFTREECODE (POSTDECREMENT_EXPR, "postdecrement_expr", tcc_expression, 2)
DEFTREECODE (POSTINCREMENT_EXPR, "postincrement_expr", tcc_expression, 2)
/* Used to implement `va_arg'. */
DEFTREECODE (VA_ARG_EXPR, "va_arg_expr", 'e', 1)
DEFTREECODE (VA_ARG_EXPR, "va_arg_expr", tcc_expression, 1)
/* Evaluate operand 1. If and only if an exception is thrown during
the evaluation of operand 1, evaluate operand 2.
This differs from TRY_FINALLY_EXPR in that operand 2 is not evaluated
on a normal or jump exit, only on an exception. */
DEFTREECODE (TRY_CATCH_EXPR, "try_catch_expr", 's', 2)
DEFTREECODE (TRY_CATCH_EXPR, "try_catch_expr", tcc_statement, 2)
/* Evaluate the first operand.
The second operand is a cleanup expression which is evaluated
on any exit (normal, exception, or jump out) from this expression. */
DEFTREECODE (TRY_FINALLY_EXPR, "try_finally", 's', 2)
DEFTREECODE (TRY_FINALLY_EXPR, "try_finally", tcc_statement, 2)
/* These types of expressions have no useful value,
and always have side effects. */
/* Used to represent a local declaration. The operand is DECL_EXPR_DECL. */
DEFTREECODE (DECL_EXPR, "decl_expr", 's', 1)
DEFTREECODE (DECL_EXPR, "decl_expr", tcc_statement, 1)
/* A label definition, encapsulated as a statement.
Operand 0 is the LABEL_DECL node for the label that appears here.
The type should be void and the value should be ignored. */
DEFTREECODE (LABEL_EXPR, "label_expr", 's', 1)
DEFTREECODE (LABEL_EXPR, "label_expr", tcc_statement, 1)
/* GOTO. Operand 0 is a LABEL_DECL node or an expression.
The type should be void and the value should be ignored. */
DEFTREECODE (GOTO_EXPR, "goto_expr", 's', 1)
DEFTREECODE (GOTO_EXPR, "goto_expr", tcc_statement, 1)
/* RETURN. Evaluates operand 0, then returns from the current function.
Presumably that operand is an assignment that stores into the
RESULT_DECL that hold the value to be returned.
The operand may be null.
The type should be void and the value should be ignored. */
DEFTREECODE (RETURN_EXPR, "return_expr", 's', 1)
DEFTREECODE (RETURN_EXPR, "return_expr", tcc_statement, 1)
/* Exit the inner most loop conditionally. Operand 0 is the condition.
The type should be void and the value should be ignored. */
DEFTREECODE (EXIT_EXPR, "exit_expr", 's', 1)
DEFTREECODE (EXIT_EXPR, "exit_expr", tcc_statement, 1)
/* A loop. Operand 0 is the body of the loop.
It must contain an EXIT_EXPR or is an infinite loop.
The type should be void and the value should be ignored. */
DEFTREECODE (LOOP_EXPR, "loop_expr", 's', 1)
DEFTREECODE (LOOP_EXPR, "loop_expr", tcc_statement, 1)
/* Exit a labeled block, possibly returning a value. Operand 0 is a
LABELED_BLOCK_EXPR to exit. Operand 1 is the value to return. It
may be left null. */
DEFTREECODE (EXIT_BLOCK_EXPR, "exit_block_expr", 's', 2)
DEFTREECODE (EXIT_BLOCK_EXPR, "exit_block_expr", tcc_statement, 2)
/* Switch expression.
@ -810,28 +800,28 @@ DEFTREECODE (EXIT_BLOCK_EXPR, "exit_block_expr", 's', 2)
must not be NULL.
Operand 2 is either NULL_TREE or a TREE_VEC of the CASE_LABEL_EXPRs
of all the cases. */
DEFTREECODE (SWITCH_EXPR, "switch_expr", 's', 3)
DEFTREECODE (SWITCH_EXPR, "switch_expr", tcc_statement, 3)
/* Used to represent a case label. The operands are CASE_LOW and
CASE_HIGH, respectively. If CASE_LOW is NULL_TREE, the label is a
'default' label. If CASE_HIGH is NULL_TREE, the label is a normal case
label. CASE_LABEL is the corresponding LABEL_DECL. */
DEFTREECODE (CASE_LABEL_EXPR, "case_label_expr", 's', 3)
DEFTREECODE (CASE_LABEL_EXPR, "case_label_expr", tcc_statement, 3)
/* RESX. Resume execution after an exception. Operand 0 is a
number indicating the exception region that is being left. */
DEFTREECODE (RESX_EXPR, "resx_expr", 's', 1)
DEFTREECODE (RESX_EXPR, "resx_expr", tcc_statement, 1)
/* Used to represent an inline assembly statement. ASM_STRING returns a
STRING_CST for the instruction (e.g., "mov x, y"). ASM_OUTPUTS,
ASM_INPUTS, and ASM_CLOBBERS represent the outputs, inputs, and clobbers
for the statement. */
DEFTREECODE (ASM_EXPR, "asm_expr", 's', 4)
DEFTREECODE (ASM_EXPR, "asm_expr", tcc_statement, 4)
/* Variable references for SSA analysis. New SSA names are created every
time a variable is assigned a new value. The SSA builder uses SSA_NAME
nodes to implement SSA versioning. */
DEFTREECODE (SSA_NAME, "ssa_name", 'x', 0)
DEFTREECODE (SSA_NAME, "ssa_name", tcc_exceptional, 0)
/* SSA PHI operator. PHI_RESULT is the new SSA_NAME node created by
the PHI node. PHI_ARG_LENGTH is the number of arguments.
@ -839,50 +829,50 @@ DEFTREECODE (SSA_NAME, "ssa_name", 'x', 0)
argument list. Each tuple contains the incoming reaching
definition (SSA_NAME node) and the edge via which that definition
is coming through. */
DEFTREECODE (PHI_NODE, "phi_node", 'x', 0)
DEFTREECODE (PHI_NODE, "phi_node", tcc_exceptional, 0)
/* Used to represent a typed exception handler. CATCH_TYPES is the type (or
list of types) handled, and CATCH_BODY is the code for the handler. */
DEFTREECODE (CATCH_EXPR, "catch_expr", 's', 2)
DEFTREECODE (CATCH_EXPR, "catch_expr", tcc_statement, 2)
/* Used to represent an exception specification. EH_FILTER_TYPES is a list
of allowed types, and EH_FILTER_FAILURE is an expression to evaluate on
failure. EH_FILTER_MUST_NOT_THROW controls which range type to use when
expanding. */
DEFTREECODE (EH_FILTER_EXPR, "eh_filter_expr", 's', 2)
DEFTREECODE (EH_FILTER_EXPR, "eh_filter_expr", tcc_statement, 2)
/* Node used for describing a property that is known at compile
time. */
DEFTREECODE (SCEV_KNOWN, "scev_known", 'e', 0)
DEFTREECODE (SCEV_KNOWN, "scev_known", tcc_expression, 0)
/* Node used for describing a property that is not known at compile
time. */
DEFTREECODE (SCEV_NOT_KNOWN, "scev_not_known", 'e', 0)
DEFTREECODE (SCEV_NOT_KNOWN, "scev_not_known", tcc_expression, 0)
/* Polynomial chains of recurrences.
Under the form: cr = {CHREC_LEFT (cr), +, CHREC_RIGHT (cr)}. */
DEFTREECODE (POLYNOMIAL_CHREC, "polynomial_chrec", 'e', 3)
DEFTREECODE (POLYNOMIAL_CHREC, "polynomial_chrec", tcc_expression, 3)
/* Used to chain children of container statements together.
Use the interface in tree-iterator.h to access this node. */
DEFTREECODE (STATEMENT_LIST, "statement_list", 'x', 0)
DEFTREECODE (STATEMENT_LIST, "statement_list", tcc_exceptional, 0)
/* Value handles. Artificial nodes to represent expressions in
partial redundancy elimination (tree-ssa-pre.c). These nodes are
used for expression canonicalization. If two expressions compute
the same value, they will be assigned the same value handle. */
DEFTREECODE (VALUE_HANDLE, "value_handle", 'x', 0)
DEFTREECODE (VALUE_HANDLE, "value_handle", tcc_exceptional, 0)
/* Base class information. Holds information about a class as a
baseclass of itself or another class. */
DEFTREECODE (TREE_BINFO, "tree_binfo", 'x', 0)
DEFTREECODE (TREE_BINFO, "tree_binfo", tcc_exceptional, 0)
/* Records the size for an expression of variable size type. This is
for use in contexts in which we are accessing the entire object,
such as for a function call, or block copy.
Operand 0 is the real expression.
Operand 1 is the size of the type in the expression. */
DEFTREECODE (WITH_SIZE_EXPR, "with_size_expr", 'e', 2)
DEFTREECODE (WITH_SIZE_EXPR, "with_size_expr", tcc_expression, 2)
/*
Local variables:

131
gcc/tree.h
View File

@ -43,25 +43,103 @@ enum tree_code {
/* Number of language-independent tree codes. */
#define NUM_TREE_CODES ((int) LAST_AND_UNUSED_TREE_CODE)
/* Indexed by enum tree_code, contains a character which is
`<' for a comparison expression, `1', for a unary arithmetic
expression, `2' for a binary arithmetic expression, `e' for
other types of expressions, `r' for a reference, `c' for a
constant, `d' for a decl, `t' for a type, `s' for a statement,
and `x' for anything else (TREE_LIST, IDENTIFIER, etc). */
/* Tree code classes. */
/* Each tree_code has an associated code class represented by a
TREE_CODE_CLASS. */
enum tree_code_class {
tcc_exceptional, /* An exceptional code (fits no category). */
tcc_constant, /* A constant. */
tcc_type, /* A type object code. */
tcc_declaration, /* A declaration (also serving as variable refs). */
tcc_reference, /* A reference to storage. */
tcc_comparison, /* A comparison expression. */
tcc_unary, /* A unary arithmetic expression. */
tcc_binary, /* A binary arithmetic expression. */
tcc_statement, /* A statement expression, which have side effects
but usually no interesting value. */
tcc_expression /* Any other expression. */
};
/* Each tree code class has an associated string representation.
These must correspond to the tree_code_class entries. */
extern const char* tree_code_class_strings[];
/* Returns the string representing CLASS. */
#define TREE_CODE_CLASS_STRING(CLASS)\
tree_code_class_strings[(int) (CLASS)]
#define MAX_TREE_CODES 256
extern const char tree_code_type[];
extern const enum tree_code_class tree_code_type[];
#define TREE_CODE_CLASS(CODE) tree_code_type[(int) (CODE)]
/* Nonzero if CODE represents an exceptional code. */
#define EXCEPTIONAL_CLASS_P(CODE)\
(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_exceptional)
/* Nonzero if CODE represents a constant. */
#define CONSTANT_CLASS_P(CODE)\
(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_constant)
/* Nonzero if CODE represents a type. */
#define TYPE_P(CODE)\
(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_type)
/* Nonzero if CODE represents a declaration. */
#define DECL_P(CODE)\
(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_declaration)
/* Nonzero if CODE represents a reference. */
#define REFERENCE_CLASS_P(CODE)\
(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_reference)
/* Nonzero if CODE represents a comparison. */
#define COMPARISON_CLASS_P(CODE)\
(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_comparison)
/* Nonzero if CODE represents a unary arithmetic expression. */
#define UNARY_CLASS_P(CODE)\
(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_unary)
/* Nonzero if CODE represents a binary arithmetic expression. */
#define BINARY_CLASS_P(CODE)\
(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_binary)
/* Nonzero if CODE represents a statement expression. */
#define STATEMENT_CLASS_P(CODE)\
(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_statement)
/* Nonzero if CODE represents any other expression. */
#define EXPRESSION_CLASS_P(CODE)\
(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_expression)
/* Returns nonzero iff CLASS is not the tree code of a type. */
#define IS_NON_TYPE_CODE_CLASS(CLASS) ((CLASS) != 't')
#define IS_NON_TYPE_CODE_CLASS(CLASS) ((CLASS) != tcc_type)
/* Returns nonzero iff CODE represents a type or declaration. */
#define IS_TYPE_OR_DECL_P(CODE)\
(TYPE_P (CODE) || DECL_P (CODE))
/* Returns nonzero iff CLASS is the tree-code class of an
expression. */
#define IS_EXPR_CODE_CLASS(CLASS) (strchr ("<12ers", (CLASS)) != 0)
#define IS_EXPR_CODE_CLASS(CLASS)\
(((CLASS) >= tcc_reference) && ((CLASS) <= tcc_expression))
/* Returns nonzero iff NODE is an expression of some kind. */
@ -448,7 +526,7 @@ struct tree_common GTY(())
({ const tree __t = (T); \
char const __c = TREE_CODE_CLASS (TREE_CODE (__t)); \
if (!IS_EXPR_CODE_CLASS (__c)) \
tree_class_check_failed (__t, 'E', __FILE__, __LINE__, \
tree_class_check_failed (__t, tcc_expression, __FILE__, __LINE__, \
__FUNCTION__); \
__t; })
@ -457,7 +535,7 @@ struct tree_common GTY(())
({ const tree __t = (T); \
char const __c = TREE_CODE_CLASS (TREE_CODE (__t)); \
if (!IS_NON_TYPE_CODE_CLASS (__c)) \
tree_class_check_failed (__t, 'T', __FILE__, __LINE__, \
tree_class_check_failed (__t, tcc_type, __FILE__, __LINE__, \
__FUNCTION__); \
__t; })
@ -517,7 +595,7 @@ extern void tree_check_failed (const tree, const char *, int, const char *,
...) ATTRIBUTE_NORETURN;
extern void tree_not_check_failed (const tree, const char *, int, const char *,
...) ATTRIBUTE_NORETURN;
extern void tree_class_check_failed (const tree, int,
extern void tree_class_check_failed (const tree, const enum tree_code_class,
const char *, int, const char *)
ATTRIBUTE_NORETURN;
extern void tree_vec_elt_check_failed (int, int, const char *,
@ -557,10 +635,10 @@ extern void tree_operand_check_failed (int, enum tree_code,
#include "tree-check.h"
#define TYPE_CHECK(T) TREE_CLASS_CHECK (T, 't')
#define DECL_CHECK(T) TREE_CLASS_CHECK (T, 'd')
#define CST_CHECK(T) TREE_CLASS_CHECK (T, 'c')
#define STMT_CHECK(T) TREE_CLASS_CHECK (T, 's')
#define TYPE_CHECK(T) TREE_CLASS_CHECK (T, tcc_type)
#define DECL_CHECK(T) TREE_CLASS_CHECK (T, tcc_declaration)
#define CST_CHECK(T) TREE_CLASS_CHECK (T, tcc_constant)
#define STMT_CHECK(T) TREE_CLASS_CHECK (T, tcc_statement)
#define FUNC_OR_METHOD_CHECK(T) TREE_CHECK2 (T, FUNCTION_TYPE, METHOD_TYPE)
#define PTR_OR_REF_CHECK(T) TREE_CHECK2 (T, POINTER_TYPE, REFERENCE_TYPE)
@ -712,9 +790,6 @@ extern void tree_operand_check_failed (int, enum tree_code,
#define COMPLETE_OR_UNBOUND_ARRAY_TYPE_P(NODE) \
(COMPLETE_TYPE_P (TREE_CODE (NODE) == ARRAY_TYPE ? TREE_TYPE (NODE) : (NODE)))
/* Nonzero if TYPE represents a type. */
#define TYPE_P(TYPE) (TREE_CODE_CLASS (TREE_CODE (TYPE)) == 't')
/* Define many boolean fields that all tree nodes have. */
@ -839,7 +914,8 @@ extern void tree_operand_check_failed (int, enum tree_code,
#define TREE_READONLY(NODE) (NON_TYPE_CHECK (NODE)->common.readonly_flag)
/* Nonzero if NODE is a _DECL with TREE_READONLY set. */
#define TREE_READONLY_DECL_P(NODE) (DECL_P (NODE) && TREE_READONLY (NODE))
#define TREE_READONLY_DECL_P(NODE)\
(DECL_P (NODE) && TREE_READONLY (NODE))
/* Value of expression is constant. Always on in all ..._CST nodes. May
also appear in an expression or decl where the value is constant. */
@ -1091,17 +1167,13 @@ struct tree_vec GTY(())
decls and constants can be shared among multiple locations, so
return nothing. */
#define EXPR_LOCATION(NODE) \
(IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (NODE))) \
? (NODE)->exp.locus \
: UNKNOWN_LOCATION)
(EXPR_P (NODE) ? (NODE)->exp.locus : UNKNOWN_LOCATION)
#define SET_EXPR_LOCATION(NODE, FROM) \
(EXPR_CHECK (NODE)->exp.locus = (FROM))
#define EXPR_HAS_LOCATION(NODE) (EXPR_LOCATION (NODE) != UNKNOWN_LOCATION)
/* EXPR_LOCUS and SET_EXPR_LOCUS are deprecated. */
#define EXPR_LOCUS(NODE) \
(IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (NODE))) \
? &(NODE)->exp.locus \
: (location_t *)NULL)
(EXPR_P (NODE) ? &(NODE)->exp.locus : (location_t *)NULL)
#define SET_EXPR_LOCUS(NODE, FROM) \
do { source_location *loc_tmp = FROM; \
EXPR_CHECK (NODE)->exp.locus \
@ -1115,9 +1187,7 @@ struct tree_vec GTY(())
decls and constants can be shared among multiple locations, so
return nothing. */
#define EXPR_LOCUS(NODE) \
(IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (NODE))) \
? (NODE)->exp.locus \
: (location_t *)NULL)
(EXPR_P (NODE) ? (NODE)->exp.locus : (location_t *)NULL)
#define SET_EXPR_LOCUS(NODE, FROM) \
(EXPR_CHECK (NODE)->exp.locus = (FROM))
#define SET_EXPR_LOCATION(NODE, FROM) annotate_with_locus (NODE, FROM)
@ -1753,9 +1823,6 @@ struct tree_binfo GTY (())
/* Define fields and accessors for nodes representing declared names. */
/* Nonzero if DECL represents a decl. */
#define DECL_P(DECL) (TREE_CODE_CLASS (TREE_CODE (DECL)) == 'd')
/* Nonzero if DECL represents a variable for the SSA passes. */
#define SSA_VAR_P(DECL) \
(TREE_CODE (DECL) == VAR_DECL \

5
gcc/treelang/ChangeLog
View File

@ -1,3 +1,8 @@
2004-09-17 Jeffrey D. Oldham <oldham@codesourcery.com>
Zack Weinberg <zack@codesourcery.com>
* treetree.c: Update for new tree-class enumeration constants.
2004-09-15 Zack Weinberg <zack@codesourcery.com>
* Make-lang.in (treelang-warn): Set to $(STRICT_WARN).

4
gcc/treelang/treetree.c
View File

@ -199,9 +199,9 @@ const struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
#define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
const char tree_code_type[] = {
const enum tree_code_class tree_code_type[] = {
#include "tree.def"
'x'
tcc_exceptional
};
#undef DEFTREECODE

5
gcc/varasm.c
View File

@ -2466,7 +2466,7 @@ copy_constant (tree exp)
case ADDR_EXPR:
/* For ADDR_EXPR, we do not want to copy the decl whose address
is requested. We do want to copy constants though. */
if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == 'c')
if (CONSTANT_CLASS_P (TREE_OPERAND (exp, 0)))
return build1 (TREE_CODE (exp), TREE_TYPE (exp),
copy_constant (TREE_OPERAND (exp, 0)));
else
@ -3378,8 +3378,7 @@ output_addressed_constants (tree exp)
tem = TREE_OPERAND (tem, 0))
;
if (TREE_CODE_CLASS (TREE_CODE (tem)) == 'c'
|| TREE_CODE (tem) == CONSTRUCTOR)
if (CONSTANT_CLASS_P (tem) || TREE_CODE (tem) == CONSTRUCTOR)
output_constant_def (tem, 0);
break;