CbC/CbC_gcc: gcc/config/v850/v850.c comparison

comparison gcc/config/v850/v850.c @ 111:04ced10e8804

gcc 7

author	kono
date	Fri, 27 Oct 2017 22:46:09 +0900
parents	f6334be47118
children	84e7813d76e9

comparison

equal deleted inserted replaced

-:561a7518be6b
+:04ced10e8804
 /* Subroutines for insn-output.c for NEC V850 series
-Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+Copyright (C) 1996-2017 Free Software Foundation, Inc.
-2006, 2007, 2008, 2009, 2010 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
 <http://www.gnu.org/licenses/>.  */
 #include "config.h"
 #include "system.h"
 #include "coretypes.h"
-#include "tm.h"
+#include "backend.h"
+#include "target.h"
+#include "rtl.h"
 #include "tree.h"
-#include "rtl.h"
+#include "df.h"
+#include "memmodel.h"
+#include "tm_p.h"
+#include "stringpool.h"
+#include "attribs.h"
+#include "insn-config.h"
 #include "regs.h"
-#include "hard-reg-set.h"
+#include "emit-rtl.h"
-#include "insn-config.h"
+#include "recog.h"
+#include "diagnostic-core.h"
+#include "stor-layout.h"
+#include "varasm.h"
+#include "calls.h"
 #include "conditions.h"
 #include "output.h"
 #include "insn-attr.h"
-#include "flags.h"
-#include "recog.h"
 #include "expr.h"
-#include "function.h"
+#include "cfgrtl.h"
-#include "diagnostic-core.h"
+#include "builtins.h"
-#include "ggc.h"
-#include "integrate.h"
+/* This file should be included last.  */
-#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
-static void v850_print_operand_address (FILE *, rtx);
+static void v850_print_operand_address (FILE *, machine_mode, 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];
+const char * GHS_default_section_names [(int) COUNT_OF_GHS_SECTION_KINDS];
-tree GHS_current_section_names [(int) COUNT_OF_GHS_SECTION_KINDS];
+const char * 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;
 static GTY(()) section * rozdata_section;
 static GTY(()) section * tdata_section;
 static GTY(()) section * zdata_section;
 static GTY(()) section * zbss_section;
