3034 lines
77 KiB
C
3034 lines
77 KiB
C
/* Subroutines for insn-output.c for NEC V850 series
|
||
Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
|
||
2006, 2007, 2008, 2009 Free Software Foundation, Inc.
|
||
Contributed by Jeff Law (law@cygnus.com).
|
||
|
||
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 3, or (at your option)
|
||
any later version.
|
||
|
||
GCC is distributed in the hope that it will be useful, but WITHOUT
|
||
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||
FITNESS FOR A PARTICULAR PURPOSE. See the 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 COPYING3. If not see
|
||
<http://www.gnu.org/licenses/>. */
|
||
|
||
#include "config.h"
|
||
#include "system.h"
|
||
#include "coretypes.h"
|
||
#include "tm.h"
|
||
#include "tree.h"
|
||
#include "rtl.h"
|
||
#include "regs.h"
|
||
#include "hard-reg-set.h"
|
||
#include "real.h"
|
||
#include "insn-config.h"
|
||
#include "conditions.h"
|
||
#include "output.h"
|
||
#include "insn-attr.h"
|
||
#include "flags.h"
|
||
#include "recog.h"
|
||
#include "expr.h"
|
||
#include "function.h"
|
||
#include "toplev.h"
|
||
#include "ggc.h"
|
||
#include "integrate.h"
|
||
#include "tm_p.h"
|
||
#include "target.h"
|
||
#include "target-def.h"
|
||
#include "df.h"
|
||
|
||
#ifndef streq
|
||
#define streq(a,b) (strcmp (a, b) == 0)
|
||
#endif
|
||
|
||
/* Function prototypes for stupid compilers: */
|
||
static bool v850_handle_option (size_t, const char *, int);
|
||
static void const_double_split (rtx, HOST_WIDE_INT *, HOST_WIDE_INT *);
|
||
static int const_costs_int (HOST_WIDE_INT, int);
|
||
static int const_costs (rtx, enum rtx_code);
|
||
static bool v850_rtx_costs (rtx, int, int, int *, bool);
|
||
static void substitute_ep_register (rtx, rtx, int, int, rtx *, rtx *);
|
||
static void v850_reorg (void);
|
||
static int ep_memory_offset (enum machine_mode, int);
|
||
static void v850_set_data_area (tree, v850_data_area);
|
||
static tree v850_handle_interrupt_attribute (tree *, tree, tree, int, bool *);
|
||
static tree v850_handle_data_area_attribute (tree *, tree, tree, int, bool *);
|
||
static void v850_insert_attributes (tree, tree *);
|
||
static void v850_asm_init_sections (void);
|
||
static section *v850_select_section (tree, int, unsigned HOST_WIDE_INT);
|
||
static void v850_encode_data_area (tree, rtx);
|
||
static void v850_encode_section_info (tree, rtx, int);
|
||
static bool v850_return_in_memory (const_tree, const_tree);
|
||
static rtx v850_function_value (const_tree, const_tree, bool);
|
||
static void v850_setup_incoming_varargs (CUMULATIVE_ARGS *, enum machine_mode,
|
||
tree, int *, int);
|
||
static bool v850_pass_by_reference (CUMULATIVE_ARGS *, enum machine_mode,
|
||
const_tree, bool);
|
||
static int v850_arg_partial_bytes (CUMULATIVE_ARGS *, enum machine_mode,
|
||
tree, bool);
|
||
static bool v850_can_eliminate (const int, const int);
|
||
static void v850_asm_trampoline_template (FILE *);
|
||
static void v850_trampoline_init (rtx, tree, rtx);
|
||
|
||
/* Information about the various small memory areas. */
|
||
struct small_memory_info small_memory[ (int)SMALL_MEMORY_max ] =
|
||
{
|
||
/* name max physical max */
|
||
{ "tda", 0, 256 },
|
||
{ "sda", 0, 65536 },
|
||
{ "zda", 0, 32768 },
|
||
};
|
||
|
||
/* Names of the various data areas used on the v850. */
|
||
tree GHS_default_section_names [(int) COUNT_OF_GHS_SECTION_KINDS];
|
||
tree GHS_current_section_names [(int) COUNT_OF_GHS_SECTION_KINDS];
|
||
|
||
/* Track the current data area set by the data area pragma (which
|
||
can be nested). Tested by check_default_data_area. */
|
||
data_area_stack_element * data_area_stack = NULL;
|
||
|
||
/* True if we don't need to check any more if the current
|
||
function is an interrupt handler. */
|
||
static int v850_interrupt_cache_p = FALSE;
|
||
|
||
/* Whether current function is an interrupt handler. */
|
||
static int v850_interrupt_p = FALSE;
|
||
|
||
static GTY(()) section *rosdata_section;
|
||
static GTY(()) section *rozdata_section;
|
||
static GTY(()) section *tdata_section;
|
||
static GTY(()) section *zdata_section;
|
||
static GTY(()) section *zbss_section;
|
||
|
||
/* V850 specific attributes. */
|
||
|
||
static const struct attribute_spec v850_attribute_table[] =
|
||
{
|
||
/* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
|
||
{ "interrupt_handler", 0, 0, true, false, false, v850_handle_interrupt_attribute },
|
||
{ "interrupt", 0, 0, true, false, false, v850_handle_interrupt_attribute },
|
||
{ "sda", 0, 0, true, false, false, v850_handle_data_area_attribute },
|
||
{ "tda", 0, 0, true, false, false, v850_handle_data_area_attribute },
|
||
{ "zda", 0, 0, true, false, false, v850_handle_data_area_attribute },
|
||
{ NULL, 0, 0, false, false, false, NULL }
|
||
};
|
||
|
||
|
||
/* Initialize the GCC target structure. */
|
||
#undef TARGET_ASM_ALIGNED_HI_OP
|
||
#define TARGET_ASM_ALIGNED_HI_OP "\t.hword\t"
|
||
|
||
#undef TARGET_ATTRIBUTE_TABLE
|
||
#define TARGET_ATTRIBUTE_TABLE v850_attribute_table
|
||
|
||
#undef TARGET_INSERT_ATTRIBUTES
|
||
#define TARGET_INSERT_ATTRIBUTES v850_insert_attributes
|
||
|
||
#undef TARGET_ASM_SELECT_SECTION
|
||
#define TARGET_ASM_SELECT_SECTION v850_select_section
|
||
|
||
/* The assembler supports switchable .bss sections, but
|
||
v850_select_section doesn't yet make use of them. */
|
||
#undef TARGET_HAVE_SWITCHABLE_BSS_SECTIONS
|
||
#define TARGET_HAVE_SWITCHABLE_BSS_SECTIONS false
|
||
|
||
#undef TARGET_ENCODE_SECTION_INFO
|
||
#define TARGET_ENCODE_SECTION_INFO v850_encode_section_info
|
||
|
||
#undef TARGET_ASM_FILE_START_FILE_DIRECTIVE
|
||
#define TARGET_ASM_FILE_START_FILE_DIRECTIVE true
|
||
|
||
#undef TARGET_DEFAULT_TARGET_FLAGS
|
||
#define TARGET_DEFAULT_TARGET_FLAGS (MASK_DEFAULT | MASK_APP_REGS)
|
||
#undef TARGET_HANDLE_OPTION
|
||
#define TARGET_HANDLE_OPTION v850_handle_option
|
||
|
||
#undef TARGET_RTX_COSTS
|
||
#define TARGET_RTX_COSTS v850_rtx_costs
|
||
|
||
#undef TARGET_ADDRESS_COST
|
||
#define TARGET_ADDRESS_COST hook_int_rtx_bool_0
|
||
|
||
#undef TARGET_MACHINE_DEPENDENT_REORG
|
||
#define TARGET_MACHINE_DEPENDENT_REORG v850_reorg
|
||
|
||
#undef TARGET_PROMOTE_PROTOTYPES
|
||
#define TARGET_PROMOTE_PROTOTYPES hook_bool_const_tree_true
|
||
|
||
#undef TARGET_RETURN_IN_MEMORY
|
||
#define TARGET_RETURN_IN_MEMORY v850_return_in_memory
|
||
|
||
#undef TARGET_FUNCTION_VALUE
|
||
#define TARGET_FUNCTION_VALUE v850_function_value
|
||
|
||
#undef TARGET_PASS_BY_REFERENCE
|
||
#define TARGET_PASS_BY_REFERENCE v850_pass_by_reference
|
||
|
||
#undef TARGET_CALLEE_COPIES
|
||
#define TARGET_CALLEE_COPIES hook_bool_CUMULATIVE_ARGS_mode_tree_bool_true
|
||
|
||
#undef TARGET_SETUP_INCOMING_VARARGS
|
||
#define TARGET_SETUP_INCOMING_VARARGS v850_setup_incoming_varargs
|
||
|
||
#undef TARGET_ARG_PARTIAL_BYTES
|
||
#define TARGET_ARG_PARTIAL_BYTES v850_arg_partial_bytes
|
||
|
||
#undef TARGET_CAN_ELIMINATE
|
||
#define TARGET_CAN_ELIMINATE v850_can_eliminate
|
||
|
||
#undef TARGET_ASM_TRAMPOLINE_TEMPLATE
|
||
#define TARGET_ASM_TRAMPOLINE_TEMPLATE v850_asm_trampoline_template
|
||
#undef TARGET_TRAMPOLINE_INIT
|
||
#define TARGET_TRAMPOLINE_INIT v850_trampoline_init
|
||
|
||
struct gcc_target targetm = TARGET_INITIALIZER;
|
||
|
||
/* Set the maximum size of small memory area TYPE to the value given
|
||
by VALUE. Return true if VALUE was syntactically correct. VALUE
|
||
starts with the argument separator: either "-" or "=". */
|
||
|
||
static bool
|
||
v850_handle_memory_option (enum small_memory_type type, const char *value)
|
||
{
|
||
int i, size;
|
||
|
||
if (*value != '-' && *value != '=')
|
||
return false;
|
||
|
||
value++;
|
||
for (i = 0; value[i]; i++)
|
||
if (!ISDIGIT (value[i]))
|
||
return false;
|
||
|
||
size = atoi (value);
|
||
if (size > small_memory[type].physical_max)
|
||
error ("value passed to %<-m%s%> is too large", small_memory[type].name);
|
||
else
|
||
small_memory[type].max = size;
|
||
return true;
|
||
}
|
||
|
||
/* Implement TARGET_HANDLE_OPTION. */
|
||
|
||
static bool
|
||
v850_handle_option (size_t code, const char *arg, int value ATTRIBUTE_UNUSED)
|
||
{
|
||
switch (code)
|
||
{
|
||
case OPT_mspace:
|
||
target_flags |= MASK_EP | MASK_PROLOG_FUNCTION;
|
||
return true;
|
||
|
||
case OPT_mv850:
|
||
target_flags &= ~(MASK_CPU ^ MASK_V850);
|
||
return true;
|
||
|
||
case OPT_mv850e:
|
||
case OPT_mv850e1:
|
||
target_flags &= ~(MASK_CPU ^ MASK_V850E);
|
||
return true;
|
||
|
||
case OPT_mtda:
|
||
return v850_handle_memory_option (SMALL_MEMORY_TDA, arg);
|
||
|
||
case OPT_msda:
|
||
return v850_handle_memory_option (SMALL_MEMORY_SDA, arg);
|
||
|
||
case OPT_mzda:
|
||
return v850_handle_memory_option (SMALL_MEMORY_ZDA, arg);
|
||
|
||
default:
|
||
return true;
|
||
}
|
||
}
|
||
|
||
static bool
|
||
v850_pass_by_reference (CUMULATIVE_ARGS *cum ATTRIBUTE_UNUSED,
|
||
enum machine_mode mode, const_tree type,
|
||
bool named ATTRIBUTE_UNUSED)
|
||
{
|
||
unsigned HOST_WIDE_INT size;
|
||
|
||
if (type)
|
||
size = int_size_in_bytes (type);
|
||
else
|
||
size = GET_MODE_SIZE (mode);
|
||
|
||
return size > 8;
|
||
}
|
||
|
||
/* Return an RTX to represent where an argument with mode MODE
|
||
and type TYPE will be passed to a function. If the result
|
||
is NULL_RTX, the argument will be pushed. */
|
||
|
||
rtx
|
||
function_arg (CUMULATIVE_ARGS * cum,
|
||
enum machine_mode mode,
|
||
tree type,
|
||
int named)
|
||
{
|
||
rtx result = NULL_RTX;
|
||
int size, align;
|
||
|
||
if (TARGET_GHS && !named)
|
||
return NULL_RTX;
|
||
|
||
if (mode == BLKmode)
|
||
size = int_size_in_bytes (type);
|
||
else
|
||
size = GET_MODE_SIZE (mode);
|
||
|
||
if (size < 1)
|
||
{
|
||
/* Once we have stopped using argument registers, do not start up again. */
|
||
cum->nbytes = 4 * UNITS_PER_WORD;
|
||
return NULL_RTX;
|
||
}
|
||
|
||
if (type)
|
||
align = TYPE_ALIGN (type) / BITS_PER_UNIT;
|
||
else
|
||
align = size;
|
||
|
||
cum->nbytes = (cum->nbytes + align - 1) &~(align - 1);
|
||
|
||
if (cum->nbytes > 4 * UNITS_PER_WORD)
|
||
return NULL_RTX;
|
||
|
||
if (type == NULL_TREE
|
||
&& cum->nbytes + size > 4 * UNITS_PER_WORD)
|
||
return NULL_RTX;
|
||
|
||
switch (cum->nbytes / UNITS_PER_WORD)
|
||
{
|
||
case 0:
|
||
result = gen_rtx_REG (mode, 6);
|
||
break;
|
||
case 1:
|
||
result = gen_rtx_REG (mode, 7);
|
||
break;
|
||
case 2:
|
||
result = gen_rtx_REG (mode, 8);
|
||
break;
|
||
case 3:
|
||
result = gen_rtx_REG (mode, 9);
|
||
break;
|
||
default:
|
||
result = NULL_RTX;
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
|
||
/* Return the number of bytes which must be put into registers
|
||
for values which are part in registers and part in memory. */
|
||
|
||
static int
|
||
v850_arg_partial_bytes (CUMULATIVE_ARGS * cum, enum machine_mode mode,
|
||
tree type, bool named)
|
||
{
|
||
int size, align;
|
||
|
||
if (TARGET_GHS && !named)
|
||
return 0;
|
||
|
||
if (mode == BLKmode)
|
||
size = int_size_in_bytes (type);
|
||
else
|
||
size = GET_MODE_SIZE (mode);
|
||
|
||
if (size < 1)
|
||
size = 1;
|
||
|
||
if (type)
|
||
align = TYPE_ALIGN (type) / BITS_PER_UNIT;
|
||
else
|
||
align = size;
|
||
|
||
cum->nbytes = (cum->nbytes + align - 1) & ~ (align - 1);
|
||
|
||
if (cum->nbytes > 4 * UNITS_PER_WORD)
|
||
return 0;
|
||
|
||
if (cum->nbytes + size <= 4 * UNITS_PER_WORD)
|
||
return 0;
|
||
|
||
if (type == NULL_TREE
|
||
&& cum->nbytes + size > 4 * UNITS_PER_WORD)
|
||
return 0;
|
||
|
||
return 4 * UNITS_PER_WORD - cum->nbytes;
|
||
}
|
||
|
||
|
||
/* Return the high and low words of a CONST_DOUBLE */
|
||
|
||
static void
|
||
const_double_split (rtx x, HOST_WIDE_INT * p_high, HOST_WIDE_INT * p_low)
|
||
{
|
||
if (GET_CODE (x) == CONST_DOUBLE)
|
||
{
|
||
long t[2];
|
||
REAL_VALUE_TYPE rv;
|
||
|
||
switch (GET_MODE (x))
|
||
{
|
||
case DFmode:
|
||
REAL_VALUE_FROM_CONST_DOUBLE (rv, x);
|
||
REAL_VALUE_TO_TARGET_DOUBLE (rv, t);
|
||
*p_high = t[1]; /* since v850 is little endian */
|
||
*p_low = t[0]; /* high is second word */
|
||
return;
|
||
|
||
case SFmode:
|
||
REAL_VALUE_FROM_CONST_DOUBLE (rv, x);
|
||
REAL_VALUE_TO_TARGET_SINGLE (rv, *p_high);
|
||
*p_low = 0;
|
||
return;
|
||
|
||
case VOIDmode:
|
||
case DImode:
|
||
*p_high = CONST_DOUBLE_HIGH (x);
|
||
*p_low = CONST_DOUBLE_LOW (x);
|
||
return;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
fatal_insn ("const_double_split got a bad insn:", x);
|
||
}
|
||
|
||
|
||
/* Return the cost of the rtx R with code CODE. */
|
||
|
||
static int
|
||
const_costs_int (HOST_WIDE_INT value, int zero_cost)
|
||
{
|
||
if (CONST_OK_FOR_I (value))
|
||
return zero_cost;
|
||
else if (CONST_OK_FOR_J (value))
|
||
return 1;
|
||
else if (CONST_OK_FOR_K (value))
|
||
return 2;
|
||
else
|
||
return 4;
|
||
}
|
||
|
||
static int
|
||
const_costs (rtx r, enum rtx_code c)
|
||
{
|
||
HOST_WIDE_INT high, low;
|
||
|
||
switch (c)
|
||
{
|
||
case CONST_INT:
|
||
return const_costs_int (INTVAL (r), 0);
|
||
|
||
case CONST_DOUBLE:
|
||
const_double_split (r, &high, &low);
|
||
if (GET_MODE (r) == SFmode)
|
||
return const_costs_int (high, 1);
|
||
else
|
||
return const_costs_int (high, 1) + const_costs_int (low, 1);
|
||
|
||
case SYMBOL_REF:
|
||
case LABEL_REF:
|
||
case CONST:
|
||
return 2;
|
||
|
||
case HIGH:
|
||
return 1;
|
||
|
||
default:
|
||
return 4;
|
||
}
|
||
}
|
||
|
||
static bool
|
||
v850_rtx_costs (rtx x,
|
||
int codearg,
|
||
int outer_code ATTRIBUTE_UNUSED,
|
||
int * total, bool speed)
|
||
{
|
||
enum rtx_code code = (enum rtx_code) codearg;
|
||
|
||
switch (code)
|
||
{
|
||
case CONST_INT:
|
||
case CONST_DOUBLE:
|
||
case CONST:
|
||
case SYMBOL_REF:
|
||
case LABEL_REF:
|
||
*total = COSTS_N_INSNS (const_costs (x, code));
|
||
return true;
|
||
|
||
case MOD:
|
||
case DIV:
|
||
case UMOD:
|
||
case UDIV:
|
||
if (TARGET_V850E && !speed)
|
||
*total = 6;
|
||
else
|
||
*total = 60;
|
||
return true;
|
||
|
||
case MULT:
|
||
if (TARGET_V850E
|
||
&& ( GET_MODE (x) == SImode
|
||
|| GET_MODE (x) == HImode
|
||
|| GET_MODE (x) == QImode))
|
||
{
|
||
if (GET_CODE (XEXP (x, 1)) == REG)
|
||
*total = 4;
|
||
else if (GET_CODE (XEXP (x, 1)) == CONST_INT)
|
||
{
|
||
if (CONST_OK_FOR_O (INTVAL (XEXP (x, 1))))
|
||
*total = 6;
|
||
else if (CONST_OK_FOR_K (INTVAL (XEXP (x, 1))))
|
||
*total = 10;
|
||
}
|
||
}
|
||
else
|
||
*total = 20;
|
||
return true;
|
||
|
||
case ZERO_EXTRACT:
|
||
if (outer_code == COMPARE)
|
||
*total = 0;
|
||
return false;
|
||
|
||
default:
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/* Print operand X using operand code CODE to assembly language output file
|
||
FILE. */
|
||
|
||
void
|
||
print_operand (FILE * file, rtx x, int code)
|
||
{
|
||
HOST_WIDE_INT high, low;
|
||
|
||
switch (code)
|
||
{
|
||
case 'c':
|
||
/* We use 'c' operands with symbols for .vtinherit */
|
||
if (GET_CODE (x) == SYMBOL_REF)
|
||
{
|
||
output_addr_const(file, x);
|
||
break;
|
||
}
|
||
/* fall through */
|
||
case 'b':
|
||
case 'B':
|
||
case 'C':
|
||
switch ((code == 'B' || code == 'C')
|
||
? reverse_condition (GET_CODE (x)) : GET_CODE (x))
|
||
{
|
||
case NE:
|
||
if (code == 'c' || code == 'C')
|
||
fprintf (file, "nz");
|
||
else
|
||
fprintf (file, "ne");
|
||
break;
|
||
case EQ:
|
||
if (code == 'c' || code == 'C')
|
||
fprintf (file, "z");
|
||
else
|
||
fprintf (file, "e");
|
||
break;
|
||
case GE:
|
||
fprintf (file, "ge");
|
||
break;
|
||
case GT:
|
||
fprintf (file, "gt");
|
||
break;
|
||
case LE:
|
||
fprintf (file, "le");
|
||
break;
|
||
case LT:
|
||
fprintf (file, "lt");
|
||
break;
|
||
case GEU:
|
||
fprintf (file, "nl");
|
||
break;
|
||
case GTU:
|
||
fprintf (file, "h");
|
||
break;
|
||
case LEU:
|
||
fprintf (file, "nh");
|
||
break;
|
||
case LTU:
|
||
fprintf (file, "l");
|
||
break;
|
||
default:
|
||
gcc_unreachable ();
|
||
}
|
||
break;
|
||
case 'F': /* high word of CONST_DOUBLE */
|
||
switch (GET_CODE (x))
|
||
{
|
||
case CONST_INT:
|
||
fprintf (file, "%d", (INTVAL (x) >= 0) ? 0 : -1);
|
||
break;
|
||
|
||
case CONST_DOUBLE:
|
||
const_double_split (x, &high, &low);
|
||
fprintf (file, "%ld", (long) high);
|
||
break;
|
||
|
||
default:
|
||
gcc_unreachable ();
|
||
}
|
||
break;
|
||
case 'G': /* low word of CONST_DOUBLE */
|
||
switch (GET_CODE (x))
|
||
{
|
||
case CONST_INT:
|
||
fprintf (file, "%ld", (long) INTVAL (x));
|
||
break;
|
||
|
||
case CONST_DOUBLE:
|
||
const_double_split (x, &high, &low);
|
||
fprintf (file, "%ld", (long) low);
|
||
break;
|
||
|
||
default:
|
||
gcc_unreachable ();
|
||
}
|
||
break;
|
||
case 'L':
|
||
fprintf (file, "%d\n", (int)(INTVAL (x) & 0xffff));
|
||
break;
|
||
case 'M':
|
||
fprintf (file, "%d", exact_log2 (INTVAL (x)));
|
||
break;
|
||
case 'O':
|
||
gcc_assert (special_symbolref_operand (x, VOIDmode));
|
||
|
||
if (GET_CODE (x) == CONST)
|
||
x = XEXP (XEXP (x, 0), 0);
|
||
else
|
||
gcc_assert (GET_CODE (x) == SYMBOL_REF);
|
||
|
||
if (SYMBOL_REF_ZDA_P (x))
|
||
fprintf (file, "zdaoff");
|
||
else if (SYMBOL_REF_SDA_P (x))
|
||
fprintf (file, "sdaoff");
|
||
else if (SYMBOL_REF_TDA_P (x))
|
||
fprintf (file, "tdaoff");
|
||
else
|
||
gcc_unreachable ();
|
||
break;
|
||
case 'P':
|
||
gcc_assert (special_symbolref_operand (x, VOIDmode));
|
||
output_addr_const (file, x);
|
||
break;
|
||
case 'Q':
|
||
gcc_assert (special_symbolref_operand (x, VOIDmode));
|
||
|
||
if (GET_CODE (x) == CONST)
|
||
x = XEXP (XEXP (x, 0), 0);
|
||
else
|
||
gcc_assert (GET_CODE (x) == SYMBOL_REF);
|
||
|
||
if (SYMBOL_REF_ZDA_P (x))
|
||
fprintf (file, "r0");
|
||
else if (SYMBOL_REF_SDA_P (x))
|
||
fprintf (file, "gp");
|
||
else if (SYMBOL_REF_TDA_P (x))
|
||
fprintf (file, "ep");
|
||
else
|
||
gcc_unreachable ();
|
||
break;
|
||
case 'R': /* 2nd word of a double. */
|
||
switch (GET_CODE (x))
|
||
{
|
||
case REG:
|
||
fprintf (file, reg_names[REGNO (x) + 1]);
|
||
break;
|
||
case MEM:
|
||
x = XEXP (adjust_address (x, SImode, 4), 0);
|
||
print_operand_address (file, x);
|
||
if (GET_CODE (x) == CONST_INT)
|
||
fprintf (file, "[r0]");
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
break;
|
||
case 'S':
|
||
{
|
||
/* If it's a reference to a TDA variable, use sst/sld vs. st/ld. */
|
||
if (GET_CODE (x) == MEM && ep_memory_operand (x, GET_MODE (x), FALSE))
|
||
fputs ("s", file);
|
||
|
||
break;
|
||
}
|
||
case 'T':
|
||
{
|
||
/* Like an 'S' operand above, but for unsigned loads only. */
|
||
if (GET_CODE (x) == MEM && ep_memory_operand (x, GET_MODE (x), TRUE))
|
||
fputs ("s", file);
|
||
|
||
break;
|
||
}
|
||
case 'W': /* print the instruction suffix */
|
||
switch (GET_MODE (x))
|
||
{
|
||
default:
|
||
gcc_unreachable ();
|
||
|
||
case QImode: fputs (".b", file); break;
|
||
case HImode: fputs (".h", file); break;
|
||
case SImode: fputs (".w", file); break;
|
||
case SFmode: fputs (".w", file); break;
|
||
}
|
||
break;
|
||
case '.': /* register r0 */
|
||
fputs (reg_names[0], file);
|
||
break;
|
||
case 'z': /* reg or zero */
|
||
if (GET_CODE (x) == REG)
|
||
fputs (reg_names[REGNO (x)], file);
|
||
else
|
||
{
|
||
gcc_assert (x == const0_rtx);
|
||
fputs (reg_names[0], file);
|
||
}
|
||
break;
|
||
default:
|
||
switch (GET_CODE (x))
|
||
{
|
||
case MEM:
|
||
if (GET_CODE (XEXP (x, 0)) == CONST_INT)
|
||
output_address (gen_rtx_PLUS (SImode, gen_rtx_REG (SImode, 0),
|
||
XEXP (x, 0)));
|
||
else
|
||
output_address (XEXP (x, 0));
|
||
break;
|
||
|
||
case REG:
|
||
fputs (reg_names[REGNO (x)], file);
|
||
break;
|
||
case SUBREG:
|
||
fputs (reg_names[subreg_regno (x)], file);
|
||
break;
|
||
case CONST_INT:
|
||
case SYMBOL_REF:
|
||
case CONST:
|
||
case LABEL_REF:
|
||
case CODE_LABEL:
|
||
print_operand_address (file, x);
|
||
break;
|
||
default:
|
||
gcc_unreachable ();
|
||
}
|
||
break;
|
||
|
||
}
|
||
}
|
||
|
||
|
||
/* Output assembly language output for the address ADDR to FILE. */
|
||
|
||
void
|
||
print_operand_address (FILE * file, rtx addr)
|
||
{
|
||
switch (GET_CODE (addr))
|
||
{
|
||
case REG:
|
||
fprintf (file, "0[");
|
||
print_operand (file, addr, 0);
|
||
fprintf (file, "]");
|
||
break;
|
||
case LO_SUM:
|
||
if (GET_CODE (XEXP (addr, 0)) == REG)
|
||
{
|
||
/* reg,foo */
|
||
fprintf (file, "lo(");
|
||
print_operand (file, XEXP (addr, 1), 0);
|
||
fprintf (file, ")[");
|
||
print_operand (file, XEXP (addr, 0), 0);
|
||
fprintf (file, "]");
|
||
}
|
||
break;
|
||
case PLUS:
|
||
if (GET_CODE (XEXP (addr, 0)) == REG
|
||
|| GET_CODE (XEXP (addr, 0)) == SUBREG)
|
||
{
|
||
/* reg,foo */
|
||
print_operand (file, XEXP (addr, 1), 0);
|
||
fprintf (file, "[");
|
||
print_operand (file, XEXP (addr, 0), 0);
|
||
fprintf (file, "]");
|
||
}
|
||
else
|
||
{
|
||
print_operand (file, XEXP (addr, 0), 0);
|
||
fprintf (file, "+");
|
||
print_operand (file, XEXP (addr, 1), 0);
|
||
}
|
||
break;
|
||
case SYMBOL_REF:
|
||
{
|
||
const char *off_name = NULL;
|
||
const char *reg_name = NULL;
|
||
|
||
if (SYMBOL_REF_ZDA_P (addr))
|
||
{
|
||
off_name = "zdaoff";
|
||
reg_name = "r0";
|
||
}
|
||
else if (SYMBOL_REF_SDA_P (addr))
|
||
{
|
||
off_name = "sdaoff";
|
||
reg_name = "gp";
|
||
}
|
||
else if (SYMBOL_REF_TDA_P (addr))
|
||
{
|
||
off_name = "tdaoff";
|
||
reg_name = "ep";
|
||
}
|
||
|
||
if (off_name)
|
||
fprintf (file, "%s(", off_name);
|
||
output_addr_const (file, addr);
|
||
if (reg_name)
|
||
fprintf (file, ")[%s]", reg_name);
|
||
}
|
||
break;
|
||
case CONST:
|
||
if (special_symbolref_operand (addr, VOIDmode))
|
||
{
|
||
rtx x = XEXP (XEXP (addr, 0), 0);
|
||
const char *off_name;
|
||
const char *reg_name;
|
||
|
||
if (SYMBOL_REF_ZDA_P (x))
|
||
{
|
||
off_name = "zdaoff";
|
||
reg_name = "r0";
|
||
}
|
||
else if (SYMBOL_REF_SDA_P (x))
|
||
{
|
||
off_name = "sdaoff";
|
||
reg_name = "gp";
|
||
}
|
||
else if (SYMBOL_REF_TDA_P (x))
|
||
{
|
||
off_name = "tdaoff";
|
||
reg_name = "ep";
|
||
}
|
||
else
|
||
gcc_unreachable ();
|
||
|
||
fprintf (file, "%s(", off_name);
|
||
output_addr_const (file, addr);
|
||
fprintf (file, ")[%s]", reg_name);
|
||
}
|
||
else
|
||
output_addr_const (file, addr);
|
||
break;
|
||
default:
|
||
output_addr_const (file, addr);
|
||
break;
|
||
}
|
||
}
|
||
|
||
/* When assemble_integer is used to emit the offsets for a switch
|
||
table it can encounter (TRUNCATE:HI (MINUS:SI (LABEL_REF:SI) (LABEL_REF:SI))).
|
||
output_addr_const will normally barf at this, but it is OK to omit
|
||
the truncate and just emit the difference of the two labels. The
|
||
.hword directive will automatically handle the truncation for us.
|
||
|
||
Returns 1 if rtx was handled, 0 otherwise. */
|
||
|
||
int
|
||
v850_output_addr_const_extra (FILE * file, rtx x)
|
||
{
|
||
if (GET_CODE (x) != TRUNCATE)
|
||
return 0;
|
||
|
||
x = XEXP (x, 0);
|
||
|
||
/* We must also handle the case where the switch table was passed a
|
||
constant value and so has been collapsed. In this case the first
|
||
label will have been deleted. In such a case it is OK to emit
|
||
nothing, since the table will not be used.
|
||
(cf gcc.c-torture/compile/990801-1.c). */
|
||
if (GET_CODE (x) == MINUS
|
||
&& GET_CODE (XEXP (x, 0)) == LABEL_REF
|
||
&& GET_CODE (XEXP (XEXP (x, 0), 0)) == CODE_LABEL
|
||
&& INSN_DELETED_P (XEXP (XEXP (x, 0), 0)))
|
||
return 1;
|
||
|
||
output_addr_const (file, x);
|
||
return 1;
|
||
}
|
||
|
||
/* Return appropriate code to load up a 1, 2, or 4 integer/floating
|
||
point value. */
|
||
|
||
const char *
|
||
output_move_single (rtx * operands)
|
||
{
|
||
rtx dst = operands[0];
|
||
rtx src = operands[1];
|
||
|
||
if (REG_P (dst))
|
||
{
|
||
if (REG_P (src))
|
||
return "mov %1,%0";
|
||
|
||
else if (GET_CODE (src) == CONST_INT)
|
||
{
|
||
HOST_WIDE_INT value = INTVAL (src);
|
||
|
||
if (CONST_OK_FOR_J (value)) /* Signed 5-bit immediate. */
|
||
return "mov %1,%0";
|
||
|
||
else if (CONST_OK_FOR_K (value)) /* Signed 16-bit immediate. */
|
||
return "movea lo(%1),%.,%0";
|
||
|
||
else if (CONST_OK_FOR_L (value)) /* Upper 16 bits were set. */
|
||
return "movhi hi(%1),%.,%0";
|
||
|
||
/* A random constant. */
|
||
else if (TARGET_V850E)
|
||
return "mov %1,%0";
|
||
else
|
||
return "movhi hi(%1),%.,%0\n\tmovea lo(%1),%0,%0";
|
||
}
|
||
|
||
else if (GET_CODE (src) == CONST_DOUBLE && GET_MODE (src) == SFmode)
|
||
{
|
||
HOST_WIDE_INT high, low;
|
||
|
||
const_double_split (src, &high, &low);
|
||
|
||
if (CONST_OK_FOR_J (high)) /* Signed 5-bit immediate. */
|
||
return "mov %F1,%0";
|
||
|
||
else if (CONST_OK_FOR_K (high)) /* Signed 16-bit immediate. */
|
||
return "movea lo(%F1),%.,%0";
|
||
|
||
else if (CONST_OK_FOR_L (high)) /* Upper 16 bits were set. */
|
||
return "movhi hi(%F1),%.,%0";
|
||
|
||
/* A random constant. */
|
||
else if (TARGET_V850E)
|
||
return "mov %F1,%0";
|
||
|
||
else
|
||
return "movhi hi(%F1),%.,%0\n\tmovea lo(%F1),%0,%0";
|
||
}
|
||
|
||
else if (GET_CODE (src) == MEM)
|
||
return "%S1ld%W1 %1,%0";
|
||
|
||
else if (special_symbolref_operand (src, VOIDmode))
|
||
return "movea %O1(%P1),%Q1,%0";
|
||
|
||
else if (GET_CODE (src) == LABEL_REF
|
||
|| GET_CODE (src) == SYMBOL_REF
|
||
|| GET_CODE (src) == CONST)
|
||
{
|
||
if (TARGET_V850E)
|
||
return "mov hilo(%1),%0";
|
||
else
|
||
return "movhi hi(%1),%.,%0\n\tmovea lo(%1),%0,%0";
|
||
}
|
||
|
||
else if (GET_CODE (src) == HIGH)
|
||
return "movhi hi(%1),%.,%0";
|
||
|
||
else if (GET_CODE (src) == LO_SUM)
|
||
{
|
||
operands[2] = XEXP (src, 0);
|
||
operands[3] = XEXP (src, 1);
|
||
return "movea lo(%3),%2,%0";
|
||
}
|
||
}
|
||
|
||
else if (GET_CODE (dst) == MEM)
|
||
{
|
||
if (REG_P (src))
|
||
return "%S0st%W0 %1,%0";
|
||
|
||
else if (GET_CODE (src) == CONST_INT && INTVAL (src) == 0)
|
||
return "%S0st%W0 %.,%0";
|
||
|
||
else if (GET_CODE (src) == CONST_DOUBLE
|
||
&& CONST0_RTX (GET_MODE (dst)) == src)
|
||
return "%S0st%W0 %.,%0";
|
||
}
|
||
|
||
fatal_insn ("output_move_single:", gen_rtx_SET (VOIDmode, dst, src));
|
||
return "";
|
||
}
|
||
|
||
|
||
/* Return maximum offset supported for a short EP memory reference of mode
|
||
MODE and signedness UNSIGNEDP. */
|
||
|
||
static int
|
||
ep_memory_offset (enum machine_mode mode, int unsignedp ATTRIBUTE_UNUSED)
|
||
{
|
||
int max_offset = 0;
|
||
|
||
switch (mode)
|
||
{
|
||
case QImode:
|
||
if (TARGET_SMALL_SLD)
|
||
max_offset = (1 << 4);
|
||
else if (TARGET_V850E
|
||
&& ( ( unsignedp && ! TARGET_US_BIT_SET)
|
||
|| (! unsignedp && TARGET_US_BIT_SET)))
|
||
max_offset = (1 << 4);
|
||
else
|
||
max_offset = (1 << 7);
|
||
break;
|
||
|
||
case HImode:
|
||
if (TARGET_SMALL_SLD)
|
||
max_offset = (1 << 5);
|
||
else if (TARGET_V850E
|
||
&& ( ( unsignedp && ! TARGET_US_BIT_SET)
|
||
|| (! unsignedp && TARGET_US_BIT_SET)))
|
||
max_offset = (1 << 5);
|
||
else
|
||
max_offset = (1 << 8);
|
||
break;
|
||
|
||
case SImode:
|
||
case SFmode:
|
||
max_offset = (1 << 8);
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
|
||
return max_offset;
|
||
}
|
||
|
||
/* Return true if OP is a valid short EP memory reference */
|
||
|
||
int
|
||
ep_memory_operand (rtx op, enum machine_mode mode, int unsigned_load)
|
||
{
|
||
rtx addr, op0, op1;
|
||
int max_offset;
|
||
int mask;
|
||
|
||
/* If we are not using the EP register on a per-function basis
|
||
then do not allow this optimization at all. This is to
|
||
prevent the use of the SLD/SST instructions which cannot be
|
||
guaranteed to work properly due to a hardware bug. */
|
||
if (!TARGET_EP)
|
||
return FALSE;
|
||
|
||
if (GET_CODE (op) != MEM)
|
||
return FALSE;
|
||
|
||
max_offset = ep_memory_offset (mode, unsigned_load);
|
||
|
||
mask = GET_MODE_SIZE (mode) - 1;
|
||
|
||
addr = XEXP (op, 0);
|
||
if (GET_CODE (addr) == CONST)
|
||
addr = XEXP (addr, 0);
|
||
|
||
switch (GET_CODE (addr))
|
||
{
|
||
default:
|
||
break;
|
||
|
||
case SYMBOL_REF:
|
||
return SYMBOL_REF_TDA_P (addr);
|
||
|
||
case REG:
|
||
return REGNO (addr) == EP_REGNUM;
|
||
|
||
case PLUS:
|
||
op0 = XEXP (addr, 0);
|
||
op1 = XEXP (addr, 1);
|
||
if (GET_CODE (op1) == CONST_INT
|
||
&& INTVAL (op1) < max_offset
|
||
&& INTVAL (op1) >= 0
|
||
&& (INTVAL (op1) & mask) == 0)
|
||
{
|
||
if (GET_CODE (op0) == REG && REGNO (op0) == EP_REGNUM)
|
||
return TRUE;
|
||
|
||
if (GET_CODE (op0) == SYMBOL_REF && SYMBOL_REF_TDA_P (op0))
|
||
return TRUE;
|
||
}
|
||
break;
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
/* Substitute memory references involving a pointer, to use the ep pointer,
|
||
taking care to save and preserve the ep. */
|
||
|
||
static void
|
||
substitute_ep_register (rtx first_insn,
|
||
rtx last_insn,
|
||
int uses,
|
||
int regno,
|
||
rtx * p_r1,
|
||
rtx * p_ep)
|
||
{
|
||
rtx reg = gen_rtx_REG (Pmode, regno);
|
||
rtx insn;
|
||
|
||
if (!*p_r1)
|
||
{
|
||
df_set_regs_ever_live (1, true);
|
||
*p_r1 = gen_rtx_REG (Pmode, 1);
|
||
*p_ep = gen_rtx_REG (Pmode, 30);
|
||
}
|
||
|
||
if (TARGET_DEBUG)
|
||
fprintf (stderr, "\
|
||
Saved %d bytes (%d uses of register %s) in function %s, starting as insn %d, ending at %d\n",
|
||
2 * (uses - 3), uses, reg_names[regno],
|
||
IDENTIFIER_POINTER (DECL_NAME (current_function_decl)),
|
||
INSN_UID (first_insn), INSN_UID (last_insn));
|
||
|
||
if (GET_CODE (first_insn) == NOTE)
|
||
first_insn = next_nonnote_insn (first_insn);
|
||
|
||
last_insn = next_nonnote_insn (last_insn);
|
||
for (insn = first_insn; insn && insn != last_insn; insn = NEXT_INSN (insn))
|
||
{
|
||
if (GET_CODE (insn) == INSN)
|
||
{
|
||
rtx pattern = single_set (insn);
|
||
|
||
/* Replace the memory references. */
|
||
if (pattern)
|
||
{
|
||
rtx *p_mem;
|
||
/* Memory operands are signed by default. */
|
||
int unsignedp = FALSE;
|
||
|
||
if (GET_CODE (SET_DEST (pattern)) == MEM
|
||
&& GET_CODE (SET_SRC (pattern)) == MEM)
|
||
p_mem = (rtx *)0;
|
||
|
||
else if (GET_CODE (SET_DEST (pattern)) == MEM)
|
||
p_mem = &SET_DEST (pattern);
|
||
|
||
else if (GET_CODE (SET_SRC (pattern)) == MEM)
|
||
p_mem = &SET_SRC (pattern);
|
||
|
||
else if (GET_CODE (SET_SRC (pattern)) == SIGN_EXTEND
|
||
&& GET_CODE (XEXP (SET_SRC (pattern), 0)) == MEM)
|
||
p_mem = &XEXP (SET_SRC (pattern), 0);
|
||
|
||
else if (GET_CODE (SET_SRC (pattern)) == ZERO_EXTEND
|
||
&& GET_CODE (XEXP (SET_SRC (pattern), 0)) == MEM)
|
||
{
|
||
p_mem = &XEXP (SET_SRC (pattern), 0);
|
||
unsignedp = TRUE;
|
||
}
|
||
else
|
||
p_mem = (rtx *)0;
|
||
|
||
if (p_mem)
|
||
{
|
||
rtx addr = XEXP (*p_mem, 0);
|
||
|
||
if (GET_CODE (addr) == REG && REGNO (addr) == (unsigned) regno)
|
||
*p_mem = change_address (*p_mem, VOIDmode, *p_ep);
|
||
|
||
else if (GET_CODE (addr) == PLUS
|
||
&& GET_CODE (XEXP (addr, 0)) == REG
|
||
&& REGNO (XEXP (addr, 0)) == (unsigned) regno
|
||
&& GET_CODE (XEXP (addr, 1)) == CONST_INT
|
||
&& ((INTVAL (XEXP (addr, 1)))
|
||
< ep_memory_offset (GET_MODE (*p_mem),
|
||
unsignedp))
|
||
&& ((INTVAL (XEXP (addr, 1))) >= 0))
|
||
*p_mem = change_address (*p_mem, VOIDmode,
|
||
gen_rtx_PLUS (Pmode,
|
||
*p_ep,
|
||
XEXP (addr, 1)));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/* Optimize back to back cases of ep <- r1 & r1 <- ep. */
|
||
insn = prev_nonnote_insn (first_insn);
|
||
if (insn && GET_CODE (insn) == INSN
|
||
&& GET_CODE (PATTERN (insn)) == SET
|
||
&& SET_DEST (PATTERN (insn)) == *p_ep
|
||
&& SET_SRC (PATTERN (insn)) == *p_r1)
|
||
delete_insn (insn);
|
||
else
|
||
emit_insn_before (gen_rtx_SET (Pmode, *p_r1, *p_ep), first_insn);
|
||
|
||
emit_insn_before (gen_rtx_SET (Pmode, *p_ep, reg), first_insn);
|
||
emit_insn_before (gen_rtx_SET (Pmode, *p_ep, *p_r1), last_insn);
|
||
}
|
||
|
||
|
||
/* TARGET_MACHINE_DEPENDENT_REORG. On the 850, we use it to implement
|
||
the -mep mode to copy heavily used pointers to ep to use the implicit
|
||
addressing. */
|
||
|
||
static void
|
||
v850_reorg (void)
|
||
{
|
||
struct
|
||
{
|
||
int uses;
|
||
rtx first_insn;
|
||
rtx last_insn;
|
||
}
|
||
regs[FIRST_PSEUDO_REGISTER];
|
||
|
||
int i;
|
||
int use_ep = FALSE;
|
||
rtx r1 = NULL_RTX;
|
||
rtx ep = NULL_RTX;
|
||
rtx insn;
|
||
rtx pattern;
|
||
|
||
/* If not ep mode, just return now. */
|
||
if (!TARGET_EP)
|
||
return;
|
||
|
||
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
|
||
{
|
||
regs[i].uses = 0;
|
||
regs[i].first_insn = NULL_RTX;
|
||
regs[i].last_insn = NULL_RTX;
|
||
}
|
||
|
||
for (insn = get_insns (); insn != NULL_RTX; insn = NEXT_INSN (insn))
|
||
{
|
||
switch (GET_CODE (insn))
|
||
{
|
||
/* End of basic block */
|
||
default:
|
||
if (!use_ep)
|
||
{
|
||
int max_uses = -1;
|
||
int max_regno = -1;
|
||
|
||
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
|
||
{
|
||
if (max_uses < regs[i].uses)
|
||
{
|
||
max_uses = regs[i].uses;
|
||
max_regno = i;
|
||
}
|
||
}
|
||
|
||
if (max_uses > 3)
|
||
substitute_ep_register (regs[max_regno].first_insn,
|
||
regs[max_regno].last_insn,
|
||
max_uses, max_regno, &r1, &ep);
|
||
}
|
||
|
||
use_ep = FALSE;
|
||
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
|
||
{
|
||
regs[i].uses = 0;
|
||
regs[i].first_insn = NULL_RTX;
|
||
regs[i].last_insn = NULL_RTX;
|
||
}
|
||
break;
|
||
|
||
case NOTE:
|
||
break;
|
||
|
||
case INSN:
|
||
pattern = single_set (insn);
|
||
|
||
/* See if there are any memory references we can shorten */
|
||
if (pattern)
|
||
{
|
||
rtx src = SET_SRC (pattern);
|
||
rtx dest = SET_DEST (pattern);
|
||
rtx mem;
|
||
/* Memory operands are signed by default. */
|
||
int unsignedp = FALSE;
|
||
|
||
/* We might have (SUBREG (MEM)) here, so just get rid of the
|
||
subregs to make this code simpler. */
|
||
if (GET_CODE (dest) == SUBREG
|
||
&& (GET_CODE (SUBREG_REG (dest)) == MEM
|
||
|| GET_CODE (SUBREG_REG (dest)) == REG))
|
||
alter_subreg (&dest);
|
||
if (GET_CODE (src) == SUBREG
|
||
&& (GET_CODE (SUBREG_REG (src)) == MEM
|
||
|| GET_CODE (SUBREG_REG (src)) == REG))
|
||
alter_subreg (&src);
|
||
|
||
if (GET_CODE (dest) == MEM && GET_CODE (src) == MEM)
|
||
mem = NULL_RTX;
|
||
|
||
else if (GET_CODE (dest) == MEM)
|
||
mem = dest;
|
||
|
||
else if (GET_CODE (src) == MEM)
|
||
mem = src;
|
||
|
||
else if (GET_CODE (src) == SIGN_EXTEND
|
||
&& GET_CODE (XEXP (src, 0)) == MEM)
|
||
mem = XEXP (src, 0);
|
||
|
||
else if (GET_CODE (src) == ZERO_EXTEND
|
||
&& GET_CODE (XEXP (src, 0)) == MEM)
|
||
{
|
||
mem = XEXP (src, 0);
|
||
unsignedp = TRUE;
|
||
}
|
||
else
|
||
mem = NULL_RTX;
|
||
|
||
if (mem && ep_memory_operand (mem, GET_MODE (mem), unsignedp))
|
||
use_ep = TRUE;
|
||
|
||
else if (!use_ep && mem
|
||
&& GET_MODE_SIZE (GET_MODE (mem)) <= UNITS_PER_WORD)
|
||
{
|
||
rtx addr = XEXP (mem, 0);
|
||
int regno = -1;
|
||
int short_p;
|
||
|
||
if (GET_CODE (addr) == REG)
|
||
{
|
||
short_p = TRUE;
|
||
regno = REGNO (addr);
|
||
}
|
||
|
||
else if (GET_CODE (addr) == PLUS
|
||
&& GET_CODE (XEXP (addr, 0)) == REG
|
||
&& GET_CODE (XEXP (addr, 1)) == CONST_INT
|
||
&& ((INTVAL (XEXP (addr, 1)))
|
||
< ep_memory_offset (GET_MODE (mem), unsignedp))
|
||
&& ((INTVAL (XEXP (addr, 1))) >= 0))
|
||
{
|
||
short_p = TRUE;
|
||
regno = REGNO (XEXP (addr, 0));
|
||
}
|
||
|
||
else
|
||
short_p = FALSE;
|
||
|
||
if (short_p)
|
||
{
|
||
regs[regno].uses++;
|
||
regs[regno].last_insn = insn;
|
||
if (!regs[regno].first_insn)
|
||
regs[regno].first_insn = insn;
|
||
}
|
||
}
|
||
|
||
/* Loading up a register in the basic block zaps any savings
|
||
for the register */
|
||
if (GET_CODE (dest) == REG)
|
||
{
|
||
enum machine_mode mode = GET_MODE (dest);
|
||
int regno;
|
||
int endregno;
|
||
|
||
regno = REGNO (dest);
|
||
endregno = regno + HARD_REGNO_NREGS (regno, mode);
|
||
|
||
if (!use_ep)
|
||
{
|
||
/* See if we can use the pointer before this
|
||
modification. */
|
||
int max_uses = -1;
|
||
int max_regno = -1;
|
||
|
||
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
|
||
{
|
||
if (max_uses < regs[i].uses)
|
||
{
|
||
max_uses = regs[i].uses;
|
||
max_regno = i;
|
||
}
|
||
}
|
||
|
||
if (max_uses > 3
|
||
&& max_regno >= regno
|
||
&& max_regno < endregno)
|
||
{
|
||
substitute_ep_register (regs[max_regno].first_insn,
|
||
regs[max_regno].last_insn,
|
||
max_uses, max_regno, &r1,
|
||
&ep);
|
||
|
||
/* Since we made a substitution, zap all remembered
|
||
registers. */
|
||
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
|
||
{
|
||
regs[i].uses = 0;
|
||
regs[i].first_insn = NULL_RTX;
|
||
regs[i].last_insn = NULL_RTX;
|
||
}
|
||
}
|
||
}
|
||
|
||
for (i = regno; i < endregno; i++)
|
||
{
|
||
regs[i].uses = 0;
|
||
regs[i].first_insn = NULL_RTX;
|
||
regs[i].last_insn = NULL_RTX;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/* # of registers saved by the interrupt handler. */
|
||
#define INTERRUPT_FIXED_NUM 4
|
||
|
||
/* # of bytes for registers saved by the interrupt handler. */
|
||
#define INTERRUPT_FIXED_SAVE_SIZE (4 * INTERRUPT_FIXED_NUM)
|
||
|
||
/* # of registers saved in register parameter area. */
|
||
#define INTERRUPT_REGPARM_NUM 4
|
||
/* # of words saved for other registers. */
|
||
#define INTERRUPT_ALL_SAVE_NUM \
|
||
(30 - INTERRUPT_FIXED_NUM + INTERRUPT_REGPARM_NUM)
|
||
|
||
#define INTERRUPT_ALL_SAVE_SIZE (4 * INTERRUPT_ALL_SAVE_NUM)
|
||
|
||
int
|
||
compute_register_save_size (long * p_reg_saved)
|
||
{
|
||
int size = 0;
|
||
int i;
|
||
int interrupt_handler = v850_interrupt_function_p (current_function_decl);
|
||
int call_p = df_regs_ever_live_p (LINK_POINTER_REGNUM);
|
||
long reg_saved = 0;
|
||
|
||
/* Count the return pointer if we need to save it. */
|
||
if (crtl->profile && !call_p)
|
||
{
|
||
df_set_regs_ever_live (LINK_POINTER_REGNUM, true);
|
||
call_p = 1;
|
||
}
|
||
|
||
/* Count space for the register saves. */
|
||
if (interrupt_handler)
|
||
{
|
||
for (i = 0; i <= 31; i++)
|
||
switch (i)
|
||
{
|
||
default:
|
||
if (df_regs_ever_live_p (i) || call_p)
|
||
{
|
||
size += 4;
|
||
reg_saved |= 1L << i;
|
||
}
|
||
break;
|
||
|
||
/* We don't save/restore r0 or the stack pointer */
|
||
case 0:
|
||
case STACK_POINTER_REGNUM:
|
||
break;
|
||
|
||
/* For registers with fixed use, we save them, set them to the
|
||
appropriate value, and then restore them.
|
||
These registers are handled specially, so don't list them
|
||
on the list of registers to save in the prologue. */
|
||
case 1: /* temp used to hold ep */
|
||
case 4: /* gp */
|
||
case 10: /* temp used to call interrupt save/restore */
|
||
case EP_REGNUM: /* ep */
|
||
size += 4;
|
||
break;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
/* Find the first register that needs to be saved. */
|
||
for (i = 0; i <= 31; i++)
|
||
if (df_regs_ever_live_p (i) && ((! call_used_regs[i])
|
||
|| i == LINK_POINTER_REGNUM))
|
||
break;
|
||
|
||
/* If it is possible that an out-of-line helper function might be
|
||
used to generate the prologue for the current function, then we
|
||
need to cover the possibility that such a helper function will
|
||
be used, despite the fact that there might be gaps in the list of
|
||
registers that need to be saved. To detect this we note that the
|
||
helper functions always push at least register r29 (provided
|
||
that the function is not an interrupt handler). */
|
||
|
||
if (TARGET_PROLOG_FUNCTION
|
||
&& (i == 2 || ((i >= 20) && (i < 30))))
|
||
{
|
||
if (i == 2)
|
||
{
|
||
size += 4;
|
||
reg_saved |= 1L << i;
|
||
|
||
i = 20;
|
||
}
|
||
|
||
/* Helper functions save all registers between the starting
|
||
register and the last register, regardless of whether they
|
||
are actually used by the function or not. */
|
||
for (; i <= 29; i++)
|
||
{
|
||
size += 4;
|
||
reg_saved |= 1L << i;
|
||
}
|
||
|
||
if (df_regs_ever_live_p (LINK_POINTER_REGNUM))
|
||
{
|
||
size += 4;
|
||
reg_saved |= 1L << LINK_POINTER_REGNUM;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
for (; i <= 31; i++)
|
||
if (df_regs_ever_live_p (i) && ((! call_used_regs[i])
|
||
|| i == LINK_POINTER_REGNUM))
|
||
{
|
||
size += 4;
|
||
reg_saved |= 1L << i;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (p_reg_saved)
|
||
*p_reg_saved = reg_saved;
|
||
|
||
return size;
|
||
}
|
||
|
||
int
|
||
compute_frame_size (int size, long * p_reg_saved)
|
||
{
|
||
return (size
|
||
+ compute_register_save_size (p_reg_saved)
|
||
+ crtl->outgoing_args_size);
|
||
}
|
||
|
||
|
||
void
|
||
expand_prologue (void)
|
||
{
|
||
unsigned int i;
|
||
int offset;
|
||
unsigned int size = get_frame_size ();
|
||
unsigned int actual_fsize;
|
||
unsigned int init_stack_alloc = 0;
|
||
rtx save_regs[32];
|
||
rtx save_all;
|
||
unsigned int num_save;
|
||
unsigned int default_stack;
|
||
int code;
|
||
int interrupt_handler = v850_interrupt_function_p (current_function_decl);
|
||
long reg_saved = 0;
|
||
|
||
actual_fsize = compute_frame_size (size, ®_saved);
|
||
|
||
/* Save/setup global registers for interrupt functions right now. */
|
||
if (interrupt_handler)
|
||
{
|
||
if (TARGET_V850E && ! TARGET_DISABLE_CALLT)
|
||
emit_insn (gen_callt_save_interrupt ());
|
||
else
|
||
emit_insn (gen_save_interrupt ());
|
||
|
||
actual_fsize -= INTERRUPT_FIXED_SAVE_SIZE;
|
||
|
||
if (((1L << LINK_POINTER_REGNUM) & reg_saved) != 0)
|
||
actual_fsize -= INTERRUPT_ALL_SAVE_SIZE;
|
||
}
|
||
|
||
/* Save arg registers to the stack if necessary. */
|
||
else if (crtl->args.info.anonymous_args)
|
||
{
|
||
if (TARGET_PROLOG_FUNCTION && TARGET_V850E && !TARGET_DISABLE_CALLT)
|
||
emit_insn (gen_save_r6_r9_v850e ());
|
||
else if (TARGET_PROLOG_FUNCTION && ! TARGET_LONG_CALLS)
|
||
emit_insn (gen_save_r6_r9 ());
|
||
else
|
||
{
|
||
offset = 0;
|
||
for (i = 6; i < 10; i++)
|
||
{
|
||
emit_move_insn (gen_rtx_MEM (SImode,
|
||
plus_constant (stack_pointer_rtx,
|
||
offset)),
|
||
gen_rtx_REG (SImode, i));
|
||
offset += 4;
|
||
}
|
||
}
|
||
}
|
||
|
||
/* Identify all of the saved registers. */
|
||
num_save = 0;
|
||
default_stack = 0;
|
||
for (i = 1; i < 31; i++)
|
||
{
|
||
if (((1L << i) & reg_saved) != 0)
|
||
save_regs[num_save++] = gen_rtx_REG (Pmode, i);
|
||
}
|
||
|
||
/* If the return pointer is saved, the helper functions also allocate
|
||
16 bytes of stack for arguments to be saved in. */
|
||
if (((1L << LINK_POINTER_REGNUM) & reg_saved) != 0)
|
||
{
|
||
save_regs[num_save++] = gen_rtx_REG (Pmode, LINK_POINTER_REGNUM);
|
||
default_stack = 16;
|
||
}
|
||
|
||
/* See if we have an insn that allocates stack space and saves the particular
|
||
registers we want to. */
|
||
save_all = NULL_RTX;
|
||
if (TARGET_PROLOG_FUNCTION && num_save > 0 && actual_fsize >= default_stack)
|
||
{
|
||
int alloc_stack = (4 * num_save) + default_stack;
|
||
int unalloc_stack = actual_fsize - alloc_stack;
|
||
int save_func_len = 4;
|
||
int save_normal_len;
|
||
|
||
if (unalloc_stack)
|
||
save_func_len += CONST_OK_FOR_J (unalloc_stack) ? 2 : 4;
|
||
|
||
/* see if we would have used ep to save the stack */
|
||
if (TARGET_EP && num_save > 3 && (unsigned)actual_fsize < 255)
|
||
save_normal_len = (3 * 2) + (2 * num_save);
|
||
else
|
||
save_normal_len = 4 * num_save;
|
||
|
||
save_normal_len += CONST_OK_FOR_J (actual_fsize) ? 2 : 4;
|
||
|
||
/* Don't bother checking if we don't actually save any space.
|
||
This happens for instance if one register is saved and additional
|
||
stack space is allocated. */
|
||
if (save_func_len < save_normal_len)
|
||
{
|
||
save_all = gen_rtx_PARALLEL
|
||
(VOIDmode,
|
||
rtvec_alloc (num_save + 1
|
||
+ (TARGET_V850 ? (TARGET_LONG_CALLS ? 2 : 1) : 0)));
|
||
|
||
XVECEXP (save_all, 0, 0)
|
||
= gen_rtx_SET (VOIDmode,
|
||
stack_pointer_rtx,
|
||
plus_constant (stack_pointer_rtx, -alloc_stack));
|
||
|
||
offset = - default_stack;
|
||
for (i = 0; i < num_save; i++)
|
||
{
|
||
XVECEXP (save_all, 0, i+1)
|
||
= gen_rtx_SET (VOIDmode,
|
||
gen_rtx_MEM (Pmode,
|
||
plus_constant (stack_pointer_rtx,
|
||
offset)),
|
||
save_regs[i]);
|
||
offset -= 4;
|
||
}
|
||
|
||
if (TARGET_V850)
|
||
{
|
||
XVECEXP (save_all, 0, num_save + 1)
|
||
= gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (Pmode, 10));
|
||
|
||
if (TARGET_LONG_CALLS)
|
||
XVECEXP (save_all, 0, num_save + 2)
|
||
= gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (Pmode, 11));
|
||
}
|
||
|
||
code = recog (save_all, NULL_RTX, NULL);
|
||
if (code >= 0)
|
||
{
|
||
rtx insn = emit_insn (save_all);
|
||
INSN_CODE (insn) = code;
|
||
actual_fsize -= alloc_stack;
|
||
|
||
if (TARGET_DEBUG)
|
||
fprintf (stderr, "\
|
||
Saved %d bytes via prologue function (%d vs. %d) for function %s\n",
|
||
save_normal_len - save_func_len,
|
||
save_normal_len, save_func_len,
|
||
IDENTIFIER_POINTER (DECL_NAME (current_function_decl)));
|
||
}
|
||
else
|
||
save_all = NULL_RTX;
|
||
}
|
||
}
|
||
|
||
/* If no prolog save function is available, store the registers the old
|
||
fashioned way (one by one). */
|
||
if (!save_all)
|
||
{
|
||
/* Special case interrupt functions that save all registers for a call. */
|
||
if (interrupt_handler && ((1L << LINK_POINTER_REGNUM) & reg_saved) != 0)
|
||
{
|
||
if (TARGET_V850E && ! TARGET_DISABLE_CALLT)
|
||
emit_insn (gen_callt_save_all_interrupt ());
|
||
else
|
||
emit_insn (gen_save_all_interrupt ());
|
||
}
|
||
else
|
||
{
|
||
/* If the stack is too big, allocate it in chunks so we can do the
|
||
register saves. We use the register save size so we use the ep
|
||
register. */
|
||
if (actual_fsize && !CONST_OK_FOR_K (-actual_fsize))
|
||
init_stack_alloc = compute_register_save_size (NULL);
|
||
else
|
||
init_stack_alloc = actual_fsize;
|
||
|
||
/* Save registers at the beginning of the stack frame. */
|
||
offset = init_stack_alloc - 4;
|
||
|
||
if (init_stack_alloc)
|
||
emit_insn (gen_addsi3 (stack_pointer_rtx,
|
||
stack_pointer_rtx,
|
||
GEN_INT (- (signed) init_stack_alloc)));
|
||
|
||
/* Save the return pointer first. */
|
||
if (num_save > 0 && REGNO (save_regs[num_save-1]) == LINK_POINTER_REGNUM)
|
||
{
|
||
emit_move_insn (gen_rtx_MEM (SImode,
|
||
plus_constant (stack_pointer_rtx,
|
||
offset)),
|
||
save_regs[--num_save]);
|
||
offset -= 4;
|
||
}
|
||
|
||
for (i = 0; i < num_save; i++)
|
||
{
|
||
emit_move_insn (gen_rtx_MEM (SImode,
|
||
plus_constant (stack_pointer_rtx,
|
||
offset)),
|
||
save_regs[i]);
|
||
offset -= 4;
|
||
}
|
||
}
|
||
}
|
||
|
||
/* Allocate the rest of the stack that was not allocated above (either it is
|
||
> 32K or we just called a function to save the registers and needed more
|
||
stack. */
|
||
if (actual_fsize > init_stack_alloc)
|
||
{
|
||
int diff = actual_fsize - init_stack_alloc;
|
||
if (CONST_OK_FOR_K (diff))
|
||
emit_insn (gen_addsi3 (stack_pointer_rtx,
|
||
stack_pointer_rtx,
|
||
GEN_INT (-diff)));
|
||
else
|
||
{
|
||
rtx reg = gen_rtx_REG (Pmode, 12);
|
||
emit_move_insn (reg, GEN_INT (-diff));
|
||
emit_insn (gen_addsi3 (stack_pointer_rtx, stack_pointer_rtx, reg));
|
||
}
|
||
}
|
||
|
||
/* If we need a frame pointer, set it up now. */
|
||
if (frame_pointer_needed)
|
||
emit_move_insn (hard_frame_pointer_rtx, stack_pointer_rtx);
|
||
}
|
||
|
||
|
||
void
|
||
expand_epilogue (void)
|
||
{
|
||
unsigned int i;
|
||
int offset;
|
||
unsigned int size = get_frame_size ();
|
||
long reg_saved = 0;
|
||
int actual_fsize = compute_frame_size (size, ®_saved);
|
||
unsigned int init_stack_free = 0;
|
||
rtx restore_regs[32];
|
||
rtx restore_all;
|
||
unsigned int num_restore;
|
||
unsigned int default_stack;
|
||
int code;
|
||
int interrupt_handler = v850_interrupt_function_p (current_function_decl);
|
||
|
||
/* Eliminate the initial stack stored by interrupt functions. */
|
||
if (interrupt_handler)
|
||
{
|
||
actual_fsize -= INTERRUPT_FIXED_SAVE_SIZE;
|
||
if (((1L << LINK_POINTER_REGNUM) & reg_saved) != 0)
|
||
actual_fsize -= INTERRUPT_ALL_SAVE_SIZE;
|
||
}
|
||
|
||
/* Cut off any dynamic stack created. */
|
||
if (frame_pointer_needed)
|
||
emit_move_insn (stack_pointer_rtx, hard_frame_pointer_rtx);
|
||
|
||
/* Identify all of the saved registers. */
|
||
num_restore = 0;
|
||
default_stack = 0;
|
||
for (i = 1; i < 31; i++)
|
||
{
|
||
if (((1L << i) & reg_saved) != 0)
|
||
restore_regs[num_restore++] = gen_rtx_REG (Pmode, i);
|
||
}
|
||
|
||
/* If the return pointer is saved, the helper functions also allocate
|
||
16 bytes of stack for arguments to be saved in. */
|
||
if (((1L << LINK_POINTER_REGNUM) & reg_saved) != 0)
|
||
{
|
||
restore_regs[num_restore++] = gen_rtx_REG (Pmode, LINK_POINTER_REGNUM);
|
||
default_stack = 16;
|
||
}
|
||
|
||
/* See if we have an insn that restores the particular registers we
|
||
want to. */
|
||
restore_all = NULL_RTX;
|
||
|
||
if (TARGET_PROLOG_FUNCTION
|
||
&& num_restore > 0
|
||
&& actual_fsize >= (signed) default_stack
|
||
&& !interrupt_handler)
|
||
{
|
||
int alloc_stack = (4 * num_restore) + default_stack;
|
||
int unalloc_stack = actual_fsize - alloc_stack;
|
||
int restore_func_len = 4;
|
||
int restore_normal_len;
|
||
|
||
if (unalloc_stack)
|
||
restore_func_len += CONST_OK_FOR_J (unalloc_stack) ? 2 : 4;
|
||
|
||
/* See if we would have used ep to restore the registers. */
|
||
if (TARGET_EP && num_restore > 3 && (unsigned)actual_fsize < 255)
|
||
restore_normal_len = (3 * 2) + (2 * num_restore);
|
||
else
|
||
restore_normal_len = 4 * num_restore;
|
||
|
||
restore_normal_len += (CONST_OK_FOR_J (actual_fsize) ? 2 : 4) + 2;
|
||
|
||
/* Don't bother checking if we don't actually save any space. */
|
||
if (restore_func_len < restore_normal_len)
|
||
{
|
||
restore_all = gen_rtx_PARALLEL (VOIDmode,
|
||
rtvec_alloc (num_restore + 2));
|
||
XVECEXP (restore_all, 0, 0) = gen_rtx_RETURN (VOIDmode);
|
||
XVECEXP (restore_all, 0, 1)
|
||
= gen_rtx_SET (VOIDmode, stack_pointer_rtx,
|
||
gen_rtx_PLUS (Pmode,
|
||
stack_pointer_rtx,
|
||
GEN_INT (alloc_stack)));
|
||
|
||
offset = alloc_stack - 4;
|
||
for (i = 0; i < num_restore; i++)
|
||
{
|
||
XVECEXP (restore_all, 0, i+2)
|
||
= gen_rtx_SET (VOIDmode,
|
||
restore_regs[i],
|
||
gen_rtx_MEM (Pmode,
|
||
plus_constant (stack_pointer_rtx,
|
||
offset)));
|
||
offset -= 4;
|
||
}
|
||
|
||
code = recog (restore_all, NULL_RTX, NULL);
|
||
|
||
if (code >= 0)
|
||
{
|
||
rtx insn;
|
||
|
||
actual_fsize -= alloc_stack;
|
||
if (actual_fsize)
|
||
{
|
||
if (CONST_OK_FOR_K (actual_fsize))
|
||
emit_insn (gen_addsi3 (stack_pointer_rtx,
|
||
stack_pointer_rtx,
|
||
GEN_INT (actual_fsize)));
|
||
else
|
||
{
|
||
rtx reg = gen_rtx_REG (Pmode, 12);
|
||
emit_move_insn (reg, GEN_INT (actual_fsize));
|
||
emit_insn (gen_addsi3 (stack_pointer_rtx,
|
||
stack_pointer_rtx,
|
||
reg));
|
||
}
|
||
}
|
||
|
||
insn = emit_jump_insn (restore_all);
|
||
INSN_CODE (insn) = code;
|
||
|
||
if (TARGET_DEBUG)
|
||
fprintf (stderr, "\
|
||
Saved %d bytes via epilogue function (%d vs. %d) in function %s\n",
|
||
restore_normal_len - restore_func_len,
|
||
restore_normal_len, restore_func_len,
|
||
IDENTIFIER_POINTER (DECL_NAME (current_function_decl)));
|
||
}
|
||
else
|
||
restore_all = NULL_RTX;
|
||
}
|
||
}
|
||
|
||
/* If no epilogue save function is available, restore the registers the
|
||
old fashioned way (one by one). */
|
||
if (!restore_all)
|
||
{
|
||
/* If the stack is large, we need to cut it down in 2 pieces. */
|
||
if (actual_fsize && !CONST_OK_FOR_K (-actual_fsize))
|
||
init_stack_free = 4 * num_restore;
|
||
else
|
||
init_stack_free = (signed) actual_fsize;
|
||
|
||
/* Deallocate the rest of the stack if it is > 32K. */
|
||
if ((unsigned int) actual_fsize > init_stack_free)
|
||
{
|
||
int diff;
|
||
|
||
diff = actual_fsize - ((interrupt_handler) ? 0 : init_stack_free);
|
||
|
||
if (CONST_OK_FOR_K (diff))
|
||
emit_insn (gen_addsi3 (stack_pointer_rtx,
|
||
stack_pointer_rtx,
|
||
GEN_INT (diff)));
|
||
else
|
||
{
|
||
rtx reg = gen_rtx_REG (Pmode, 12);
|
||
emit_move_insn (reg, GEN_INT (diff));
|
||
emit_insn (gen_addsi3 (stack_pointer_rtx,
|
||
stack_pointer_rtx,
|
||
reg));
|
||
}
|
||
}
|
||
|
||
/* Special case interrupt functions that save all registers
|
||
for a call. */
|
||
if (interrupt_handler && ((1L << LINK_POINTER_REGNUM) & reg_saved) != 0)
|
||
{
|
||
if (TARGET_V850E && ! TARGET_DISABLE_CALLT)
|
||
emit_insn (gen_callt_restore_all_interrupt ());
|
||
else
|
||
emit_insn (gen_restore_all_interrupt ());
|
||
}
|
||
else
|
||
{
|
||
/* Restore registers from the beginning of the stack frame. */
|
||
offset = init_stack_free - 4;
|
||
|
||
/* Restore the return pointer first. */
|
||
if (num_restore > 0
|
||
&& REGNO (restore_regs [num_restore - 1]) == LINK_POINTER_REGNUM)
|
||
{
|
||
emit_move_insn (restore_regs[--num_restore],
|
||
gen_rtx_MEM (SImode,
|
||
plus_constant (stack_pointer_rtx,
|
||
offset)));
|
||
offset -= 4;
|
||
}
|
||
|
||
for (i = 0; i < num_restore; i++)
|
||
{
|
||
emit_move_insn (restore_regs[i],
|
||
gen_rtx_MEM (SImode,
|
||
plus_constant (stack_pointer_rtx,
|
||
offset)));
|
||
|
||
emit_use (restore_regs[i]);
|
||
offset -= 4;
|
||
}
|
||
|
||
/* Cut back the remainder of the stack. */
|
||
if (init_stack_free)
|
||
emit_insn (gen_addsi3 (stack_pointer_rtx,
|
||
stack_pointer_rtx,
|
||
GEN_INT (init_stack_free)));
|
||
}
|
||
|
||
/* And return or use reti for interrupt handlers. */
|
||
if (interrupt_handler)
|
||
{
|
||
if (TARGET_V850E && ! TARGET_DISABLE_CALLT)
|
||
emit_insn (gen_callt_return_interrupt ());
|
||
else
|
||
emit_jump_insn (gen_return_interrupt ());
|
||
}
|
||
else if (actual_fsize)
|
||
emit_jump_insn (gen_return_internal ());
|
||
else
|
||
emit_jump_insn (gen_return_simple ());
|
||
}
|
||
|
||
v850_interrupt_cache_p = FALSE;
|
||
v850_interrupt_p = FALSE;
|
||
}
|
||
|
||
|
||
/* Update the condition code from the insn. */
|
||
|
||
void
|
||
notice_update_cc (rtx body, rtx insn)
|
||
{
|
||
switch (get_attr_cc (insn))
|
||
{
|
||
case CC_NONE:
|
||
/* Insn does not affect CC at all. */
|
||
break;
|
||
|
||
case CC_NONE_0HIT:
|
||
/* Insn does not change CC, but the 0'th operand has been changed. */
|
||
if (cc_status.value1 != 0
|
||
&& reg_overlap_mentioned_p (recog_data.operand[0], cc_status.value1))
|
||
cc_status.value1 = 0;
|
||
break;
|
||
|
||
case CC_SET_ZN:
|
||
/* Insn sets the Z,N flags of CC to recog_data.operand[0].
|
||
V,C is in an unusable state. */
|
||
CC_STATUS_INIT;
|
||
cc_status.flags |= CC_OVERFLOW_UNUSABLE | CC_NO_CARRY;
|
||
cc_status.value1 = recog_data.operand[0];
|
||
break;
|
||
|
||
case CC_SET_ZNV:
|
||
/* Insn sets the Z,N,V flags of CC to recog_data.operand[0].
|
||
C is in an unusable state. */
|
||
CC_STATUS_INIT;
|
||
cc_status.flags |= CC_NO_CARRY;
|
||
cc_status.value1 = recog_data.operand[0];
|
||
break;
|
||
|
||
case CC_COMPARE:
|
||
/* The insn is a compare instruction. */
|
||
CC_STATUS_INIT;
|
||
cc_status.value1 = SET_SRC (body);
|
||
break;
|
||
|
||
case CC_CLOBBER:
|
||
/* Insn doesn't leave CC in a usable state. */
|
||
CC_STATUS_INIT;
|
||
break;
|
||
}
|
||
}
|
||
|
||
/* Retrieve the data area that has been chosen for the given decl. */
|
||
|
||
v850_data_area
|
||
v850_get_data_area (tree decl)
|
||
{
|
||
if (lookup_attribute ("sda", DECL_ATTRIBUTES (decl)) != NULL_TREE)
|
||
return DATA_AREA_SDA;
|
||
|
||
if (lookup_attribute ("tda", DECL_ATTRIBUTES (decl)) != NULL_TREE)
|
||
return DATA_AREA_TDA;
|
||
|
||
if (lookup_attribute ("zda", DECL_ATTRIBUTES (decl)) != NULL_TREE)
|
||
return DATA_AREA_ZDA;
|
||
|
||
return DATA_AREA_NORMAL;
|
||
}
|
||
|
||
/* Store the indicated data area in the decl's attributes. */
|
||
|
||
static void
|
||
v850_set_data_area (tree decl, v850_data_area data_area)
|
||
{
|
||
tree name;
|
||
|
||
switch (data_area)
|
||
{
|
||
case DATA_AREA_SDA: name = get_identifier ("sda"); break;
|
||
case DATA_AREA_TDA: name = get_identifier ("tda"); break;
|
||
case DATA_AREA_ZDA: name = get_identifier ("zda"); break;
|
||
default:
|
||
return;
|
||
}
|
||
|
||
DECL_ATTRIBUTES (decl) = tree_cons
|
||
(name, NULL, DECL_ATTRIBUTES (decl));
|
||
}
|
||
|
||
/* Handle an "interrupt" attribute; arguments as in
|
||
struct attribute_spec.handler. */
|
||
static tree
|
||
v850_handle_interrupt_attribute (tree * node,
|
||
tree name,
|
||
tree args ATTRIBUTE_UNUSED,
|
||
int flags ATTRIBUTE_UNUSED,
|
||
bool * no_add_attrs)
|
||
{
|
||
if (TREE_CODE (*node) != FUNCTION_DECL)
|
||
{
|
||
warning (OPT_Wattributes, "%qE attribute only applies to functions",
|
||
name);
|
||
*no_add_attrs = true;
|
||
}
|
||
|
||
return NULL_TREE;
|
||
}
|
||
|
||
/* Handle a "sda", "tda" or "zda" attribute; arguments as in
|
||
struct attribute_spec.handler. */
|
||
static tree
|
||
v850_handle_data_area_attribute (tree* node,
|
||
tree name,
|
||
tree args ATTRIBUTE_UNUSED,
|
||
int flags ATTRIBUTE_UNUSED,
|
||
bool * no_add_attrs)
|
||
{
|
||
v850_data_area data_area;
|
||
v850_data_area area;
|
||
tree decl = *node;
|
||
|
||
/* Implement data area attribute. */
|
||
if (is_attribute_p ("sda", name))
|
||
data_area = DATA_AREA_SDA;
|
||
else if (is_attribute_p ("tda", name))
|
||
data_area = DATA_AREA_TDA;
|
||
else if (is_attribute_p ("zda", name))
|
||
data_area = DATA_AREA_ZDA;
|
||
else
|
||
gcc_unreachable ();
|
||
|
||
switch (TREE_CODE (decl))
|
||
{
|
||
case VAR_DECL:
|
||
if (current_function_decl != NULL_TREE)
|
||
{
|
||
error_at (DECL_SOURCE_LOCATION (decl),
|
||
"data area attributes cannot be specified for "
|
||
"local variables");
|
||
*no_add_attrs = true;
|
||
}
|
||
|
||
/* Drop through. */
|
||
|
||
case FUNCTION_DECL:
|
||
area = v850_get_data_area (decl);
|
||
if (area != DATA_AREA_NORMAL && data_area != area)
|
||
{
|
||
error ("data area of %q+D conflicts with previous declaration",
|
||
decl);
|
||
*no_add_attrs = true;
|
||
}
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
|
||
return NULL_TREE;
|
||
}
|
||
|
||
|
||
/* Return nonzero if FUNC is an interrupt function as specified
|
||
by the "interrupt" attribute. */
|
||
|
||
int
|
||
v850_interrupt_function_p (tree func)
|
||
{
|
||
tree a;
|
||
int ret = 0;
|
||
|
||
if (v850_interrupt_cache_p)
|
||
return v850_interrupt_p;
|
||
|
||
if (TREE_CODE (func) != FUNCTION_DECL)
|
||
return 0;
|
||
|
||
a = lookup_attribute ("interrupt_handler", DECL_ATTRIBUTES (func));
|
||
if (a != NULL_TREE)
|
||
ret = 1;
|
||
|
||
else
|
||
{
|
||
a = lookup_attribute ("interrupt", DECL_ATTRIBUTES (func));
|
||
ret = a != NULL_TREE;
|
||
}
|
||
|
||
/* Its not safe to trust global variables until after function inlining has
|
||
been done. */
|
||
if (reload_completed | reload_in_progress)
|
||
v850_interrupt_p = ret;
|
||
|
||
return ret;
|
||
}
|
||
|
||
|
||
static void
|
||
v850_encode_data_area (tree decl, rtx symbol)
|
||
{
|
||
int flags;
|
||
|
||
/* Map explicit sections into the appropriate attribute */
|
||
if (v850_get_data_area (decl) == DATA_AREA_NORMAL)
|
||
{
|
||
if (DECL_SECTION_NAME (decl))
|
||
{
|
||
const char *name = TREE_STRING_POINTER (DECL_SECTION_NAME (decl));
|
||
|
||
if (streq (name, ".zdata") || streq (name, ".zbss"))
|
||
v850_set_data_area (decl, DATA_AREA_ZDA);
|
||
|
||
else if (streq (name, ".sdata") || streq (name, ".sbss"))
|
||
v850_set_data_area (decl, DATA_AREA_SDA);
|
||
|
||
else if (streq (name, ".tdata"))
|
||
v850_set_data_area (decl, DATA_AREA_TDA);
|
||
}
|
||
|
||
/* If no attribute, support -m{zda,sda,tda}=n */
|
||
else
|
||
{
|
||
int size = int_size_in_bytes (TREE_TYPE (decl));
|
||
if (size <= 0)
|
||
;
|
||
|
||
else if (size <= small_memory [(int) SMALL_MEMORY_TDA].max)
|
||
v850_set_data_area (decl, DATA_AREA_TDA);
|
||
|
||
else if (size <= small_memory [(int) SMALL_MEMORY_SDA].max)
|
||
v850_set_data_area (decl, DATA_AREA_SDA);
|
||
|
||
else if (size <= small_memory [(int) SMALL_MEMORY_ZDA].max)
|
||
v850_set_data_area (decl, DATA_AREA_ZDA);
|
||
}
|
||
|
||
if (v850_get_data_area (decl) == DATA_AREA_NORMAL)
|
||
return;
|
||
}
|
||
|
||
flags = SYMBOL_REF_FLAGS (symbol);
|
||
switch (v850_get_data_area (decl))
|
||
{
|
||
case DATA_AREA_ZDA: flags |= SYMBOL_FLAG_ZDA; break;
|
||
case DATA_AREA_TDA: flags |= SYMBOL_FLAG_TDA; break;
|
||
case DATA_AREA_SDA: flags |= SYMBOL_FLAG_SDA; break;
|
||
default: gcc_unreachable ();
|
||
}
|
||
SYMBOL_REF_FLAGS (symbol) = flags;
|
||
}
|
||
|
||
static void
|
||
v850_encode_section_info (tree decl, rtx rtl, int first)
|
||
{
|
||
default_encode_section_info (decl, rtl, first);
|
||
|
||
if (TREE_CODE (decl) == VAR_DECL
|
||
&& (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
|
||
v850_encode_data_area (decl, XEXP (rtl, 0));
|
||
}
|
||
|
||
/* Construct a JR instruction to a routine that will perform the equivalent of
|
||
the RTL passed in as an argument. This RTL is a function epilogue that
|
||
pops registers off the stack and possibly releases some extra stack space
|
||
as well. The code has already verified that the RTL matches these
|
||
requirements. */
|
||
char *
|
||
construct_restore_jr (rtx op)
|
||
{
|
||
int count = XVECLEN (op, 0);
|
||
int stack_bytes;
|
||
unsigned long int mask;
|
||
unsigned long int first;
|
||
unsigned long int last;
|
||
int i;
|
||
static char buff [100]; /* XXX */
|
||
|
||
if (count <= 2)
|
||
{
|
||
error ("bogus JR construction: %d", count);
|
||
return NULL;
|
||
}
|
||
|
||
/* Work out how many bytes to pop off the stack before retrieving
|
||
registers. */
|
||
gcc_assert (GET_CODE (XVECEXP (op, 0, 1)) == SET);
|
||
gcc_assert (GET_CODE (SET_SRC (XVECEXP (op, 0, 1))) == PLUS);
|
||
gcc_assert (GET_CODE (XEXP (SET_SRC (XVECEXP (op, 0, 1)), 1)) == CONST_INT);
|
||
|
||
stack_bytes = INTVAL (XEXP (SET_SRC (XVECEXP (op, 0, 1)), 1));
|
||
|
||
/* Each pop will remove 4 bytes from the stack.... */
|
||
stack_bytes -= (count - 2) * 4;
|
||
|
||
/* Make sure that the amount we are popping either 0 or 16 bytes. */
|
||
if (stack_bytes != 0 && stack_bytes != 16)
|
||
{
|
||
error ("bad amount of stack space removal: %d", stack_bytes);
|
||
return NULL;
|
||
}
|
||
|
||
/* Now compute the bit mask of registers to push. */
|
||
mask = 0;
|
||
for (i = 2; i < count; i++)
|
||
{
|
||
rtx vector_element = XVECEXP (op, 0, i);
|
||
|
||
gcc_assert (GET_CODE (vector_element) == SET);
|
||
gcc_assert (GET_CODE (SET_DEST (vector_element)) == REG);
|
||
gcc_assert (register_is_ok_for_epilogue (SET_DEST (vector_element),
|
||
SImode));
|
||
|
||
mask |= 1 << REGNO (SET_DEST (vector_element));
|
||
}
|
||
|
||
/* Scan for the first register to pop. */
|
||
for (first = 0; first < 32; first++)
|
||
{
|
||
if (mask & (1 << first))
|
||
break;
|
||
}
|
||
|
||
gcc_assert (first < 32);
|
||
|
||
/* Discover the last register to pop. */
|
||
if (mask & (1 << LINK_POINTER_REGNUM))
|
||
{
|
||
gcc_assert (stack_bytes == 16);
|
||
|
||
last = LINK_POINTER_REGNUM;
|
||
}
|
||
else
|
||
{
|
||
gcc_assert (!stack_bytes);
|
||
gcc_assert (mask & (1 << 29));
|
||
|
||
last = 29;
|
||
}
|
||
|
||
/* Note, it is possible to have gaps in the register mask.
|
||
We ignore this here, and generate a JR anyway. We will
|
||
be popping more registers than is strictly necessary, but
|
||
it does save code space. */
|
||
|
||
if (TARGET_LONG_CALLS)
|
||
{
|
||
char name[40];
|
||
|
||
if (first == last)
|
||
sprintf (name, "__return_%s", reg_names [first]);
|
||
else
|
||
sprintf (name, "__return_%s_%s", reg_names [first], reg_names [last]);
|
||
|
||
sprintf (buff, "movhi hi(%s), r0, r6\n\tmovea lo(%s), r6, r6\n\tjmp r6",
|
||
name, name);
|
||
}
|
||
else
|
||
{
|
||
if (first == last)
|
||
sprintf (buff, "jr __return_%s", reg_names [first]);
|
||
else
|
||
sprintf (buff, "jr __return_%s_%s", reg_names [first], reg_names [last]);
|
||
}
|
||
|
||
return buff;
|
||
}
|
||
|
||
|
||
/* Construct a JARL instruction to a routine that will perform the equivalent
|
||
of the RTL passed as a parameter. This RTL is a function prologue that
|
||
saves some of the registers r20 - r31 onto the stack, and possibly acquires
|
||
some stack space as well. The code has already verified that the RTL
|
||
matches these requirements. */
|
||
char *
|
||
construct_save_jarl (rtx op)
|
||
{
|
||
int count = XVECLEN (op, 0);
|
||
int stack_bytes;
|
||
unsigned long int mask;
|
||
unsigned long int first;
|
||
unsigned long int last;
|
||
int i;
|
||
static char buff [100]; /* XXX */
|
||
|
||
if (count <= 2)
|
||
{
|
||
error ("bogus JARL construction: %d\n", count);
|
||
return NULL;
|
||
}
|
||
|
||
/* Paranoia. */
|
||
gcc_assert (GET_CODE (XVECEXP (op, 0, 0)) == SET);
|
||
gcc_assert (GET_CODE (SET_SRC (XVECEXP (op, 0, 0))) == PLUS);
|
||
gcc_assert (GET_CODE (XEXP (SET_SRC (XVECEXP (op, 0, 0)), 0)) == REG);
|
||
gcc_assert (GET_CODE (XEXP (SET_SRC (XVECEXP (op, 0, 0)), 1)) == CONST_INT);
|
||
|
||
/* Work out how many bytes to push onto the stack after storing the
|
||
registers. */
|
||
stack_bytes = INTVAL (XEXP (SET_SRC (XVECEXP (op, 0, 0)), 1));
|
||
|
||
/* Each push will put 4 bytes from the stack.... */
|
||
stack_bytes += (count - (TARGET_LONG_CALLS ? 3 : 2)) * 4;
|
||
|
||
/* Make sure that the amount we are popping either 0 or 16 bytes. */
|
||
if (stack_bytes != 0 && stack_bytes != -16)
|
||
{
|
||
error ("bad amount of stack space removal: %d", stack_bytes);
|
||
return NULL;
|
||
}
|
||
|
||
/* Now compute the bit mask of registers to push. */
|
||
mask = 0;
|
||
for (i = 1; i < count - (TARGET_LONG_CALLS ? 2 : 1); i++)
|
||
{
|
||
rtx vector_element = XVECEXP (op, 0, i);
|
||
|
||
gcc_assert (GET_CODE (vector_element) == SET);
|
||
gcc_assert (GET_CODE (SET_SRC (vector_element)) == REG);
|
||
gcc_assert (register_is_ok_for_epilogue (SET_SRC (vector_element),
|
||
SImode));
|
||
|
||
mask |= 1 << REGNO (SET_SRC (vector_element));
|
||
}
|
||
|
||
/* Scan for the first register to push. */
|
||
for (first = 0; first < 32; first++)
|
||
{
|
||
if (mask & (1 << first))
|
||
break;
|
||
}
|
||
|
||
gcc_assert (first < 32);
|
||
|
||
/* Discover the last register to push. */
|
||
if (mask & (1 << LINK_POINTER_REGNUM))
|
||
{
|
||
gcc_assert (stack_bytes == -16);
|
||
|
||
last = LINK_POINTER_REGNUM;
|
||
}
|
||
else
|
||
{
|
||
gcc_assert (!stack_bytes);
|
||
gcc_assert (mask & (1 << 29));
|
||
|
||
last = 29;
|
||
}
|
||
|
||
/* Note, it is possible to have gaps in the register mask.
|
||
We ignore this here, and generate a JARL anyway. We will
|
||
be pushing more registers than is strictly necessary, but
|
||
it does save code space. */
|
||
|
||
if (TARGET_LONG_CALLS)
|
||
{
|
||
char name[40];
|
||
|
||
if (first == last)
|
||
sprintf (name, "__save_%s", reg_names [first]);
|
||
else
|
||
sprintf (name, "__save_%s_%s", reg_names [first], reg_names [last]);
|
||
|
||
sprintf (buff, "movhi hi(%s), r0, r11\n\tmovea lo(%s), r11, r11\n\tjarl .+4, r10\n\tadd 4, r10\n\tjmp r11",
|
||
name, name);
|
||
}
|
||
else
|
||
{
|
||
if (first == last)
|
||
sprintf (buff, "jarl __save_%s, r10", reg_names [first]);
|
||
else
|
||
sprintf (buff, "jarl __save_%s_%s, r10", reg_names [first],
|
||
reg_names [last]);
|
||
}
|
||
|
||
return buff;
|
||
}
|
||
|
||
extern tree last_assemble_variable_decl;
|
||
extern int size_directive_output;
|
||
|
||
/* A version of asm_output_aligned_bss() that copes with the special
|
||
data areas of the v850. */
|
||
void
|
||
v850_output_aligned_bss (FILE * file,
|
||
tree decl,
|
||
const char * name,
|
||
unsigned HOST_WIDE_INT size,
|
||
int align)
|
||
{
|
||
switch (v850_get_data_area (decl))
|
||
{
|
||
case DATA_AREA_ZDA:
|
||
switch_to_section (zbss_section);
|
||
break;
|
||
|
||
case DATA_AREA_SDA:
|
||
switch_to_section (sbss_section);
|
||
break;
|
||
|
||
case DATA_AREA_TDA:
|
||
switch_to_section (tdata_section);
|
||
|
||
default:
|
||
switch_to_section (bss_section);
|
||
break;
|
||
}
|
||
|
||
ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT));
|
||
#ifdef ASM_DECLARE_OBJECT_NAME
|
||
last_assemble_variable_decl = decl;
|
||
ASM_DECLARE_OBJECT_NAME (file, name, decl);
|
||
#else
|
||
/* Standard thing is just output label for the object. */
|
||
ASM_OUTPUT_LABEL (file, name);
|
||
#endif /* ASM_DECLARE_OBJECT_NAME */
|
||
ASM_OUTPUT_SKIP (file, size ? size : 1);
|
||
}
|
||
|
||
/* Called via the macro ASM_OUTPUT_DECL_COMMON */
|
||
void
|
||
v850_output_common (FILE * file,
|
||
tree decl,
|
||
const char * name,
|
||
int size,
|
||
int align)
|
||
{
|
||
if (decl == NULL_TREE)
|
||
{
|
||
fprintf (file, "%s", COMMON_ASM_OP);
|
||
}
|
||
else
|
||
{
|
||
switch (v850_get_data_area (decl))
|
||
{
|
||
case DATA_AREA_ZDA:
|
||
fprintf (file, "%s", ZCOMMON_ASM_OP);
|
||
break;
|
||
|
||
case DATA_AREA_SDA:
|
||
fprintf (file, "%s", SCOMMON_ASM_OP);
|
||
break;
|
||
|
||
case DATA_AREA_TDA:
|
||
fprintf (file, "%s", TCOMMON_ASM_OP);
|
||
break;
|
||
|
||
default:
|
||
fprintf (file, "%s", COMMON_ASM_OP);
|
||
break;
|
||
}
|
||
}
|
||
|
||
assemble_name (file, name);
|
||
fprintf (file, ",%u,%u\n", size, align / BITS_PER_UNIT);
|
||
}
|
||
|
||
/* Called via the macro ASM_OUTPUT_DECL_LOCAL */
|
||
void
|
||
v850_output_local (FILE * file,
|
||
tree decl,
|
||
const char * name,
|
||
int size,
|
||
int align)
|
||
{
|
||
fprintf (file, "%s", LOCAL_ASM_OP);
|
||
assemble_name (file, name);
|
||
fprintf (file, "\n");
|
||
|
||
ASM_OUTPUT_ALIGNED_DECL_COMMON (file, decl, name, size, align);
|
||
}
|
||
|
||
/* Add data area to the given declaration if a ghs data area pragma is
|
||
currently in effect (#pragma ghs startXXX/endXXX). */
|
||
static void
|
||
v850_insert_attributes (tree decl, tree * attr_ptr ATTRIBUTE_UNUSED )
|
||
{
|
||
if (data_area_stack
|
||
&& data_area_stack->data_area
|
||
&& current_function_decl == NULL_TREE
|
||
&& (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == CONST_DECL)
|
||
&& v850_get_data_area (decl) == DATA_AREA_NORMAL)
|
||
v850_set_data_area (decl, data_area_stack->data_area);
|
||
|
||
/* Initialize the default names of the v850 specific sections,
|
||
if this has not been done before. */
|
||
|
||
if (GHS_default_section_names [(int) GHS_SECTION_KIND_SDATA] == NULL)
|
||
{
|
||
GHS_default_section_names [(int) GHS_SECTION_KIND_SDATA]
|
||
= build_string (sizeof (".sdata")-1, ".sdata");
|
||
|
||
GHS_default_section_names [(int) GHS_SECTION_KIND_ROSDATA]
|
||
= build_string (sizeof (".rosdata")-1, ".rosdata");
|
||
|
||
GHS_default_section_names [(int) GHS_SECTION_KIND_TDATA]
|
||
= build_string (sizeof (".tdata")-1, ".tdata");
|
||
|
||
GHS_default_section_names [(int) GHS_SECTION_KIND_ZDATA]
|
||
= build_string (sizeof (".zdata")-1, ".zdata");
|
||
|
||
GHS_default_section_names [(int) GHS_SECTION_KIND_ROZDATA]
|
||
= build_string (sizeof (".rozdata")-1, ".rozdata");
|
||
}
|
||
|
||
if (current_function_decl == NULL_TREE
|
||
&& (TREE_CODE (decl) == VAR_DECL
|
||
|| TREE_CODE (decl) == CONST_DECL
|
||
|| TREE_CODE (decl) == FUNCTION_DECL)
|
||
&& (!DECL_EXTERNAL (decl) || DECL_INITIAL (decl))
|
||
&& !DECL_SECTION_NAME (decl))
|
||
{
|
||
enum GHS_section_kind kind = GHS_SECTION_KIND_DEFAULT;
|
||
tree chosen_section;
|
||
|
||
if (TREE_CODE (decl) == FUNCTION_DECL)
|
||
kind = GHS_SECTION_KIND_TEXT;
|
||
else
|
||
{
|
||
/* First choose a section kind based on the data area of the decl. */
|
||
switch (v850_get_data_area (decl))
|
||
{
|
||
default:
|
||
gcc_unreachable ();
|
||
|
||
case DATA_AREA_SDA:
|
||
kind = ((TREE_READONLY (decl))
|
||
? GHS_SECTION_KIND_ROSDATA
|
||
: GHS_SECTION_KIND_SDATA);
|
||
break;
|
||
|
||
case DATA_AREA_TDA:
|
||
kind = GHS_SECTION_KIND_TDATA;
|
||
break;
|
||
|
||
case DATA_AREA_ZDA:
|
||
kind = ((TREE_READONLY (decl))
|
||
? GHS_SECTION_KIND_ROZDATA
|
||
: GHS_SECTION_KIND_ZDATA);
|
||
break;
|
||
|
||
case DATA_AREA_NORMAL: /* default data area */
|
||
if (TREE_READONLY (decl))
|
||
kind = GHS_SECTION_KIND_RODATA;
|
||
else if (DECL_INITIAL (decl))
|
||
kind = GHS_SECTION_KIND_DATA;
|
||
else
|
||
kind = GHS_SECTION_KIND_BSS;
|
||
}
|
||
}
|
||
|
||
/* Now, if the section kind has been explicitly renamed,
|
||
then attach a section attribute. */
|
||
chosen_section = GHS_current_section_names [(int) kind];
|
||
|
||
/* Otherwise, if this kind of section needs an explicit section
|
||
attribute, then also attach one. */
|
||
if (chosen_section == NULL)
|
||
chosen_section = GHS_default_section_names [(int) kind];
|
||
|
||
if (chosen_section)
|
||
{
|
||
/* Only set the section name if specified by a pragma, because
|
||
otherwise it will force those variables to get allocated storage
|
||
in this module, rather than by the linker. */
|
||
DECL_SECTION_NAME (decl) = chosen_section;
|
||
}
|
||
}
|
||
}
|
||
|
||
/* Construct a DISPOSE instruction that is the equivalent of
|
||
the given RTX. We have already verified that this should
|
||
be possible. */
|
||
|
||
char *
|
||
construct_dispose_instruction (rtx op)
|
||
{
|
||
int count = XVECLEN (op, 0);
|
||
int stack_bytes;
|
||
unsigned long int mask;
|
||
int i;
|
||
static char buff[ 100 ]; /* XXX */
|
||
int use_callt = 0;
|
||
|
||
if (count <= 2)
|
||
{
|
||
error ("bogus DISPOSE construction: %d", count);
|
||
return NULL;
|
||
}
|
||
|
||
/* Work out how many bytes to pop off the
|
||
stack before retrieving registers. */
|
||
gcc_assert (GET_CODE (XVECEXP (op, 0, 1)) == SET);
|
||
gcc_assert (GET_CODE (SET_SRC (XVECEXP (op, 0, 1))) == PLUS);
|
||
gcc_assert (GET_CODE (XEXP (SET_SRC (XVECEXP (op, 0, 1)), 1)) == CONST_INT);
|
||
|
||
stack_bytes = INTVAL (XEXP (SET_SRC (XVECEXP (op, 0, 1)), 1));
|
||
|
||
/* Each pop will remove 4 bytes from the stack.... */
|
||
stack_bytes -= (count - 2) * 4;
|
||
|
||
/* Make sure that the amount we are popping
|
||
will fit into the DISPOSE instruction. */
|
||
if (stack_bytes > 128)
|
||
{
|
||
error ("too much stack space to dispose of: %d", stack_bytes);
|
||
return NULL;
|
||
}
|
||
|
||
/* Now compute the bit mask of registers to push. */
|
||
mask = 0;
|
||
|
||
for (i = 2; i < count; i++)
|
||
{
|
||
rtx vector_element = XVECEXP (op, 0, i);
|
||
|
||
gcc_assert (GET_CODE (vector_element) == SET);
|
||
gcc_assert (GET_CODE (SET_DEST (vector_element)) == REG);
|
||
gcc_assert (register_is_ok_for_epilogue (SET_DEST (vector_element),
|
||
SImode));
|
||
|
||
if (REGNO (SET_DEST (vector_element)) == 2)
|
||
use_callt = 1;
|
||
else
|
||
mask |= 1 << REGNO (SET_DEST (vector_element));
|
||
}
|
||
|
||
if (! TARGET_DISABLE_CALLT
|
||
&& (use_callt || stack_bytes == 0 || stack_bytes == 16))
|
||
{
|
||
if (use_callt)
|
||
{
|
||
sprintf (buff, "callt ctoff(__callt_return_r2_r%d)", (mask & (1 << 31)) ? 31 : 29);
|
||
return buff;
|
||
}
|
||
else
|
||
{
|
||
for (i = 20; i < 32; i++)
|
||
if (mask & (1 << i))
|
||
break;
|
||
|
||
if (i == 31)
|
||
sprintf (buff, "callt ctoff(__callt_return_r31c)");
|
||
else
|
||
sprintf (buff, "callt ctoff(__callt_return_r%d_r%d%s)",
|
||
i, (mask & (1 << 31)) ? 31 : 29, stack_bytes ? "c" : "");
|
||
}
|
||
}
|
||
else
|
||
{
|
||
static char regs [100]; /* XXX */
|
||
int done_one;
|
||
|
||
/* Generate the DISPOSE instruction. Note we could just issue the
|
||
bit mask as a number as the assembler can cope with this, but for
|
||
the sake of our readers we turn it into a textual description. */
|
||
regs[0] = 0;
|
||
done_one = 0;
|
||
|
||
for (i = 20; i < 32; i++)
|
||
{
|
||
if (mask & (1 << i))
|
||
{
|
||
int first;
|
||
|
||
if (done_one)
|
||
strcat (regs, ", ");
|
||
else
|
||
done_one = 1;
|
||
|
||
first = i;
|
||
strcat (regs, reg_names[ first ]);
|
||
|
||
for (i++; i < 32; i++)
|
||
if ((mask & (1 << i)) == 0)
|
||
break;
|
||
|
||
if (i > first + 1)
|
||
{
|
||
strcat (regs, " - ");
|
||
strcat (regs, reg_names[ i - 1 ] );
|
||
}
|
||
}
|
||
}
|
||
|
||
sprintf (buff, "dispose %d {%s}, r31", stack_bytes / 4, regs);
|
||
}
|
||
|
||
return buff;
|
||
}
|
||
|
||
/* Construct a PREPARE instruction that is the equivalent of
|
||
the given RTL. We have already verified that this should
|
||
be possible. */
|
||
|
||
char *
|
||
construct_prepare_instruction (rtx op)
|
||
{
|
||
int count = XVECLEN (op, 0);
|
||
int stack_bytes;
|
||
unsigned long int mask;
|
||
int i;
|
||
static char buff[ 100 ]; /* XXX */
|
||
int use_callt = 0;
|
||
|
||
if (count <= 1)
|
||
{
|
||
error ("bogus PREPEARE construction: %d", count);
|
||
return NULL;
|
||
}
|
||
|
||
/* Work out how many bytes to push onto
|
||
the stack after storing the registers. */
|
||
gcc_assert (GET_CODE (XVECEXP (op, 0, 0)) == SET);
|
||
gcc_assert (GET_CODE (SET_SRC (XVECEXP (op, 0, 0))) == PLUS);
|
||
gcc_assert (GET_CODE (XEXP (SET_SRC (XVECEXP (op, 0, 0)), 1)) == CONST_INT);
|
||
|
||
stack_bytes = INTVAL (XEXP (SET_SRC (XVECEXP (op, 0, 0)), 1));
|
||
|
||
/* Each push will put 4 bytes from the stack. */
|
||
stack_bytes += (count - 1) * 4;
|
||
|
||
/* Make sure that the amount we are popping
|
||
will fit into the DISPOSE instruction. */
|
||
if (stack_bytes < -128)
|
||
{
|
||
error ("too much stack space to prepare: %d", stack_bytes);
|
||
return NULL;
|
||
}
|
||
|
||
/* Now compute the bit mask of registers to push. */
|
||
mask = 0;
|
||
for (i = 1; i < count; i++)
|
||
{
|
||
rtx vector_element = XVECEXP (op, 0, i);
|
||
|
||
gcc_assert (GET_CODE (vector_element) == SET);
|
||
gcc_assert (GET_CODE (SET_SRC (vector_element)) == REG);
|
||
gcc_assert (register_is_ok_for_epilogue (SET_SRC (vector_element),
|
||
SImode));
|
||
|
||
if (REGNO (SET_SRC (vector_element)) == 2)
|
||
use_callt = 1;
|
||
else
|
||
mask |= 1 << REGNO (SET_SRC (vector_element));
|
||
}
|
||
|
||
if ((! TARGET_DISABLE_CALLT)
|
||
&& (use_callt || stack_bytes == 0 || stack_bytes == -16))
|
||
{
|
||
if (use_callt)
|
||
{
|
||
sprintf (buff, "callt ctoff(__callt_save_r2_r%d)", (mask & (1 << 31)) ? 31 : 29 );
|
||
return buff;
|
||
}
|
||
|
||
for (i = 20; i < 32; i++)
|
||
if (mask & (1 << i))
|
||
break;
|
||
|
||
if (i == 31)
|
||
sprintf (buff, "callt ctoff(__callt_save_r31c)");
|
||
else
|
||
sprintf (buff, "callt ctoff(__callt_save_r%d_r%d%s)",
|
||
i, (mask & (1 << 31)) ? 31 : 29, stack_bytes ? "c" : "");
|
||
}
|
||
else
|
||
{
|
||
static char regs [100]; /* XXX */
|
||
int done_one;
|
||
|
||
|
||
/* Generate the PREPARE instruction. Note we could just issue the
|
||
bit mask as a number as the assembler can cope with this, but for
|
||
the sake of our readers we turn it into a textual description. */
|
||
regs[0] = 0;
|
||
done_one = 0;
|
||
|
||
for (i = 20; i < 32; i++)
|
||
{
|
||
if (mask & (1 << i))
|
||
{
|
||
int first;
|
||
|
||
if (done_one)
|
||
strcat (regs, ", ");
|
||
else
|
||
done_one = 1;
|
||
|
||
first = i;
|
||
strcat (regs, reg_names[ first ]);
|
||
|
||
for (i++; i < 32; i++)
|
||
if ((mask & (1 << i)) == 0)
|
||
break;
|
||
|
||
if (i > first + 1)
|
||
{
|
||
strcat (regs, " - ");
|
||
strcat (regs, reg_names[ i - 1 ] );
|
||
}
|
||
}
|
||
}
|
||
|
||
sprintf (buff, "prepare {%s}, %d", regs, (- stack_bytes) / 4);
|
||
}
|
||
|
||
return buff;
|
||
}
|
||
|
||
/* Return an RTX indicating where the return address to the
|
||
calling function can be found. */
|
||
|
||
rtx
|
||
v850_return_addr (int count)
|
||
{
|
||
if (count != 0)
|
||
return const0_rtx;
|
||
|
||
return get_hard_reg_initial_val (Pmode, LINK_POINTER_REGNUM);
|
||
}
|
||
|
||
/* Implement TARGET_ASM_INIT_SECTIONS. */
|
||
|
||
static void
|
||
v850_asm_init_sections (void)
|
||
{
|
||
rosdata_section
|
||
= get_unnamed_section (0, output_section_asm_op,
|
||
"\t.section .rosdata,\"a\"");
|
||
|
||
rozdata_section
|
||
= get_unnamed_section (0, output_section_asm_op,
|
||
"\t.section .rozdata,\"a\"");
|
||
|
||
tdata_section
|
||
= get_unnamed_section (SECTION_WRITE, output_section_asm_op,
|
||
"\t.section .tdata,\"aw\"");
|
||
|
||
zdata_section
|
||
= get_unnamed_section (SECTION_WRITE, output_section_asm_op,
|
||
"\t.section .zdata,\"aw\"");
|
||
|
||
zbss_section
|
||
= get_unnamed_section (SECTION_WRITE | SECTION_BSS,
|
||
output_section_asm_op,
|
||
"\t.section .zbss,\"aw\"");
|
||
}
|
||
|
||
static section *
|
||
v850_select_section (tree exp,
|
||
int reloc ATTRIBUTE_UNUSED,
|
||
unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
|
||
{
|
||
if (TREE_CODE (exp) == VAR_DECL)
|
||
{
|
||
int is_const;
|
||
if (!TREE_READONLY (exp)
|
||
|| TREE_SIDE_EFFECTS (exp)
|
||
|| !DECL_INITIAL (exp)
|
||
|| (DECL_INITIAL (exp) != error_mark_node
|
||
&& !TREE_CONSTANT (DECL_INITIAL (exp))))
|
||
is_const = FALSE;
|
||
else
|
||
is_const = TRUE;
|
||
|
||
switch (v850_get_data_area (exp))
|
||
{
|
||
case DATA_AREA_ZDA:
|
||
return is_const ? rozdata_section : zdata_section;
|
||
|
||
case DATA_AREA_TDA:
|
||
return tdata_section;
|
||
|
||
case DATA_AREA_SDA:
|
||
return is_const ? rosdata_section : sdata_section;
|
||
|
||
default:
|
||
return is_const ? readonly_data_section : data_section;
|
||
}
|
||
}
|
||
return readonly_data_section;
|
||
}
|
||
|
||
/* Worker function for TARGET_RETURN_IN_MEMORY. */
|
||
|
||
static bool
|
||
v850_return_in_memory (const_tree type, const_tree fntype ATTRIBUTE_UNUSED)
|
||
{
|
||
/* Return values > 8 bytes in length in memory. */
|
||
return int_size_in_bytes (type) > 8 || TYPE_MODE (type) == BLKmode;
|
||
}
|
||
|
||
/* Worker function for TARGET_FUNCTION_VALUE. */
|
||
|
||
rtx
|
||
v850_function_value (const_tree valtype,
|
||
const_tree fn_decl_or_type ATTRIBUTE_UNUSED,
|
||
bool outgoing ATTRIBUTE_UNUSED)
|
||
{
|
||
return gen_rtx_REG (TYPE_MODE (valtype), 10);
|
||
}
|
||
|
||
|
||
/* Worker function for TARGET_SETUP_INCOMING_VARARGS. */
|
||
|
||
static void
|
||
v850_setup_incoming_varargs (CUMULATIVE_ARGS *ca,
|
||
enum machine_mode mode ATTRIBUTE_UNUSED,
|
||
tree type ATTRIBUTE_UNUSED,
|
||
int *pretend_arg_size ATTRIBUTE_UNUSED,
|
||
int second_time ATTRIBUTE_UNUSED)
|
||
{
|
||
ca->anonymous_args = (!TARGET_GHS ? 1 : 0);
|
||
}
|
||
|
||
/* Worker function for TARGET_CAN_ELIMINATE. */
|
||
|
||
static bool
|
||
v850_can_eliminate (const int from ATTRIBUTE_UNUSED, const int to)
|
||
{
|
||
return (to == STACK_POINTER_REGNUM ? ! frame_pointer_needed : true);
|
||
}
|
||
|
||
|
||
/* Worker function for TARGET_ASM_TRAMPOLINE_TEMPLATE. */
|
||
|
||
static void
|
||
v850_asm_trampoline_template (FILE *f)
|
||
{
|
||
fprintf (f, "\tjarl .+4,r12\n");
|
||
fprintf (f, "\tld.w 12[r12],r20\n");
|
||
fprintf (f, "\tld.w 16[r12],r12\n");
|
||
fprintf (f, "\tjmp [r12]\n");
|
||
fprintf (f, "\tnop\n");
|
||
fprintf (f, "\t.long 0\n");
|
||
fprintf (f, "\t.long 0\n");
|
||
}
|
||
|
||
/* Worker function for TARGET_TRAMPOLINE_INIT. */
|
||
|
||
static void
|
||
v850_trampoline_init (rtx m_tramp, tree fndecl, rtx chain_value)
|
||
{
|
||
rtx mem, fnaddr = XEXP (DECL_RTL (fndecl), 0);
|
||
|
||
emit_block_move (m_tramp, assemble_trampoline_template (),
|
||
GEN_INT (TRAMPOLINE_SIZE), BLOCK_OP_NORMAL);
|
||
|
||
mem = adjust_address (m_tramp, SImode, 16);
|
||
emit_move_insn (mem, chain_value);
|
||
mem = adjust_address (m_tramp, SImode, 20);
|
||
emit_move_insn (mem, fnaddr);
|
||
}
|
||
|
||
#include "gt-v850.h"
|