#include "flags.h"
#include "ggc.h"
#include "rtl.h"
-#include "expr.h"
#include "output.h"
#include "timevar.h"
#include "predict.h"
#include "tree-inline.h"
+#include "tree-gimple.h"
#include "langhooks.h"
/* Create an empty statement tree rooted at T. */
-void
-begin_stmt_tree (tree *t)
-{
- /* We create a trivial EXPR_STMT so that last_tree is never NULL in
- what follows. We remove the extraneous statement in
- finish_stmt_tree. */
- *t = build_nt (EXPR_STMT, void_zero_node);
- last_tree = *t;
- last_expr_type = NULL_TREE;
- last_expr_filename = input_filename;
-}
-
-/* T is a statement. Add it to the statement-tree. */
-
tree
-add_stmt (tree t)
+push_stmt_list (void)
{
- if (!EXPR_LOCUS (t))
- annotate_with_locus (t, input_location);
-
- /* Add T to the statement-tree. */
- TREE_CHAIN (last_tree) = t;
- last_tree = t;
-
- /* When we expand a statement-tree, we must know whether or not the
- statements are full-expressions. We record that fact here. */
- STMT_IS_FULL_EXPR_P (last_tree) = stmts_are_full_exprs_p ();
-
+ tree t;
+ t = alloc_stmt_list ();
+ TREE_CHAIN (t) = cur_stmt_list;
+ cur_stmt_list = t;
return t;
}
-/* Create a declaration statement for the declaration given by the
- DECL. */
+/* Similarly, except that T may have already been pushed/popped, and
+ thus may already contain statement(s). Arrage for new statements
+ to be appended. */
-void
-add_decl_stmt (tree decl)
+tree
+re_push_stmt_list (tree t)
{
- tree decl_stmt;
-
- /* We need the type to last until instantiation time. */
- decl_stmt = build_stmt (DECL_STMT, decl);
- add_stmt (decl_stmt);
+ if (t)
+ {
+ if (TREE_CODE (t) != STATEMENT_LIST)
+ {
+ tree u = alloc_stmt_list ();
+ append_to_statement_list_force (t, &u);
+ t = u;
+ }
+ }
+ else
+ t = alloc_stmt_list ();
+ TREE_CHAIN (t) = cur_stmt_list;
+ cur_stmt_list = t;
+ return t;
}
-/* Add a scope-statement to the statement-tree. BEGIN_P indicates
- whether this statements opens or closes a scope. PARTIAL_P is true
- for a partial scope, i.e, the scope that begins after a label when
- an object that needs a cleanup is created. If BEGIN_P is nonzero,
- returns a new TREE_LIST representing the top of the SCOPE_STMT
- stack. The TREE_PURPOSE is the new SCOPE_STMT. If BEGIN_P is
- zero, returns a TREE_LIST whose TREE_VALUE is the new SCOPE_STMT,
- and whose TREE_PURPOSE is the matching SCOPE_STMT with
- SCOPE_BEGIN_P set. */
+/* Finish the statement tree rooted at T. */
tree
-add_scope_stmt (int begin_p, int partial_p)
+pop_stmt_list (tree t)
{
- tree *stack_ptr = current_scope_stmt_stack ();
- tree ss;
- tree top = *stack_ptr;
-
- /* Build the statement. */
- ss = build_stmt (SCOPE_STMT, NULL_TREE);
- SCOPE_BEGIN_P (ss) = begin_p;
- SCOPE_PARTIAL_P (ss) = partial_p;
+ tree u = cur_stmt_list, chain;
- /* Keep the scope stack up to date. */
- if (begin_p)
+ /* Pop statement lists until we reach the target level. The extra
+ nestings will be due to outstanding cleanups. */
+ while (1)
{
- top = tree_cons (ss, NULL_TREE, top);
- *stack_ptr = top;
+ chain = TREE_CHAIN (u);
+ TREE_CHAIN (u) = NULL_TREE;
+ if (t == u)
+ break;
+ u = chain;
}
- else
+ cur_stmt_list = chain;
+
+ /* If the statement list is completely empty, just return it. This is
+ just as good small as build_empty_stmt, with the advantage that
+ statement lists are merged when they appended to one another. So
+ using the STATEMENT_LIST avoids pathological buildup of EMPTY_STMT_P
+ statements. */
+ if (TREE_SIDE_EFFECTS (t))
{
- if (partial_p != SCOPE_PARTIAL_P (TREE_PURPOSE (top)))
- abort ();
- TREE_VALUE (top) = ss;
- *stack_ptr = TREE_CHAIN (top);
+ tree_stmt_iterator i = tsi_start (t);
+
+ /* If the statement list contained exactly one statement, then
+ extract it immediately. */
+ if (tsi_one_before_end_p (i))
+ {
+ u = tsi_stmt (i);
+ tsi_delink (&i);
+ free_stmt_list (t);
+ t = u;
+ }
}
- /* Add the new statement to the statement-tree. */
- add_stmt (ss);
-
- return top;
+ return t;
}
-/* Finish the statement tree rooted at T. */
+/* T is a statement. Add it to the statement-tree. */
-void
-finish_stmt_tree (tree *t)
+tree
+add_stmt (tree t)
{
- tree stmt;
+ enum tree_code code = TREE_CODE (t);
- /* Remove the fake extra statement added in begin_stmt_tree. */
- stmt = TREE_CHAIN (*t);
- *t = stmt;
- last_tree = NULL_TREE;
+ if ((EXPR_P (t) || STATEMENT_CODE_P (code)) && code != LABEL_EXPR)
+ {
+ if (!EXPR_HAS_LOCATION (t))
+ SET_EXPR_LOCATION (t, input_location);
+
+ /* When we expand a statement-tree, we must know whether or not the
+ statements are full-expressions. We record that fact here. */
+ STMT_IS_FULL_EXPR_P (t) = stmts_are_full_exprs_p ();
+ }
+
+ /* Add T to the statement-tree. Non-side-effect statements need to be
+ recorded during statement expressions. */
+ append_to_statement_list_force (t, &cur_stmt_list);
+
+ return t;
}
/* Build a generic statement based on the given type of node and
arguments. Similar to `build_nt', except that we set
- EXPR_LOCUS to be the current source location. */
+ EXPR_LOCATION to be the current source location. */
/* ??? This should be obsolete with the lineno_stmt productions
in the grammar. */
va_start (p, code);
ret = make_node (code);
+ TREE_TYPE (ret) = void_type_node;
length = TREE_CODE_LENGTH (code);
- annotate_with_locus (ret, input_location);
+ SET_EXPR_LOCATION (ret, input_location);
/* Most statements have implicit side effects all on their own,
such as control transfer. For those that do, we'll compute
}
}
-/* Build the node for a return statement and return it. */
-
-tree
-build_return_stmt (tree expr)
-{
- return (build_stmt (RETURN_STMT, expr));
-}
-
/* Build a break statement node and return it. */
tree
return (build_stmt (CONTINUE_STMT));
}
-/* Create a CASE_LABEL tree node and return it. */
+/* Create a CASE_LABEL_EXPR tree node and return it. */
tree
build_case_label (tree low_value, tree high_value, tree label_decl)
{
- return build_stmt (CASE_LABEL, 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);
+ return build_stmt (CASE_LABEL_EXPR, low_value, high_value, label_decl);
}