-/* Set the maximum size of small memory area TYPE to the value given
+/* We use this to wrap all emitted insns in the prologue.  */
-by VALUE.  Return true if VALUE was syntactically correct.  VALUE
+static rtx
-starts with the argument separator: either "-" or "=".  */
+F (rtx x)
+{
-static bool
+if (GET_CODE (x) != CLOBBER)
-v850_handle_memory_option (enum small_memory_type type, const char *value)
+RTX_FRAME_RELATED_P (x) = 1;
-{
+return x;
-int i, size;
+}
-if (*value != '-' && *value != '=')
+/* Mark all the subexpressions of the PARALLEL rtx PAR as
-return false;
+frame-related.  Return PAR.
-value++;
+dwarf2out.c:dwarf2out_frame_debug_expr ignores sub-expressions of a
-for (i = 0; value[i]; i++)
+PARALLEL rtx other than the first if they do not have the
-if (!ISDIGIT (value[i]))
+FRAME_RELATED flag set on them.  */
-return false;
+static rtx
-size = atoi (value);
+v850_all_frame_related (rtx par)
-if (size > small_memory[type].physical_max)
+{
-error ("value passed to %<-m%s%> is too large", small_memory[type].name);
+int len = XVECLEN (par, 0);
-else
+int i;
-small_memory[type].max = size;
-return true;
+gcc_assert (GET_CODE (par) == PARALLEL);
-}
+for (i = 0; i < len; i++)
+F (XVECEXP (par, 0, i));
-/* Implement TARGET_HANDLE_OPTION.  */
+return par;
-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;
-}
-}
-/* Implement TARGET_OPTION_OPTIMIZATION_TABLE.  */
-static const struct default_options v850_option_optimization_table[] =
-{
-{ OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
-/* Note - we no longer enable MASK_EP when optimizing.  This is
-because of a hardware bug which stops the SLD and SST instructions
-from correctly detecting some hazards.  If the user is sure that
-their hardware is fixed or that their program will not encounter
-the conditions that trigger the bug then they can enable -mep by
-hand.  */
-{ OPT_LEVELS_1_PLUS, OPT_mprolog_function, NULL, 1 },
-{ OPT_LEVELS_NONE, 0, NULL, 0 }
-};
 /* Handle the TARGET_PASS_BY_REFERENCE target hook.
 Specify whether to pass the argument by reference.  */
 static bool
-v850_pass_by_reference (CUMULATIVE_ARGS *cum ATTRIBUTE_UNUSED,
+v850_pass_by_reference (cumulative_args_t cum ATTRIBUTE_UNUSED,
-			enum machine_mode mode, const_tree type,
+			machine_mode mode, const_tree type,
 			bool named ATTRIBUTE_UNUSED)
 {
 unsigned HOST_WIDE_INT size;
+if (!TARGET_GCC_ABI)
+return 0;
 if (type)
 size = int_size_in_bytes (type);
 else
 size = GET_MODE_SIZE (mode);
 return size > 8;
 }
-/* Implementing the Varargs Macros.  */
-static bool
-v850_strict_argument_naming (CUMULATIVE_ARGS * ca ATTRIBUTE_UNUSED)
-{
-return !TARGET_GHS ? true : false;
-}
 /* 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.  */
 static rtx
-v850_function_arg (CUMULATIVE_ARGS * cum, enum machine_mode mode,
+v850_function_arg (cumulative_args_t cum_v, machine_mode mode,
 		   const_tree type, bool named)
 {
+CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
 rtx result = NULL_RTX;
 int size, align;
 if (!named)
 return NULL_RTX;
 /* Once we have stopped using argument registers, do not start up again.  */
 cum->nbytes = 4 * UNITS_PER_WORD;
 return NULL_RTX;
 }
-if (size <= UNITS_PER_WORD && type)
+if (!TARGET_GCC_ABI)
+align = UNITS_PER_WORD;
+else if (size <= UNITS_PER_WORD && type)
 align = TYPE_ALIGN (type) / BITS_PER_UNIT;
 else
 align = size;
 cum->nbytes = (cum->nbytes + align - 1) &~(align - 1);
 }
 /* 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,
+v850_arg_partial_bytes (cumulative_args_t cum_v, machine_mode mode,
 tree type, bool named)
 {
+CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
 int size, align;
-if (TARGET_GHS && !named)
+if (!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)
+if (!TARGET_GCC_ABI)
+align = UNITS_PER_WORD;
+else if (type)
 align = TYPE_ALIGN (type) / BITS_PER_UNIT;
 else
 align = size;
 cum->nbytes = (cum->nbytes + align - 1) & ~ (align - 1);
 /* Update the data in CUM to advance over an argument
 of mode MODE and data type TYPE.
 (TYPE is null for libcalls where that information may not be available.)  */
 static void
-v850_function_arg_advance (CUMULATIVE_ARGS *cum, enum machine_mode mode,
+v850_function_arg_advance (cumulative_args_t cum_v, machine_mode mode,
 			   const_tree type, bool named ATTRIBUTE_UNUSED)
 {
-cum->nbytes += (((type && int_size_in_bytes (type) > 8
+CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
-		    ? GET_MODE_SIZE (Pmode)
-		    : (mode != BLKmode
+if (!TARGET_GCC_ABI)
-		       ? GET_MODE_SIZE (mode)
+cum->nbytes += (((mode != BLKmode
-		       : int_size_in_bytes (type))) + UNITS_PER_WORD - 1)
+		      ? GET_MODE_SIZE (mode)
-		  & -UNITS_PER_WORD);
+		      : int_size_in_bytes (type)) + UNITS_PER_WORD - 1)
+		    & -UNITS_PER_WORD);
+else
+cum->nbytes += (((type && int_size_in_bytes (type) > 8
+		      ? GET_MODE_SIZE (Pmode)
+		      : (mode != BLKmode
+			 ? GET_MODE_SIZE (mode)
+			 : int_size_in_bytes (type))) + UNITS_PER_WORD - 1)
+		    & -UNITS_PER_WORD);
 }
 /* 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:
+	case E_DFmode:
-	  REAL_VALUE_FROM_CONST_DOUBLE (rv, x);
+	  REAL_VALUE_TO_TARGET_DOUBLE (*CONST_DOUBLE_REAL_VALUE (x), t);
-	  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:
+	case E_SFmode:
-	  REAL_VALUE_FROM_CONST_DOUBLE (rv, x);
+	  REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (x), *p_high);
-	  REAL_VALUE_TO_TARGET_SINGLE (rv, *p_high);
 	  *p_low = 0;
 	  return;
-	case VOIDmode:
+	case E_VOIDmode:
-	case DImode:
+	case E_DImode:
 	  *p_high = CONST_DOUBLE_HIGH (x);
 	  *p_low  = CONST_DOUBLE_LOW (x);
 	  return;
 	default:
 return 4;
 }
 }
 static bool
-v850_rtx_costs (rtx x,
+v850_rtx_costs (rtx x, machine_mode mode, int outer_code,
-int codearg,
+		int opno ATTRIBUTE_UNUSED, int *total, bool speed)
-int outer_code ATTRIBUTE_UNUSED,
+{
-int * total, bool speed)
+enum rtx_code code = GET_CODE (x);
-{
-enum rtx_code code = (enum rtx_code) codearg;
 switch (code)
 {
 case CONST_INT:
 case CONST_DOUBLE:
 	*total = 60;
 return true;
 case MULT:
 if (TARGET_V850E
-	  && (   GET_MODE (x) == SImode
+	  && (mode == SImode || mode == HImode || mode == QImode))
-	      || 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)
 	    {
 HOST_WIDE_INT high, low;
 switch (code)
 {
 case 'c':
-/* We use 'c' operands with symbols for .vtinherit */
+/* We use 'c' operands with symbols for .vtinherit.  */
 if (GET_CODE (x) == SYMBOL_REF)
 {
 output_addr_const(file, x);
 break;
 }
-/* fall through */
+/* Fall through.  */
 case 'b':
 case 'B':
 case 'C':
 switch ((code == 'B' || code == 'C')
 	      ? reverse_condition (GET_CODE (x)) : GET_CODE (x))
 	    break;
 	  default:
 	    gcc_unreachable ();
 	}
 break;
-case 'F':			/* high word of CONST_DOUBLE */
+case 'F':			/* High word of CONST_DOUBLE.  */
 switch (GET_CODE (x))
 	{
 	case CONST_INT:
 	  fprintf (file, "%d", (INTVAL (x) >= 0) ? 0 : -1);
 	  break;
 	default:
 	  gcc_unreachable ();
 	}
 break;
-case 'G':			/* low word of CONST_DOUBLE */
+case 'G':			/* Low word of CONST_DOUBLE.  */
 switch (GET_CODE (x))
 	{
 	case CONST_INT:
 	  fprintf (file, "%ld", (long) INTVAL (x));
 	  break;
 	{
 	case REG:
 	  fprintf (file, reg_names[REGNO (x) + 1]);
 	  break;
 	case MEM:
-	  x = XEXP (adjust_address (x, SImode, 4), 0);
+	  {
-	  v850_print_operand_address (file, x);
+	    machine_mode mode = GET_MODE (x);
-	  if (GET_CODE (x) == CONST_INT)
+	    x = XEXP (adjust_address (x, SImode, 4), 0);
-	    fprintf (file, "[r0]");
+	    v850_print_operand_address (file, mode, x);
+	    if (GET_CODE (x) == CONST_INT)
+	      fprintf (file, "[r0]");
+	  }
 	  break;
+	case CONST_INT:
+	  {
+	    unsigned HOST_WIDE_INT v = INTVAL (x);
+	    /* Trickery to avoid problems with shifting
+	       32-bits at a time on a 32-bit host.  */
+	    v = v >> 16;
+	    v = v >> 16;
+	    fprintf (file, HOST_WIDE_INT_PRINT_HEX, v);
+	    break;
+	  }
+	case CONST_DOUBLE:
+	  fprintf (file, HOST_WIDE_INT_PRINT_HEX, CONST_DOUBLE_HIGH (x));
+	  break;
 	default:
-	  break;
+	  debug_rtx (x);
+	  gcc_unreachable ();
 	}
 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), TRUE))
 fputs ("s", file);
 break;
 }
-case 'W':			/* print the instruction suffix */
+case 'W':			/* Print the instruction suffix.  */
 switch (GET_MODE (x))
 	{
 	default:
 	  gcc_unreachable ();
-	case QImode: fputs (".b", file); break;
+	case E_QImode: fputs (".b", file); break;
-	case HImode: fputs (".h", file); break;
+	case E_HImode: fputs (".h", file); break;
-	case SImode: fputs (".w", file); break;
+	case E_SImode: fputs (".w", file); break;
-	case SFmode: fputs (".w", file); break;
+	case E_SFmode: fputs (".w", file); break;
 	}
 break;
-case '.':			/* register r0 */
+case '.':			/* Register r0.  */
 fputs (reg_names[0], file);
 break;
