Skip to content

R
riscv-gcc-1
Commit 7c34ced1 by Richard Henderson Committed by Richard Henderson
Options

c-common.c, c-common.h (lang_gimplify_stmt): Remove. 

        * c-common.c, c-common.h (lang_gimplify_stmt): Remove.
        * c-gimplify.c: Remove unnecessary prototypes.
        (c_gimplify_stmt): Merge into ...
        (c_gimplify_expr): ... here.  Don't play with prep_stmt.
        * c-semantics.c (prep_stmt): Remove.
        * gimplify.c (annotate_one_with_locus): Break out from ...
        (annotate_all_with_locus): ... here.
        (gimplify_expr): Add locus to expressions even if pre/post queues
        are not present.
cp/
        * cp-gimplify.c: Remove unnecessary prototypes.
        (cp_gimplify_stmt): Merge into ...
        (cp_gimplify_expr): ... here.  Move to end of file.  Handle
        stmts_are_full_exprs_p frobbing.
        * cp-tree.h (cp_gimplify_stmt): Remove.
        * pt.c (tsubst_expr): Merge prep_stmt and unify.
        * tree.c (init_tree): Don't set lang_gimplify_stmt.

From-SVN: r83397
parent ebca59c3
Showing with 225 additions and 346 deletions
gcc/ChangeLog
2004-04-19 Richard Henderson <rth@redhat.com>
* c-common.c, c-common.h (lang_gimplify_stmt): Remove.
* c-gimplify.c: Remove unnecessary prototypes.
(c_gimplify_stmt): Merge into ...
(c_gimplify_expr): ... here. Don't play with prep_stmt.
* c-semantics.c (prep_stmt): Remove.
* gimplify.c (annotate_one_with_locus): Break out from ...
(annotate_all_with_locus): ... here.
(gimplify_expr): Add locus to expressions even if pre/post queues
are not present.
2004-06-19 Richard Henderson <rth@redhat.com>
PR target/15941
......
gcc/c-common.c
......@@ -690,11 +690,6 @@ tree (*make_fname_decl) (tree, int);
returns 1 for language-specific statement codes. */
int (*lang_statement_code_p) (enum tree_code);
/* If non-NULL, the address of a language-specific function that does any
language-specific gimplification for _STMT nodes and returns 1 iff
handled. */
int (*lang_gimplify_stmt) (tree *);
/* If non-NULL, the address of a language-specific function that takes
any action required right before expand_function_end is called. */
void (*lang_expand_function_end) (void);
......
gcc/c-common.h
......@@ -280,7 +280,6 @@ struct c_language_function GTY(()) {
/* Language-specific hooks. */
extern int (*lang_gimplify_stmt) (tree *);
extern void (*lang_expand_function_end) (void);
/* Callback that determines if it's ok for a function to have no
......@@ -299,7 +298,6 @@ extern void add_decl_stmt (tree);
extern void push_cleanup (tree, tree, bool);
extern tree walk_stmt_tree (tree *, walk_tree_fn, void *);
extern void prep_stmt (tree);
extern int c_expand_decl (tree);
extern int field_decl_cmp (const void *, const void *);
......@@ -1113,14 +1111,13 @@ extern void dump_time_statistics (void);
extern bool c_dump_tree (void *, tree);
extern int c_gimplify_expr (tree *, tree *, tree *);
extern tree c_walk_subtrees (tree*, int*, walk_tree_fn, void*, void*);
extern void c_warn_unused_result (tree *);
/* In c-simplify.c */
/* In c-gimplify.c */
extern void c_genericize (tree);
extern int c_gimplify_stmt (tree *);
extern int c_gimplify_expr (tree *, tree *, tree *);
extern tree c_build_bind_expr (tree, tree);
extern void pch_init (void);
......
gcc/c-gimplify.c
......@@ -72,25 +72,9 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
/* Local declarations. */
static enum gimplify_status gimplify_expr_stmt (tree *);
static enum gimplify_status gimplify_decl_stmt (tree *);
static enum gimplify_status gimplify_for_stmt (tree *, tree *);
static enum gimplify_status gimplify_while_stmt (tree *);
static enum gimplify_status gimplify_do_stmt (tree *);
static enum gimplify_status gimplify_if_stmt (tree *);
static enum gimplify_status gimplify_switch_stmt (tree *);
static enum gimplify_status gimplify_return_stmt (tree *);
static enum gimplify_status gimplify_compound_literal_expr (tree *);
static void gimplify_cleanup_stmts (tree);
static tree gimplify_c_loop (tree, tree, tree, bool);
static void push_context (void);
static void pop_context (void);
static void add_block_to_enclosing (tree);
enum bc_t { bc_break = 0, bc_continue = 1 };
static tree begin_bc_block (enum bc_t);
static tree finish_bc_block (tree, tree);
static tree build_bc_goto (enum bc_t);
static struct c_gimplify_ctx
{
......@@ -192,122 +176,6 @@ gimplify_cleanup_stmts (tree fndecl)
walk_tree (&DECL_SAVED_TREE (fndecl), gimplify_cleanup_stmt, NULL, NULL);
}
/* Entry point for the tree lowering pass. Recursively scan
*STMT_P and convert it to a GIMPLE tree. */
int
c_gimplify_stmt (tree *stmt_p)
{
tree stmt = *stmt_p;
tree pre, post;
int saved_stmts_are_full_exprs_p;
location_t stmt_locus;
enum gimplify_status ret;
/* PRE and POST are tree chains that contain the side-effects of the
gimplified tree. For instance, given the expression tree:
c = ++a * 3 + b++;
After gimplification, the tree will be re-written as:
a = a + 1;
t1 = a * 3; <-- PRE
c = t1 + b;
b = b + 1; <-- POST */
/* Set up context appropriately for handling this statement. */
saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
prep_stmt (stmt);
stmt_locus = input_location;
pre = NULL_TREE;
post = NULL_TREE;
switch (TREE_CODE (stmt))
{
case FOR_STMT:
ret = gimplify_for_stmt (&stmt, &pre);
break;
case WHILE_STMT:
ret = gimplify_while_stmt (&stmt);
break;
case DO_STMT:
ret = gimplify_do_stmt (&stmt);
break;
case IF_STMT:
ret = gimplify_if_stmt (&stmt);
break;
case SWITCH_STMT:
ret = gimplify_switch_stmt (&stmt);
break;
case EXPR_STMT:
ret = gimplify_expr_stmt (&stmt);
break;
case RETURN_STMT:
ret = gimplify_return_stmt (&stmt);
break;
case DECL_STMT:
ret = gimplify_decl_stmt (&stmt);
break;
case CONTINUE_STMT:
stmt = build_bc_goto (bc_continue);
ret = GS_OK;
break;
case BREAK_STMT:
stmt = build_bc_goto (bc_break);
ret = GS_OK;
break;
default:
if (lang_gimplify_stmt && (*lang_gimplify_stmt) (&stmt))
{
ret = GS_OK;
break;
}
fprintf (stderr, "unhandled statement node in c_gimplify_stmt:\n");
debug_tree (stmt);
abort ();
break;
}
switch (ret)
{
case GS_ERROR:
goto cont;
case GS_OK:
gimplify_stmt (&stmt);
break;
case GS_ALL_DONE:
break;
default:
abort ();
}
/* PRE and POST now contain a list of statements for all the
side-effects in STMT. */
append_to_statement_list (stmt, &pre);
append_to_statement_list (post, &pre);
annotate_all_with_locus (&pre, stmt_locus);
cont:
/* Restore saved state. */
current_stmt_tree ()->stmts_are_full_exprs_p = saved_stmts_are_full_exprs_p;
*stmt_p = pre;
return GS_ALL_DONE;
}
static void
add_block_to_enclosing (tree block)
{
......@@ -784,19 +652,47 @@ gimplify_compound_literal_expr (tree *expr_p)
/* Do C-specific gimplification. Args are as for gimplify_expr. */
int
c_gimplify_expr (tree *expr_p, tree *pre_p ATTRIBUTE_UNUSED,
tree *post_p ATTRIBUTE_UNUSED)
c_gimplify_expr (tree *expr_p, tree *pre_p, tree *post_p ATTRIBUTE_UNUSED)
{
enum tree_code code = TREE_CODE (*expr_p);
if (STATEMENT_CODE_P (code))
return c_gimplify_stmt (expr_p);
switch (code)
{
case COMPOUND_LITERAL_EXPR:
return gimplify_compound_literal_expr (expr_p);
case FOR_STMT:
return gimplify_for_stmt (expr_p, pre_p);
case WHILE_STMT:
return gimplify_while_stmt (expr_p);
case DO_STMT:
return gimplify_do_stmt (expr_p);
case IF_STMT:
return gimplify_if_stmt (expr_p);
case SWITCH_STMT:
return gimplify_switch_stmt (expr_p);
case EXPR_STMT:
return gimplify_expr_stmt (expr_p);
case RETURN_STMT:
return gimplify_return_stmt (expr_p);
case DECL_STMT:
return gimplify_decl_stmt (expr_p);
case CONTINUE_STMT:
*expr_p = build_bc_goto (bc_continue);
return GS_ALL_DONE;
case BREAK_STMT:
*expr_p = build_bc_goto (bc_break);
return GS_ALL_DONE;
default:
return GS_UNHANDLED;
}
......
gcc/c-semantics.c
......@@ -304,14 +304,3 @@ build_case_label (tree low_value, tree high_value, tree label_decl)
{
return build_stmt (CASE_LABEL_EXPR, low_value, high_value, label_decl);
}
/* We're about to expand T, a statement. Set up appropriate context
for the substitution. */
void
prep_stmt (tree t)
{
if (EXPR_LOCUS (t))
input_location = *EXPR_LOCUS (t);
current_stmt_tree ()->stmts_are_full_exprs_p = STMT_IS_FULL_EXPR_P (t);
}
gcc/cp/ChangeLog
2004-06-19 Richard Henderson <rth@redhat.com>
* cp-gimplify.c: Remove unnecessary prototypes.
(cp_gimplify_stmt): Merge into ...
(cp_gimplify_expr): ... here. Move to end of file. Handle
stmts_are_full_exprs_p frobbing.
* cp-tree.h (cp_gimplify_stmt): Remove.
* pt.c (tsubst_expr): Merge prep_stmt and unify.
* tree.c (init_tree): Don't set lang_gimplify_stmt.
2004-06-18 Richard Henderson <rth@redhat.com>
PR c++/16034
......
gcc/cp/cp-gimplify.c
......@@ -30,43 +30,6 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
#include "toplev.h"
#include "tree-gimple.h"
static void genericize_try_block (tree *);
static void genericize_catch_block (tree *);
static void genericize_eh_spec_block (tree *);
static void gimplify_must_not_throw_expr (tree *, tree *);
static void cp_gimplify_init_expr (tree *, tree *, tree *);
/* Genericize a C++ _STMT. Called from c_gimplify_stmt. */
int
cp_gimplify_stmt (tree *stmt_p)
{
tree stmt = *stmt_p;
switch (TREE_CODE (stmt))
{
case TRY_BLOCK:
genericize_try_block (stmt_p);
return 1;
case HANDLER:
genericize_catch_block (stmt_p);
return 1;
case EH_SPEC_BLOCK:
genericize_eh_spec_block (stmt_p);
return 1;
case USING_STMT:
/* Just ignore for now. Eventually we will want to pass this on to
the debugger. */
*stmt_p = build_empty_stmt ();
return 1;
default:
break;
}
return 0;
}
/* Genericize a TRY_BLOCK. */
......@@ -116,54 +79,6 @@ genericize_eh_spec_block (tree *stmt_p)
*stmt_p = gimple_build_eh_filter (body, allowed, failure);
}
/* Do C++-specific gimplification. Args are as for gimplify_expr. */
int
cp_gimplify_expr (tree *expr_p, tree *pre_p, tree *post_p)
{
switch (TREE_CODE (*expr_p))
{
case PTRMEM_CST:
*expr_p = cplus_expand_constant (*expr_p);
return GS_OK;
case AGGR_INIT_EXPR:
simplify_aggr_init_expr (expr_p);
return GS_OK;
case THROW_EXPR:
/* FIXME communicate throw type to backend, probably by moving
THROW_EXPR into ../tree.def. */
*expr_p = TREE_OPERAND (*expr_p, 0);
return GS_OK;
case MUST_NOT_THROW_EXPR:
gimplify_must_not_throw_expr (expr_p, pre_p);
return GS_OK;
case INIT_EXPR:
case MODIFY_EXPR:
cp_gimplify_init_expr (expr_p, pre_p, post_p);
return GS_OK;
case EMPTY_CLASS_EXPR:
{
/* Yes, an INTEGER_CST with RECORD_TYPE. */
tree i = build_int_2 (0, 0);
TREE_TYPE (i) = TREE_TYPE (*expr_p);
*expr_p = i;
}
return GS_OK;
case BASELINK:
*expr_p = BASELINK_FUNCTIONS (*expr_p);
return GS_OK;
default:
return c_gimplify_expr (expr_p, pre_p, post_p);
}
}
/* Gimplify initialization from an AGGR_INIT_EXPR. */
static void
......@@ -225,3 +140,99 @@ gimplify_must_not_throw_expr (tree *expr_p, tree *pre_p)
else
*expr_p = stmt;
}
/* Do C++-specific gimplification. Args are as for gimplify_expr. */
int
cp_gimplify_expr (tree *expr_p, tree *pre_p, tree *post_p)
{
int saved_stmts_are_full_exprs_p = 0;
enum tree_code code = TREE_CODE (*expr_p);
enum gimplify_status ret;
if (STATEMENT_CODE_P (code))
{
saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
current_stmt_tree ()->stmts_are_full_exprs_p
= STMT_IS_FULL_EXPR_P (*expr_p);
}
switch (code)
{
case PTRMEM_CST:
*expr_p = cplus_expand_constant (*expr_p);
ret = GS_OK;
break;
case AGGR_INIT_EXPR:
simplify_aggr_init_expr (expr_p);
ret = GS_OK;
break;
case THROW_EXPR:
/* FIXME communicate throw type to backend, probably by moving
THROW_EXPR into ../tree.def. */
*expr_p = TREE_OPERAND (*expr_p, 0);
ret = GS_OK;
break;
case MUST_NOT_THROW_EXPR:
gimplify_must_not_throw_expr (expr_p, pre_p);
ret = GS_OK;
break;
case INIT_EXPR:
case MODIFY_EXPR:
cp_gimplify_init_expr (expr_p, pre_p, post_p);
ret = GS_OK;
break;
case EMPTY_CLASS_EXPR:
{
/* Yes, an INTEGER_CST with RECORD_TYPE. */
tree i = build_int_2 (0, 0);
TREE_TYPE (i) = TREE_TYPE (*expr_p);
*expr_p = i;
}
ret = GS_OK;
break;
case BASELINK:
*expr_p = BASELINK_FUNCTIONS (*expr_p);
ret = GS_OK;
break;
case TRY_BLOCK:
genericize_try_block (expr_p);
ret = GS_OK;
break;
case HANDLER:
genericize_catch_block (expr_p);
ret = GS_OK;
break;
case EH_SPEC_BLOCK:
genericize_eh_spec_block (expr_p);
ret = GS_OK;
break;
case USING_STMT:
/* Just ignore for now. Eventually we will want to pass this on to
the debugger. */
*expr_p = build_empty_stmt ();
ret = GS_ALL_DONE;
break;
default:
ret = c_gimplify_expr (expr_p, pre_p, post_p);
break;
}
/* Restore saved state. */
if (STATEMENT_CODE_P (code))
current_stmt_tree ()->stmts_are_full_exprs_p
= saved_stmts_are_full_exprs_p;
return ret;
}
gcc/cp/cp-tree.h
......@@ -4305,7 +4305,6 @@ extern bool cp_dump_tree (void *, tree);
/* in cp-simplify.c */
extern int cp_gimplify_expr (tree *, tree *, tree *);
extern int cp_gimplify_stmt (tree *);
/* -- end of C++ */
......
gcc/cp/pt.c
......@@ -7747,6 +7747,11 @@ tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl)
if (t == NULL_TREE || t == error_mark_node)
return t;
if (EXPR_LOCUS (t))
input_location = *EXPR_LOCUS (t);
if (STATEMENT_CODE_P (TREE_CODE (t)))
current_stmt_tree ()->stmts_are_full_exprs_p = STMT_IS_FULL_EXPR_P (t);
switch (TREE_CODE (t))
{
case STATEMENT_LIST:
......@@ -7758,13 +7763,11 @@ tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl)
}
case CTOR_INITIALIZER:
prep_stmt (t);
finish_mem_initializers (tsubst_initializer_list
(TREE_OPERAND (t, 0), args));
break;
case RETURN_STMT:
prep_stmt (t);
finish_return_stmt (tsubst_expr (RETURN_STMT_EXPR (t),
args, complain, in_decl));
break;
......@@ -7783,21 +7786,14 @@ tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl)
}
case EXPR_STMT:
{
tree r;
prep_stmt (t);
r = tsubst_expr (EXPR_STMT_EXPR (t), args, complain, in_decl);
if (EXPR_STMT_STMT_EXPR_RESULT (t))
finish_stmt_expr_expr (r, cur_stmt_expr);
else
finish_expr_stmt (r);
break;
}
tmp = tsubst_expr (EXPR_STMT_EXPR (t), args, complain, in_decl);
if (EXPR_STMT_STMT_EXPR_RESULT (t))
finish_stmt_expr_expr (tmp, cur_stmt_expr);
else
finish_expr_stmt (tmp);
break;
case USING_STMT:
prep_stmt (t);
do_using_directive (tsubst_expr (USING_STMT_NAMESPACE (t),
args, complain, in_decl));
break;
......@@ -7807,7 +7803,6 @@ tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl)
tree decl;
tree init;
prep_stmt (t);
decl = DECL_STMT_DECL (t);
if (TREE_CODE (decl) == LABEL_DECL)
finish_label_decl (DECL_NAME (decl));
......@@ -7870,122 +7865,92 @@ tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl)
}
case FOR_STMT:
{
prep_stmt (t);
stmt = begin_for_stmt ();
tsubst_expr (FOR_INIT_STMT (t), args, complain, in_decl);
finish_for_init_stmt (stmt);
finish_for_cond (tsubst_expr (FOR_COND (t),
args, complain, in_decl),
stmt);
tmp = tsubst_expr (FOR_EXPR (t), args, complain, in_decl);
finish_for_expr (tmp, stmt);
tsubst_expr (FOR_BODY (t), args, complain, in_decl);
finish_for_stmt (stmt);
}
stmt = begin_for_stmt ();
tsubst_expr (FOR_INIT_STMT (t), args, complain, in_decl);
finish_for_init_stmt (stmt);
tmp = tsubst_expr (FOR_COND (t), args, complain, in_decl);
finish_for_cond (tmp, stmt);
tmp = tsubst_expr (FOR_EXPR (t), args, complain, in_decl);
finish_for_expr (tmp, stmt);
tsubst_expr (FOR_BODY (t), args, complain, in_decl);
finish_for_stmt (stmt);
break;
case WHILE_STMT:
{
prep_stmt (t);
stmt = begin_while_stmt ();
finish_while_stmt_cond (tsubst_expr (WHILE_COND (t),
args, complain, in_decl),
stmt);
tsubst_expr (WHILE_BODY (t), args, complain, in_decl);
finish_while_stmt (stmt);
}
stmt = begin_while_stmt ();
tmp = tsubst_expr (WHILE_COND (t), args, complain, in_decl);
finish_while_stmt_cond (tmp, stmt);
tsubst_expr (WHILE_BODY (t), args, complain, in_decl);
finish_while_stmt (stmt);
break;
case DO_STMT:
{
prep_stmt (t);
stmt = begin_do_stmt ();
tsubst_expr (DO_BODY (t), args, complain, in_decl);
finish_do_body (stmt);
finish_do_stmt (tsubst_expr (DO_COND (t),
args, complain, in_decl),
stmt);
}
stmt = begin_do_stmt ();
tsubst_expr (DO_BODY (t), args, complain, in_decl);
finish_do_body (stmt);
tmp = tsubst_expr (DO_COND (t), args, complain, in_decl);
finish_do_stmt (tmp, stmt);
break;
case IF_STMT:
{
prep_stmt (t);
stmt = begin_if_stmt ();
finish_if_stmt_cond (tsubst_expr (IF_COND (t),
args, complain, in_decl),
stmt);
tsubst_expr (THEN_CLAUSE (t), args, complain, in_decl);
finish_then_clause (stmt);
if (ELSE_CLAUSE (t))
{
begin_else_clause (stmt);
tsubst_expr (ELSE_CLAUSE (t), args, complain, in_decl);
finish_else_clause (stmt);
}
stmt = begin_if_stmt ();
tmp = tsubst_expr (IF_COND (t), args, complain, in_decl);
finish_if_stmt_cond (tmp, stmt);
tsubst_expr (THEN_CLAUSE (t), args, complain, in_decl);
finish_then_clause (stmt);
finish_if_stmt (stmt);
}
if (ELSE_CLAUSE (t))
{
begin_else_clause (stmt);
tsubst_expr (ELSE_CLAUSE (t), args, complain, in_decl);
finish_else_clause (stmt);
}
finish_if_stmt (stmt);
break;
case BIND_EXPR:
{
prep_stmt (t);
if (BIND_EXPR_BODY_BLOCK (t))
stmt = begin_function_body ();
else
stmt = begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t)
? BCS_TRY_BLOCK : 0);
if (BIND_EXPR_BODY_BLOCK (t))
stmt = begin_function_body ();
else
stmt = begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t)
? BCS_TRY_BLOCK : 0);
tsubst_expr (BIND_EXPR_BODY (t), args, complain, in_decl);
tsubst_expr (BIND_EXPR_BODY (t), args, complain, in_decl);
if (BIND_EXPR_BODY_BLOCK (t))
finish_function_body (stmt);
else
finish_compound_stmt (stmt);
}
if (BIND_EXPR_BODY_BLOCK (t))
finish_function_body (stmt);
else
finish_compound_stmt (stmt);
break;
case BREAK_STMT:
prep_stmt (t);
finish_break_stmt ();
break;
case CONTINUE_STMT:
prep_stmt (t);
finish_continue_stmt ();
break;
case SWITCH_STMT:
{
tree val;
prep_stmt (t);
stmt = begin_switch_stmt ();
val = tsubst_expr (SWITCH_COND (t), args, complain, in_decl);
finish_switch_cond (val, stmt);
tsubst_expr (SWITCH_BODY (t), args, complain, in_decl);
finish_switch_stmt (stmt);
}
stmt = begin_switch_stmt ();
tmp = tsubst_expr (SWITCH_COND (t), args, complain, in_decl);
finish_switch_cond (tmp, stmt);
tsubst_expr (SWITCH_BODY (t), args, complain, in_decl);
finish_switch_stmt (stmt);
break;
case CASE_LABEL_EXPR:
prep_stmt (t);
finish_case_label (tsubst_expr (CASE_LOW (t), args, complain, in_decl),
tsubst_expr (CASE_HIGH (t), args, complain,
in_decl));
break;
case LABEL_EXPR:
prep_stmt (t);
finish_label_stmt (DECL_NAME (LABEL_EXPR_LABEL (t)));
break;
case GOTO_EXPR:
prep_stmt (t);
tmp = GOTO_DESTINATION (t);
if (TREE_CODE (tmp) != LABEL_DECL)
/* Computed goto's must be tsubst'd into. On the other hand,
......@@ -7998,7 +7963,6 @@ tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl)
break;
case ASM_EXPR:
prep_stmt (t);
tmp = finish_asm_stmt
(ASM_VOLATILE_P (t),
tsubst_expr (ASM_STRING (t), args, complain, in_decl),
......@@ -8009,7 +7973,6 @@ tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl)
break;
case TRY_BLOCK:
prep_stmt (t);
if (CLEANUP_P (t))
{
stmt = begin_try_block ();
......@@ -8045,7 +8008,6 @@ tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl)
{
tree decl;
prep_stmt (t);
stmt = begin_handler ();
if (HANDLER_PARMS (t))
{
......@@ -8065,7 +8027,6 @@ tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl)
break;
case TAG_DEFN:
prep_stmt (t);
tsubst (TREE_TYPE (t), args, complain, NULL_TREE);
break;
......
gcc/cp/tree.c
......@@ -2196,7 +2196,6 @@ cp_update_decl_after_saving (tree fn,
void
init_tree (void)
{
lang_gimplify_stmt = cp_gimplify_stmt;
list_hash_table = htab_create_ggc (31, list_hash, list_hash_eq, NULL);
}
......
gcc/gimplify.c
......@@ -563,6 +563,15 @@ should_carry_locus_p (tree stmt)
return true;
}
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))
annotate_with_locus (t, locus);
}
void
annotate_all_with_locus (tree *stmt_p, location_t locus)
{
......@@ -583,10 +592,7 @@ annotate_all_with_locus (tree *stmt_p, location_t locus)
abort ();
#endif
if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (t)))
&& ! EXPR_HAS_LOCATION (t)
&& should_carry_locus_p (t))
annotate_with_locus (t, locus);
annotate_one_with_locus (t, locus);
}
}
......@@ -3558,6 +3564,10 @@ gimplify_expr (tree *expr_p, tree *pre_p, tree *post_p,
annotate_all_with_locus (&internal_pre, input_location);
*expr_p = internal_pre;
}
else if (TREE_CODE (*expr_p) == STATEMENT_LIST)
annotate_all_with_locus (expr_p, input_location);
else
annotate_one_with_locus (*expr_p, input_location);
goto out;
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment