int
any_operand (op, mode)
- register rtx op ATTRIBUTE_UNUSED;
+ rtx op ATTRIBUTE_UNUSED;
enum machine_mode mode ATTRIBUTE_UNUSED;
{
return 1;
/* Returns 1 if op is the count register */
int
count_register_operand(op, mode)
- register rtx op;
+ rtx op;
enum machine_mode mode ATTRIBUTE_UNUSED;
{
if (GET_CODE (op) != REG)
int
xer_operand(op, mode)
- register rtx op;
+ rtx op;
enum machine_mode mode ATTRIBUTE_UNUSED;
{
if (GET_CODE (op) != REG)
int
short_cint_operand (op, mode)
- register rtx op;
+ rtx op;
enum machine_mode mode ATTRIBUTE_UNUSED;
{
return (GET_CODE (op) == CONST_INT
int
u_short_cint_operand (op, mode)
- register rtx op;
+ rtx op;
enum machine_mode mode ATTRIBUTE_UNUSED;
{
return (GET_CODE (op) == CONST_INT
int
non_short_cint_operand (op, mode)
- register rtx op;
+ rtx op;
enum machine_mode mode ATTRIBUTE_UNUSED;
{
return (GET_CODE (op) == CONST_INT
int
exact_log2_cint_operand (op, mode)
- register rtx op;
+ rtx op;
enum machine_mode mode ATTRIBUTE_UNUSED;
{
return (GET_CODE (op) == CONST_INT
int
gpc_reg_operand (op, mode)
- register rtx op;
+ rtx op;
enum machine_mode mode;
{
return (register_operand (op, mode)
int
cc_reg_operand (op, mode)
- register rtx op;
+ rtx op;
enum machine_mode mode;
{
return (register_operand (op, mode)
int
cc_reg_not_cr0_operand (op, mode)
- register rtx op;
+ rtx op;
enum machine_mode mode;
{
return (register_operand (op, mode)
int
reg_or_short_operand (op, mode)
- register rtx op;
+ rtx op;
enum machine_mode mode;
{
return short_cint_operand (op, mode) || gpc_reg_operand (op, mode);
int
reg_or_neg_short_operand (op, mode)
- register rtx op;
+ rtx op;
enum machine_mode mode;
{
if (GET_CODE (op) == CONST_INT)
int
reg_or_u_short_operand (op, mode)
- register rtx op;
+ rtx op;
enum machine_mode mode;
{
return u_short_cint_operand (op, mode) || gpc_reg_operand (op, mode);
int
reg_or_cint_operand (op, mode)
- register rtx op;
+ rtx op;
enum machine_mode mode;
{
return (GET_CODE (op) == CONST_INT || gpc_reg_operand (op, mode));
int
reg_or_arith_cint_operand (op, mode)
- register rtx op;
+ rtx op;
enum machine_mode mode;
{
return (gpc_reg_operand (op, mode)
int
reg_or_add_cint64_operand (op, mode)
- register rtx op;
+ rtx op;
enum machine_mode mode;
{
return (gpc_reg_operand (op, mode)
int
reg_or_sub_cint64_operand (op, mode)
- register rtx op;
+ rtx op;
enum machine_mode mode;
{
return (gpc_reg_operand (op, mode)
int
reg_or_logical_cint_operand (op, mode)
- register rtx op;
+ rtx op;
enum machine_mode mode;
{
if (GET_CODE (op) == CONST_INT)
int
got_operand (op, mode)
- register rtx op;
+ rtx op;
enum machine_mode mode ATTRIBUTE_UNUSED;
{
return (GET_CODE (op) == SYMBOL_REF
int
got_no_const_operand (op, mode)
- register rtx op;
+ rtx op;
enum machine_mode mode ATTRIBUTE_UNUSED;
{
return (GET_CODE (op) == SYMBOL_REF || GET_CODE (op) == LABEL_REF);
int
easy_fp_constant (op, mode)
- register rtx op;
- register enum machine_mode mode;
+ rtx op;
+ enum machine_mode mode;
{
if (GET_CODE (op) != CONST_DOUBLE
|| GET_MODE (op) != mode
/* Return 1 if the operand is 0.0. */
int
zero_fp_constant (op, mode)
- register rtx op;
- register enum machine_mode mode;
+ rtx op;
+ enum machine_mode mode;
{
return GET_MODE_CLASS (mode) == MODE_FLOAT && op == CONST0_RTX (mode);
}
int
volatile_mem_operand (op, mode)
- register rtx op;
+ rtx op;
enum machine_mode mode;
{
if (GET_CODE (op) != MEM)
int
offsettable_mem_operand (op, mode)
- register rtx op;
+ rtx op;
enum machine_mode mode;
{
return ((GET_CODE (op) == MEM)
int
mem_or_easy_const_operand (op, mode)
- register rtx op;
+ rtx op;
enum machine_mode mode;
{
return memory_operand (op, mode) || easy_fp_constant (op, mode);
int
add_operand (op, mode)
- register rtx op;
+ rtx op;
enum machine_mode mode;
{
if (GET_CODE (op) == CONST_INT)
int
non_add_cint_operand (op, mode)
- register rtx op;
+ rtx op;
enum machine_mode mode ATTRIBUTE_UNUSED;
{
return (GET_CODE (op) == CONST_INT
int
logical_operand (op, mode)
- register rtx op;
+ rtx op;
enum machine_mode mode;
{
HOST_WIDE_INT opl, oph;
int
non_logical_cint_operand (op, mode)
- register rtx op;
+ rtx op;
enum machine_mode mode;
{
return ((GET_CODE (op) == CONST_INT || GET_CODE (op) == CONST_DOUBLE)
int
mask_operand (op, mode)
- register rtx op;
+ rtx op;
enum machine_mode mode ATTRIBUTE_UNUSED;
{
HOST_WIDE_INT c, lsb;
int
mask64_operand (op, mode)
- register rtx op;
+ rtx op;
enum machine_mode mode;
{
if (GET_CODE (op) == CONST_INT)
int
and64_operand (op, mode)
- register rtx op;
+ rtx op;
enum machine_mode mode;
{
if (fixed_regs[CR0_REGNO]) /* CR0 not available, don't do andi./andis. */
int
and_operand (op, mode)
- register rtx op;
+ rtx op;
enum machine_mode mode;
{
if (fixed_regs[CR0_REGNO]) /* CR0 not available, don't do andi./andis. */
int
reg_or_mem_operand (op, mode)
- register rtx op;
- register enum machine_mode mode;
+ rtx op;
+ enum machine_mode mode;
{
return (gpc_reg_operand (op, mode)
|| memory_operand (op, mode)
int
lwa_operand (op, mode)
- register rtx op;
- register enum machine_mode mode;
+ rtx op;
+ enum machine_mode mode;
{
rtx inner = op;
int
call_operand (op, mode)
- register rtx op;
+ rtx op;
enum machine_mode mode;
{
if (mode != VOIDmode && GET_MODE (op) != mode)
int
current_file_function_operand (op, mode)
- register rtx op;
+ rtx op;
enum machine_mode mode ATTRIBUTE_UNUSED;
{
return (GET_CODE (op) == SYMBOL_REF
int
input_operand (op, mode)
- register rtx op;
+ rtx op;
enum machine_mode mode;
{
/* Memory is always valid. */
int
branch_comparison_operator (op, mode)
- register rtx op;
+ rtx op;
enum machine_mode mode ATTRIBUTE_UNUSED;
{
enum rtx_code code = GET_CODE (op);
int
branch_positive_comparison_operator (op, mode)
- register rtx op;
+ rtx op;
enum machine_mode mode;
{
enum rtx_code code;
int
scc_comparison_operator (op, mode)
- register rtx op;
+ rtx op;
enum machine_mode mode;
{
enum rtx_code code = GET_CODE (op);
int
includes_lshift_p (shiftop, andop)
- register rtx shiftop;
- register rtx andop;
+ rtx shiftop;
+ rtx andop;
{
unsigned HOST_WIDE_INT shift_mask = ~(unsigned HOST_WIDE_INT) 0;
int
includes_rshift_p (shiftop, andop)
- register rtx shiftop;
- register rtx andop;
+ rtx shiftop;
+ rtx andop;
{
unsigned HOST_WIDE_INT shift_mask = ~(unsigned HOST_WIDE_INT) 0;
int
includes_rldic_lshift_p (shiftop, andop)
- register rtx shiftop;
- register rtx andop;
+ rtx shiftop;
+ rtx andop;
{
if (GET_CODE (andop) == CONST_INT)
{
int
includes_rldicr_lshift_p (shiftop, andop)
- register rtx shiftop;
- register rtx andop;
+ rtx shiftop;
+ rtx andop;
{
if (GET_CODE (andop) == CONST_INT)
{
int
addrs_ok_for_quad_peep (addr1, addr2)
- register rtx addr1;
- register rtx addr2;
+ rtx addr1;
+ rtx addr2;
{
unsigned int reg1;
int offset1;
int
ccr_bit (op, scc_p)
- register rtx op;
+ rtx op;
int scc_p;
{
enum rtx_code code = GET_CODE (op);
void
print_operand_address (file, x)
FILE *file;
- register rtx x;
+ rtx x;
{
if (GET_CODE (x) == REG)
fprintf (file, "0(%s)", reg_names[ REGNO (x) ]);
complicated by having two separate calling sequences, the AIX calling
sequence and the V.4 calling sequence.
- AIX (and Darwin/Mac OS) stack frames look like:
+ AIX (and Darwin/Mac OS X) stack frames look like:
32-bit 64-bit
SP----> +---------------------------------------+
| back chain to caller | 0 0
info_ptr->first_fp_reg_save = first_fp_reg_to_save ();
info_ptr->fp_size = 8 * (64 - info_ptr->first_fp_reg_save);
- /* Does this function call anything? */
+ /* Does this function call anything? */
info_ptr->calls_p = (! current_function_is_leaf
|| cfun->machine->ra_needs_full_frame);
else
ehrd_size = 0;
- /* Determine various sizes */
+ /* Determine various sizes. */
info_ptr->reg_size = reg_size;
info_ptr->fixed_size = RS6000_SAVE_AREA;
info_ptr->varargs_size = RS6000_VARARGS_AREA;
if (DEFAULT_ABI == ABI_DARWIN)
info_ptr->save_size = RS6000_ALIGN (info_ptr->save_size, 16);
- /* Calculate the offsets */
+ /* Calculate the offsets. */
switch (abi)
{
case ABI_NONE:
int
symbolic_operand (op)
- register rtx op;
+ rtx op;
{
switch (GET_CODE (op))
{