-case 'z':			/* reg or zero */
+case 'z':			/* Reg or zero.  */
-if (GET_CODE (x) == REG)
+if (REG_P (x))
 	fputs (reg_names[REGNO (x)], file);
 else if ((GET_MODE(x) == SImode
 		|| GET_MODE(x) == DFmode
 		|| GET_MODE(x) == SFmode)
 		&& x == CONST0_RTX(GET_MODE(x)))
 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),
+	    output_address (GET_MODE (x),
+			    gen_rtx_PLUS (SImode, gen_rtx_REG (SImode, 0),
 					  XEXP (x, 0)));
 	  else
-	    output_address (XEXP (x, 0));
+	    output_address (GET_MODE (x), 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_DOUBLE:
+	  fprintf (file, HOST_WIDE_INT_PRINT_HEX, CONST_DOUBLE_LOW (x));
+	  break;
 	case CONST_INT:
 	case SYMBOL_REF:
 	case CONST:
 	case LABEL_REF:
 	case CODE_LABEL:
-	  v850_print_operand_address (file, x);
+	  v850_print_operand_address (file, VOIDmode, x);
 	  break;
 	default:
 	  gcc_unreachable ();
 	}
 break;
 /* Output assembly language output for the address ADDR to FILE.  */
 static void
-v850_print_operand_address (FILE * file, rtx addr)
+v850_print_operand_address (FILE * file, machine_mode /*mode*/, rtx addr)
 {
 switch (GET_CODE (addr))
 {
 case REG:
 fprintf (file, "0[");
 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.  */
+Returns true if rtx was handled, false otherwise.  */
-int
+static bool
 v850_output_addr_const_extra (FILE * file, rtx x)
 {
 if (GET_CODE (x) != TRUNCATE)
-return 0;
+return false;
 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 (x, 0)) == LABEL_REF)
-&& GET_CODE (XEXP (XEXP (x, 0), 0)) == CODE_LABEL
+{
-&& INSN_DELETED_P (XEXP (XEXP (x, 0), 0)))
+rtx_code_label *label
-return 1;
+	= dyn_cast<rtx_code_label *> (XEXP (XEXP (x, 0), 0));
+if (label && label->deleted ())
+	return true;
+}
 output_addr_const (file, x);
-return 1;
+return true;
 }
 /* Return appropriate code to load up a 1, 2, or 4 integer/floating
 point value.  */
 	  else if (CONST_OK_FOR_L (value))	/* Upper 16 bits were set.  */
 	    return "movhi hi0(%1),%.,%0";
 	  /* A random constant.  */
-	  else if (TARGET_V850E || TARGET_V850E2_ALL)
+	  else if (TARGET_V850E_UP)
 	      return "mov %1,%0";
 	  else
 	    return "movhi hi(%1),%.,%0\n\tmovea lo(%1),%0,%0";
 	}
 	  else if (CONST_OK_FOR_L (high))	/* Upper 16 bits were set.  */
 	    return "movhi hi0(%F1),%.,%0";
 	  /* A random constant.  */
-	else if (TARGET_V850E || TARGET_V850E2_ALL)
+	else if (TARGET_V850E_UP)
 	      return "mov %F1,%0";
 	  else
 	    return "movhi hi(%F1),%.,%0\n\tmovea lo(%F1),%0,%0";
 	}
 else if (GET_CODE (src) == LABEL_REF
 	       || GET_CODE (src) == SYMBOL_REF
 	       || GET_CODE (src) == CONST)
 	{
-	  if (TARGET_V850E || TARGET_V850E2_ALL)
+	  if (TARGET_V850E_UP)
 	    return "mov hilo(%1),%0";
 	  else
 	    return "movhi hi(%1),%.,%0\n\tmovea lo(%1),%0,%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));
+fatal_insn ("output_move_single:", gen_rtx_SET (dst, src));
 return "";
 }
-/* Generate comparison code.  */
+machine_mode
-int
-v850_float_z_comparison_operator (rtx op, enum machine_mode mode)
-{
-enum rtx_code code = GET_CODE (op);
-if (GET_RTX_CLASS (code) != RTX_COMPARE
-&& GET_RTX_CLASS (code) != RTX_COMM_COMPARE)
-return 0;
-if (mode != GET_MODE (op) && mode != VOIDmode)
-return 0;
-if ((GET_CODE (XEXP (op, 0)) != REG
-|| REGNO (XEXP (op, 0)) != CC_REGNUM)
-|| XEXP (op, 1) != const0_rtx)
-return 0;
-if (GET_MODE (XEXP (op, 0)) == CC_FPU_LTmode)
-return code == LT;
-if (GET_MODE (XEXP (op, 0)) == CC_FPU_LEmode)
-return code == LE;
-if (GET_MODE (XEXP (op, 0)) == CC_FPU_EQmode)
-return code == EQ;
-return 0;
-}
-int
-v850_float_nz_comparison_operator (rtx op, enum machine_mode mode)
-{
-enum rtx_code code = GET_CODE (op);
-if (GET_RTX_CLASS (code) != RTX_COMPARE
-&& GET_RTX_CLASS (code) != RTX_COMM_COMPARE)
-return 0;
-if (mode != GET_MODE (op) && mode != VOIDmode)
-return 0;
-if ((GET_CODE (XEXP (op, 0)) != REG
-|| REGNO (XEXP (op, 0)) != CC_REGNUM)
-|| XEXP (op, 1) != const0_rtx)
-return 0;
-if (GET_MODE (XEXP (op, 0)) == CC_FPU_GTmode)
-return code == GT;
-if (GET_MODE (XEXP (op, 0)) == CC_FPU_GEmode)
-return code == GE;
-if (GET_MODE (XEXP (op, 0)) == CC_FPU_NEmode)
-return code == NE;
-return 0;
-}
-enum machine_mode
 v850_select_cc_mode (enum rtx_code cond, rtx op0, rtx op1 ATTRIBUTE_UNUSED)
 {
 if (GET_MODE_CLASS (GET_MODE (op0)) == MODE_FLOAT)
 {
 switch (cond)
 	case EQ:
 	  return CC_FPU_EQmode;
 	case NE:
 	  return CC_FPU_NEmode;
 	default:
-	  abort ();
+	  gcc_unreachable ();
 	}
 }
 return CCmode;
 }
