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

comparison gcc/config/iq2000/iq2000.c @ 67:f6334be47118

update gcc from gcc-4.6-20100522 to gcc-4.6-20110318

author	nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
date	Tue, 22 Mar 2011 17:18:12 +0900
parents	b7f97abdc517
children	04ced10e8804

comparison

equal deleted inserted replaced

-:65488c3d617d
+:f6334be47118
 /* Subroutines used for code generation on Vitesse IQ2000 processors
-Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009
+Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
 Free Software Foundation, Inc.
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify
 <http://www.gnu.org/licenses/>.  */
 #include "config.h"
 #include "system.h"
 #include "coretypes.h"
-#include <signal.h>
 #include "tm.h"
 #include "tree.h"
 #include "rtl.h"
 #include "regs.h"
 #include "hard-reg-set.h"
 #include "function.h"
 #include "expr.h"
 #include "optabs.h"
 #include "libfuncs.h"
 #include "recog.h"
-#include "toplev.h"
+#include "diagnostic-core.h"
 #include "reload.h"
 #include "ggc.h"
 #include "tm_p.h"
 #include "debug.h"
 #include "target.h"
 #include "target-def.h"
 #include "langhooks.h"
+#include "df.h"
 /* Enumeration for all of the relational tests, so that we can build
 arrays indexed by the test type, and not worry about the order
 of EQ, NE, etc.  */
 int  num_gp;			/* Number of gp registers saved.  */
 };
 /* Global variables for machine-dependent things.  */
-/* List of all IQ2000 punctuation characters used by print_operand.  */
+/* List of all IQ2000 punctuation characters used by iq2000_print_operand.  */
-char iq2000_print_operand_punct[256];
+static char iq2000_print_operand_punct[256];
 /* The target cpu for optimization and scheduling.  */
 enum processor_type iq2000_tune;
 /* Which instruction set architecture to use.  */
 /* Initialize the GCC target structure.  */
 static struct machine_function* iq2000_init_machine_status (void);
 static bool iq2000_handle_option      (size_t, const char *, int);
+static void iq2000_option_override    (void);
 static section *iq2000_select_rtx_section (enum machine_mode, rtx,
 					   unsigned HOST_WIDE_INT);
 static void iq2000_init_builtins      (void);
 static rtx  iq2000_expand_builtin     (tree, rtx, rtx, enum machine_mode, int);
 static bool iq2000_return_in_memory   (const_tree, const_tree);
 static rtx  iq2000_legitimize_address (rtx, rtx, enum machine_mode);
 static bool iq2000_pass_by_reference  (CUMULATIVE_ARGS *, enum machine_mode,
 				       const_tree, bool);
 static int  iq2000_arg_partial_bytes  (CUMULATIVE_ARGS *, enum machine_mode,
 				       tree, bool);
+static rtx iq2000_function_arg	      (CUMULATIVE_ARGS *,
+				       enum machine_mode, const_tree, bool);
+static void iq2000_function_arg_advance (CUMULATIVE_ARGS *,
+					 enum machine_mode, const_tree, bool);
+static unsigned int iq2000_function_arg_boundary (enum machine_mode,
+						  const_tree);
 static void iq2000_va_start	      (tree, rtx);
 static bool iq2000_legitimate_address_p (enum machine_mode, rtx, bool);
 static bool iq2000_can_eliminate      (const int, const int);
 static void iq2000_asm_trampoline_template (FILE *);
 static void iq2000_trampoline_init    (rtx, tree, rtx);
 static rtx iq2000_function_value      (const_tree, const_tree, bool);
 static rtx iq2000_libcall_value       (enum machine_mode, const_rtx);
