From: Alexandre Petit-Bianco Date: Wed, 1 Aug 2001 02:28:43 +0000 (-0700) Subject: *** empty log message *** X-Git-Tag: prereleases/libstdc++-3.0.95~2939 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=6ad7895ac23ac971a2f3de9e7899a5389ec21a7c;p=thirdparty%2Fgcc.git *** empty log message *** From-SVN: r44528 --- diff --git a/gcc/ChangeLog b/gcc/ChangeLog index f5d2ec568cd5..aae0db0f68bf 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,19 @@ +2001-07-31 Alexandre Petit-Bianco + + * expr.c (safe_from_p): Use WITH_CLEANUP_EXPR_RTL instead of + RTL_EXPR_RTL while handling WITH_CLEANUP_EXPR nodes. Fixed typo in + comment. + (expand_expr): Use WITH_CLEANUP_EXPR_RTL instead of RTL_EXPR_RTL + while handling WITH_CLEANUP_EXPR node. Use second operand calling + expand_decl_cleanup. + * tree.c (firt_rtl_op): The third operand of WITH_CLEANUP_EXPR is + the first RTX. + (simple_cst_equal): WITH_CLEANUP_EXPR node to use its second + operand while calling simple_cst_equal. + * tree.def (WITH_CLEANUP_EXPR): Switched operands: the second + operand is the cleanup expression, the third is the RTL_EXPR. + * tree.h (WITH_CLEANUP_EXPR_RTL): New macro. + 2001-07-31 Jeff Sturm * except.c (duplicate_eh_regions): Test n_array[i] for NULL. diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index 39689e8cd3bf..393da2e43322 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,8 @@ +2001-07-31 Alexandre Petit-Bianco + + * tree.c (cp_tree_equal): WITH_CLEANUP_EXPR node to use its second + operand while calling cp_tree_equal. + 2001-07-31 Nathan Sidwell The 3.0 ABI no longer has vbase pointer fields. diff --git a/gcc/cp/tree.c b/gcc/cp/tree.c index 59c08bcbf13d..348942c29ea5 100644 --- a/gcc/cp/tree.c +++ b/gcc/cp/tree.c @@ -1958,7 +1958,7 @@ cp_tree_equal (t1, t2) cmp = cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)); if (cmp <= 0) return cmp; - return cp_tree_equal (TREE_OPERAND (t1, 2), TREE_OPERAND (t1, 2)); + return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1)); case COMPONENT_REF: if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1)) diff --git a/gcc/expr.c b/gcc/expr.c index bd60d3f59b96..80f73f854dcd 100644 --- a/gcc/expr.c +++ b/gcc/expr.c @@ -5858,7 +5858,7 @@ safe_from_p (x, exp, top_p) break; case WITH_CLEANUP_EXPR: - exp_rtl = RTL_EXPR_RTL (exp); + exp_rtl = WITH_CLEANUP_EXPR_RTL (exp); break; case CLEANUP_POINT_EXPR: @@ -6452,7 +6452,7 @@ expand_expr (exp, target, tmode, modifier) lineno = EXPR_WFL_LINENO (exp); if (EXPR_WFL_EMIT_LINE_NOTE (exp)) emit_line_note (input_filename, lineno); - /* Possibly avoid switching back and force here. */ + /* Possibly avoid switching back and forth here. */ to_return = expand_expr (EXPR_WFL_NODE (exp), target, tmode, modifier); input_filename = saved_input_filename; lineno = saved_lineno; @@ -7376,16 +7376,16 @@ expand_expr (exp, target, tmode, modifier) } case WITH_CLEANUP_EXPR: - if (RTL_EXPR_RTL (exp) == 0) + if (WITH_CLEANUP_EXPR_RTL (exp) == 0) { - RTL_EXPR_RTL (exp) + WITH_CLEANUP_EXPR_RTL (exp) = expand_expr (TREE_OPERAND (exp, 0), target, tmode, ro_modifier); - expand_decl_cleanup (NULL_TREE, TREE_OPERAND (exp, 2)); + expand_decl_cleanup (NULL_TREE, TREE_OPERAND (exp, 1)); /* That's it for this cleanup. */ - TREE_OPERAND (exp, 2) = 0; + TREE_OPERAND (exp, 1) = 0; } - return RTL_EXPR_RTL (exp); + return WITH_CLEANUP_EXPR_RTL (exp); case CLEANUP_POINT_EXPR: { diff --git a/gcc/java/ChangeLog b/gcc/java/ChangeLog index a694743e6ce6..69f570551621 100644 --- a/gcc/java/ChangeLog +++ b/gcc/java/ChangeLog @@ -1,3 +1,16 @@ +2001-07-31 Alexandre Petit-Bianco + + * check-init.c (check_init): WITH_CLEANUP_EXPR node to use its + second operand calling check_init. + * decl.c (complete_start_java_method): Swaped second and third + arguments while creating WITH_CLEANUP_EXPR node. + * jcf-write.c (generate_bytecode_insns): Use second operand + instead of third when handling WITH_CLEANUP_EXPR. + * parse.y (java_complete_lhs): Expand second operand of + WITH_CLEANUP_EXPR nodes. + (patch_synchronized_statement): Swaped second and third arguments + while creating WITH_CLEANUP_EXPR node. + 2001-07-18 Alexandre Petit-Bianco * parse.y (create_interface): Avoid cyclic inheritance report when diff --git a/gcc/java/check-init.c b/gcc/java/check-init.c index 05e3aa31ae62..0e340dd85416 100644 --- a/gcc/java/check-init.c +++ b/gcc/java/check-init.c @@ -537,7 +537,7 @@ check_init (exp, before) #endif check_init (TREE_OPERAND (exp, 0), before); UNION (alt->combined, alt->combined, before); - check_init (TREE_OPERAND (exp, 2), alt->combined); + check_init (TREE_OPERAND (exp, 1), alt->combined); return; } diff --git a/gcc/java/decl.c b/gcc/java/decl.c index 1e8c934f6e21..3b856db50d87 100644 --- a/gcc/java/decl.c +++ b/gcc/java/decl.c @@ -1738,7 +1738,7 @@ complete_start_java_method (fndecl) tree function_body = DECL_FUNCTION_BODY (fndecl); tree body = BLOCK_EXPR_BODY (function_body); lock = build (WITH_CLEANUP_EXPR, void_type_node, - enter, NULL_TREE, exit); + enter, exit, NULL_TREE); TREE_SIDE_EFFECTS (lock) = 1; lock = build (COMPOUND_EXPR, TREE_TYPE (body), lock, body); TREE_SIDE_EFFECTS (lock) = 1; diff --git a/gcc/java/jcf-write.c b/gcc/java/jcf-write.c index 9a4eb5b21c6b..ca453c8edd9b 100644 --- a/gcc/java/jcf-write.c +++ b/gcc/java/jcf-write.c @@ -2293,7 +2293,7 @@ generate_bytecode_insns (exp, target, state) label->next = state->labeled_blocks; state->labeled_blocks = label; state->num_finalizers++; - label->u.labeled_block = TREE_OPERAND (exp, 2); + label->u.labeled_block = TREE_OPERAND (exp, 1); label->v.start_label = get_jcf_label_here (state); if (target != IGNORE_TARGET) abort (); diff --git a/gcc/java/parse.y b/gcc/java/parse.y index 1fb08bcd343e..05be63314a8f 100644 --- a/gcc/java/parse.y +++ b/gcc/java/parse.y @@ -11326,7 +11326,7 @@ java_complete_lhs (node) case WITH_CLEANUP_EXPR: COMPLETE_CHECK_OP_0 (node); - COMPLETE_CHECK_OP_2 (node); + COMPLETE_CHECK_OP_1 (node); CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0)); TREE_TYPE (node) = void_type_node; @@ -15326,7 +15326,7 @@ patch_synchronized_statement (node, wfl_op1) build (WITH_CLEANUP_EXPR, NULL_TREE, build (COMPOUND_EXPR, NULL_TREE, assignment, enter), - NULL_TREE, exit), + exit, NULL_TREE), block)); node = build_expr_block (node, expr_decl); diff --git a/gcc/tree.c b/gcc/tree.c index 7ad066538d08..9ce19057b6aa 100644 --- a/gcc/tree.c +++ b/gcc/tree.c @@ -1628,8 +1628,7 @@ first_rtl_op (code) case RTL_EXPR: return 0; case WITH_CLEANUP_EXPR: - /* Should be defined to be 2. */ - return 1; + return 2; case METHOD_CALL_EXPR: return 3; default: @@ -3679,7 +3678,7 @@ simple_cst_equal (t1, t2) if (cmp <= 0) return cmp; - return simple_cst_equal (TREE_OPERAND (t1, 2), TREE_OPERAND (t1, 2)); + return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1)); case COMPONENT_REF: if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1)) diff --git a/gcc/tree.def b/gcc/tree.def index 56bc8ef15e72..84801e674fd2 100644 --- a/gcc/tree.def +++ b/gcc/tree.def @@ -472,8 +472,8 @@ DEFTREECODE (METHOD_CALL_EXPR, "method_call_expr", 'e', 4) /* Specify a value to compute along with its corresponding cleanup. Operand 0 argument is an expression whose value needs a cleanup. - Operand 1 is an RTL_EXPR which will eventually represent that value. - Operand 2 is the cleanup expression for the object. + Operand 1 is the cleanup expression for the object. + Operand 2 is an RTL_EXPR which will eventually represent that value. The RTL_EXPR is used in this expression, which is how the expression manages to act on the proper value. The cleanup is executed by the first enclosing CLEANUP_POINT_EXPR, if diff --git a/gcc/tree.h b/gcc/tree.h index efd4e6cd9532..70143515808a 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -792,6 +792,10 @@ struct tree_vec #define RTL_EXPR_SEQUENCE(NODE) (*(struct rtx_def **) &EXPR_CHECK (NODE)->exp.operands[0]) #define RTL_EXPR_RTL(NODE) (*(struct rtx_def **) &EXPR_CHECK (NODE)->exp.operands[1]) +/* In a WITH_CLEANUP_EXPR node. */ +#define WITH_CLEANUP_EXPR_RTL(NODE) \ + (*(struct rtx_def **) &EXPR_CHECK (NODE)->exp.operands[2]) + /* In a CONSTRUCTOR node. */ #define CONSTRUCTOR_ELTS(NODE) TREE_OPERAND (NODE, 1)