-enum machine_mode
+machine_mode
-v850_gen_float_compare (enum rtx_code cond, enum machine_mode mode ATTRIBUTE_UNUSED, rtx op0, rtx op1)
+v850_gen_float_compare (enum rtx_code cond, machine_mode mode ATTRIBUTE_UNUSED, rtx op0, rtx op1)
 {
-if (GET_MODE(op0) == DFmode)
+if (GET_MODE (op0) == DFmode)
 {
 switch (cond)
 	{
 	case LE:
 	  emit_insn (gen_cmpdf_le_insn (op0, op1));
 	  emit_insn (gen_cmpdf_lt_insn (op0, op1));
 	  break;
 	case GT:
 	  emit_insn (gen_cmpdf_gt_insn (op0, op1));
 	  break;
+	case NE:
+	  /* Note: There is no NE comparison operator. So we
+	     perform an EQ comparison and invert the branch.
+	     See v850_float_nz_comparison for how this is done.  */
 	case EQ:
 	  emit_insn (gen_cmpdf_eq_insn (op0, op1));
 	  break;
-	case NE:
-	  emit_insn (gen_cmpdf_ne_insn (op0, op1));
-	  break;
 	default:
-	  abort ();
+	  gcc_unreachable ();
 	}
 }
-else if (GET_MODE(v850_compare_op0) == SFmode)
+else if (GET_MODE (v850_compare_op0) == SFmode)
 {
 switch (cond)
 	{
 	case LE:
 	  emit_insn (gen_cmpsf_le_insn(op0, op1));
 	  emit_insn (gen_cmpsf_lt_insn(op0, op1));
 	  break;
 	case GT:
 	  emit_insn (gen_cmpsf_gt_insn(op0, op1));
 	  break;
+	case NE:
+	  /* Note: There is no NE comparison operator. So we
+	     perform an EQ comparison and invert the branch.
+	     See v850_float_nz_comparison for how this is done.  */
 	case EQ:
 	  emit_insn (gen_cmpsf_eq_insn(op0, op1));
 	  break;
-	case NE:
-	  emit_insn (gen_cmpsf_ne_insn(op0, op1));
-	  break;
 	default:
-	  abort ();
+	  gcc_unreachable ();
 	}
 }
 else
-{
+gcc_unreachable ();
-abort ();
-}
 return v850_select_cc_mode (cond, op0, op1);
 }
 rtx
-v850_gen_compare (enum rtx_code cond, enum machine_mode mode, rtx op0, rtx op1)
+v850_gen_compare (enum rtx_code cond, machine_mode mode, rtx op0, rtx op1)
 {
 if (GET_MODE_CLASS(GET_MODE (op0)) != MODE_FLOAT)
 {
 emit_insn (gen_cmpsi_insn (op0, op1));
 return gen_rtx_fmt_ee (cond, mode, gen_rtx_REG(CCmode, CC_REGNUM), const0_rtx);
 else
 {
 rtx cc_reg;
 mode = v850_gen_float_compare (cond, mode, op0, op1);
 cc_reg = gen_rtx_REG (mode, CC_REGNUM);
-emit_insn (gen_rtx_SET(mode, cc_reg, gen_rtx_REG (mode, FCC_REGNUM)));
+emit_insn (gen_rtx_SET (cc_reg, gen_rtx_REG (mode, FCC_REGNUM)));
 return gen_rtx_fmt_ee (cond, mode, cc_reg, const0_rtx);
 }
 }
 /* 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)
+ep_memory_offset (machine_mode mode, int unsignedp ATTRIBUTE_UNUSED)
 {
 int max_offset = 0;
 switch (mode)
 {
-case QImode:
+case E_QImode:
 if (TARGET_SMALL_SLD)
 	max_offset = (1 << 4);
-else if ((TARGET_V850E || TARGET_V850E2_ALL)
+else if ((TARGET_V850E_UP)
 		&& unsignedp)
 	max_offset = (1 << 4);
 else
 	max_offset = (1 << 7);
 break;
-case HImode:
+case E_HImode:
 if (TARGET_SMALL_SLD)
 	max_offset = (1 << 5);
-else if ((TARGET_V850E || TARGET_V850E2_ALL)
+else if ((TARGET_V850E_UP)
 		&& unsignedp)
 	max_offset = (1 << 5);
 else
 	max_offset = (1 << 8);
 break;
-case SImode:
+case E_SImode:
-case SFmode:
+case E_SFmode:
 max_offset = (1 << 8);
 break;
 default:
 break;
 }
 /* Return true if OP is a valid short EP memory reference */
 int
-ep_memory_operand (rtx op, enum machine_mode mode, int unsigned_load)
+ep_memory_operand (rtx op, machine_mode mode, int unsigned_load)
 {
 rtx addr, op0, op1;
 int max_offset;
 int mask;
 /* 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,
+substitute_ep_register (rtx_insn *first_insn,
-rtx last_insn,
+rtx_insn *last_insn,
 int uses,
 int regno,
 rtx * p_r1,
 rtx * p_ep)
 {
 rtx reg = gen_rtx_REG (Pmode, regno);
-rtx insn;
+rtx_insn *insn;
 if (!*p_r1)
 {
 df_set_regs_ever_live (1, true);
 *p_r1 = gen_rtx_REG (Pmode, 1);
 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)
+if (NOTE_P (first_insn))
 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)
+if (NONJUMP_INSN_P (insn))
 	{
 	  rtx pattern = single_set (insn);
 	  /* Replace the memory references.  */
 	  if (pattern)
 	}
 }
 /* Optimize back to back cases of ep <- r1 & r1 <- ep.  */
 insn = prev_nonnote_insn (first_insn);
