into RTL. */
struct ssaexpand SA;
+/* This variable holds the currently expanded gimple statement for purposes
+ of comminucating the profile info to the builtin expanders. */
+gimple currently_expanding_gimple_stmt;
+
/* Return an expression tree corresponding to the RHS of GIMPLE
statement STMT. */
{
tree t;
enum gimple_rhs_class grhs_class;
-
+
grhs_class = get_gimple_rhs_class (gimple_expr_code (stmt));
if (grhs_class == GIMPLE_BINARY_RHS)
is lower triangular. */
static bool *stack_vars_conflict;
static size_t stack_vars_conflict_alloc;
+static size_t n_stack_vars_conflict;
/* The phase of the stack frame. This is the known misalignment of
virtual_stack_vars_rtx from PREFERRED_STACK_BOUNDARY. That is,
size_t t;
t = i, i = j, j = t;
}
- return (i * (i + 1)) / 2 + j;
+
+ if (i & 1)
+ return ((i + 1) / 2) * i + j;
+ else
+ return (i / 2) * (i + 1) + j;
}
/* Ensure that STACK_VARS_CONFLICT is large enough for N objects. */
size_t size = triangular_index (n-1, n-1) + 1;
if (size <= stack_vars_conflict_alloc)
- return;
+ {
+ if (n > n_stack_vars_conflict)
+ fatal_error ("program is too large to be compiled on this machine");
+ return;
+ }
stack_vars_conflict = XRESIZEVEC (bool, stack_vars_conflict, size);
memset (stack_vars_conflict + stack_vars_conflict_alloc, 0,
(size - stack_vars_conflict_alloc) * sizeof (bool));
stack_vars_conflict_alloc = size;
+ n_stack_vars_conflict = n;
}
/* Make the decls associated with luid's X and Y conflict. */
gcc_assert (index < stack_vars_conflict_alloc);
return stack_vars_conflict[index];
}
-
+
/* Returns true if TYPE is or contains a union type. */
static bool
/* A subroutine of expand_used_vars. Expand one variable according to
its flavor. Variables to be placed on the stack are not actually
- expanded yet, merely recorded.
+ expanded yet, merely recorded.
When REALLY_EXPAND is false, only add stack values to be allocated.
Return stack usage this variable is supposed to take.
*/
}
/* Prepare for expanding variables. */
-static void
+static void
init_vars_expansion (void)
{
tree t;
return (rtx) *elt;
/* Find the tree label if it is present. */
-
+
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
{
lab_stmt = gsi_stmt (gsi);
/* A subroutine of expand_gimple_cond. Given E, a fallthrough edge
of a basic block where we just expanded the conditional at the end,
- possibly clean up the CFG and instruction sequence. */
+ possibly clean up the CFG and instruction sequence. LAST is the
+ last instruction before the just emitted jump sequence. */
static void
-maybe_cleanup_end_of_block (edge e)
+maybe_cleanup_end_of_block (edge e, rtx last)
{
/* Special case: when jumpif decides that the condition is
trivial it emits an unconditional jump (and the necessary
normally isn't there in a cleaned CFG), fix it here. */
if (BARRIER_P (get_last_insn ()))
{
- basic_block bb = e->src;
rtx insn;
remove_edge (e);
/* Now, we have a single successor block, if we have insns to
/* Make sure we have an unconditional jump. Otherwise we're
confused. */
gcc_assert (JUMP_P (insn) && !any_condjump_p (insn));
- for (insn = PREV_INSN (insn); insn != BB_HEAD (bb);)
+ for (insn = PREV_INSN (insn); insn != last;)
{
insn = PREV_INSN (insn);
if (JUMP_P (NEXT_INSN (insn)))
}
true_edge->goto_block = NULL;
false_edge->flags |= EDGE_FALLTHRU;
- maybe_cleanup_end_of_block (false_edge);
+ maybe_cleanup_end_of_block (false_edge, last);
return NULL;
}
if (true_edge->dest == bb->next_bb)
}
false_edge->goto_block = NULL;
true_edge->flags |= EDGE_FALLTHRU;
- maybe_cleanup_end_of_block (true_edge);
+ maybe_cleanup_end_of_block (true_edge, last);
return NULL;
}
{
tree exp;
tree lhs = gimple_call_lhs (stmt);
- tree fndecl = gimple_call_fndecl (stmt);
size_t i;
exp = build_vl_exp (CALL_EXPR, gimple_call_num_args (stmt) + 3);
for (i = 0; i < gimple_call_num_args (stmt); i++)
CALL_EXPR_ARG (exp, i) = gimple_call_arg (stmt, i);
- if (!(gimple_call_flags (stmt) & (ECF_CONST | ECF_PURE)))
+ if (gimple_has_side_effects (stmt))
TREE_SIDE_EFFECTS (exp) = 1;
- if (gimple_call_flags (stmt) & ECF_NOTHROW)
+ if (gimple_call_nothrow_p (stmt))
TREE_NOTHROW (exp) = 1;
CALL_EXPR_TAILCALL (exp) = gimple_call_tail_p (stmt);
SET_EXPR_LOCATION (exp, gimple_location (stmt));
TREE_BLOCK (exp) = gimple_block (stmt);
- /* Record the original call statement, as it may be used
- to retrieve profile information during expansion. */
-
- if (fndecl && DECL_BUILT_IN (fndecl))
- {
- tree_ann_common_t ann = get_tree_common_ann (exp);
- ann->stmt = stmt;
- }
-
if (lhs)
expand_assignment (lhs, exp, false);
else
const1_rtx, const0_rtx);
}
-/* Wrap modeless constants in CONST:MODE. */
-rtx
-wrap_constant (enum machine_mode mode, rtx x)
-{
- if (GET_MODE (x) != VOIDmode)
- return x;
-
- if (CONST_INT_P (x)
- || GET_CODE (x) == CONST_FIXED
- || GET_CODE (x) == CONST_DOUBLE
- || GET_CODE (x) == LABEL_REF)
- {
- gcc_assert (mode != VOIDmode);
-
- x = gen_rtx_CONST (mode, x);
- }
-
- return x;
-}
-
-/* Remove CONST wrapper added by wrap_constant(). */
-rtx
-unwrap_constant (rtx x)
-{
- rtx ret = x;
-
- if (GET_CODE (x) != CONST)
- return x;
-
- x = XEXP (x, 0);
-
- if (CONST_INT_P (x)
- || GET_CODE (x) == CONST_FIXED
- || GET_CODE (x) == CONST_DOUBLE
- || GET_CODE (x) == LABEL_REF)
- ret = x;
-
- return ret;
-}
-
/* Convert X to MODE, that must be Pmode or ptr_mode, without emitting
any rtl. */
rtx op0 = NULL_RTX, op1 = NULL_RTX, op2 = NULL_RTX;
enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
int unsignedp = TYPE_UNSIGNED (TREE_TYPE (exp));
+ addr_space_t as;
+ enum machine_mode address_mode;
+ enum machine_mode pointer_mode;
switch (TREE_CODE_CLASS (TREE_CODE (exp)))
{
case COMPLEX_CST:
gcc_assert (COMPLEX_MODE_P (mode));
op0 = expand_debug_expr (TREE_REALPART (exp));
- op0 = wrap_constant (GET_MODE_INNER (mode), op0);
op1 = expand_debug_expr (TREE_IMAGPART (exp));
- op1 = wrap_constant (GET_MODE_INNER (mode), op1);
return gen_rtx_CONCAT (mode, op0, op1);
case DEBUG_EXPR_DECL:
|| DECL_EXTERNAL (exp)
|| !TREE_STATIC (exp)
|| !DECL_NAME (exp)
- || DECL_HARD_REGISTER (exp))
+ || DECL_HARD_REGISTER (exp)
+ || mode == VOIDmode)
return NULL;
op0 = DECL_RTL (exp);
if (!op0)
return NULL;
- gcc_assert (GET_MODE (op0) == Pmode
- || GET_MODE (op0) == ptr_mode
+ if (POINTER_TYPE_P (TREE_TYPE (exp)))
+ as = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp)));
+ else
+ as = ADDR_SPACE_GENERIC;
+
+ address_mode = targetm.addr_space.address_mode (as);
+ pointer_mode = targetm.addr_space.pointer_mode (as);
+
+ gcc_assert (GET_MODE (op0) == address_mode
+ || GET_MODE (op0) == pointer_mode
|| GET_CODE (op0) == CONST_INT
|| GET_CODE (op0) == CONST_DOUBLE);
if (TREE_CODE (exp) == ALIGN_INDIRECT_REF)
{
int align = TYPE_ALIGN_UNIT (TREE_TYPE (exp));
- op0 = gen_rtx_AND (Pmode, op0, GEN_INT (-align));
+ op0 = gen_rtx_AND (address_mode, op0, GEN_INT (-align));
}
op0 = gen_rtx_MEM (mode, op0);
set_mem_attributes (op0, exp, 0);
+ set_mem_addr_space (op0, as);
return op0;
if (!op0)
return NULL;
- gcc_assert (GET_MODE (op0) == Pmode
- || GET_MODE (op0) == ptr_mode
+ as = TYPE_ADDR_SPACE (TREE_TYPE (exp));
+ address_mode = targetm.addr_space.address_mode (as);
+ pointer_mode = targetm.addr_space.pointer_mode (as);
+
+ gcc_assert (GET_MODE (op0) == address_mode
+ || GET_MODE (op0) == pointer_mode
|| GET_CODE (op0) == CONST_INT
|| GET_CODE (op0) == CONST_DOUBLE);
op0 = gen_rtx_MEM (mode, op0);
set_mem_attributes (op0, exp, 0);
+ set_mem_addr_space (op0, as);
return op0;
basic_block new_bb;
stmt = gsi_stmt (gsi);
+ currently_expanding_gimple_stmt = stmt;
/* Expand this statement, then evaluate the resulting RTL and
fixup the CFG accordingly. */
/* Ignore this stmt if it is in the list of
replaceable expressions. */
if (SA.values
- && bitmap_bit_p (SA.values,
+ && bitmap_bit_p (SA.values,
SSA_NAME_VERSION (DEF_FROM_PTR (def_p))))
continue;
}
}
}
+ currently_expanding_gimple_stmt = NULL;
+
/* Expand implicit goto and convert goto_locus. */
FOR_EACH_EDGE (e, ei, bb->succs)
{
}
}
+ /* Expanded RTL can create a jump in the last instruction of block.
+ This later might be assumed to be a jump to successor and break edge insertion.
+ We need to insert dummy move to prevent this. PR41440. */
+ if (single_succ_p (bb)
+ && (single_succ_edge (bb)->flags & EDGE_FALLTHRU)
+ && (last = get_last_insn ())
+ && JUMP_P (last))
+ {
+ rtx dummy = gen_reg_rtx (SImode);
+ emit_insn_after_noloc (gen_move_insn (dummy, dummy), last, NULL);
+ }
+
do_pending_stack_adjust ();
/* Find the block tail. The last insn in the block is the insn
if (! SUPPORTS_STACK_ALIGNMENT)
return;
-
+
if (cfun->calls_alloca
|| cfun->has_nonlocal_label
|| crtl->has_nonlocal_goto)
crtl->need_drap = true;
- gcc_assert (crtl->stack_alignment_needed
- <= crtl->stack_alignment_estimated);
+ /* Call update_stack_boundary here again to update incoming stack
+ boundary. It may set incoming stack alignment to a different
+ value after RTL expansion. TARGET_FUNCTION_OK_FOR_SIBCALL may
+ use the minimum incoming stack alignment to check if it is OK
+ to perform sibcall optimization since sibcall optimization will
+ only align the outgoing stack to incoming stack boundary. */
+ if (targetm.calls.update_stack_boundary)
+ targetm.calls.update_stack_boundary ();
+
+ /* The incoming stack frame has to be aligned at least at
+ parm_stack_boundary. */
+ gcc_assert (crtl->parm_stack_boundary <= INCOMING_STACK_BOUNDARY);
/* Update crtl->stack_alignment_estimated and use it later to align
stack. We check PREFERRED_STACK_BOUNDARY if there may be non-call
if (preferred_stack_boundary > crtl->stack_alignment_needed)
crtl->stack_alignment_needed = preferred_stack_boundary;
+ gcc_assert (crtl->stack_alignment_needed
+ <= crtl->stack_alignment_estimated);
+
crtl->stack_realign_needed
= INCOMING_STACK_BOUNDARY < crtl->stack_alignment_estimated;
crtl->stack_realign_tried = crtl->stack_realign_needed;
/* Target has to redefine TARGET_GET_DRAP_RTX to support stack
alignment. */
gcc_assert (targetm.calls.get_drap_rtx != NULL);
- drap_rtx = targetm.calls.get_drap_rtx ();
+ drap_rtx = targetm.calls.get_drap_rtx ();
/* stack_realign_drap and drap_rtx must match. */
gcc_assert ((stack_realign_drap != 0) == (drap_rtx != NULL));
targetm.expand_to_rtl_hook ();
crtl->stack_alignment_needed = STACK_BOUNDARY;
crtl->max_used_stack_slot_alignment = STACK_BOUNDARY;
- crtl->stack_alignment_estimated = STACK_BOUNDARY;
+ crtl->stack_alignment_estimated = 0;
crtl->preferred_stack_boundary = STACK_BOUNDARY;
cfun->cfg->max_jumptable_ents = 0;
if (warn_stack_protect)
{
if (cfun->calls_alloca)
- warning (OPT_Wstack_protector,
+ warning (OPT_Wstack_protector,
"not protecting local variables: variable length buffer");
if (has_short_buffer && !crtl->stack_protect_guard)
- warning (OPT_Wstack_protector,
+ warning (OPT_Wstack_protector,
"not protecting function: no buffer at least %d bytes long",
(int) PARAM_VALUE (PARAM_SSP_BUFFER_SIZE));
}
if (crtl->stack_protect_guard)
stack_protect_prologue ();
- /* Update stack boundary if needed. */
- if (SUPPORTS_STACK_ALIGNMENT)
- {
- /* Call update_stack_boundary here to update incoming stack
- boundary before TARGET_FUNCTION_OK_FOR_SIBCALL is called.
- TARGET_FUNCTION_OK_FOR_SIBCALL needs to know the accurate
- incoming stack alignment to check if it is OK to perform
- sibcall optimization since sibcall optimization will only
- align the outgoing stack to incoming stack boundary. */
- if (targetm.calls.update_stack_boundary)
- targetm.calls.update_stack_boundary ();
-
- /* The incoming stack frame has to be aligned at least at
- parm_stack_boundary. */
- gcc_assert (crtl->parm_stack_boundary <= INCOMING_STACK_BOUNDARY);
- }
-
expand_phi_nodes (&SA);
/* Register rtl specific functions for cfg. */