+static void iq2000_print_operand      (FILE *, rtx, int);
+static void iq2000_print_operand_address (FILE *, rtx);
+static bool iq2000_print_operand_punct_valid_p (unsigned char code);
+/* Implement TARGET_OPTION_OPTIMIZATION_TABLE.  */
+static const struct default_options iq2000_option_optimization_table[] =
+{
+{ OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
+{ OPT_LEVELS_NONE, 0, NULL, 0 }
+};
 #undef  TARGET_INIT_BUILTINS
 #define TARGET_INIT_BUILTINS 		iq2000_init_builtins
 #undef  TARGET_EXPAND_BUILTIN
 #define TARGET_EXPAND_BUILTIN 		iq2000_expand_builtin
 #undef  TARGET_ASM_SELECT_RTX_SECTION
 #define TARGET_ASM_SELECT_RTX_SECTION	iq2000_select_rtx_section
 #undef  TARGET_HANDLE_OPTION
 #define TARGET_HANDLE_OPTION		iq2000_handle_option
+#undef  TARGET_OPTION_OVERRIDE
+#define TARGET_OPTION_OVERRIDE		iq2000_option_override
+#undef  TARGET_OPTION_OPTIMIZATION_TABLE
+#define TARGET_OPTION_OPTIMIZATION_TABLE iq2000_option_optimization_table
 #undef  TARGET_RTX_COSTS
 #define TARGET_RTX_COSTS		iq2000_rtx_costs
 #undef  TARGET_ADDRESS_COST
 #define TARGET_ADDRESS_COST		iq2000_address_cost
 #undef  TARGET_ASM_SELECT_SECTION
 /* The assembler supports switchable .bss sections, but
 iq2000_select_section doesn't yet make use of them.  */
 #undef  TARGET_HAVE_SWITCHABLE_BSS_SECTIONS
 #define TARGET_HAVE_SWITCHABLE_BSS_SECTIONS false
+#undef  TARGET_PRINT_OPERAND
+#define TARGET_PRINT_OPERAND		iq2000_print_operand
+#undef  TARGET_PRINT_OPERAND_ADDRESS
+#define TARGET_PRINT_OPERAND_ADDRESS	iq2000_print_operand_address
+#undef  TARGET_PRINT_OPERAND_PUNCT_VALID_P
+#define TARGET_PRINT_OPERAND_PUNCT_VALID_P iq2000_print_operand_punct_valid_p
 #undef  TARGET_PROMOTE_FUNCTION_MODE
 #define TARGET_PROMOTE_FUNCTION_MODE	default_promote_function_mode_always_promote
 #undef  TARGET_PROMOTE_PROTOTYPES
 #define TARGET_PROMOTE_PROTOTYPES	hook_bool_const_tree_true
 #define TARGET_PASS_BY_REFERENCE	iq2000_pass_by_reference
 #undef  TARGET_CALLEE_COPIES
 #define TARGET_CALLEE_COPIES		hook_callee_copies_named
 #undef  TARGET_ARG_PARTIAL_BYTES
 #define TARGET_ARG_PARTIAL_BYTES	iq2000_arg_partial_bytes
+#undef  TARGET_FUNCTION_ARG
+#define TARGET_FUNCTION_ARG		iq2000_function_arg
+#undef  TARGET_FUNCTION_ARG_ADVANCE
+#define TARGET_FUNCTION_ARG_ADVANCE	iq2000_function_arg_advance
+#undef  TARGET_FUNCTION_ARG_BOUNDARY
+#define TARGET_FUNCTION_ARG_BOUNDARY	iq2000_function_arg_boundary
 #undef  TARGET_SETUP_INCOMING_VARARGS
 #define TARGET_SETUP_INCOMING_VARARGS	iq2000_setup_incoming_varargs
 #undef  TARGET_STRICT_ARGUMENT_NAMING
 #define TARGET_STRICT_ARGUMENT_NAMING	hook_bool_CUMULATIVE_ARGS_true
 }
 /* Advance the argument of type TYPE and mode MODE to the next argument
 position in CUM.  */
-void
+static void
-function_arg_advance (CUMULATIVE_ARGS *cum, enum machine_mode mode, tree type,
+iq2000_function_arg_advance (CUMULATIVE_ARGS *cum, enum machine_mode mode,
-		      int named)
+			     const_tree type, bool named)
 {
 if (TARGET_DEBUG_D_MODE)
 {
 fprintf (stderr,
 	       "function_adv({gp reg found = %d, arg # = %2d, words = %2d}, %4s, ",
 	       cum->gp_reg_found, cum->arg_number, cum->arg_words,
 	       GET_MODE_NAME (mode));
-fprintf (stderr, "%p", (void *) type);
+fprintf (stderr, "%p", CONST_CAST2 (void *, const_tree,  type));
 fprintf (stderr, ", %d )\n\n", named);
 }
 cum->arg_number++;
 switch (mode)
 }
 /* Return an RTL expression containing the register for the given mode MODE
 and type TYPE in CUM, or 0 if the argument is to be passed on the stack.  */
