/* A pass for lowering trees to RTL.
- Copyright (C) 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
+ Copyright (C) 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2, or (at your option)
+the Free Software Foundation; either version 3, or (at your option)
any later version.
GCC is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
-along with GCC; see the file COPYING. If not, write to
-the Free Software Foundation, 51 Franklin Street, Fifth Floor,
-Boston, MA 02110-1301, USA. */
+along with GCC; see the file COPYING3. If not see
+<http://www.gnu.org/licenses/>. */
#include "config.h"
#include "system.h"
#include "params.h"
#include "tree-inline.h"
#include "value-prof.h"
+#include "target.h"
/* Verify that there is exactly single jump instruction since last and attach
REG_BR_PROB note specifying probability.
align = LOCAL_ALIGNMENT (TREE_TYPE (decl), align);
if (align > PREFERRED_STACK_BOUNDARY)
align = PREFERRED_STACK_BOUNDARY;
- if (cfun->stack_alignment_needed < align)
- cfun->stack_alignment_needed = align;
+ if (crtl->stack_alignment_needed < align)
+ crtl->stack_alignment_needed = align;
return align / BITS_PER_UNIT;
}
fputc ('\t', dump_file);
print_generic_expr (dump_file, stack_vars[j].decl, dump_flags);
fprintf (dump_file, ", offset " HOST_WIDE_INT_PRINT_DEC "\n",
- stack_vars[i].offset);
+ stack_vars[j].offset);
}
}
}
/* Create rtl for each variable based on their location within the
partition. */
for (j = i; j != EOC; j = stack_vars[j].next)
- expand_one_stack_var_at (stack_vars[j].decl,
- stack_vars[j].offset + offset);
+ {
+ gcc_assert (stack_vars[j].offset <= stack_vars[i].size);
+ expand_one_stack_var_at (stack_vars[j].decl,
+ stack_vars[j].offset + offset);
+ }
}
}
if (TREE_ASM_WRITTEN (var))
return;
- /* Give the front end a chance to do whatever. In practice, this is
- resolving duplicate names for IMA in C. */
- if (lang_hooks.expand_decl (var))
- return;
-
/* Otherwise, just emit the variable. */
rest_of_decl_compilation (var, 0, 0);
}
/* Note if the object is a user variable. */
if (!DECL_ARTIFICIAL (var))
- {
mark_user_reg (x);
- /* Trust user variables which have a pointer type to really
- be pointers. Do not trust compiler generated temporaries
- as our type system is totally busted as it relates to
- pointer arithmetic which translates into lots of compiler
- generated objects with pointer types, but which are not really
- pointers. */
- if (POINTER_TYPE_P (type))
- mark_reg_pointer (x, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (var))));
- }
+ if (POINTER_TYPE_P (type))
+ mark_reg_pointer (x, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (var))));
}
/* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL that
expand_one_var (tree var, bool toplevel, bool really_expand)
{
if (TREE_CODE (var) != VAR_DECL)
- {
- if (really_expand)
- lang_hooks.expand_decl (var);
- }
+ ;
else if (DECL_EXTERNAL (var))
;
else if (DECL_HAS_VALUE_EXPR_P (var))
TREE_THIS_VOLATILE (guard) = 1;
TREE_USED (guard) = 1;
expand_one_stack_var (guard);
- cfun->stack_protect_guard = guard;
+ crtl->stack_protect_guard = guard;
}
/* A subroutine of expand_used_vars. Walk down through the BLOCK tree
init_vars_expansion (void)
{
tree t;
- /* Set TREE_USED on all variables in the unexpanded_var_list. */
- for (t = cfun->unexpanded_var_list; t; t = TREE_CHAIN (t))
+ /* Set TREE_USED on all variables in the local_decls. */
+ for (t = cfun->local_decls; t; t = TREE_CHAIN (t))
TREE_USED (TREE_VALUE (t)) = 1;
/* Clear TREE_USED on all variables associated with a block scope. */
init_vars_expansion ();
- /* At this point all variables on the unexpanded_var_list with TREE_USED
+ /* At this point all variables on the local_decls with TREE_USED
set are not associated with any block scope. Lay them out. */
- for (t = cfun->unexpanded_var_list; t; t = TREE_CHAIN (t))
+ for (t = cfun->local_decls; t; t = TREE_CHAIN (t))
{
tree var = TREE_VALUE (t);
init_vars_expansion ();
- /* At this point all variables on the unexpanded_var_list with TREE_USED
+ /* At this point all variables on the local_decls with TREE_USED
set are not associated with any block scope. Lay them out. */
- for (t = cfun->unexpanded_var_list; t; t = TREE_CHAIN (t))
+ for (t = cfun->local_decls; t; t = TREE_CHAIN (t))
{
tree var = TREE_VALUE (t);
bool expand_now = false;
if (expand_now)
expand_one_var (var, true, true);
}
- cfun->unexpanded_var_list = NULL_TREE;
+ cfun->local_decls = NULL_TREE;
/* At this point, all variables within the block tree with TREE_USED
set are actually used by the optimized function. Lay them out. */
}
}
+/* Maps the blocks that do not contain tree labels to rtx labels. */
+
+static struct pointer_map_t *lab_rtx_for_bb;
+
+/* Returns the label_rtx expression for a label starting basic block BB. */
+
+static rtx
+label_rtx_for_bb (basic_block bb)
+{
+ tree_stmt_iterator tsi;
+ tree lab, lab_stmt;
+ void **elt;
+
+ if (bb->flags & BB_RTL)
+ return block_label (bb);
+
+ elt = pointer_map_contains (lab_rtx_for_bb, bb);
+ if (elt)
+ return (rtx) *elt;
+
+ /* Find the tree label if it is present. */
+
+ for (tsi = tsi_start (bb_stmt_list (bb)); !tsi_end_p (tsi); tsi_next (&tsi))
+ {
+ lab_stmt = tsi_stmt (tsi);
+ if (TREE_CODE (lab_stmt) != LABEL_EXPR)
+ break;
+
+ lab = LABEL_EXPR_LABEL (lab_stmt);
+ if (DECL_NONLOCAL (lab))
+ break;
+
+ return label_rtx (lab);
+ }
+
+ elt = pointer_map_insert (lab_rtx_for_bb, bb);
+ *elt = gen_label_rtx ();
+ return (rtx) *elt;
+}
+
/* A subroutine of expand_gimple_basic_block. Expand one COND_EXPR.
Returns a new basic block if we've terminated the current basic
block and created a new one. */
edge true_edge;
edge false_edge;
tree pred = COND_EXPR_COND (stmt);
- tree then_exp = COND_EXPR_THEN (stmt);
- tree else_exp = COND_EXPR_ELSE (stmt);
rtx last2, last;
+ gcc_assert (COND_EXPR_THEN (stmt) == NULL_TREE);
+ gcc_assert (COND_EXPR_ELSE (stmt) == NULL_TREE);
last2 = last = get_last_insn ();
extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
if (EXPR_LOCUS (stmt))
{
- emit_line_note (*(EXPR_LOCUS (stmt)));
- record_block_change (TREE_BLOCK (stmt));
+ set_curr_insn_source_location (*(EXPR_LOCUS (stmt)));
+ set_curr_insn_block (TREE_BLOCK (stmt));
}
/* These flags have no purpose in RTL land. */
/* We can either have a pure conditional jump with one fallthru edge or
two-way jump that needs to be decomposed into two basic blocks. */
- if (TREE_CODE (then_exp) == GOTO_EXPR && IS_EMPTY_STMT (else_exp))
+ if (false_edge->dest == bb->next_bb)
{
- jumpif (pred, label_rtx (GOTO_DESTINATION (then_exp)));
+ jumpif (pred, label_rtx_for_bb (true_edge->dest));
add_reg_br_prob_note (last, true_edge->probability);
maybe_dump_rtl_for_tree_stmt (stmt, last);
- if (EXPR_LOCUS (then_exp))
- emit_line_note (*(EXPR_LOCUS (then_exp)));
+ if (true_edge->goto_locus)
+ set_curr_insn_source_location (true_edge->goto_locus);
+ false_edge->flags |= EDGE_FALLTHRU;
return NULL;
}
- if (TREE_CODE (else_exp) == GOTO_EXPR && IS_EMPTY_STMT (then_exp))
+ if (true_edge->dest == bb->next_bb)
{
- jumpifnot (pred, label_rtx (GOTO_DESTINATION (else_exp)));
+ jumpifnot (pred, label_rtx_for_bb (false_edge->dest));
add_reg_br_prob_note (last, false_edge->probability);
maybe_dump_rtl_for_tree_stmt (stmt, last);
- if (EXPR_LOCUS (else_exp))
- emit_line_note (*(EXPR_LOCUS (else_exp)));
+ if (false_edge->goto_locus)
+ set_curr_insn_source_location (false_edge->goto_locus);
+ true_edge->flags |= EDGE_FALLTHRU;
return NULL;
}
- gcc_assert (TREE_CODE (then_exp) == GOTO_EXPR
- && TREE_CODE (else_exp) == GOTO_EXPR);
- jumpif (pred, label_rtx (GOTO_DESTINATION (then_exp)));
+ jumpif (pred, label_rtx_for_bb (true_edge->dest));
add_reg_br_prob_note (last, true_edge->probability);
last = get_last_insn ();
- expand_expr (else_exp, const0_rtx, VOIDmode, 0);
+ emit_jump (label_rtx_for_bb (false_edge->dest));
BB_END (bb) = last;
if (BARRIER_P (BB_END (bb)))
maybe_dump_rtl_for_tree_stmt (stmt, last2);
- if (EXPR_LOCUS (else_exp))
- emit_line_note (*(EXPR_LOCUS (else_exp)));
+ if (false_edge->goto_locus)
+ set_curr_insn_source_location (false_edge->goto_locus);
return new_bb;
}
static basic_block
expand_gimple_basic_block (basic_block bb)
{
- block_stmt_iterator bsi = bsi_start (bb);
+ tree_stmt_iterator tsi;
+ tree stmts = bb_stmt_list (bb);
tree stmt = NULL;
rtx note, last;
edge e;
edge_iterator ei;
+ void **elt;
if (dump_file)
{
bb->index);
}
+ bb->il.tree = NULL;
init_rtl_bb_info (bb);
bb->flags |= BB_RTL;
- if (!bsi_end_p (bsi))
- stmt = bsi_stmt (bsi);
+ /* Remove the RETURN_EXPR if we may fall though to the exit
+ instead. */
+ tsi = tsi_last (stmts);
+ if (!tsi_end_p (tsi)
+ && TREE_CODE (tsi_stmt (tsi)) == RETURN_EXPR)
+ {
+ tree ret_stmt = tsi_stmt (tsi);
+
+ gcc_assert (single_succ_p (bb));
+ gcc_assert (single_succ (bb) == EXIT_BLOCK_PTR);
+
+ if (bb->next_bb == EXIT_BLOCK_PTR
+ && !TREE_OPERAND (ret_stmt, 0))
+ {
+ tsi_delink (&tsi);
+ single_succ_edge (bb)->flags |= EDGE_FALLTHRU;
+ }
+ }
+
+ tsi = tsi_start (stmts);
+ if (!tsi_end_p (tsi))
+ {
+ stmt = tsi_stmt (tsi);
+ if (TREE_CODE (stmt) != LABEL_EXPR)
+ stmt = NULL_TREE;
+ }
+
+ elt = pointer_map_contains (lab_rtx_for_bb, bb);
- if (stmt && TREE_CODE (stmt) == LABEL_EXPR)
+ if (stmt || elt)
{
last = get_last_insn ();
- expand_expr_stmt (stmt);
+ if (stmt)
+ {
+ expand_expr_stmt (stmt);
+ tsi_next (&tsi);
+ }
+
+ if (elt)
+ emit_label ((rtx) *elt);
/* Java emits line number notes in the top of labels.
??? Make this go away once line number notes are obsoleted. */
BB_HEAD (bb) = NEXT_INSN (last);
if (NOTE_P (BB_HEAD (bb)))
BB_HEAD (bb) = NEXT_INSN (BB_HEAD (bb));
- bsi_next (&bsi);
note = emit_note_after (NOTE_INSN_BASIC_BLOCK, BB_HEAD (bb));
maybe_dump_rtl_for_tree_stmt (stmt, last);
ei_next (&ei);
}
- for (; !bsi_end_p (bsi); bsi_next (&bsi))
+ for (; !tsi_end_p (tsi); tsi_next (&tsi))
{
- tree stmt = bsi_stmt (bsi);
+ tree stmt = tsi_stmt (tsi);
basic_block new_bb;
if (!stmt)
}
}
+ /* Expand implicit goto. */
+ FOR_EACH_EDGE (e, ei, bb->succs)
+ {
+ if (e->flags & EDGE_FALLTHRU)
+ break;
+ }
+
+ if (e && e->dest != bb->next_bb)
+ {
+ emit_jump (label_rtx_for_bb (e->dest));
+ if (e->goto_locus)
+ set_curr_insn_source_location (e->goto_locus);
+ e->flags &= ~EDGE_FALLTHRU;
+ }
+
do_pending_stack_adjust ();
/* Find the block tail. The last insn in the block is the insn
return init_block;
}
+/* For each lexical block, set BLOCK_NUMBER to the depth at which it is
+ found in the block tree. */
+
+static void
+set_block_levels (tree block, int level)
+{
+ while (block)
+ {
+ BLOCK_NUMBER (block) = level;
+ set_block_levels (BLOCK_SUBBLOCKS (block), level + 1);
+ block = BLOCK_CHAIN (block);
+ }
+}
/* Create a block containing landing pads and similar stuff. */
/* Make sure the locus is set to the end of the function, so that
epilogue line numbers and warnings are set properly. */
-#ifdef USE_MAPPED_LOCATION
if (cfun->function_end_locus != UNKNOWN_LOCATION)
-#else
- if (cfun->function_end_locus.file)
-#endif
input_location = cfun->function_end_locus;
/* The following insns belong to the top scope. */
- record_block_change (DECL_INITIAL (current_function_decl));
+ set_curr_insn_block (DECL_INITIAL (current_function_decl));
/* Generate rtl for function exit. */
expand_function_end ();
/* Some backends want to know that we are expanding to RTL. */
currently_expanding_to_rtl = 1;
- /* Prepare the rtl middle end to start recording block changes. */
- reset_block_changes ();
+ insn_locators_alloc ();
+ if (!DECL_BUILT_IN (current_function_decl))
+ set_curr_insn_source_location (DECL_SOURCE_LOCATION (current_function_decl));
+ set_curr_insn_block (DECL_INITIAL (current_function_decl));
+ prologue_locator = curr_insn_locator ();
+
+ /* Make sure first insn is a note even if we don't want linenums.
+ This makes sure the first insn will never be deleted.
+ Also, final expects a note to appear there. */
+ emit_note (NOTE_INSN_DELETED);
/* Mark arrays indexed with non-constant indices with TREE_ADDRESSABLE. */
discover_nonconstant_array_refs ();
+ targetm.expand_to_rtl_hook ();
+ crtl->stack_alignment_needed = STACK_BOUNDARY;
+ crtl->preferred_stack_boundary = STACK_BOUNDARY;
+ cfun->cfg->max_jumptable_ents = 0;
+
+
/* Expand the variables recorded during gimple lowering. */
expand_used_vars ();
if (warn_stack_protect)
{
if (current_function_calls_alloca)
- warning (0, "not protecting local variables: variable length buffer");
- if (has_short_buffer && !cfun->stack_protect_guard)
- warning (0, "not protecting function: no buffer at least %d bytes long",
+ warning (OPT_Wstack_protector,
+ "not protecting local variables: variable length buffer");
+ if (has_short_buffer && !crtl->stack_protect_guard)
+ warning (OPT_Wstack_protector,
+ "not protecting function: no buffer at least %d bytes long",
(int) PARAM_VALUE (PARAM_SSP_BUFFER_SIZE));
}
/* Initialize the stack_protect_guard field. This must happen after the
call to __main (if any) so that the external decl is initialized. */
- if (cfun->stack_protect_guard)
+ if (crtl->stack_protect_guard)
stack_protect_prologue ();
/* Register rtl specific functions for cfg. */
FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs)
e->flags &= ~EDGE_EXECUTABLE;
+ lab_rtx_for_bb = pointer_map_create ();
FOR_BB_BETWEEN (bb, init_block->next_bb, EXIT_BLOCK_PTR, next_bb)
bb = expand_gimple_basic_block (bb);
+ pointer_map_destroy (lab_rtx_for_bb);
+ free_histograms ();
construct_exit_block ();
+ set_curr_insn_block (DECL_INITIAL (current_function_decl));
+ insn_locators_finalize ();
/* We're done expanding trees to RTL. */
currently_expanding_to_rtl = 0;
more CONCATs anywhere. */
generating_concat_p = 0;
- finalize_block_changes ();
-
if (dump_file)
{
fprintf (dump_file,
/* After expanding, the return labels are no longer needed. */
return_label = NULL;
naked_return_label = NULL;
- free_histograms ();
+ /* Tag the blocks with a depth number so that change_scope can find
+ the common parent easily. */
+ set_block_levels (DECL_INITIAL (cfun->decl), 0);
return 0;
}
-struct tree_opt_pass pass_expand =
+struct gimple_opt_pass pass_expand =
{
+ {
+ GIMPLE_PASS,
"expand", /* name */
NULL, /* gate */
tree_expand_cfg, /* execute */
PROP_trees, /* properties_destroyed */
0, /* todo_flags_start */
TODO_dump_func, /* todo_flags_finish */
- 'r' /* letter */
+ }
};