+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
(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
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>
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.
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
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.
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.
* 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>
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.
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
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
+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
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>
* 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
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.
(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.
(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.
(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,
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.
(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
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,
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,
* *
* 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- *
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. */
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)
/* 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)
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)
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));
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
#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
/* 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);
/* 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)
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. */
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),
force));
break;
- case '1':
+ case tcc_unary:
/* Recursively stabilize each operand. */
result = build1 (code, type,
gnat_stabilize_reference_1 (TREE_OPERAND (e, 0),
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),
? 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))
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:
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 ();
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:
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
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));
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;
}
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);
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
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;
}
{
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
({ }). */
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;
- }
+ default:
+ /* 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;
}
}
/* 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:
&& 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);
#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
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)
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 ();
}
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);
|| 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 |");
}
|| 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 ^");
}
|| 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");
}
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),
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);
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);
/* 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))
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;
/* 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;
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);
/* 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);
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;
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
&& 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) == '@')
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. */
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
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);
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);
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;
+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
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>
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>
/* 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
{
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);
&& 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
#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
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,
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
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
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
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
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
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.
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:
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;
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);
|| 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))
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))
|| 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
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:
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;
|| 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)
return true;
return false;
}
+ case tcc_reference:
+ case tcc_statement:
+ /* These cannot be value dependent. */
+ return false;
+
+ default:
+ gcc_unreachable ();
}
}
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;
/* 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.
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;
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;
}
{
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);
}
}
|| 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)
|| 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));
}
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);
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;
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);
}
/* 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
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);
/* 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)
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
|| !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
>= (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
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. */
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);
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);
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))
{
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),
&& 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)
return 0;
}
- case 'e':
+ case tcc_expression:
switch (TREE_CODE (arg0))
{
case ADDR_EXPR:
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)
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
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)
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
{
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:
}
/* Fall through - ??? */
- case '<':
+ case tcc_comparison:
{
tree arg0 = TREE_OPERAND (arg, 0);
tree arg1 = TREE_OPERAND (arg, 1);
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)
== 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)
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
{
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);
}
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;
}
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;
}
}
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);
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
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))
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)
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);
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),
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)
{
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),
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);
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);
/* 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))))
{
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))))
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),
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)))
{
}
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:
break;
}
break;
- case 'x':
+ case tcc_exceptional:
switch (code)
{
case TREE_LIST:
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);
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);
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;
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)))
return t;
break;
- case 'e':
+ case tcc_expression:
switch (TREE_CODE (t))
{
case COMPOUND_EXPR:
+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.
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>
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,
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.
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>
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.
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>
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.
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>
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>
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>
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>
* 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>
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>
* 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.
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>
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>
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>
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>
#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
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;
{
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. */
{
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);
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);
}
{
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
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;
&& 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;
}
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
/* 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;
break;
}
- case 'd':
- case 'c':
+ case tcc_declaration:
+ case tcc_constant:
ret = GS_ALL_DONE;
goto dont_recalculate;
+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:
* 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,
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.
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.
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,
/* 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
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:
/* 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)
{
#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
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)
{
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))
{
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);
}
{
while (node)
{
- char code;
+ enum tree_code_class code;
tree to_return;
switch (TREE_CODE (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;
{
/* 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;
}
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.
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
}
/* 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)
{
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
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;
#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
/* 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.
/* 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:
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);
void
print_node_brief (FILE *file, const char *prefix, tree node, int indent)
{
- char class;
+ enum tree_code_class class;
if (node == 0)
return;
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))
{
int hash;
struct bucket *b;
enum machine_mode mode;
- char class;
+ enum tree_code_class class;
int len;
int first_rtl;
int i;
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;
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))
{
switch (TREE_CODE_CLASS (TREE_CODE (node)))
{
- case 'd':
+ case tcc_declaration:
mode = DECL_MODE (node);
if (DECL_UNSIGNED (node))
print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4);
break;
- case 't':
+ case tcc_type:
if (TYPE_UNSIGNED (node))
fputs (" unsigned", file);
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)
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:
break;
default:
- if (TREE_CODE_CLASS (TREE_CODE (node)) == 'x')
+ if (EXCEPTIONAL_CLASS_P (node))
lang_hooks.print_xnode (file, node, indent);
break;
}
/* 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]));
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:
/* 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.
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;
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));
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
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;
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;
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 { \
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 { \
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
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))
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;
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;
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
/* 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;
}
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
{
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)
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);
/* 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;
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. */
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;
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);
/* 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);
/* 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.
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);
switch (TREE_CODE_CLASS (code))
{
- case '1':
- case '2':
- case '<':
+ case tcc_unary:
+ case tcc_binary:
+ case tcc_comparison:
return true;
default:
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. */
switch (TREE_CODE_CLASS (code))
{
- case 'e':
+ case tcc_expression:
switch (code)
{
case INIT_EXPR:
}
/* 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)
{
TREE_SIDE_EFFECTS (t) = 1;
}
break;
+
+ default:
+ /* Can never be used with non-expressions. */
+ gcc_unreachable ();
}
}
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;
/* 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))
/* 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)
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);
break;
default:
- if (!DECL_P (t) && !TYPE_P (t))
+ if (!IS_TYPE_OR_DECL_P (t))
{
*walk_subtrees = 1;
wi->val_only = true;
break;
default:
- if (!DECL_P (t) && !TYPE_P (t))
+ if (!IS_TYPE_OR_DECL_P (t))
{
*walk_subtrees = 1;
wi->val_only = true;
break;
default:
- if (!DECL_P (t) && !TYPE_P (t))
+ if (!IS_TYPE_OR_DECL_P (t))
*walk_subtrees = 1;
break;
}
{
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)
{
/* 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.
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)
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 ");
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))
{
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
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;
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;
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))
{
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;
/* 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);
/* 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)
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;
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)
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;
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;
}
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
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,
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);
|| 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);
/* 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);
{
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);
{
/* 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)
{
/* 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);
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;
/* 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;
}
/* 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);
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);
/* 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;
}
/* 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.
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;
/* Loop invariant motion.
- Copyright (C) 2003 Free Software Foundation, Inc.
+ Copyright (C) 2003, 2004 Free Software Foundation, Inc.
This file is part of GCC.
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;
|| 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));
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)
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));
/* Induction variable optimizations.
- Copyright (C) 2003 Free Software Foundation, Inc.
+ Copyright (C) 2003, 2004 Free Software Foundation, Inc.
This file is part of GCC.
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;
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;
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));
/* 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.
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)
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;
}
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),
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);
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;
phi_trans_add (oldexpr, newexpr, pred);
}
}
- break;
- case 'd':
- gcc_unreachable ();
- case 'x':
+ return expr;
+
+ case tcc_exceptional:
{
tree phi = NULL;
int i;
return PHI_ARG_DEF (phi, i);
}
}
- break;
+ return expr;
+
+ default:
+ gcc_unreachable ();
}
- return expr;
}
static void
{
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
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;
switch (TREE_CODE_CLASS (TREE_CODE (expr)))
{
- case '2':
+ case tcc_binary:
{
tree_stmt_iterator tsi;
tree genop1, genop2;
pre_stats.insertions++;
break;
}
- case '1':
+ case tcc_unary:
{
tree_stmt_iterator tsi;
tree genop1;
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;
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,
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);
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,
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;
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;
/* 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.
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
/* 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.
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.
#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);
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);
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;
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)
else
kind = x_kind;
break;
-
- default:
- gcc_unreachable ();
}
tree_node_counts[(int) kind]++;
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;
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;
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:
break;
}
break;
+
+ default:
+ /* Other classes need no special treatment. */
+ break;
}
return t;
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
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);
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;
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:
/* 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
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:
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;
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)))
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:
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
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. */
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;
else
ti = tc = false;
}
- else if (TREE_CODE_CLASS (TREE_CODE (node)) == 'c')
+ else if (CONSTANT_CLASS_P (node))
;
else
{
#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:
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)
{
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;
}
/* 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;
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;
}
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;
}
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;
}
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++)
{
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);
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;
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);
}
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
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)
\f
/* Each data type is represented by a tree node whose code is one of
the following: */
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.
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
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.
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:
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.
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)
\f
/* Expressions */
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
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)
\f
/* References to storage. */
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.
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:
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.
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.
/* 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
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.
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.
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
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
/* 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
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,
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.
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
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)
\f
/* 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.
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.
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:
/* 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. */
({ 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; })
({ 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; })
...) 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 *,
#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)
#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')
\f
/* Define many boolean fields that all tree nodes have. */
#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. */
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 \
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)
\f
/* 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 \
+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).
#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
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
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;
projects / platform / upstream / gcc.git / commitdiff