-struct rtx_def *
+static rtx
-function_arg (CUMULATIVE_ARGS *cum, enum machine_mode mode, const_tree type,
+iq2000_function_arg (CUMULATIVE_ARGS *cum, enum machine_mode mode,
-	      int named)
+		     const_tree type, bool named)
 {
 rtx ret;
 int regbase = -1;
 int bias = 0;
 unsigned int *arg_words = &cum->arg_words;
 	ret = gen_rtx_REG (mode, regbase + *arg_words + bias);
 else
 	{
 	  tree field;
-	  for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
+	  for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
 	    if (TREE_CODE (field) == FIELD_DECL
 		&& TREE_CODE (TREE_TYPE (field)) == REAL_TYPE
 		&& TYPE_PRECISION (TREE_TYPE (field)) == BITS_PER_WORD
 		&& host_integerp (bit_position (field), 0)
 		&& int_bit_position (field) % BITS_PER_WORD == 0)
 	      field = TYPE_FIELDS (type);
 	      for (i = 0; i < chunks; i++)
 		{
 		  rtx reg;
-		  for (; field; field = TREE_CHAIN (field))
+		  for (; field; field = DECL_CHAIN (field))
 		    if (TREE_CODE (field) == FIELD_DECL
 			&& int_bit_position (field) >= bitpos)
 		      break;
 		  if (field
 }
 return ret;
 }
+static unsigned int
+iq2000_function_arg_boundary (enum machine_mode mode, const_tree type)
+{
+return (type != NULL_TREE
+	  ? (TYPE_ALIGN (type) <= PARM_BOUNDARY
+	     ? PARM_BOUNDARY
+	     : TYPE_ALIGN (type))
+	  : (GET_MODE_ALIGNMENT (mode) <= PARM_BOUNDARY
+	     ? PARM_BOUNDARY
+	     : GET_MODE_ALIGNMENT (mode)));
+}
 static int
 iq2000_arg_partial_bytes (CUMULATIVE_ARGS *cum, enum machine_mode mode,
 			  tree type ATTRIBUTE_UNUSED,
 			  bool named ATTRIBUTE_UNUSED)
 {
 /* Allocate a chunk of memory for per-function machine-dependent data.  */
 static struct machine_function *
 iq2000_init_machine_status (void)
 {
-struct machine_function *f;
+return ggc_alloc_cleared_machine_function ();
-f = GGC_CNEW (struct machine_function);
-return f;
 }
 /* Implement TARGET_HANDLE_OPTION.  */
 static bool
 }
 }
 /* Detect any conflicts in the switches.  */
-void
+static void
-override_options (void)
+iq2000_option_override (void)
 {
 target_flags &= ~MASK_GPOPT;
 iq2000_isa = IQ2000_ISA_DEFAULT;
 HOST_WIDE_INT extra_size;	/* # extra bytes.  */
 HOST_WIDE_INT gp_reg_rounded;	/* # bytes needed to store gp after rounding.  */
 HOST_WIDE_INT gp_reg_size;	/* # bytes needed to store gp regs.  */
 HOST_WIDE_INT fp_reg_size;	/* # bytes needed to store fp regs.  */
 long mask;			/* mask of saved gp registers.  */
-int  fp_inc;			/* 1 or 2 depending on the size of fp regs.  */
-long fp_bits;			/* bitmask to use for each fp register.  */
 gp_reg_size = 0;
 fp_reg_size = 0;
 mask = 0;
 extra_size = IQ2000_STACK_ALIGN ((0));
 	  gp_reg_size += GET_MODE_SIZE (gpr_mode);
 	  mask |= 1L << (regno - GP_REG_FIRST);
 	}
 }
-fp_inc = 2;
-fp_bits = 3;
 gp_reg_rounded = IQ2000_STACK_ALIGN (gp_reg_size);
 total_size += gp_reg_rounded + IQ2000_STACK_ALIGN (fp_reg_size);
 /* The gp reg is caller saved, so there is no need for leaf routines
 (total_size == extra_size) to save the gp reg.  */
 bool
 iq2000_can_eliminate (const int from, const int to)
 {
 return (from == RETURN_ADDRESS_POINTER_REGNUM
 && (! leaf_function_p ()
-|| (to == GP_REG_FIRST + 31 && leaf_function_p)))
+|| (to == GP_REG_FIRST + 31 && leaf_function_p ())))
 || (from != RETURN_ADDRESS_POINTER_REGNUM
 && (to == HARD_FRAME_POINTER_REGNUM
 || (to == STACK_POINTER_REGNUM
 && ! frame_pointer_needed)));
 }
 	(offset) = 0;
 else (offset) = cfun->machine->gp_sp_offset
 	     + ((UNITS_PER_WORD - (POINTER_SIZE / BITS_PER_UNIT))
 		* (BYTES_BIG_ENDIAN != 0));
 }
