/* Definitions for GCC. Part of the machine description for CRIS.
- Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
+ Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
+ Free Software Foundation, Inc.
Contributed by Axis Communications. Written by Hans-Peter Nilsson.
This file is part of GCC.
#include "target.h"
#include "target-def.h"
#include "ggc.h"
+#include "optabs.h"
/* Usable when we have an amount to add or subtract, and want the
optimal size of the insn. */
just the "sym:GOTOFF" part. */
static int cris_pic_sympart_only = 0;
+/* In code for output macros, this is how we know whether e.g. constant
+ goes in code or in a static initializer. */
+static int in_code = 0;
+
/* Fix for reg_overlap_mentioned_p. */
-static int cris_reg_overlap_mentioned_p PARAMS ((rtx, rtx));
+static int cris_reg_overlap_mentioned_p (rtx, rtx);
+
+static void cris_print_base (rtx, FILE *);
+
+static void cris_print_index (rtx, FILE *);
-static void cris_print_base PARAMS ((rtx, FILE *));
+static void cris_output_addr_const (FILE *, rtx);
-static void cris_print_index PARAMS ((rtx, FILE *));
+static struct machine_function * cris_init_machine_status (void);
-static struct machine_function * cris_init_machine_status PARAMS ((void));
+static rtx cris_struct_value_rtx (tree, int);
-static int cris_initial_frame_pointer_offset PARAMS ((void));
+static void cris_setup_incoming_varargs (CUMULATIVE_ARGS *, enum machine_mode,
+ tree type, int *, int);
-static int saved_regs_mentioned PARAMS ((rtx));
+static int cris_initial_frame_pointer_offset (void);
-static void cris_target_asm_function_prologue
- PARAMS ((FILE *, HOST_WIDE_INT));
+static int saved_regs_mentioned (rtx);
-static void cris_target_asm_function_epilogue
- PARAMS ((FILE *, HOST_WIDE_INT));
+static void cris_target_asm_function_prologue (FILE *, HOST_WIDE_INT);
-static void cris_operand_lossage PARAMS ((const char *, rtx));
+static void cris_target_asm_function_epilogue (FILE *, HOST_WIDE_INT);
+
+static void cris_operand_lossage (const char *, rtx);
static void cris_asm_output_mi_thunk
- PARAMS ((FILE *, tree, HOST_WIDE_INT, HOST_WIDE_INT, tree));
+ (FILE *, tree, HOST_WIDE_INT, HOST_WIDE_INT, tree);
+
+static void cris_file_start (void);
+static void cris_init_libfuncs (void);
-static bool cris_rtx_costs PARAMS ((rtx, int, int, int *));
-static int cris_address_cost PARAMS ((rtx));
+static bool cris_rtx_costs (rtx, int, int, int *);
+static int cris_address_cost (rtx);
+static bool cris_pass_by_reference (CUMULATIVE_ARGS *, enum machine_mode,
+ tree, bool);
+static int cris_arg_partial_bytes (CUMULATIVE_ARGS *, enum machine_mode,
+ tree, bool);
/* The function cris_target_asm_function_epilogue puts the last insn to
output here. It always fits; there won't be a symbol operand. Used in
#undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
#define TARGET_ASM_CAN_OUTPUT_MI_THUNK default_can_output_mi_thunk_no_vcall
+#undef TARGET_ASM_FILE_START
+#define TARGET_ASM_FILE_START cris_file_start
+
+#undef TARGET_INIT_LIBFUNCS
+#define TARGET_INIT_LIBFUNCS cris_init_libfuncs
+
#undef TARGET_RTX_COSTS
#define TARGET_RTX_COSTS cris_rtx_costs
#undef TARGET_ADDRESS_COST
#define TARGET_ADDRESS_COST cris_address_cost
+#undef TARGET_PROMOTE_FUNCTION_ARGS
+#define TARGET_PROMOTE_FUNCTION_ARGS hook_bool_tree_true
+#undef TARGET_STRUCT_VALUE_RTX
+#define TARGET_STRUCT_VALUE_RTX cris_struct_value_rtx
+#undef TARGET_SETUP_INCOMING_VARARGS
+#define TARGET_SETUP_INCOMING_VARARGS cris_setup_incoming_varargs
+#undef TARGET_PASS_BY_REFERENCE
+#define TARGET_PASS_BY_REFERENCE cris_pass_by_reference
+#undef TARGET_ARG_PARTIAL_BYTES
+#define TARGET_ARG_PARTIAL_BYTES cris_arg_partial_bytes
+
struct gcc_target targetm = TARGET_INITIALIZER;
/* Predicate functions. */
c) a [r] or [r+] in SImode, or sign-extend from HI or QI. */
int
-cris_bdap_operand (op, mode)
- rtx op;
- enum machine_mode mode;
+cris_bdap_operand (rtx op, enum machine_mode mode)
{
register enum rtx_code code = GET_CODE (op);
d) a [r] or [r+] in SImode, or sign-extend from HI or QI. */
int
-cris_bdap_biap_operand (op, mode)
- rtx op;
- enum machine_mode mode;
+cris_bdap_biap_operand (rtx op, enum machine_mode mode)
{
register enum rtx_code code = GET_CODE (op);
rtx reg;
AND or UMIN. */
int
-cris_orthogonal_operator (x, mode)
- rtx x;
- enum machine_mode mode;
+cris_orthogonal_operator (rtx x, enum machine_mode mode)
{
enum rtx_code code = GET_CODE (x);
UMIN. */
int
-cris_commutative_orth_op (x, mode)
- rtx x;
- enum machine_mode mode;
+cris_commutative_orth_op (rtx x, enum machine_mode mode)
{
enum rtx_code code = GET_CODE (x);
|| code == IOR || code == AND || code == UMIN));
}
-/* Check if MODE is same as mode for X, and X is PLUS or MINUS or UMIN. */
+/* Check if MODE is same as mode for X, and X is PLUS or MINUS or UMIN.
+ By the name, you might think we should include MULT. We don't because
+ it doesn't accept the same addressing modes as the others (ony
+ registers) and there's also the problem of handling TARGET_MUL_BUG. */
int
-cris_operand_extend_operator (x, mode)
- rtx x;
- enum machine_mode mode;
+cris_operand_extend_operator (rtx x, enum machine_mode mode)
{
enum rtx_code code = GET_CODE (x);
/* Check if MODE is same as mode for X, and X is PLUS or MINUS. */
int
-cris_additive_operand_extend_operator (x, mode)
- rtx x;
- enum machine_mode mode;
+cris_additive_operand_extend_operator (rtx x, enum machine_mode mode)
{
enum rtx_code code = GET_CODE (x);
ZERO_EXTEND. */
int
-cris_extend_operator (x, mode)
- rtx x;
- enum machine_mode mode;
+cris_extend_operator (rtx x, enum machine_mode mode)
{
enum rtx_code code = GET_CODE (x);
/* Check to see if MODE is same as mode for X, and X is PLUS or BOUND. */
int
-cris_plus_or_bound_operator (x, mode)
- rtx x;
- enum machine_mode mode;
+cris_plus_or_bound_operator (rtx x, enum machine_mode mode)
{
enum rtx_code code = GET_CODE (x);
(GET_MODE (x) == mode && (code == UMIN || code == PLUS));
}
+/* Used as an operator to get a handle on a already-known-valid MEM rtx:es
+ (no need to validate the address), where some address expression parts
+ have their own match_operand. */
+
+int
+cris_mem_op (rtx x, enum machine_mode mode)
+{
+ if (mode == VOIDmode)
+ mode = GET_MODE (x);
+
+ return GET_MODE (x) == mode && GET_CODE (x) == MEM;
+}
+
/* Since with -fPIC, not all symbols are valid PIC symbols or indeed
general_operands, we have to have a predicate that matches it for the
"movsi" expander. */
int
-cris_general_operand_or_symbol (op, mode)
- rtx op;
- enum machine_mode mode;
+cris_general_operand_or_symbol (rtx op, enum machine_mode mode)
{
return general_operand (op, mode)
|| (CONSTANT_P (op) && cris_symbol (op));
"movsi" anonymous pattern for PIC symbols. */
int
-cris_general_operand_or_gotless_symbol (op, mode)
- rtx op;
- enum machine_mode mode;
+cris_general_operand_or_gotless_symbol (rtx op, enum machine_mode mode)
{
return general_operand (op, mode)
|| (CONSTANT_P (op) && cris_gotless_symbol (op));
"call" and "call_value" anonymous patterns. */
int
-cris_general_operand_or_plt_symbol (op, mode)
- rtx op;
- enum machine_mode mode;
+cris_general_operand_or_plt_symbol (rtx op, enum machine_mode mode)
{
return general_operand (op, mode)
|| (GET_CODE (op) == CONST
UNSPEC 0). */
int
-cris_mem_call_operand (op, mode)
- rtx op;
- enum machine_mode mode;
+cris_mem_call_operand (rtx op, enum machine_mode mode)
{
rtx xmem;
return cris_general_operand_or_symbol (xmem, GET_MODE (op));
}
-/* The CONDITIONAL_REGISTER_USAGE worker. */
+/* The CONDITIONAL_REGISTER_USAGE worker. */
void
-cris_conditional_register_usage ()
+cris_conditional_register_usage (void)
{
/* FIXME: This isn't nice. We should be able to use that register for
something else if the PIC table isn't needed. */
since some generated files do not include function.h. */
int
-cris_cfun_uses_pic_table ()
+cris_cfun_uses_pic_table (void)
{
return current_function_uses_pic_offset_table;
}
define_insn. */
const char *
-cris_op_str (x)
- rtx x;
+cris_op_str (rtx x)
{
cris_output_insn_is_bound = 0;
switch (GET_CODE (x))
break;
case MULT:
- return "mul";
+ /* This function is for retrieving a part of an instruction name for
+ an operator, for immediate output. If that ever happens for
+ MULT, we need to apply TARGET_MUL_BUG in the caller. Make sure
+ we notice. */
+ abort ();
break;
case DIV:
categorization of the error. */
static void
-cris_operand_lossage (msgid, op)
- const char *msgid;
- rtx op;
+cris_operand_lossage (const char *msgid, rtx op)
{
debug_rtx (op);
output_operand_lossage ("%s", msgid);
/* Print an index part of an address to file. */
static void
-cris_print_index (index, file)
- rtx index;
- FILE * file;
+cris_print_index (rtx index, FILE *file)
{
rtx inner = XEXP (index, 0);
/* Print a base rtx of an address to file. */
static void
-cris_print_base (base, file)
- rtx base;
- FILE *file;
+cris_print_base (rtx base, FILE *file)
{
if (REG_P (base))
fprintf (file, "$%s", reg_names[REGNO (base)]);
/* Usable as a guard in expressions. */
int
-cris_fatal (arg)
- char *arg;
+cris_fatal (char *arg)
{
internal_error (arg);
return 0;
}
+/* This variable belongs to cris_target_asm_function_prologue but must
+ be located outside it for GTY reasons. */
+static GTY(()) unsigned long cfa_label_num = 0;
+
/* Textual function prologue. */
static void
-cris_target_asm_function_prologue (file, size)
- FILE *file;
- HOST_WIDE_INT size;
+cris_target_asm_function_prologue (FILE *file, HOST_WIDE_INT size)
{
int regno;
int framesize;
int faked_args_size = 0;
int cfa_write_offset = 0;
- char *cfa_label = NULL;
+ static char cfa_label[30];
int return_address_on_stack
= regs_ever_live[CRIS_SRP_REGNUM]
|| cfun->machine->needs_return_address_on_stack != 0;
cfa_offset += cris_initial_frame_pointer_offset ();
}
- cfa_label = dwarf2out_cfi_label ();
+ ASM_GENERATE_INTERNAL_LABEL (cfa_label, "LCFIT",
+ cfa_label_num++);
dwarf2out_def_cfa (cfa_label, cfa_reg, cfa_offset);
cfa_write_offset = - faked_args_size - 4;
reg_names[PIC_OFFSET_TABLE_REGNUM],
reg_names[PIC_OFFSET_TABLE_REGNUM]);
+ if (doing_dwarf)
+ ASM_OUTPUT_LABEL (file, cfa_label);
+
if (TARGET_PDEBUG)
fprintf (file,
"; parm #%d @ %d; frame " HOST_WIDE_INT_PRINT_DEC
can be put in the epilogue. */
static int
-saved_regs_mentioned (x)
- rtx x;
+saved_regs_mentioned (rtx x)
{
int i;
const char *fmt;
/* Figure out if the insn may be put in the epilogue. */
int
-cris_eligible_for_epilogue_delay (insn)
- rtx insn;
+cris_eligible_for_epilogue_delay (rtx insn)
{
/* First of all, it must be as slottable as for a delayed branch insn. */
if (get_attr_slottable (insn) != SLOTTABLE_YES)
contains "ret", else 0. */
int
-cris_delay_slots_for_epilogue ()
+cris_delay_slots_for_epilogue (void)
{
/* Check if we use a return insn, which we only do for leaf functions.
Else there is no slot to fill. */
itself by storing the delay insn in save_last. */
static void
-cris_target_asm_function_epilogue (file, size)
- FILE *file;
- HOST_WIDE_INT size;
+cris_target_asm_function_epilogue (FILE *file, HOST_WIDE_INT size)
{
int regno;
int last_movem_reg = -1;
/* Output the delay-slot-insn the mandated way. */
final_scan_insn (XEXP (current_function_epilogue_delay_list, 0),
- file, 1, -2, 1);
+ file, 1, -2, 1, NULL);
}
else if (file)
{
/* The PRINT_OPERAND worker. */
void
-cris_print_operand (file, x, code)
- FILE *file;
- rtx x;
- int code;
+cris_print_operand (FILE *file, rtx x, int code)
{
rtx operand = x;
switch (code)
{
case 'b':
- /* Print the unsigned supplied integer as if it was signed
+ /* Print the unsigned supplied integer as if it were signed
and < 0, i.e print 255 or 65535 as -1, 254, 65534 as -2, etc. */
if (GET_CODE (x) != CONST_INT
|| ! CONST_OK_FOR_LETTER_P (INTVAL (x), 'O'))
fputs ("\n\tnop", file);
return;
+ case '!':
+ /* Output directive for alignment padded with "nop" insns.
+ Optimizing for size, it's plain 4-byte alignment, otherwise we
+ align the section to a cache-line (32 bytes) and skip at max 2
+ bytes, i.e. we skip if it's the last insn on a cache-line. The
+ latter is faster by a small amount (for two test-programs 99.6%
+ and 99.9%) and larger by a small amount (ditto 100.1% and
+ 100.2%). This is supposed to be the simplest yet performance-
+ wise least intrusive way to make sure the immediately following
+ (supposed) muls/mulu insn isn't located at the end of a
+ cache-line. */
+ if (TARGET_MUL_BUG)
+ fputs (optimize_size
+ ? ".p2alignw 2,0x050f\n\t"
+ : ".p2alignw 5,0x050f,2\n\t", file);
+ return;
+
case 'H':
/* Print high (most significant) part of something. */
switch (GET_CODE (operand))
/* The PRINT_OPERAND_ADDRESS worker. */
void
-cris_print_operand_address (file, x)
- FILE *file;
- rtx x;
+cris_print_operand_address (FILE *file, rtx x)
{
/* All these were inside MEM:s so output indirection characters. */
putc ('[', file);
initial-value machinery. */
rtx
-cris_return_addr_rtx (count, frameaddr)
- int count;
- rtx frameaddr ATTRIBUTE_UNUSED;
+cris_return_addr_rtx (int count, rtx frameaddr ATTRIBUTE_UNUSED)
{
cfun->machine->needs_return_address_on_stack = 1;
: NULL_RTX;
}
+/* Accessor used in cris.md:return because cfun->machine isn't available
+ there. */
+
+int
+cris_return_address_on_stack ()
+{
+ return cfun->machine->needs_return_address_on_stack;
+}
+
/* This used to be the INITIAL_FRAME_POINTER_OFFSET worker; now only
handles FP -> SP elimination offset. */
static int
-cris_initial_frame_pointer_offset ()
+cris_initial_frame_pointer_offset (void)
{
int regno;
and imaginary arg pointer. */
int
-cris_initial_elimination_offset (fromreg, toreg)
- int fromreg;
- int toreg;
+cris_initial_elimination_offset (int fromreg, int toreg)
{
int fp_sp_offset
= cris_initial_frame_pointer_offset ();
= regs_ever_live[CRIS_SRP_REGNUM]
|| cfun->machine->needs_return_address_on_stack != 0;
- /* Here we act as if the frame-pointer is needed. */
+ /* Here we act as if the frame-pointer were needed. */
int ap_fp_offset = 4 + (return_address_on_stack ? 4 : 0);
if (fromreg == ARG_POINTER_REGNUM
check-cc-attribute methods. */
void
-cris_notice_update_cc (exp, insn)
- rtx exp;
- rtx insn;
+cris_notice_update_cc (rtx exp, rtx insn)
{
/* Check if user specified "-mcc-init" as a bug-workaround. FIXME:
TARGET_CCINIT does not work; we must set CC_REVERSED as below.
- Several test-cases will otherwise fail, for example
+ Several testcases will otherwise fail, for example
gcc.c-torture/execute/20000217-1.c -O0 and -O1. */
if (TARGET_CCINIT)
{
if (GET_CODE (exp) == SET)
{
if (cc_status.value1
- && cris_reg_overlap_mentioned_p (SET_DEST (exp),
- cc_status.value1))
+ && modified_in_p (cc_status.value1, insn))
cc_status.value1 = 0;
if (cc_status.value2
- && cris_reg_overlap_mentioned_p (SET_DEST (exp),
- cc_status.value2))
+ && modified_in_p (cc_status.value2, insn))
cc_status.value2 = 0;
}
return;
{
/* There's no CC0 change when clearing a register or
memory. Just check for overlap. */
- if ((cc_status.value1
- && cris_reg_overlap_mentioned_p (SET_DEST (exp),
- cc_status.value1)))
+ if (cc_status.value1
+ && modified_in_p (cc_status.value1, insn))
cc_status.value1 = 0;
- if ((cc_status.value2
- && cris_reg_overlap_mentioned_p (SET_DEST (exp),
- cc_status.value2)))
+ if (cc_status.value2
+ && modified_in_p (cc_status.value2, insn))
cc_status.value2 = 0;
return;
{
/* When SET to MEM, then CC is not changed (except for
overlap). */
- if ((cc_status.value1
- && cris_reg_overlap_mentioned_p (SET_DEST (exp),
- cc_status.value1)))
+ if (cc_status.value1
+ && modified_in_p (cc_status.value1, insn))
cc_status.value1 = 0;
- if ((cc_status.value2
- && cris_reg_overlap_mentioned_p (SET_DEST (exp),
- cc_status.value2)))
+ if (cc_status.value2
+ && modified_in_p (cc_status.value2, insn))
cc_status.value2 = 0;
return;
value1=rz and value2=[rx] */
cc_status.value1 = XEXP (XVECEXP (exp, 0, 0), 0);
cc_status.value2
- = gen_rtx_MEM (GET_MODE (XEXP (XVECEXP (exp, 0, 0), 0)),
- XEXP (XVECEXP (exp, 0, 1), 0));
+ = replace_equiv_address (XEXP (XVECEXP (exp, 0, 0), 1),
+ XEXP (XVECEXP (exp, 0, 1), 0));
cc_status.flags = 0;
/* Huh? A side-effect cannot change the destination
/* For "move.S rz,[rx=ry+o]" and "clear.S [rx=ry+o]",
say flags are not changed, except for overlap. */
if (cc_status.value1
- && cris_reg_overlap_mentioned_p (XEXP
- (XVECEXP
- (exp, 0, 0), 0),
- cc_status.value1))
- cc_status.value1 = 0;
-
- if (cc_status.value1
- && cris_reg_overlap_mentioned_p (XEXP
- (XVECEXP
- (exp, 0, 1), 0),
- cc_status.value1))
+ && modified_in_p (cc_status.value1, insn))
cc_status.value1 = 0;
if (cc_status.value2
- && cris_reg_overlap_mentioned_p (XEXP
- (XVECEXP
- (exp, 0, 0), 0),
- cc_status.value2))
- cc_status.value2 = 0;
-
- if (cc_status.value2
- && cris_reg_overlap_mentioned_p (XEXP
- (XVECEXP
- (exp, 0, 1), 0),
- cc_status.value2))
+ && modified_in_p (cc_status.value2, insn))
cc_status.value2 = 0;
return;
many registers must be saved, so return 0 then. */
int
-cris_simple_epilogue ()
+cris_simple_epilogue (void)
{
int regno;
int reglimit = STACK_POINTER_REGNUM;
scanned. In either case, *TOTAL contains the cost result. */
static bool
-cris_rtx_costs (x, code, outer_code, total)
- rtx x;
- int code, outer_code;
- int *total;
+cris_rtx_costs (rtx x, int code, int outer_code, int *total)
{
switch (code)
{
/* The ADDRESS_COST worker. */
static int
-cris_address_cost (x)
- rtx x;
+cris_address_cost (rtx x)
{
/* The metric to use for the cost-macros is unclear.
The metric used here is (the number of cycles needed) / 2,
whose mode we must consider. */
int
-cris_side_effect_mode_ok (code, ops, lreg, rreg, rval, multop, other_op)
- enum rtx_code code;
- rtx *ops;
- int lreg, rreg, rval, multop, other_op;
+cris_side_effect_mode_ok (enum rtx_code code, rtx *ops,
+ int lreg, int rreg, int rval,
+ int multop, int other_op)
{
/* Find what value to multiply with, for rx =ry + rz * n. */
int mult = multop < 0 ? 1 : INTVAL (ops[multop]);
anyway. */
static int
-cris_reg_overlap_mentioned_p (x, in)
- rtx x, in;
+cris_reg_overlap_mentioned_p (rtx x, rtx in)
{
/* The function reg_overlap_mentioned now handles when X is
strict_low_part, but not when IN is a STRICT_LOW_PART. */
We just dispatch to the functions for ELF and a.out. */
void
-cris_target_asm_named_section (name, flags)
- const char *name;
- unsigned int flags;
+cris_target_asm_named_section (const char *name, unsigned int flags,
+ tree decl)
{
if (! TARGET_ELF)
- default_no_named_section (name, flags);
+ default_no_named_section (name, flags, decl);
else
- default_elf_asm_named_section (name, flags);
+ default_elf_asm_named_section (name, flags, decl);
}
/* The LEGITIMATE_PIC_OPERAND_P worker. */
int
-cris_legitimate_pic_operand (x)
- rtx x;
+cris_legitimate_pic_operand (rtx x)
{
/* The PIC representation of a symbol with a GOT entry will be (for
example; relocations differ):
CONSTANT_P. */
int
-cris_symbol (x)
- rtx x;
+cris_symbol (rtx x)
{
switch (GET_CODE (x))
{
case CONST_INT:
case CONST_DOUBLE:
- case CONSTANT_P_RTX:
return 0;
default:
see something that would need one. */
int
-cris_gotless_symbol (x)
- rtx x;
+cris_gotless_symbol (rtx x)
{
#ifdef ENABLE_CHECKING
if (!flag_pic)
case CONST_INT:
case CONST_DOUBLE:
- case CONSTANT_P_RTX:
return 0;
default:
CONSTANT_P, and the symbol needs a GOT entry. */
int
-cris_got_symbol (x)
- rtx x;
+cris_got_symbol (rtx x)
{
#ifdef ENABLE_CHECKING
if (!flag_pic)
case CONST_INT:
case CONST_DOUBLE:
- case CONSTANT_P_RTX:
return 0;
default:
As is the norm, this also parses -mfoo=bar type parameters. */
void
-cris_override_options ()
+cris_override_options (void)
{
if (cris_max_stackframe_str)
{
flag_no_function_cse = 1;
}
- if ((write_symbols == DWARF_DEBUG
- || write_symbols == DWARF2_DEBUG) && ! TARGET_ELF)
+ if (write_symbols == DWARF2_DEBUG && ! TARGET_ELF)
{
warning ("that particular -g option is invalid with -maout and -melinux");
write_symbols = DBX_DEBUG;
/* The TARGET_ASM_OUTPUT_MI_THUNK worker. */
static void
-cris_asm_output_mi_thunk (stream, thunkdecl, delta, vcall_offset, funcdecl)
- FILE *stream;
- tree thunkdecl ATTRIBUTE_UNUSED;
- HOST_WIDE_INT delta;
- HOST_WIDE_INT vcall_offset ATTRIBUTE_UNUSED;
- tree funcdecl;
+cris_asm_output_mi_thunk (FILE *stream,
+ tree thunkdecl ATTRIBUTE_UNUSED,
+ HOST_WIDE_INT delta,
+ HOST_WIDE_INT vcall_offset ATTRIBUTE_UNUSED,
+ tree funcdecl)
{
if (delta > 0)
- {
- fprintf (stream, "\tadd%s ", ADDITIVE_SIZE_MODIFIER (delta));
- fprintf (stream, HOST_WIDE_INT_PRINT_DEC, delta);
- fprintf (stream, ",$%s\n", reg_names[CRIS_FIRST_ARG_REG]);
- }
+ fprintf (stream, "\tadd%s " HOST_WIDE_INT_PRINT_DEC ",$%s\n",
+ ADDITIVE_SIZE_MODIFIER (delta), delta,
+ reg_names[CRIS_FIRST_ARG_REG]);
else if (delta < 0)
- {
- fprintf (stream, "\tsub%s ", ADDITIVE_SIZE_MODIFIER (-delta));
- fprintf (stream, HOST_WIDE_INT_PRINT_DEC, -delta);
- fprintf (stream, ",$%s\n", reg_names[CRIS_FIRST_ARG_REG]);
- }
+ fprintf (stream, "\tsub%s " HOST_WIDE_INT_PRINT_DEC ",$%s\n",
+ ADDITIVE_SIZE_MODIFIER (-delta), -delta,
+ reg_names[CRIS_FIRST_ARG_REG]);
if (flag_pic)
{
}
}
-/* The EXPAND_BUILTIN_VA_ARG worker. This is modified from the
- "standard" implementation of va_arg: read the value from the current
- address and increment by the size of one or two registers. The
- important difference for CRIS is that if the type is
- pass-by-reference, then perform an indirection. */
+/* Boilerplate emitted at start of file.
-rtx
-cris_expand_builtin_va_arg (valist, type)
- tree valist;
- tree type;
-{
- tree addr_tree, t;
- rtx addr;
- tree passed_size = size_zero_node;
- tree type_size = NULL;
- tree size3 = size_int (3);
- tree size4 = size_int (4);
- tree size8 = size_int (8);
- tree rounded_size;
-
- /* Get AP. */
- addr_tree = valist;
-
- if (type == error_mark_node
- || (type_size = TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (type))) == NULL
- || TREE_OVERFLOW (type_size))
- /* Presumably an error; the size isn't computable. A message has
- supposedly been emitted elsewhere. */
- rounded_size = size_zero_node;
- else
- rounded_size
- = fold (build (MULT_EXPR, sizetype,
- fold (build (TRUNC_DIV_EXPR, sizetype,
- fold (build (PLUS_EXPR, sizetype,
- type_size, size3)),
- size4)),
- size4));
-
- if (!integer_zerop (rounded_size))
- {
- /* Check if the type is passed by value or by reference. Values up
- to 8 bytes are passed by-value, padded to register-size (4
- bytes). Larger values and varying-size types are passed
- by reference. */
- passed_size
- = (!really_constant_p (type_size)
- ? size4
- : fold (build (COND_EXPR, sizetype,
- fold (build (GT_EXPR, sizetype,
- rounded_size,
- size8)),
- size4,
- rounded_size)));
-
- addr_tree
- = (!really_constant_p (type_size)
- ? build1 (INDIRECT_REF, build_pointer_type (type), addr_tree)
- : fold (build (COND_EXPR, TREE_TYPE (addr_tree),
- fold (build (GT_EXPR, sizetype,
- rounded_size,
- size8)),
- build1 (INDIRECT_REF, build_pointer_type (type),
- addr_tree),
- addr_tree)));
- }
+ NO_APP *only at file start* means faster assembly. It also means
+ comments are not allowed. In some cases comments will be output
+ for debugging purposes. Make sure they are allowed then.
- addr = expand_expr (addr_tree, NULL_RTX, Pmode, EXPAND_NORMAL);
- addr = copy_to_reg (addr);
+ We want a .file directive only if TARGET_ELF. */
+static void
+cris_file_start (void)
+{
+ /* These expressions can vary at run time, so we cannot put
+ them into TARGET_INITIALIZER. */
+ targetm.file_start_app_off = !(TARGET_PDEBUG || flag_print_asm_name);
+ targetm.file_start_file_directive = TARGET_ELF;
- if (!integer_zerop (rounded_size))
- {
- /* Compute new value for AP. */
- t = build (MODIFY_EXPR, TREE_TYPE (valist), valist,
- build (PLUS_EXPR, TREE_TYPE (valist), valist,
- passed_size));
- TREE_SIDE_EFFECTS (t) = 1;
- expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
- }
+ default_file_start ();
+}
- return addr;
+/* Rename the function calls for integer multiply and divide. */
+static void
+cris_init_libfuncs (void)
+{
+ set_optab_libfunc (smul_optab, SImode, "__Mul");
+ set_optab_libfunc (sdiv_optab, SImode, "__Div");
+ set_optab_libfunc (udiv_optab, SImode, "__Udiv");
+ set_optab_libfunc (smod_optab, SImode, "__Mod");
+ set_optab_libfunc (umod_optab, SImode, "__Umod");
}
/* The INIT_EXPANDERS worker sets the per-function-data initializer and
mark functions. */
void
-cris_init_expanders ()
+cris_init_expanders (void)
{
/* Nothing here at the moment. */
}
/* Zero initialization is OK for all current fields. */
static struct machine_function *
-cris_init_machine_status ()
+cris_init_machine_status (void)
{
return ggc_alloc_cleared (sizeof (struct machine_function));
}
Originally a copy of gen_split_move_double in m32r.c. */
rtx
-cris_split_movdx (operands)
- rtx *operands;
+cris_split_movdx (rtx *operands)
{
enum machine_mode mode = GET_MODE (operands[0]);
rtx dest = operands[0];
int reverse
= (refers_to_regno_p (dregno, dregno + 1, addr, NULL) != 0);
- /* The original code imples that we can't do
+ /* The original code implies that we can't do
move.x [rN+],rM move.x [rN],rM+1
when rN is dead, because of REG_NOTES damage. That is
consistent with what I've seen, so don't try it.
return val;
}
-/* This is in essence a copy of output_addr_const altered to output
- symbolic operands as PIC.
+/* Use from within code, from e.g. PRINT_OPERAND and
+ PRINT_OPERAND_ADDRESS. Macros used in output_addr_const need to emit
+ different things depending on whether code operand or constant is
+ emitted. */
- FIXME: Add hooks similar to ASM_OUTPUT_SYMBOL_REF to get this effect in
- the "real" output_addr_const. All we need is one for LABEL_REF (and
- one for CODE_LABEL?). */
+static void
+cris_output_addr_const (FILE *file, rtx x)
+{
+ in_code++;
+ output_addr_const (file, x);
+ in_code--;
+}
+
+/* Worker function for ASM_OUTPUT_SYMBOL_REF. */
void
-cris_output_addr_const (file, x)
- FILE *file;
- rtx x;
+cris_asm_output_symbol_ref (FILE *file, rtx x)
{
- int is_plt = 0;
-
-restart:
- switch (GET_CODE (x))
+ if (flag_pic && in_code > 0)
{
- case UNSPEC:
- ASSERT_PLT_UNSPEC (x);
- x = XVECEXP (x, 0, 0);
- is_plt = 1;
-
- /* Fall through. */
- case SYMBOL_REF:
- if (flag_pic)
- {
- const char *origstr = XSTR (x, 0);
- const char *str;
-
- str = (* targetm.strip_name_encoding) (origstr);
-
- if (is_plt)
- {
- if (cris_pic_sympart_only)
- {
- assemble_name (file, str);
- fprintf (file, ":PLTG");
- }
- else
- {
- if (TARGET_AVOID_GOTPLT)
- /* We shouldn't get here. */
- abort ();
+ const char *origstr = XSTR (x, 0);
+ const char *str;
- fprintf (file, "[$%s+", reg_names [PIC_OFFSET_TABLE_REGNUM]);
- assemble_name (file, XSTR (x, 0));
+ str = (* targetm.strip_name_encoding) (origstr);
- if (flag_pic == 1)
- fprintf (file, ":GOTPLT16]");
- else
- fprintf (file, ":GOTPLT]");
- }
- }
- else if (cris_gotless_symbol (x))
- {
- if (! cris_pic_sympart_only)
- fprintf (file, "$%s+", reg_names [PIC_OFFSET_TABLE_REGNUM]);
- assemble_name (file, str);
- fprintf (file, ":GOTOFF");
- }
- else if (cris_got_symbol (x))
- {
- if (cris_pic_sympart_only)
- abort ();
- fprintf (file, "[$%s+", reg_names [PIC_OFFSET_TABLE_REGNUM]);
- assemble_name (file, XSTR (x, 0));
+ if (cris_gotless_symbol (x))
+ {
+ if (! cris_pic_sympart_only)
+ fprintf (file, "$%s+", reg_names [PIC_OFFSET_TABLE_REGNUM]);
+ assemble_name (file, str);
+ fprintf (file, ":GOTOFF");
+ }
+ else if (cris_got_symbol (x))
+ {
+ if (cris_pic_sympart_only)
+ abort ();
+ fprintf (file, "[$%s+", reg_names [PIC_OFFSET_TABLE_REGNUM]);
+ assemble_name (file, XSTR (x, 0));
- if (flag_pic == 1)
- fprintf (file, ":GOT16]");
- else
- fprintf (file, ":GOT]");
- }
+ if (flag_pic == 1)
+ fprintf (file, ":GOT16]");
else
- LOSE_AND_RETURN ("unexpected PIC symbol", x);
-
- /* Sanity check. */
- if (! current_function_uses_pic_offset_table)
- output_operand_lossage ("PIC register isn't set up");
+ fprintf (file, ":GOT]");
}
else
- assemble_name (file, XSTR (x, 0));
- break;
+ LOSE_AND_RETURN ("unexpected PIC symbol", x);
- case LABEL_REF:
- /* If we get one of those here, it should be dressed as PIC. Branch
- labels are normally output with the 'l' specifier, which means it
- will go directly to output_asm_label and not end up here. */
- if (GET_CODE (XEXP (x, 0)) != CODE_LABEL
- && (GET_CODE (XEXP (x, 0)) != NOTE
- || NOTE_LINE_NUMBER (XEXP (x, 0)) != NOTE_INSN_DELETED_LABEL))
- fatal_insn ("unexpected address expression", x);
+ /* Sanity check. */
+ if (! current_function_uses_pic_offset_table)
+ output_operand_lossage ("PIC register isn't set up");
+ }
+ else
+ assemble_name (file, XSTR (x, 0));
+}
- if (flag_pic)
- {
- if (cris_gotless_symbol (x))
- {
- if (! cris_pic_sympart_only)
- fprintf (file, "$%s+", reg_names [PIC_OFFSET_TABLE_REGNUM]);
- cris_output_addr_const (file, XEXP (x, 0));
+/* Worker function for ASM_OUTPUT_LABEL_REF. */
- fprintf (file, ":GOTOFF");
- }
- else
- /* Labels are never marked as global symbols. */
- fatal_insn ("unexpected PIC symbol", x);
+void
+cris_asm_output_label_ref (FILE *file, char *buf)
+{
+ if (flag_pic && in_code > 0)
+ {
+ if (! cris_pic_sympart_only)
+ fprintf (file, "$%s+", reg_names [PIC_OFFSET_TABLE_REGNUM]);
+ assemble_name (file, buf);
- /* Sanity check. */
- if (! current_function_uses_pic_offset_table)
- internal_error ("emitting PIC operand, but PIC register isn't set up");
- break;
- }
+ fprintf (file, ":GOTOFF");
- output_addr_const (file, x);
- break;
+ /* Sanity check. */
+ if (! current_function_uses_pic_offset_table)
+ internal_error ("emitting PIC operand, but PIC register isn't set up");
+ }
+ else
+ assemble_name (file, buf);
+}
- case NOTE:
- if (NOTE_LINE_NUMBER (x) != NOTE_INSN_DELETED_LABEL)
- fatal_insn ("unexpected NOTE as addr_const:", x);
- case CODE_LABEL:
- case CONST_INT:
- case CONST_DOUBLE:
- case ZERO_EXTEND:
- case SIGN_EXTEND:
- output_addr_const (file, x);
- break;
+/* Worker function for OUTPUT_ADDR_CONST_EXTRA. */
- case CONST:
- /* This used to output parentheses around the expression,
- but that does not work on the 386 (either ATT or BSD assembler). */
- cris_output_addr_const (file, XEXP (x, 0));
- break;
+bool
+cris_output_addr_const_extra (FILE *file, rtx x)
+{
+ switch (GET_CODE (x))
+ {
+ const char *origstr;
+ const char *str;
- case PLUS:
- /* Some assemblers need integer constants to appear last (eg masm). */
- if (GET_CODE (XEXP (x, 0)) == CONST_INT)
+ case UNSPEC:
+ ASSERT_PLT_UNSPEC (x);
+ x = XVECEXP (x, 0, 0);
+ origstr = XSTR (x, 0);
+ str = (* targetm.strip_name_encoding) (origstr);
+ if (cris_pic_sympart_only)
{
- cris_output_addr_const (file, XEXP (x, 1));
- if (INTVAL (XEXP (x, 0)) >= 0)
- fprintf (file, "+");
- output_addr_const (file, XEXP (x, 0));
+ assemble_name (file, str);
+ fprintf (file, ":PLTG");
}
else
{
- cris_output_addr_const (file, XEXP (x, 0));
- if (GET_CODE (XEXP (x, 1)) != CONST_INT
- || INTVAL (XEXP (x, 1)) >= 0)
- fprintf (file, "+");
- cris_output_addr_const (file, XEXP (x, 1));
- }
- break;
+ if (TARGET_AVOID_GOTPLT)
+ /* We shouldn't get here. */
+ abort ();
- case MINUS:
- /* Avoid outputting things like x-x or x+5-x,
- since some assemblers can't handle that. */
- x = simplify_subtraction (x);
- if (GET_CODE (x) != MINUS)
- goto restart;
-
- cris_output_addr_const (file, XEXP (x, 0));
- fprintf (file, "-");
- if ((GET_CODE (XEXP (x, 1)) == CONST_INT
- && INTVAL (XEXP (x, 1)) < 0)
- || GET_CODE (XEXP (x, 1)) != CONST_INT)
- {
- fprintf (file, "%s", targetm.asm_out.open_paren);
- cris_output_addr_const (file, XEXP (x, 1));
- fprintf (file, "%s", targetm.asm_out.close_paren);
+ fprintf (file, "[$%s+", reg_names [PIC_OFFSET_TABLE_REGNUM]);
+ assemble_name (file, XSTR (x, 0));
+
+ if (flag_pic == 1)
+ fprintf (file, ":GOTPLT16]");
+ else
+ fprintf (file, ":GOTPLT]");
}
- else
- output_addr_const (file, XEXP (x, 1));
- break;
+ return true;
default:
- LOSE_AND_RETURN ("unexpected address expression", x);
+ return false;
}
}
+/* Worker function for TARGET_STRUCT_VALUE_RTX. */
+
+static rtx
+cris_struct_value_rtx (tree fntype ATTRIBUTE_UNUSED,
+ int incoming ATTRIBUTE_UNUSED)
+{
+ return gen_rtx_REG (Pmode, CRIS_STRUCT_VALUE_REGNUM);
+}
+
+/* Worker function for TARGET_SETUP_INCOMING_VARARGS. */
+
+static void
+cris_setup_incoming_varargs (CUMULATIVE_ARGS *ca,
+ enum machine_mode mode ATTRIBUTE_UNUSED,
+ tree type ATTRIBUTE_UNUSED,
+ int *pretend_arg_size,
+ int second_time)
+{
+ if (ca->regs < CRIS_MAX_ARGS_IN_REGS)
+ *pretend_arg_size = (CRIS_MAX_ARGS_IN_REGS - ca->regs) * 4;
+ if (TARGET_PDEBUG)
+ {
+ fprintf (asm_out_file,
+ "\n; VA:: ANSI: %d args before, anon @ #%d, %dtime\n",
+ ca->regs, *pretend_arg_size, second_time);
+ }
+}
+
+/* Return true if TYPE must be passed by invisible reference.
+ For cris, we pass <= 8 bytes by value, others by reference. */
+
+static bool
+cris_pass_by_reference (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
+ enum machine_mode mode, tree type,
+ bool named ATTRIBUTE_UNUSED)
+{
+ return (targetm.calls.must_pass_in_stack (mode, type)
+ || CRIS_FUNCTION_ARG_SIZE (mode, type) > 8);
+}
+
+
+static int
+cris_arg_partial_bytes (CUMULATIVE_ARGS *ca, enum machine_mode mode,
+ tree type, bool named ATTRIBUTE_UNUSED)
+{
+ if (ca->regs == CRIS_MAX_ARGS_IN_REGS - 1
+ && !targetm.calls.must_pass_in_stack (mode, type)
+ && CRIS_FUNCTION_ARG_SIZE (mode, type) > 4
+ && CRIS_FUNCTION_ARG_SIZE (mode, type) <= 8)
+ return UNITS_PER_WORD;
+ else
+ return 0;
+}
+
+
#if 0
/* Various small functions to replace macros. Only called from a
debugger. They might collide with gcc functions or system functions,
so only emit them when '#if 1' above. */
-enum rtx_code Get_code PARAMS ((rtx));
+enum rtx_code Get_code (rtx);
enum rtx_code
-Get_code (x)
- rtx x;
+Get_code (rtx x)
{
return GET_CODE (x);
}
-const char *Get_mode PARAMS ((rtx));
+const char *Get_mode (rtx);
const char *
-Get_mode (x)
- rtx x;
+Get_mode (rtx x)
{
return GET_MODE_NAME (GET_MODE (x));
}
-rtx Xexp PARAMS ((rtx, int));
+rtx Xexp (rtx, int);
rtx
-Xexp (x, n)
- rtx x;
- int n;
+Xexp (rtx x, int n)
{
return XEXP (x, n);
}
-rtx Xvecexp PARAMS ((rtx, int, int));
+rtx Xvecexp (rtx, int, int);
rtx
-Xvecexp (x, n, m)
- rtx x;
- int n;
+Xvecexp (rtx x, int n, int m)
{
return XVECEXP (x, n, m);
}
-int Get_rtx_len PARAMS ((rtx));
+int Get_rtx_len (rtx);
int
-Get_rtx_len (x)
- rtx x;
+Get_rtx_len (rtx x)
{
return GET_RTX_LENGTH (GET_CODE (x));
}
/* Use upper-case to distinguish from local variables that are sometimes
called next_insn and prev_insn. */
-rtx Next_insn PARAMS ((rtx));
+rtx Next_insn (rtx);
rtx
-Next_insn (insn)
- rtx insn;
+Next_insn (rtx insn)
{
return NEXT_INSN (insn);
}
-rtx Prev_insn PARAMS ((rtx));
+rtx Prev_insn (rtx);
rtx
-Prev_insn (insn)
- rtx insn;
+Prev_insn (rtx insn)
{
return PREV_INSN (insn);
}
projects / gcc.git / blobdiff