the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
-
/* This file handles the generation of rtl code from tree structure
at the level of the function as a whole.
It creates the rtl expressions for parameters and auto variables
/* Nonzero if function being compiled doesn't contain any calls
(ignoring the prologue and epilogue). This is set prior to
local register allocation and is valid for the remaining
- compiler passes. */
+ compiler passes. */
int current_function_is_leaf;
/* Nonzero if function being compiled doesn't contain any instructions
/* Nonzero if function being compiled doesn't modify the stack pointer
(ignoring the prologue and epilogue). This is only valid after
- life_analysis has run. */
+ life_analysis has run. */
int current_function_sp_is_unchanging;
/* Nonzero if the function being compiled is a leaf function which only
/* The rtx used to represent the address if not the address of the
slot above. May be an EXPR_LIST if multiple addresses exist. */
rtx address;
- /* The alignment (in bits) of the slot. */
+ /* The alignment (in bits) of the slot. */
int align;
/* The size, in units, of the slot. */
HOST_WIDE_INT size;
rtx new;
struct fixup_replacement *next;
};
-
+
struct insns_for_mem_entry {
/* The KEY in HE will be a MEM. */
struct hash_entry he;
static void schedule_fixup_var_refs PARAMS ((struct function *, rtx, tree,
enum machine_mode,
struct hash_table *));
-static void fixup_var_refs PARAMS ((rtx, enum machine_mode, int,
+static void fixup_var_refs PARAMS ((rtx, enum machine_mode, int,
struct hash_table *));
static struct fixup_replacement
*find_fixup_replacement PARAMS ((struct fixup_replacement **, rtx));
static void emit_return_into_block PARAMS ((basic_block, rtx));
#endif
static void put_addressof_into_stack PARAMS ((rtx, struct hash_table *));
-static boolean purge_addressof_1 PARAMS ((rtx *, rtx, int, int,
+static boolean purge_addressof_1 PARAMS ((rtx *, rtx, int, int,
struct hash_table *));
static int is_addressof PARAMS ((rtx *, void *));
static struct hash_entry *insns_for_mem_newfunc PARAMS ((struct hash_entry *,
f->inl_last_parm_insn = NULL;
f->epilogue_delay_list = NULL;
}
-
\f
/* Allocate fixed slots in the stack frame of the current function. */
/* Allocate a stack slot of SIZE bytes and return a MEM rtx for it
with machine mode MODE.
-
+
ALIGN controls the amount of alignment for the address of the slot:
0 means according to MODE,
-1 means use BIGGEST_ALIGNMENT and round size to multiple of that,
if (mode == BLKmode)
alignment = BIGGEST_ALIGNMENT;
else
- alignment = GET_MODE_ALIGNMENT (mode);
+ alignment = GET_MODE_ALIGNMENT (mode);
/* Allow the target to (possibly) increase the alignment of this
stack slot. */
with this flag. KEEP is 2 if we allocate a longer term temporary,
whose lifetime is controlled by CLEANUP_POINT_EXPRs. KEEP is 3
if we are to allocate something at an inner level to be treated as
- a variable in the block (e.g., a SAVE_EXPR).
+ a variable in the block (e.g., a SAVE_EXPR).
TYPE is the type that will be used for the stack slot. */
alias set for the memory. */
if (type)
alias_set = get_alias_set (type);
- else
+ else
alias_set = 0;
if (mode == BLKmode)
p = best_p;
}
-
+
/* If we still didn't find one, make a new temporary. */
if (p == 0)
{
if (flag_strict_aliasing)
return;
- /* If there are a lot of temp slots, don't do anything unless
+ /* If there are a lot of temp slots, don't do anything unless
high levels of optimizaton. */
if (! flag_expensive_optimizations)
for (p = temp_slots, num_slots = 0; p; p = p->next, num_slots++)
return 0;
}
-
+
/* Indicate that NEW is an alternate way of referring to the temp slot
that previously was known by OLD. */
return;
}
- /* Otherwise add an alias for the temp's address. */
+ /* Otherwise add an alias for the temp's address. */
else if (p->address == 0)
p->address = new;
else
}
else
return;
-
+
if (current_function_check_memory_usage)
emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3,
XEXP (reg, 0), Pmode,
rtx insn;
/* Must scan all insns for stack-refs that exceed the limit. */
- fixup_var_refs_insns (var, promoted_mode, unsignedp, first_insn,
+ fixup_var_refs_insns (var, promoted_mode, unsignedp, first_insn,
stack == 0, ht);
/* If there's a hash table, it must record all uses of VAR. */
if (ht)
if (seq != const0_rtx && seq != 0)
{
push_to_sequence (seq);
- fixup_var_refs_insns (var, promoted_mode, unsignedp, seq, 0,
- 0);
+ fixup_var_refs_insns (var, promoted_mode, unsignedp, seq, 0, 0);
end_sequence ();
}
}
/* Scan the catch clauses for exception handling too. */
push_to_full_sequence (catch_clauses, catch_clauses_last);
- fixup_var_refs_insns (var, promoted_mode, unsignedp, catch_clauses,
- 0, 0);
+ fixup_var_refs_insns (var, promoted_mode, unsignedp, catch_clauses, 0, 0);
end_full_sequence (&catch_clauses, &catch_clauses_last);
/* Scan sequences saved in CALL_PLACEHOLDERS too. */
to walk the entire instruction chain. */
if (ht)
{
- insn_list = ((struct insns_for_mem_entry *)
+ insn_list = ((struct insns_for_mem_entry *)
hash_lookup (ht, var, /*create=*/0, /*copy=*/0))->insns;
insn = insn_list ? XEXP (insn_list, 0) : NULL_RTX;
insn_list = XEXP (insn_list, 1);
If it has a REG_LIBCALL note, delete the REG_LIBCALL
and REG_RETVAL notes too. */
- if (GET_CODE (PATTERN (insn)) == CLOBBER
+ if (GET_CODE (PATTERN (insn)) == CLOBBER
&& (XEXP (PATTERN (insn), 0) == var
|| (GET_CODE (XEXP (PATTERN (insn), 0)) == CONCAT
&& (XEXP (XEXP (PATTERN (insn), 0), 0) == var
PATTERN (insn) = replace_rtx (PATTERN (insn),
call_dest, temp);
}
-
+
if (GET_CODE (insn) == CALL_INSN
&& GET_CODE (PATTERN (insn)) == SET)
call_dest = SET_DEST (PATTERN (insn));
a list of struct fixup_replacements. If fixup_var_refs_1
needs to allocate pseudos or replacement MEMs (for SUBREGs),
it will record them in this list.
-
+
If it allocated a pseudo for any replacement, we copy into
it here. */
if (GET_CODE (note) != INSN_LIST)
XEXP (note, 0)
= walk_fixup_memory_subreg (XEXP (note, 0), insn, 1);
- note = XEXP (note, 1);
+ note = XEXP (note, 1);
}
}
}
\f
/* VAR is a MEM that used to be a pseudo register with mode PROMOTED_MODE.
- See if the rtx expression at *LOC in INSN needs to be changed.
+ See if the rtx expression at *LOC in INSN needs to be changed.
REPLACEMENTS is a pointer to a list head that starts out zero, but may
contain a list of original rtx's and replacements. If we find that we need
case MEM:
if (var == x)
{
- /* If we already have a replacement, use it. Otherwise,
+ /* If we already have a replacement, use it. Otherwise,
try to fix up this address in case it is invalid. */
replacement = find_fixup_replacement (replacements, var);
/* Unless we are forcing memory to register or we changed the mode,
we can leave things the way they are if the insn is valid. */
-
+
INSN_CODE (insn) = -1;
if (! flag_force_mem && GET_MODE (x) == promoted_mode
&& recog_memoized (insn) >= 0)
return;
}
break;
-
+
case SUBREG:
if (SUBREG_REG (x) == var)
{
}
/* If this SUBREG makes VAR wider, it has become a paradoxical
- SUBREG with VAR in memory, but these aren't allowed at this
+ SUBREG with VAR in memory, but these aren't allowed at this
stage of the compilation. So load VAR into a pseudo and take
a SUBREG of that pseudo. */
if (GET_MODE_SIZE (GET_MODE (x)) > GET_MODE_SIZE (GET_MODE (var)))
*loc = replacement->new;
return;
}
-
+
replacement->new = *loc = fixup_memory_subreg (x, insn, 0);
INSN_CODE (insn) = -1;
insn);
break;
}
-
+
{
rtx dest = SET_DEST (x);
rtx src = SET_SRC (x);
/* If VAR does not appear at the top level of the SET
just scan the lower levels of the tree. */
- if (src != var && dest != var)
+ if (src != var && dest != var)
break;
/* We will need to rerecognize this insn. */
INSN_CODE (insn) = -1;
XEXP (outerdest, 0) = newmem;
XEXP (outerdest, 2) = GEN_INT (pos);
-
+
if (recog_memoized (insn) >= 0)
return;
-
+
/* Otherwise, restore old position. XEXP (x, 0) will be
restored later. */
XEXP (outerdest, 2) = old_pos;
copy SET_SRC (x) to SET_DEST (x) in some way. So
we generate the move and see whether it requires more
than one insn. If it does, we emit those insns and
- delete INSN. Otherwise, we an just replace the pattern
+ delete INSN. Otherwise, we an just replace the pattern
of INSN; we have already verified above that INSN has
no other function that to do X. */
If X itself is a (SUBREG (MEM ...) ...), return the replacement expression.
Otherwise return X, with its contents possibly altered.
- If any insns must be emitted to compute NEWADDR, put them before INSN.
+ If any insns must be emitted to compute NEWADDR, put them before INSN.
UNCRITICAL is as in fixup_memory_subreg. */
/* The bottom of the stack points to the actual arguments. If
REG_PARM_STACK_SPACE is defined, this includes the space for the register
parameters. However, if OUTGOING_REG_PARM_STACK space is not defined,
- stack space for register parameters is not pushed by the caller, but
+ stack space for register parameters is not pushed by the caller, but
rather part of the fixed stack areas and hence not included in
`current_function_outgoing_args_size'. Nevertheless, we must allow
for it when allocating stack dynamic objects. */
#define ARG_POINTER_CFA_OFFSET(FNDECL) FIRST_PARM_OFFSET (FNDECL)
#endif
-
/* Build up a (MEM (ADDRESSOF (REG))) rtx for a register REG that just had
its address taken. DECL is the decl for the object stored in the
register, for later use if we do need to force REG into the stack.
corresponding (ADDRESSOF (REG ...)) and value is a substitution for
the all pattern. List PURGE_BITFIELD_ADDRESSOF_REPLACEMENTS is not
enough in complex cases, e.g. when some field values can be
- extracted by usage MEM with narrower mode. */
+ extracted by usage MEM with narrower mode. */
static rtx purge_addressof_replacements;
/* Helper function for purge_addressof. See if the rtx expression at *LOC
if (validate_change (insn, loc, sub, 0)
|| validate_replace_rtx (x, sub, insn))
return true;
-
+
start_sequence ();
sub = force_operand (sub, NULL_RTX);
if (! validate_change (insn, loc, sub, 0)
return true;
}
- /* See comment for purge_addressof_replacements. */
+ /* See comment for purge_addressof_replacements. */
for (tem = purge_addressof_replacements;
tem != NULL_RTX;
tem = XEXP (XEXP (tem, 1), 1))
/* It can happen that the note may speak of things
in a wider (or just different) mode than the
code did. This is especially true of
- REG_RETVAL. */
+ REG_RETVAL. */
if (GET_CODE (z) == SUBREG && SUBREG_WORD (z) == 0)
z = SUBREG_REG (z);
-
+
if (GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD
&& (GET_MODE_SIZE (GET_MODE (x))
> GET_MODE_SIZE (GET_MODE (z))))
{
/* This can occur as a result in invalid
- pointer casts, e.g. float f; ...
+ pointer casts, e.g. float f; ...
*(long long int *)&f.
??? We could emit a warning here, but
without a line number that wouldn't be
seq = gen_sequence ();
end_sequence ();
emit_insn_before (seq, insn);
- compute_insns_for_mem (p ? NEXT_INSN (p) : get_insns (),
+ compute_insns_for_mem (p ? NEXT_INSN (p) : get_insns (),
insn, ht);
-
+
start_sequence ();
store_bit_field (sub, size_x, 0, GET_MODE (x),
val, GET_MODE_SIZE (GET_MODE (sub)),
end_sequence ();
p = emit_insn_after (seq, insn);
if (NEXT_INSN (insn))
- compute_insns_for_mem (NEXT_INSN (insn),
+ compute_insns_for_mem (NEXT_INSN (insn),
p ? NEXT_INSN (p) : NULL_RTX,
ht);
}
return result;
}
- /* Scan all subexpressions. */
+ /* Scan all subexpressions. */
fmt = GET_RTX_FORMAT (code);
for (i = 0; i < GET_RTX_LENGTH (code); i++, fmt++)
{
rtx *r;
void *data;
{
- struct insns_for_mem_walk_info *ifmwi
+ struct insns_for_mem_walk_info *ifmwi
= (struct insns_for_mem_walk_info *) data;
if (ifmwi->pass == 0 && *r && GET_CODE (*r) == ADDRESSOF
else if (ifmwi->pass == 1 && *r && GET_CODE (*r) == REG)
{
/* Lookup this MEM in the hashtable, creating it if necessary. */
- struct insns_for_mem_entry *ifme
+ struct insns_for_mem_entry *ifme
= (struct insns_for_mem_entry *) hash_lookup (ifmwi->ht,
*r,
/*create=*/0,
the hash table since this memory will not be used once
the hash table is deallocated. */
push_obstacks (&ifmwi->ht->memory, &ifmwi->ht->memory);
- ifme->insns = gen_rtx_EXPR_LIST (VOIDmode, ifmwi->insn,
+ ifme->insns = gen_rtx_EXPR_LIST (VOIDmode, ifmwi->insn,
ifme->insns);
pop_obstacks ();
}
Returns true iff the rtl is an ADDRESSOF. */
static int
is_addressof (rtl, data)
- rtx * rtl;
- void * data ATTRIBUTE_UNUSED;
+ rtx *rtl;
+ void *data ATTRIBUTE_UNUSED;
{
- return GET_CODE (* rtl) == ADDRESSOF;
+ return GET_CODE (*rtl) == ADDRESSOF;
}
/* Eliminate all occurrences of ADDRESSOF from INSNS. Elide any remaining
{
rtx insn;
struct hash_table ht;
-
+
/* When we actually purge ADDRESSOFs, we turn REGs into MEMs. That
requires a fixup pass over the instruction stream to correct
INSNs that depended on the REG being a REG, and not a MEM. But,
mentioned in very many instructions. So, we speed up the process
by pre-calculating which REGs occur in which INSNs; that allows
us to perform the fixup passes much more quickly. */
- hash_table_init (&ht,
+ hash_table_init (&ht,
insns_for_mem_newfunc,
insns_for_mem_hash,
insns_for_mem_comp);
/* If we could not replace the ADDRESSOFs in the insn,
something is wrong. */
abort ();
-
+
if (! purge_addressof_1 (®_NOTES (insn), NULL_RTX, 0, 0, &ht))
{
/* If we could not replace the ADDRESSOFs in the insn's notes,
safe to delete the notes here, and instead we abort. */
if (REG_NOTE_KIND (note) == REG_RETVAL)
abort ();
- if (for_each_rtx (& note, is_addressof, NULL))
+ if (for_each_rtx (¬e, is_addressof, NULL))
remove_note (insn, note);
}
}
{
HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (decl));
- instantiate_decl (DECL_RTL (decl), size, valid_only);
+ instantiate_decl (DECL_RTL (decl), size, valid_only);
/* If the parameter was promoted, then the incoming RTL mode may be
larger than the declared type size. We must use the larger of
is not valid.
Return 1 if we either had nothing to do or if we were able to do the
- needed replacement. Return 0 otherwise; we only return zero if
+ needed replacement. Return 0 otherwise; we only return zero if
EXTRA_INSNS is zero.
We first try some simple transformations to avoid the creation of extra
appropriate offset. This is used, for example, in the handling
of non-local gotos. */
if (SET_DEST (x) == virtual_incoming_args_rtx)
- new = arg_pointer_rtx, offset = - in_arg_offset;
+ new = arg_pointer_rtx, offset = -in_arg_offset;
else if (SET_DEST (x) == virtual_stack_vars_rtx)
- new = frame_pointer_rtx, offset = - var_offset;
+ new = frame_pointer_rtx, offset = -var_offset;
else if (SET_DEST (x) == virtual_stack_dynamic_rtx)
- new = stack_pointer_rtx, offset = - dynamic_offset;
+ new = stack_pointer_rtx, offset = -dynamic_offset;
else if (SET_DEST (x) == virtual_outgoing_args_rtx)
- new = stack_pointer_rtx, offset = - out_arg_offset;
+ new = stack_pointer_rtx, offset = -out_arg_offset;
else if (SET_DEST (x) == virtual_cfa_rtx)
- new = arg_pointer_rtx, offset = - cfa_offset;
+ new = arg_pointer_rtx, offset = -cfa_offset;
if (new)
{
else if (inner == virtual_outgoing_args_rtx)
new = stack_pointer_rtx, offset = out_arg_offset;
else if (inner == virtual_cfa_rtx)
- new = arg_pointer_rtx, offset = cfa_offset;
+ new = arg_pointer_rtx, offset = cfa_offset;
else
{
loc = &XEXP (x, 0);
new = stack_pointer_rtx, offset = dynamic_offset;
else if (XEXP (x, 0) == virtual_outgoing_args_rtx)
new = stack_pointer_rtx, offset = out_arg_offset;
- else if (XEXP (x, 0) == virtual_cfa_rtx)
- new = arg_pointer_rtx, offset = cfa_offset;
+ else if (XEXP (x, 0) == virtual_cfa_rtx)
+ new = arg_pointer_rtx, offset = cfa_offset;
else
{
/* We know the second operand is a constant. Unless the
/* Most cases of MEM that convert to valid addresses have already been
handled by our scan of decls. The only special handling we
need here is to make a copy of the rtx to ensure it isn't being
- shared if we have to change it to a pseudo.
+ shared if we have to change it to a pseudo.
If the rtx is a simple reference to an address via a virtual register,
it can potentially be shared. In such cases, first try to make it
a valid address, which can also be shared. Otherwise, copy it and
- proceed normally.
+ proceed normally.
First check for common cases that need no processing. These are
usually due to instantiation already being done on a previous instance
case CLOBBER:
/* If the operand is a MEM, see if the change is a valid MEM. If not,
go ahead and make the invalid one, but do it to a copy. For a REG,
- just make the recursive call, since there's no chance of a problem. */
+ just make the recursive call, since there's no chance of a problem. */
if ((GET_CODE (XEXP (x, 0)) == MEM
&& instantiate_virtual_regs_1 (&XEXP (XEXP (x, 0), 0), XEXP (x, 0),
else if (x == virtual_outgoing_args_rtx)
new = stack_pointer_rtx, offset = out_arg_offset;
else if (x == virtual_cfa_rtx)
- new = arg_pointer_rtx, offset = cfa_offset;
+ new = arg_pointer_rtx, offset = cfa_offset;
if (new)
{
return 1;
}
break;
-
+
default:
break;
}
tree fnargs = DECL_ARGUMENTS (fndecl);
/* This is used for the arg pointer when referring to stack args. */
rtx internal_arg_pointer;
- /* This is a dummy PARM_DECL that we used for the function result if
+ /* This is a dummy PARM_DECL that we used for the function result if
the function returns a structure. */
tree function_result_decl = 0;
#ifdef SETUP_INCOMING_VARARGS
TREE_CHAIN (function_result_decl) = fnargs;
fnargs = function_result_decl;
}
-
+
max_parm_reg = LAST_VIRTUAL_REGISTER + 1;
parm_reg_stack_loc = (rtx *) xcalloc (max_parm_reg, sizeof (rtx));
#endif
#endif
fndecl, &stack_args_size, &stack_offset, &arg_size,
- &alignment_pad);
+ &alignment_pad);
{
rtx offset_rtx = ARGS_SIZE_RTX (stack_offset);
emit_group_store (validize_mem (stack_parm), entry_parm,
int_size_in_bytes (TREE_TYPE (parm)),
TYPE_ALIGN (TREE_TYPE (parm)));
-
+
else
move_block_from_reg (REGNO (entry_parm),
validize_mem (stack_parm), nregs,
{
int save_tree_used;
/* ENTRY_PARM has been converted to PROMOTED_MODE, its
- mode, by the caller. We now have to convert it to
+ mode, by the caller. We now have to convert it to
NOMINAL_MODE, if different. However, PARMREG may be in
a different mode than NOMINAL_MODE if it is being stored
promoted.
#endif /* FUNCTION_ARG_CALLEE_COPIES */
/* In any case, record the parm's desired stack location
- in case we later discover it must live in the stack.
+ in case we later discover it must live in the stack.
If it is a COMPLEX value, store the stack location for both
halves. */
}
else if ((set = single_set (linsn)) != 0
&& SET_DEST (set) == parmreg)
- REG_NOTES (linsn)
+ REG_NOTES (linsn)
= gen_rtx_EXPR_LIST (REG_EQUIV,
stack_parm, REG_NOTES (linsn));
}
push_to_sequence (conversion_insns);
emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3,
XEXP (stack_parm, 0), Pmode,
- GEN_INT (GET_MODE_SIZE (GET_MODE
+ GEN_INT (GET_MODE_SIZE (GET_MODE
(entry_parm))),
TYPE_MODE (sizetype),
GEN_INT (MEMORY_USE_RW),
}
DECL_RTL (parm) = stack_parm;
}
-
+
/* If this "parameter" was the place where we are receiving the
function's incoming structure pointer, set up the result. */
if (parm == function_result_decl)
current_function_args_size
= ((current_function_args_size + STACK_BYTES - 1)
/ STACK_BYTES) * STACK_BYTES;
-#endif
+#endif
#ifdef ARGS_GROW_DOWNWARD
current_function_arg_offset_rtx
= (stack_args_size.var == 0 ? GEN_INT (-stack_args_size.constant)
- : expand_expr (size_diffop (stack_args_size.var,
- size_int (-stack_args_size.constant)),
+ : expand_expr (size_diffop (stack_args_size.var,
+ size_int (-stack_args_size.constant)),
NULL_RTX, VOIDmode, EXPAND_MEMORY_USE_BAD));
#else
current_function_arg_offset_rtx = ARGS_SIZE_RTX (stack_args_size);
initial offset is not affected by this rounding, while the size always
is and the starting offset may be. */
-/* offset_ptr will be negative for ARGS_GROW_DOWNWARD case;
+/* offset_ptr will be negative for ARGS_GROW_DOWNWARD case;
initial_offset_ptr is positive because locate_and_pad_parm's
callers pass in the total size of args so far as
initial_offset_ptr. arg_size_ptr is always positive.*/
void
locate_and_pad_parm (passed_mode, type, in_regs, fndecl,
initial_offset_ptr, offset_ptr, arg_size_ptr,
- alignment_pad)
+ alignment_pad)
enum machine_mode passed_mode;
tree type;
int in_regs ATTRIBUTE_UNUSED;
}
else
{
- offset_ptr->constant = - initial_offset_ptr->constant;
+ offset_ptr->constant = -initial_offset_ptr->constant;
offset_ptr->var = 0;
}
if (where_pad != none
offset_ptr->var);
else
- arg_size_ptr->constant = (- initial_offset_ptr->constant
- - offset_ptr->constant);
+ arg_size_ptr->constant = (-initial_offset_ptr->constant
+ - offset_ptr->constant);
#else /* !ARGS_GROW_DOWNWARD */
pad_to_arg_alignment (initial_offset_ptr, boundary, alignment_pad);
HOST_WIDE_INT save_constant = 0;
int boundary_in_bytes = boundary / BITS_PER_UNIT;
-
+
if (boundary > PARM_BOUNDARY && boundary > STACK_BOUNDARY)
{
save_var = offset_ptr->var;
{
if (offset_ptr->var)
{
- offset_ptr->var =
+ offset_ptr->var =
#ifdef ARGS_GROW_DOWNWARD
- round_down
+ round_down
#else
round_up
#endif
save_var);
}
else
- {
+ {
offset_ptr->constant =
#ifdef ARGS_GROW_DOWNWARD
FLOOR_ROUND (offset_ptr->constant, boundary_in_bytes);
#else
CEIL_ROUND (offset_ptr->constant, boundary_in_bytes);
#endif
- if (boundary > PARM_BOUNDARY && boundary > STACK_BOUNDARY)
- alignment_pad->constant = offset_ptr->constant - save_constant;
- }
+ if (boundary > PARM_BOUNDARY && boundary > STACK_BOUNDARY)
+ alignment_pad->constant = offset_ptr->constant - save_constant;
+ }
}
}
if (DECL_RTL (decl) != 0
&& GET_CODE (DECL_RTL (decl)) == REG
&& regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl))))
- warning_with_decl (decl, "argument `%s' might be clobbered by `longjmp' or `vfork'");
+ warning_with_decl (decl,
+ "argument `%s' might be clobbered by `longjmp' or `vfork'");
}
/* If this function call setjmp, put all vars into the stack
GEN_INT (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT - 1),
temp, 0, OPTAB_LIB_WIDEN);
tramp = expand_binop (Pmode, and_optab, temp,
- GEN_INT (- TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT),
+ GEN_INT (-TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT),
temp, 0, OPTAB_LIB_WIDEN);
#endif
return tramp;
block_vector = get_block_vector (block, &n_blocks);
block_stack = (tree *) xmalloc (n_blocks * sizeof (tree));
- last_block_vector = identify_blocks_1 (get_insns (),
+ last_block_vector = identify_blocks_1 (get_insns (),
block_vector + 1,
- block_vector + n_blocks,
+ block_vector + n_blocks,
block_stack);
/* If we didn't use all of the subblocks, we've misplaced block notes. */
NOTE_BLOCK (insn) = *--block_stack;
}
- }
+ }
else if (GET_CODE (insn) == CALL_INSN
&& GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
{
rtx cp = PATTERN (insn);
- block_vector = identify_blocks_1 (XEXP (cp, 0), block_vector,
- end_block_vector, block_stack);
+ block_vector = identify_blocks_1 (XEXP (cp, 0), block_vector,
+ end_block_vector, block_stack);
if (XEXP (cp, 1))
block_vector = identify_blocks_1 (XEXP (cp, 1), block_vector,
end_block_vector, block_stack);
}
/* Identify BLOCKs referenced by more than one
- NOTE_INSN_BLOCK_{BEG,END}, and create duplicate blocks. */
+ NOTE_INSN_BLOCK_{BEG,END}, and create duplicate blocks. */
void
reorder_blocks ()
reorder_blocks_1 (get_insns (), block, &block_stack);
- BLOCK_SUBBLOCKS (block)
- = blocks_nreverse (BLOCK_SUBBLOCKS (block));
+ BLOCK_SUBBLOCKS (block) = blocks_nreverse (BLOCK_SUBBLOCKS (block));
VARRAY_FREE (block_stack);
}
}
BLOCK_SUBBLOCKS (block) = 0;
TREE_ASM_WRITTEN (block) = 1;
- BLOCK_SUPERCONTEXT (block) = current_block;
+ BLOCK_SUPERCONTEXT (block) = current_block;
BLOCK_CHAIN (block) = BLOCK_SUBBLOCKS (current_block);
BLOCK_SUBBLOCKS (current_block) = block;
current_block = block;
vector[n_blocks] = block;
++n_blocks;
-
+
/* Record the subblocks, and their subblocks... */
n_blocks += all_blocks (BLOCK_SUBBLOCKS (block),
vector ? vector + n_blocks : 0);
number of elements in the vector is stored in N_BLOCKS_P. The
vector is dynamically allocated; it is the caller's responsibility
to call `free' on the pointer returned. */
-
+
static tree *
get_block_vector (block, n_blocks_p)
tree block;
return;
}
-
\f
/* Allocate a function structure and reset its contents to the defaults. */
static void
/* Initialize the queue of pending postincrement and postdecrements,
and some other info in expr.c. */
init_expr ();
-
+
/* We haven't done register allocation yet. */
reg_renumber = 0;
/* Clear out data used for inlining. */
cfun->inlinable = 0;
cfun->original_decl_initial = 0;
- cfun->original_arg_vector = 0;
+ cfun->original_arg_vector = 0;
#ifdef STACK_BOUNDARY
cfun->stack_alignment_needed = STACK_BOUNDARY;
/* Remember this function for later. */
cfun->next_global = all_functions;
all_functions = cfun;
-
+
current_function_name = (*decl_printable_name) (subr, 2);
cfun->decl = subr;
/* Prevent ever trying to delete the first instruction of a function.
Also tell final how to output a linenum before the function prologue.
- Note linenums could be missing, e.g. when compiling a Java .class file. */
+ Note linenums could be missing, e.g. when compiling a Java .class file. */
if (line > 0)
emit_line_note (filename, line);
conflicts with regs used for parameters. */
if (! SMALL_REGISTER_CLASSES
|| GET_CODE (static_chain_incoming_rtx) == REG)
- emit_move_insn (last_ptr, static_chain_incoming_rtx);
+ emit_move_insn (last_ptr, static_chain_incoming_rtx);
}
/* If the parameters of this function need cleaning up, get a label
/* Chain thru stack frames, assuming pointer to next lexical frame
is found at the place we always store it. */
#ifdef FRAME_GROWS_DOWNWARD
- last_ptr = plus_constant (last_ptr, - GET_MODE_SIZE (Pmode));
+ last_ptr = plus_constant (last_ptr, -GET_MODE_SIZE (Pmode));
#endif
last_ptr = gen_rtx_MEM (Pmode, memory_address (Pmode, last_ptr));
MEM_ALIAS_SET (last_ptr) = get_frame_alias_set ();
return;
pcc = (current_function_returns_struct
- || current_function_returns_pcc_struct);
+ || current_function_returns_pcc_struct);
if ((GET_CODE (outgoing) == REG
&& REGNO (outgoing) >= FIRST_PSEUDO_REGISTER)
}
/* Generate RTL for the end of the current function.
- FILENAME and LINE are the current position in the source file.
+ FILENAME and LINE are the current position in the source file.
It is up to language-specific callers to do cleanups for parameters--
or else, supply 1 for END_BINDINGS and we will call expand_end_bindings. */
/* Warn about unused parms if extra warnings were specified. */
/* Either ``-W -Wunused'' or ``-Wunused-parameter'' enables this
warning. WARN_UNUSED_PARAMETER is negative when set by
- -Wunused. */
+ -Wunused. */
if (warn_unused_parameter > 0
|| (warn_unused_parameter < 0 && extra_warnings))
{
if (current_function_returns_struct
|| current_function_returns_pcc_struct)
{
- rtx value_address = XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0);
+ rtx value_address =
+ XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0);
tree type = TREE_TYPE (DECL_RESULT (current_function_decl));
#ifdef FUNCTION_OUTGOING_VALUE
rtx outgoing
instead of using the general framework. */
use_return_register ();
- /* If this is an implementation of __throw, do what's necessary to
+ /* If this is an implementation of __throw, do what's necessary to
communicate between __builtin_eh_return and the epilogue. */
expand_eh_return ();
int
sibcall_epilogue_contains (insn)
- rtx insn;
+ rtx insn;
{
if (sibcall_epilogue)
return contains (insn, sibcall_epilogue);
{
rtx p, end;
- p = NEXT_INSN (bb->end);
+ p = NEXT_INSN (bb->end);
end = emit_jump_insn_after (gen_return (), bb->end);
if (line_note)
emit_line_note_after (NOTE_SOURCE_FILE (line_note),
if (HAVE_prologue)
{
start_sequence ();
- seq = gen_prologue();
+ seq = gen_prologue ();
emit_insn (seq);
/* Retain a map of the prologue insns. */
/* If the exit block has no non-fake predecessors, we don't need
an epilogue. */
- for (e = EXIT_BLOCK_PTR->pred; e ; e = e->pred_next)
+ for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next)
if ((e->flags & EDGE_FAKE) == 0)
break;
if (e == NULL)
{
/* If we're allowed to generate a simple return instruction,
then by definition we don't need a full epilogue. Examine
- the block that falls through to EXIT. If it does not
- contain any code, examine its predecessors and try to
+ the block that falls through to EXIT. If it does not
+ contain any code, examine its predecessors and try to
emit (conditional) return instructions. */
basic_block last;
edge e_next;
rtx label;
- for (e = EXIT_BLOCK_PTR->pred; e ; e = e->pred_next)
+ for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next)
if (e->flags & EDGE_FALLTHRU)
break;
if (e == NULL)
if (last->head == label && GET_CODE (label) == CODE_LABEL)
{
- rtx epilogue_line_note = NULL_RTX;
+ rtx epilogue_line_note = NULL_RTX;
/* Locate the line number associated with the closing brace,
if we can find one. */
break;
}
- for (e = last->pred; e ; e = e_next)
+ for (e = last->pred; e; e = e_next)
{
basic_block bb = e->src;
rtx jump;
continue;
if (JUMP_LABEL (jump))
LABEL_NUSES (JUMP_LABEL (jump))--;
-
+
/* If this block has only one successor, it both jumps
and falls through to the fallthru block, so we can't
delete the edge. */
- if (bb->succ->succ_next == NULL)
- continue;
+ if (bb->succ->succ_next == NULL)
+ continue;
}
else
continue;
emit_barrier_after (last->end);
emit_return_into_block (last, epilogue_line_note);
epilogue_end = last->end;
- goto epilogue_done;
+ goto epilogue_done;
}
}
#endif
There really shouldn't be a mixture -- either all should have
been converted or none, however... */
- for (e = EXIT_BLOCK_PTR->pred; e ; e = e->pred_next)
+ for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next)
if (e->flags & EDGE_FALLTHRU)
break;
if (e == NULL)
record_insns (seq, &epilogue);
seq = gen_sequence ();
- end_sequence();
+ end_sequence ();
insert_insn_on_edge (seq, e);
inserted = 1;
#ifdef HAVE_sibcall_epilogue
/* Emit sibling epilogues before any sibling call sites. */
- for (e = EXIT_BLOCK_PTR->pred; e ; e = e->pred_next)
+ for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next)
{
basic_block bb = e->src;
rtx insn = bb->end;
note before the end of the first basic block, if there isn't
one already there. */
- for (insn = prologue_end; insn ; insn = prev)
+ for (insn = prologue_end; insn; insn = prev)
{
prev = PREV_INSN (insn);
if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0)
/* Similarly, move any line notes that appear after the epilogue.
There is no need, however, to be quite so anal about the existance
of such a note. */
- for (insn = epilogue_end; insn ; insn = next)
+ for (insn = epilogue_end; insn; insn = next)
{
next = NEXT_INSN (insn);
if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0)
next = NEXT_INSN (note);
- /* Whether or not we can depend on BLOCK_HEAD,
+ /* Whether or not we can depend on BLOCK_HEAD,
attempt to keep it up-to-date. */
if (BLOCK_HEAD (0) == note)
BLOCK_HEAD (0) = next;
break;
}
- /* Whether or not we can depend on BLOCK_HEAD,
+ /* Whether or not we can depend on BLOCK_HEAD,
attempt to keep it up-to-date. */
if (n_basic_blocks
&& BLOCK_HEAD (n_basic_blocks-1) == insn)
static void
mark_temp_slot (t)
- struct temp_slot *t;
+ struct temp_slot *t;
{
while (t)
{
OSDN Git Service