+else
+gcc_unreachable ();
 return offset;
 }
 /* Common code to emit the insns (or to write the instructions to a file)
 tree type = build_pointer_type (fntype);
 tree function_result_decl = build_decl (BUILTINS_LOCATION,
 					      PARM_DECL, NULL_TREE, type);
 DECL_ARG_TYPE (function_result_decl) = type;
-TREE_CHAIN (function_result_decl) = fnargs;
+DECL_CHAIN (function_result_decl) = fnargs;
 fnargs = function_result_decl;
 }
 /* For arguments passed in registers, find the register number
 of the first argument in the variable part of the argument list,
 	{
 	  passed_type = build_pointer_type (passed_type);
 	  passed_mode = Pmode;
 	}
-entry_parm = FUNCTION_ARG (args_so_far, passed_mode, passed_type, 1);
+entry_parm = iq2000_function_arg (&args_so_far, passed_mode,
+					passed_type, true);
-FUNCTION_ARG_ADVANCE (args_so_far, passed_mode, passed_type, 1);
-next_arg = TREE_CHAIN (cur_arg);
+iq2000_function_arg_advance (&args_so_far, passed_mode,
+				   passed_type, true);
+next_arg = DECL_CHAIN (cur_arg);
 if (entry_parm && store_args_on_stack)
 	{
 	  if (next_arg == 0
 	      && DECL_NAME (cur_arg)
 	}
 }
 /* In order to pass small structures by value in registers we need to
 shift the value into the high part of the register.
-Function_arg has encoded a PARALLEL rtx, holding a vector of
+iq2000_unction_arg has encoded a PARALLEL rtx, holding a vector of
-adjustments to be made as the next_arg_reg variable, so we split up the
+adjustments to be made as the next_arg_reg variable, so we split up
-insns, and emit them separately.  */
+the insns, and emit them separately.  */
-next_arg_reg = FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1);
+next_arg_reg = iq2000_function_arg (&args_so_far, VOIDmode,
+				      void_type_node, true);
 if (next_arg_reg != 0 && GET_CODE (next_arg_reg) == PARALLEL)
 {
 rtvec adjust = XVEC (next_arg_reg, 0);
 int num = GET_NUM_ELEM (adjust);
 for (i = 0; i < num; i++)
 	{
-	  rtx insn, pattern;
+	  rtx pattern;
 	  pattern = RTVEC_ELT (adjust, i);
 	  if (GET_CODE (pattern) != SET
 	      || GET_CODE (SET_SRC (pattern)) != ASHIFT)
 	    abort_with_insn (pattern, "Insn is not a shift");
 	  PUT_CODE (SET_SRC (pattern), ASHIFTRT);
-	  insn = emit_insn (pattern);
+	  emit_insn (pattern);
 	}
 }
 tsize = compute_frame_size (get_frame_size ());
 /* If this function is a varargs function, store any registers that
 would normally hold arguments ($4 - $7) on the stack.  */
 if (store_args_on_stack
-&& ((TYPE_ARG_TYPES (fntype) != 0
+&& (stdarg_p (fntype)
-	   && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype)))
-	       != void_type_node))
 	  || last_arg_is_vararg_marker))
 {
 int offset = (regno - GP_ARG_FIRST) * UNITS_PER_WORD;
 rtx ptr = stack_pointer_rtx;
 return cfun->machine->total_size == 0;
 return compute_frame_size (get_frame_size ()) == 0;
 }