-if (insn && GET_CODE (insn) == INSN
+if (insn && NONJUMP_INSN_P (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 (*p_r1, *p_ep), first_insn);
-emit_insn_before (gen_rtx_SET (Pmode, *p_ep, reg), first_insn);
+emit_insn_before (gen_rtx_SET (*p_ep, reg), first_insn);
-emit_insn_before (gen_rtx_SET (Pmode, *p_ep, *p_r1), last_insn);
+emit_insn_before (gen_rtx_SET (*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
 v850_reorg (void)
 {
 struct
 {
 int uses;
-rtx first_insn;
+rtx_insn *first_insn;
-rtx last_insn;
+rtx_insn *last_insn;
 }
 regs[FIRST_PSEUDO_REGISTER];
 int i;
 int use_ep = FALSE;
 rtx r1 = NULL_RTX;
 rtx ep = NULL_RTX;
-rtx insn;
+rtx_insn *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].first_insn = NULL;
-regs[i].last_insn = NULL_RTX;
+regs[i].last_insn = NULL;
 }
 for (insn = get_insns (); insn != NULL_RTX; insn = NEXT_INSN (insn))
 {
 switch (GET_CODE (insn))
 	  use_ep = FALSE;
 	  for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 	    {
 	      regs[i].uses = 0;
-	      regs[i].first_insn = NULL_RTX;
+	      regs[i].first_insn = NULL;
-	      regs[i].last_insn = NULL_RTX;
+	      regs[i].last_insn = NULL;
 	    }
 	  break;
 	case NOTE:
 	  break;
 	case INSN:
 	  pattern = single_set (insn);
-	  /* See if there are any memory references we can shorten */
+	  /* See if there are any memory references we can shorten.  */
 	  if (pattern)
 	    {
 	      rtx src = SET_SRC (pattern);
 	      rtx dest = SET_DEST (pattern);
 	      rtx mem;
 	      /* 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);
+		alter_subreg (&dest, false);
 	      if (GET_CODE (src) == SUBREG
 		  && (GET_CODE (SUBREG_REG (src)) == MEM
 		      || GET_CODE (SUBREG_REG (src)) == REG))
-		alter_subreg (&src);
+		alter_subreg (&src, false);
 	      if (GET_CODE (dest) == MEM && GET_CODE (src) == MEM)
 		mem = NULL_RTX;
 	      else if (GET_CODE (dest) == MEM)
 	      /* 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);
+		  endregno = END_REGNO (dest);
 		  if (!use_ep)
 		    {
 		      /* See if we can use the pointer before this
 			 modification.  */
 			  /* 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].first_insn = NULL;
-			      regs[i].last_insn = NULL_RTX;
+			      regs[i].last_insn = NULL;
 			    }
 			}
 		    }
 		  for (i = regno; i < endregno; i++)
 		    {
 		      regs[i].uses = 0;
-		      regs[i].first_insn = NULL_RTX;
+		      regs[i].first_insn = NULL;
-		      regs[i].last_insn = NULL_RTX;
+		      regs[i].last_insn = NULL;
 		    }
 		}
 	    }
 	}
 }
 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)
 *p_reg_saved = reg_saved;
 return size;
 }
+/* Typical stack layout should looks like this after the function's prologue:
+|    |
+--                       ^
+|    | \                   |
+|    |   arguments saved   | Increasing
+|    |   on the stack      |  addresses
+PARENT   arg pointer -> |    | /
+-------------------------- ---- -------------------
+|    | - space for argument split between regs & stack
+			      --
+CHILD                   |    | \    <-- (return address here)
+|    |   other call
+|    |   saved registers
+|    | /
+--
+frame pointer ->    |    | \             ___
+|    |   local        |
+|    |   variables    |f
+|    | /              |r
+--                  |a
+|    | \              |m
+|    |   outgoing     |e
+|    |   arguments    |    | Decreasing
+(hard) frame pointer    |    |  /             |    |  addresses
+and stack pointer -> |    | /             _|_   |
+-------------------------- ---- ------------------   V */
 int
 compute_frame_size (int size, long * p_reg_saved)
 {
 return (size
 	  + compute_register_save_size (p_reg_saved)
 /* 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.  */
 return ((save_func_len + restore_func_len) < (save_normal_len + restore_normal_len));
+}
+static void
+increment_stack (signed int amount, bool in_prologue)
+{
+rtx inc;
+if (amount == 0)
+return;
+inc = GEN_INT (amount);
+if (! CONST_OK_FOR_K (amount))
+{
+rtx reg = gen_rtx_REG (Pmode, 12);
+inc = emit_move_insn (reg, inc);
+if (in_prologue)
+	F (inc);
+inc = reg;
+}
+inc = emit_insn (gen_addsi3 (stack_pointer_rtx, stack_pointer_rtx, inc));
+if (in_prologue)
+F (inc);
 }
 void
 expand_prologue (void)
 {
 int interrupt_handler = v850_interrupt_function_p (current_function_decl);
 long reg_saved = 0;
 actual_fsize = compute_frame_size (size, &reg_saved);
+if (flag_stack_usage_info)
+current_function_static_stack_size = actual_fsize;
 /* Save/setup global registers for interrupt functions right now.  */
 if (interrupt_handler)
 {
-if (! TARGET_DISABLE_CALLT)
+if (! TARGET_DISABLE_CALLT && (TARGET_V850E_UP))
 	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;
+/* Interrupt functions are not passed arguments, so no need to
+	 allocate space for split structure arguments.  */
+gcc_assert (crtl->args.pretend_args_size == 0);
 }
 /* Identify all of the saved registers.  */
 num_save = 0;
 for (i = 1; i < 32; i++)
 {
 if (((1L << i) & reg_saved) != 0)
 	save_regs[num_save++] = gen_rtx_REG (Pmode, i);
 }
+if (crtl->args.pretend_args_size)
+{
+if (num_save == 0)
+	{
+	  increment_stack (- (actual_fsize + crtl->args.pretend_args_size), true);
+	  actual_fsize = 0;
+	}
+else
+	increment_stack (- crtl->args.pretend_args_size, true);
+}
 /* See if we have an insn that allocates stack space and saves the particular
-registers we want to.  */
+registers we want to.  Note that the helpers won't
+allocate additional space for registers GCC saves to complete a
+"split" structure argument.  */
 save_all = NULL_RTX;
-if (TARGET_PROLOG_FUNCTION && num_save > 0)
+if (TARGET_PROLOG_FUNCTION
+&& !crtl->args.pretend_args_size
+&& num_save > 0)
 {
 if (use_prolog_function (num_save, actual_fsize))
 	{
 	  int alloc_stack = 4 * num_save;
 	  int offset = 0;
 	    (VOIDmode,
 	     rtvec_alloc (num_save + 1
 			  + (TARGET_DISABLE_CALLT ? (TARGET_LONG_CALLS ? 2 : 1) : 0)));
 	  XVECEXP (save_all, 0, 0)
-	    = gen_rtx_SET (VOIDmode,
+	    = gen_rtx_SET (stack_pointer_rtx,
-			   stack_pointer_rtx,
 			   gen_rtx_PLUS (Pmode,
 					 stack_pointer_rtx,
 					 GEN_INT(-alloc_stack)));
 	  for (i = 0; i < num_save; i++)
 	    {
 	      offset -= 4;
 	      XVECEXP (save_all, 0, i+1)
-		= gen_rtx_SET (VOIDmode,
+		= gen_rtx_SET (gen_rtx_MEM (Pmode,
-			       gen_rtx_MEM (Pmode,
 					    gen_rtx_PLUS (Pmode,
 							  stack_pointer_rtx,
 							  GEN_INT(offset))),
 			       save_regs[i]);
 	    }
 	      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);
+	  v850_all_frame_related (save_all);
+	  code = recog (save_all, NULL, NULL);
 	  if (code >= 0)
 	    {
 	      rtx insn = emit_insn (save_all);
 	      INSN_CODE (insn) = code;
 	      actual_fsize -= alloc_stack;
 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_DISABLE_CALLT)
+	  if (! TARGET_DISABLE_CALLT && (TARGET_V850E_UP))
 	    emit_insn (gen_callt_save_all_interrupt ());
 	  else
 	    emit_insn (gen_save_all_interrupt ());
 	}
 else
 	  /* 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,
+	    increment_stack (- (signed) init_stack_alloc, true);
-				   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,
+	      F (emit_move_insn (gen_rtx_MEM (SImode,
-					   plus_constant (stack_pointer_rtx,
+					      plus_constant (Pmode,
-							  offset)),
+							     stack_pointer_rtx,
-			      save_regs[--num_save]);
+							     offset)),
+				 save_regs[--num_save]));
 	      offset -= 4;
 	    }
 	  for (i = 0; i < num_save; i++)
 	    {
-	      emit_move_insn (gen_rtx_MEM (SImode,
+	      F (emit_move_insn (gen_rtx_MEM (SImode,
-					   plus_constant (stack_pointer_rtx,
+					      plus_constant (Pmode,
-							  offset)),
+							     stack_pointer_rtx,
-			      save_regs[i]);
+							     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)
-{
+increment_stack (init_stack_alloc - actual_fsize, true);
-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);
+F (emit_move_insn (hard_frame_pointer_rtx, stack_pointer_rtx));
 }
 void
 expand_epilogue (void)
 want to.  */
 restore_all = NULL_RTX;
 if (TARGET_PROLOG_FUNCTION
 && num_restore > 0
+&& !crtl->args.pretend_args_size
 && !interrupt_handler)
 {
 int alloc_stack = (4 * num_restore);
 /* Don't bother checking if we don't actually save any space.  */
 if (use_prolog_function (num_restore, actual_fsize))
 	{
 	  int offset;
 	  restore_all = gen_rtx_PARALLEL (VOIDmode,
 					  rtvec_alloc (num_restore + 2));
-	  XVECEXP (restore_all, 0, 0) = gen_rtx_RETURN (VOIDmode);
+	  XVECEXP (restore_all, 0, 0) = ret_rtx;
 	  XVECEXP (restore_all, 0, 1)
-	    = gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+	    = gen_rtx_SET (stack_pointer_rtx,
-			    gen_rtx_PLUS (Pmode,
+			   gen_rtx_PLUS (Pmode,
-					  stack_pointer_rtx,
+					 stack_pointer_rtx,
-					  GEN_INT (alloc_stack)));
+					 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,
+		= gen_rtx_SET (restore_regs[i],
-			       restore_regs[i],
 			       gen_rtx_MEM (Pmode,
 gen_rtx_PLUS (Pmode,
 stack_pointer_rtx,
 GEN_INT(offset))));
 	      offset -= 4;
 	    }
-	  code = recog (restore_all, NULL_RTX, NULL);
+	  code = recog (restore_all, NULL, NULL);
 	  if (code >= 0)
 	    {
 	      rtx insn;
 	      actual_fsize -= alloc_stack;
-	      if (actual_fsize)
+	      increment_stack (actual_fsize, false);
-		{
-		  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;
 	    }
 	  else
 	    restore_all = NULL_RTX;
 	}
 }
 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)
-	{
+	increment_stack (actual_fsize - init_stack_free, false);
-	  int diff;
-	  diff = actual_fsize - 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 (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,
+					   plus_constant (Pmode,
+							  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,
+					   plus_constant (Pmode,
+							  stack_pointer_rtx,
 							  offset)));
 	      emit_use (restore_regs[i]);
 	      offset -= 4;
 	    }
 	  /* Cut back the remainder of the stack.  */
-	  if (init_stack_free)
+	  increment_stack (init_stack_free + crtl->args.pretend_args_size,
-	    emit_insn (gen_addsi3 (stack_pointer_rtx,
+			   false);
-				   stack_pointer_rtx,
-				   GEN_INT (init_stack_free)));
 	}
 /* And return or use reti for interrupt handlers.  */
 if (interrupt_handler)
 {
-if (! TARGET_DISABLE_CALLT)
+if (! TARGET_DISABLE_CALLT && (TARGET_V850E_UP))
 emit_insn (gen_callt_return_interrupt ());
 else
 emit_jump_insn (gen_return_interrupt ());
 	 }
 else if (actual_fsize)
 v850_interrupt_p = FALSE;
 }
 /* Update the condition code from the insn.  */
 void
-notice_update_cc (rtx body, rtx insn)
+notice_update_cc (rtx body, rtx_insn *insn)
 {
 switch (get_attr_cc (insn))
 {
 case CC_NONE:
 /* Insn does not affect CC at all.  */
 		    "data area attributes cannot be specified for "
 		    "local variables");
 	  *no_add_attrs = true;
 	}
-/* Drop through.  */
+/* FALLTHRU */
 case FUNCTION_DECL:
 area = v850_get_data_area (decl);
 if (area != DATA_AREA_NORMAL && data_area != area)
 	{
 /* 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));
+	  const char *name = 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"))
 	{
 	  int size = int_size_in_bytes (TREE_TYPE (decl));
 	  if (size <= 0)
 	    ;
-	  else if (size <= small_memory [(int) SMALL_MEMORY_TDA].max)
+	  else if (size <= small_memory_max [(int) SMALL_MEMORY_TDA])
 	    v850_set_data_area (decl, DATA_AREA_TDA);
-	  else if (size <= small_memory [(int) SMALL_MEMORY_SDA].max)
+	  else if (size <= small_memory_max [(int) SMALL_MEMORY_SDA])
 	    v850_set_data_area (decl, DATA_AREA_SDA);
-	  else if (size <= small_memory [(int) SMALL_MEMORY_ZDA].max)
+	  else if (size <= small_memory_max [(int) SMALL_MEMORY_ZDA])
 	    v850_set_data_area (decl, DATA_AREA_ZDA);
 	}
 if (v850_get_data_area (decl) == DATA_AREA_NORMAL)
 	return;
 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",
+if (TARGET_V850E3V5_UP)
-	       name, name);
+	sprintf (buff, "mov hilo(%s), r11\n\tjarl [r11], r10", name);
+else
+	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]);
 		 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,
 switch_to_section (sbss_section);
 break;
 case DATA_AREA_TDA:
 switch_to_section (tdata_section);
+break;
 default:
 switch_to_section (bss_section);
 break;
 }
 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");
+	= ".sdata";
 GHS_default_section_names [(int) GHS_SECTION_KIND_ROSDATA]
-	= build_string (sizeof (".rosdata")-1, ".rosdata");
+	= ".rosdata";
 GHS_default_section_names [(int) GHS_SECTION_KIND_TDATA]
-	= build_string (sizeof (".tdata")-1, ".tdata");
+	= ".tdata";
 GHS_default_section_names [(int) GHS_SECTION_KIND_ZDATA]
-	= build_string (sizeof (".zdata")-1, ".zdata");
+	= ".zdata";
 GHS_default_section_names [(int) GHS_SECTION_KIND_ROZDATA]
-	= build_string (sizeof (".rozdata")-1, ".rozdata");
+	= ".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;
+const char * chosen_section;
 if (TREE_CODE (decl) == FUNCTION_DECL)
 	kind = GHS_SECTION_KIND_TEXT;
 else
 	{
 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;
+	  set_decl_section_name (decl, chosen_section);
 	}
 }
 }
 /* Construct a DISPOSE instruction that is the equivalent of
 /* Worker function for TARGET_FUNCTION_VALUE_REGNO_P.  */
 static bool
 v850_function_value_regno_p (const unsigned int regno)
 {
-return (regno == 10);
+return (regno == RV_REGNUM);
 }
 /* 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;
+return int_size_in_bytes (type) > 8
+|| TYPE_MODE (type) == BLKmode
+/* With the rh850 ABI return all aggregates in memory.  */
+|| ((! TARGET_GCC_ABI) && AGGREGATE_TYPE_P (type))
+;
 }
 /* Worker function for TARGET_FUNCTION_VALUE.  */
 static 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);
+return gen_rtx_REG (TYPE_MODE (valtype), RV_REGNUM);
+}
+/* Implement TARGET_LIBCALL_VALUE.  */
+static rtx
+v850_libcall_value (machine_mode mode,
+		    const_rtx func ATTRIBUTE_UNUSED)
+{
+return gen_rtx_REG (mode, RV_REGNUM);
 }
-/* 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)
 {
 }
 static int
 v850_issue_rate (void)
 {
-return (TARGET_V850E2_ALL? 2 : 1);
+return (TARGET_V850E2_UP ? 2 : 1);
+}
+/* Implement TARGET_LEGITIMATE_CONSTANT_P.  */
+static bool
+v850_legitimate_constant_p (machine_mode mode ATTRIBUTE_UNUSED, rtx x)
+{
+return (GET_CODE (x) == CONST_DOUBLE
+	  || !(GET_CODE (x) == CONST
+	       && GET_CODE (XEXP (x, 0)) == PLUS
+	       && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
+	       && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
+	       && !CONST_OK_FOR_K (INTVAL (XEXP (XEXP (x, 0), 1)))));
+}
+/* Helper function for `v850_legitimate_address_p'.  */
+static bool
+v850_reg_ok_for_base_p (const_rtx reg, bool strict_p)
+{
+if (strict_p)
+{
+return REGNO_OK_FOR_BASE_P (REGNO (reg));
+} else {
+return true;
+}
+}
+/* Accept either REG or SUBREG where a register is valid.  */
+static bool
+v850_rtx_ok_for_base_p (const_rtx x, bool strict_p)
+{
+return ((REG_P (x) && v850_reg_ok_for_base_p  (x, strict_p))
+	  || (SUBREG_P (x) && REG_P (SUBREG_REG (x))
+	      && v850_reg_ok_for_base_p (SUBREG_REG (x), strict_p)));
+}
+/* Implement TARGET_LEGITIMATE_ADDRESS_P.  */
+static bool
+v850_legitimate_address_p (machine_mode mode, rtx x, bool strict_p,
+			   addr_space_t as ATTRIBUTE_UNUSED)
+{
+gcc_assert (ADDR_SPACE_GENERIC_P (as));
+if (v850_rtx_ok_for_base_p (x, strict_p))
+return true;
+if (CONSTANT_ADDRESS_P (x)
+&& (mode == QImode || INTVAL (x) % 2 == 0)
+&& (GET_MODE_SIZE (mode) <= 4 || INTVAL (x) % 4 == 0))
+return true;
+if (GET_CODE (x) == LO_SUM
+&& REG_P (XEXP (x, 0))
+&& v850_reg_ok_for_base_p (XEXP (x, 0), strict_p)
+&& CONSTANT_P (XEXP (x, 1))
+&& (!CONST_INT_P (XEXP (x, 1))
+	  || ((mode == QImode || INTVAL (XEXP (x, 1)) % 2 == 0)
+	      && constraint_satisfied_p (XEXP (x, 1), CONSTRAINT_K)))
+&& GET_MODE_SIZE (mode) <= GET_MODE_SIZE (word_mode))
+return true;
+if (special_symbolref_operand (x, mode)
+&& (GET_MODE_SIZE (mode) <= GET_MODE_SIZE (word_mode)))
+return true;
+if (GET_CODE (x) == PLUS
+&& v850_rtx_ok_for_base_p (XEXP (x, 0), strict_p)
+&& constraint_satisfied_p (XEXP (x,1), CONSTRAINT_K)
+&& ((mode == QImode || INTVAL (XEXP (x, 1)) % 2 == 0)
+	   && CONST_OK_FOR_K (INTVAL (XEXP (x, 1))
+			      + (GET_MODE_NUNITS (mode) * UNITS_PER_WORD))))
+return true;
+return false;
+}
+static int
+v850_memory_move_cost (machine_mode mode,
+		       reg_class_t reg_class ATTRIBUTE_UNUSED,
+		       bool in)
+{
+switch (GET_MODE_SIZE (mode))
+{
+case 0:
+return in ? 24 : 8;
+case 1:
+case 2:
+case 3:
+case 4:
+return in ? 6 : 2;
+default:
+return (GET_MODE_SIZE (mode) / 2) * (in ? 3 : 1);
+}
+}
+int
+v850_adjust_insn_length (rtx_insn *insn, int length)
+{
+if (TARGET_V850E3V5_UP)
+{
+if (CALL_P (insn))
+	{
+	  if (TARGET_LONG_CALLS)
+	    {
+	      /* call_internal_long, call_value_internal_long.  */
+	      if (length == 8)
+		length = 4;
+	      if (length == 16)
+		length = 10;
+	    }
+	  else
+	    {
+	      /* call_internal_short, call_value_internal_short.  */
+	      if (length == 8)
+		length = 4;
+	    }
+	}
+}
+return length;
 }
 /* V850 specific attributes.  */
 static const struct attribute_spec v850_attribute_table[] =
 {
-/* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
+/* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
-{ "interrupt_handler", 0, 0, true,  false, false, v850_handle_interrupt_attribute },
+affects_type_identity } */
-{ "interrupt",         0, 0, true,  false, false, v850_handle_interrupt_attribute },
+{ "interrupt_handler", 0, 0, true,  false, false,
-{ "sda",               0, 0, true,  false, false, v850_handle_data_area_attribute },
+v850_handle_interrupt_attribute, false },
-{ "tda",               0, 0, true,  false, false, v850_handle_data_area_attribute },
+{ "interrupt",         0, 0, true,  false, false,
-{ "zda",               0, 0, true,  false, false, v850_handle_data_area_attribute },
+v850_handle_interrupt_attribute, false },
-{ NULL,                0, 0, false, false, false, NULL }
+{ "sda",               0, 0, true,  false, false,
+v850_handle_data_area_attribute, false },
+{ "tda",               0, 0, true,  false, false,
+v850_handle_data_area_attribute, false },
+{ "zda",               0, 0, true,  false, false,
+v850_handle_data_area_attribute, false },
+{ NULL,                0, 0, false, false, false, NULL, false }
 };
+static void
+v850_option_override (void)
+{
+if (flag_exceptions || flag_non_call_exceptions)
+flag_omit_frame_pointer = 0;
+/* The RH850 ABI does not (currently) support the use of the CALLT instruction.  */
+if (! TARGET_GCC_ABI)
+target_flags |= MASK_DISABLE_CALLT;
+}
+const char *
+v850_gen_movdi (rtx * operands)
+{
+if (REG_P (operands[0]))
+{
+if (REG_P (operands[1]))
+	{
+	  if (REGNO (operands[0]) == (REGNO (operands[1]) - 1))
+	    return "mov %1, %0; mov %R1, %R0";
+	  return "mov %R1, %R0; mov %1, %0";
+	}
+if (MEM_P (operands[1]))
+	{
+	  if (REGNO (operands[0]) & 1)
+	    /* Use two load word instructions to synthesise a load double.  */
+	    return "ld.w %1, %0 ; ld.w %R1, %R0" ;
+	  return "ld.dw %1, %0";
+	}
+return "mov %1, %0; mov %R1, %R0";
+}
+gcc_assert (REG_P (operands[1]));
+if (REGNO (operands[1]) & 1)
+/* Use two store word instructions to synthesise a store double.  */
+return "st.w %1, %0 ; st.w %R1, %R0 ";
+return "st.dw %1, %0";
+}
+/* Implement TARGET_HARD_REGNO_MODE_OK.  */
+static bool
+v850_hard_regno_mode_ok (unsigned int regno, machine_mode mode)
+{
+return GET_MODE_SIZE (mode) <= 4 || ((regno & 1) == 0 && regno != 0);
+}
+/* Implement TARGET_MODES_TIEABLE_P.  */
+static bool
+v850_modes_tieable_p (machine_mode mode1, machine_mode mode2)
+{
+return (mode1 == mode2
+	  || (GET_MODE_SIZE (mode1) <= 4 && GET_MODE_SIZE (mode2) <= 4));
+}
 /* Initialize the GCC target structure.  */
+#undef  TARGET_OPTION_OVERRIDE
+#define TARGET_OPTION_OVERRIDE		v850_option_override
+#undef  TARGET_MEMORY_MOVE_COST
+#define TARGET_MEMORY_MOVE_COST 	v850_memory_move_cost
 #undef  TARGET_ASM_ALIGNED_HI_OP
 #define TARGET_ASM_ALIGNED_HI_OP "\t.hword\t"
 #undef  TARGET_PRINT_OPERAND
-#define TARGET_PRINT_OPERAND v850_print_operand
+#define TARGET_PRINT_OPERAND 		v850_print_operand
 #undef  TARGET_PRINT_OPERAND_ADDRESS
-#define TARGET_PRINT_OPERAND_ADDRESS v850_print_operand_address
+#define TARGET_PRINT_OPERAND_ADDRESS 		v850_print_operand_address
 #undef  TARGET_PRINT_OPERAND_PUNCT_VALID_P
-#define TARGET_PRINT_OPERAND_PUNCT_VALID_P v850_print_operand_punct_valid_p
+#define TARGET_PRINT_OPERAND_PUNCT_VALID_P 	v850_print_operand_punct_valid_p
+#undef TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA
+#define TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA v850_output_addr_const_extra
 #undef  TARGET_ATTRIBUTE_TABLE
 #define TARGET_ATTRIBUTE_TABLE v850_attribute_table
 #undef  TARGET_INSERT_ATTRIBUTES
 #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
+#define TARGET_ADDRESS_COST hook_int_rtx_mode_as_bool_0
 #undef  TARGET_MACHINE_DEPENDENT_REORG
 #define TARGET_MACHINE_DEPENDENT_REORG v850_reorg
 #undef  TARGET_SCHED_ISSUE_RATE
 #undef  TARGET_FUNCTION_VALUE_REGNO_P
 #define TARGET_FUNCTION_VALUE_REGNO_P v850_function_value_regno_p
 #undef  TARGET_FUNCTION_VALUE
 #define TARGET_FUNCTION_VALUE v850_function_value
+#undef  TARGET_LIBCALL_VALUE
+#define TARGET_LIBCALL_VALUE v850_libcall_value
 #undef  TARGET_PROMOTE_PROTOTYPES
 #define TARGET_PROMOTE_PROTOTYPES hook_bool_const_tree_true
 #undef  TARGET_RETURN_IN_MEMORY
 #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_FUNCTION_ARG
 #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
-#undef  TARGET_STRICT_ARGUMENT_NAMING
+#undef  TARGET_LEGITIMATE_CONSTANT_P
-#define TARGET_STRICT_ARGUMENT_NAMING v850_strict_argument_naming
+#define TARGET_LEGITIMATE_CONSTANT_P v850_legitimate_constant_p
-#undef  TARGET_OPTION_OPTIMIZATION_TABLE
+#undef TARGET_LRA_P
-#define TARGET_OPTION_OPTIMIZATION_TABLE v850_option_optimization_table
+#define TARGET_LRA_P hook_bool_void_false
+#undef  TARGET_ADDR_SPACE_LEGITIMATE_ADDRESS_P
+#define TARGET_ADDR_SPACE_LEGITIMATE_ADDRESS_P v850_legitimate_address_p
+#undef  TARGET_CAN_USE_DOLOOP_P
+#define TARGET_CAN_USE_DOLOOP_P can_use_doloop_if_innermost
+#undef  TARGET_HARD_REGNO_MODE_OK
+#define TARGET_HARD_REGNO_MODE_OK v850_hard_regno_mode_ok
+#undef  TARGET_MODES_TIEABLE_P
+#define TARGET_MODES_TIEABLE_P v850_modes_tieable_p
 struct gcc_target targetm = TARGET_INITIALIZER;
 #include "gt-v850.h"

Mercurial > hg > CbC > CbC_gcc

comparison gcc/config/v850/v850.c @ 111:04ced10e8804