-/* Returns nonzero if X contains a SYMBOL_REF.  */
-static int
-symbolic_expression_p (rtx x)
-{
-if (GET_CODE (x) == SYMBOL_REF)
-return 1;
-if (GET_CODE (x) == CONST)
-return symbolic_expression_p (XEXP (x, 0));
-if (UNARY_P (x))
-return symbolic_expression_p (XEXP (x, 0));
-if (ARITHMETIC_P (x))
-return (symbolic_expression_p (XEXP (x, 0))
-	    || symbolic_expression_p (XEXP (x, 1)));
-return 0;
-}
 /* Choose the section to use for the constant rtx expression X that has
 mode MODE.  */
 static section *
 iq2000_select_rtx_section (enum machine_mode mode, rtx x ATTRIBUTE_UNUSED,
 		       bool outgoing ATTRIBUTE_UNUSED)
 {
 int reg = GP_RETURN;
 enum machine_mode mode = TYPE_MODE (valtype);
 int unsignedp = TYPE_UNSIGNED (valtype);
-tree func = fn_decl_or_type;
+const_tree func = fn_decl_or_type;
 if (fn_decl_or_type
 && !DECL_P (fn_decl_or_type))
 fn_decl_or_type = NULL;
 	  get double copies of any offsets generated for small structs
 	  passed in registers.  */
 CUMULATIVE_ARGS temp;
 temp = *cum;
-if (FUNCTION_ARG (temp, mode, type, named) != 0)
+if (iq2000_function_arg (&temp, mode, type, named) != 0)
 	 return 1;
 }
 if (type == NULL_TREE || mode == DImode || mode == DFmode)
 return 0;
 mode[0] = insn_data[icode].operand[0].mode;
 for (i = 0; i < argcount; i++)
 {
 arg[i] = CALL_EXPR_ARG (exp, i);
-op[i] = expand_expr (arg[i], NULL_RTX, VOIDmode, 0);
+op[i] = expand_normal (arg[i]);
 mode[i] = insn_data[icode].operand[i].mode;
 if (code[i] == CONST_INT && GET_CODE (op[i]) != CONST_INT)
 	error ("argument %qd is not a constant", i + 1);
 if (code[i] == REG
 	  && ! (*insn_data[icode].operand[i].predicate) (op[i], mode[i]))
 /* A C compound statement to output to stdio stream STREAM the
 assembler syntax for an instruction operand that is a memory
 reference whose address is ADDR.  ADDR is an RTL expression.  */
-void
+static void
-print_operand_address (FILE * file, rtx addr)
+iq2000_print_operand_address (FILE * file, rtx addr)
 {
 if (!addr)
 error ("PRINT_OPERAND_ADDRESS, null pointer");
 else
 	  if (GET_CODE (arg0) != REG)
 	    abort_with_insn (addr,
 			     "PRINT_OPERAND_ADDRESS, LO_SUM with #1 not REG.");
 	  fprintf (file, "%%lo(");
-	  print_operand_address (file, arg1);
+	  iq2000_print_operand_address (file, arg1);
 	  fprintf (file, ")(%s)", reg_names [REGNO (arg0)]);
 	}
 	break;
 case PLUS:
 '@'	Print the name of the assembler temporary register (at or $1).
 '.'	Print the name of the register with a hard-wired zero (zero or $0).
 '$'	Print the name of the stack pointer register (sp or $29).
 '+'	Print the name of the gp register (gp or $28).  */
-void
+static void
-print_operand (FILE *file, rtx op, int letter)
+iq2000_print_operand (FILE *file, rtx op, int letter)
 {
 enum rtx_code code;
-if (PRINT_OPERAND_PUNCT_VALID_P (letter))
+if (iq2000_print_operand_punct_valid_p (letter))
 {
 switch (letter)
 	{
 	case '?':
 	  if (iq2000_branch_likely)
 {
 int value;
 if (code != CONST_INT
 	  || (value = exact_log2 (INTVAL (op))) < 0)
 	output_operand_lossage ("invalid %%p value");
-fprintf (file, "%d", value);
+else
+	fprintf (file, "%d", value);
 }
 else if (letter == 'Z')
 {
 gcc_unreachable ();
 else if (letter == 't')
 fputs (code == EQ ? "t" : "f", file);
 else if (code == CONST && GET_CODE (XEXP (op, 0)) == REG)
 {
-print_operand (file, XEXP (op, 0), letter);
+iq2000_print_operand (file, XEXP (op, 0), letter);
 }
 else
 output_addr_const (file, op);
 }
+static bool
+iq2000_print_operand_punct_valid_p (unsigned char code)
+{
+return iq2000_print_operand_punct[code];
+}
 /* For the IQ2000, transform:
 memory(X + <large int>)
 into:

Mercurial > hg > CbC > CbC_gcc

comparison gcc/config/iq2000/iq2000.c @ 67:f6334be47118