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

comparison gcc/config/m68k/m68k.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
 #include "insn-config.h"
 #include "conditions.h"
 #include "output.h"
 #include "insn-attr.h"
 #include "recog.h"
-#include "toplev.h"
+#include "diagnostic-core.h"
 #include "expr.h"
 #include "reload.h"
 #include "tm_p.h"
 #include "target.h"
 #include "target-def.h"
 static void m68k_sched_dfa_pre_advance_cycle (void);
 static void m68k_sched_dfa_post_advance_cycle (void);
 static int m68k_sched_first_cycle_multipass_dfa_lookahead (void);
 static bool m68k_can_eliminate (const int, const int);
+static void m68k_conditional_register_usage (void);
 static bool m68k_legitimate_address_p (enum machine_mode, rtx, bool);
 static bool m68k_handle_option (size_t, const char *, int);
+static void m68k_option_override (void);
 static rtx find_addr_reg (rtx);
 static const char *singlemove_string (rtx *);
 static void m68k_output_mi_thunk (FILE *, tree, HOST_WIDE_INT,
 					  HOST_WIDE_INT, tree);
 static rtx m68k_struct_value_rtx (tree, int);
 #if M68K_HONOR_TARGET_STRICT_ALIGNMENT
 static bool m68k_return_in_memory (const_tree, const_tree);
 #endif
 static void m68k_output_dwarf_dtprel (FILE *, int, rtx) ATTRIBUTE_UNUSED;
 static void m68k_trampoline_init (rtx, tree, rtx);
+static int m68k_return_pops_args (tree, tree, int);
 static rtx m68k_delegitimize_address (rtx);
+static void m68k_function_arg_advance (CUMULATIVE_ARGS *, enum machine_mode,
+				       const_tree, bool);
+static rtx m68k_function_arg (CUMULATIVE_ARGS *, enum machine_mode,
+			      const_tree, bool);
 /* Specify the identification number of the library being built */
 const char *m68k_library_id_string = "_current_shared_library_a5_offset_";
 m68k_sched_first_cycle_multipass_dfa_lookahead
 #undef TARGET_HANDLE_OPTION
 #define TARGET_HANDLE_OPTION m68k_handle_option
+#undef TARGET_OPTION_OVERRIDE
+#define TARGET_OPTION_OVERRIDE m68k_option_override
 #undef TARGET_RTX_COSTS
 #define TARGET_RTX_COSTS m68k_rtx_costs
 #undef TARGET_ATTRIBUTE_TABLE
 #define TARGET_ATTRIBUTE_TABLE m68k_attribute_table
 #define TARGET_LEGITIMATE_ADDRESS_P	m68k_legitimate_address_p
 #undef TARGET_CAN_ELIMINATE
 #define TARGET_CAN_ELIMINATE m68k_can_eliminate
+#undef TARGET_CONDITIONAL_REGISTER_USAGE
+#define TARGET_CONDITIONAL_REGISTER_USAGE m68k_conditional_register_usage
 #undef TARGET_TRAMPOLINE_INIT
 #define TARGET_TRAMPOLINE_INIT m68k_trampoline_init
+#undef TARGET_RETURN_POPS_ARGS
+#define TARGET_RETURN_POPS_ARGS m68k_return_pops_args
 #undef TARGET_DELEGITIMIZE_ADDRESS
 #define TARGET_DELEGITIMIZE_ADDRESS m68k_delegitimize_address
+#undef TARGET_FUNCTION_ARG
+#define TARGET_FUNCTION_ARG m68k_function_arg
+#undef TARGET_FUNCTION_ARG_ADVANCE
+#define TARGET_FUNCTION_ARG_ADVANCE m68k_function_arg_advance
 static const struct attribute_spec m68k_attribute_table[] =
 {
 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
 { "interrupt", 0, 0, true,  false, false, m68k_handle_fndecl_attribute },
 default:
 return true;
 }
 }
-/* Sometimes certain combinations of command options do not make
+/* Implement TARGET_OPTION_OVERRIDE.  */
-sense on a particular target machine.  You can define a macro
-`OVERRIDE_OPTIONS' to take account of this.  This macro, if
+static void
-defined, is executed once just after all the command options have
+m68k_option_override (void)
-been parsed.
-Don't use this macro to turn on various extra optimizations for
-`-O'.  That is what `OPTIMIZATION_OPTIONS' is for.  */
-void
-override_options (void)
 {
 const struct m68k_target_selection *entry;
 unsigned long target_mask;
 /* User can choose:
 void
 m68k_expand_prologue (void)
 {
 HOST_WIDE_INT fsize_with_regs;
-rtx limit, src, dest, insn;
+rtx limit, src, dest;
 m68k_compute_frame_layout ();
 /* If the stack limit is a symbol, we can check it here,
 before actually allocating the space.  */
 			    current_frame.reg_mask, true, true));
 }
 if (!TARGET_SEP_DATA
 && crtl->uses_pic_offset_table)
-insn = emit_insn (gen_load_got (pic_offset_table_rtx));
+emit_insn (gen_load_got (pic_offset_table_rtx));
 }
 /* Return true if a simple (return) instruction is sufficient for this
 instruction (i.e. if no epilogue is needed).  */
 the same.  */
 if (decl && m68k_get_function_kind (decl) == kind)
 return true;
 return false;
+}
+/* On the m68k all args are always pushed.  */
+static rtx
+m68k_function_arg (CUMULATIVE_ARGS *cum ATTRIBUTE_UNUSED,
+		   enum machine_mode mode ATTRIBUTE_UNUSED,
+		   const_tree type ATTRIBUTE_UNUSED,
+		   bool named ATTRIBUTE_UNUSED)
+{
+return NULL_RTX;
+}
+static void
+m68k_function_arg_advance (CUMULATIVE_ARGS *cum, enum machine_mode mode,
+			   const_tree type, bool named ATTRIBUTE_UNUSED)
+{
+*cum += (mode != BLKmode
+	   ? (GET_MODE_SIZE (mode) + 3) & ~3
+	   : (int_size_in_bytes (type) + 3) & ~3);
 }
 /* Convert X to a legitimate function call memory reference and return the
 result.  */
 return;
 }
 /* Normal case: do the two words, low-numbered first.  */
+m68k_final_prescan_insn (NULL, operands, 2);
 handle_movsi (operands);
 /* Do the middle one of the three words for long double */
 if (size == 12)
 {
 if (addreg0)
 	handle_reg_adjust (addreg0, 4);
 if (addreg1)
 	handle_reg_adjust (addreg1, 4);
+m68k_final_prescan_insn (NULL, middlehalf, 2);
 handle_movsi (middlehalf);
 }
 /* Make any unoffsettable addresses point at high-numbered word.  */
 if (addreg0)
 handle_reg_adjust (addreg0, 4);
 if (addreg1)
 handle_reg_adjust (addreg1, 4);
 /* Do that word.  */
+m68k_final_prescan_insn (NULL, latehalf, 2);
 handle_movsi (latehalf);
 /* Undo the adds we just did.  */
 if (addreg0)
 handle_reg_adjust (addreg0, -(size - 4));
 switch (XINT (x, 1))
 	{
 	case UNSPEC_RELOC16:
 	case UNSPEC_RELOC32:
 	  output_addr_const (file, XVECEXP (x, 0, 0));
-	  fputs (m68k_get_reloc_decoration (INTVAL (XVECEXP (x, 0, 1))), file);
+	  fputs (m68k_get_reloc_decoration
+		 ((enum m68k_reloc) INTVAL (XVECEXP (x, 0, 1))), file);
 	  return true;
 	default:
 	  break;
 	}
 /* In the name of slightly smaller debug output, and to cater to
 general assembler lossage, recognize various UNSPEC sequences
 and turn them back into a direct symbol reference.  */
 static rtx
-m68k_delegitimize_address (rtx x)
+m68k_delegitimize_address (rtx orig_x)
 {
-rtx orig_x = delegitimize_mem_from_attrs (x);
+rtx x;
-rtx y;
+struct m68k_address addr;
-rtx addend = NULL_RTX;
+rtx unspec;
-rtx result;
+orig_x = delegitimize_mem_from_attrs (orig_x);
 x = orig_x;
 if (MEM_P (x))
 x = XEXP (x, 0);
-if (GET_CODE (x) == PLUS
+if (GET_CODE (x) != PLUS || GET_MODE (x) != Pmode)
-&& GET_CODE (XEXP (x, 1)) == CONST
+return orig_x;
-&& REG_P (XEXP (x, 0))
-&& REGNO (XEXP (x, 0)) == PIC_REG)
+if (!m68k_decompose_address (GET_MODE (x), x, false, &addr)
-{
+|| addr.offset == NULL_RTX
-y = x = XEXP (XEXP (x, 1), 0);
+|| GET_CODE (addr.offset) != CONST)
+return orig_x;
-/* Handle an addend.  */
-if ((GET_CODE (x) == PLUS || GET_CODE (x) == MINUS)
+unspec = XEXP (addr.offset, 0);
-	  && CONST_INT_P (XEXP (x, 1)))
+if (GET_CODE (unspec) == PLUS && CONST_INT_P (XEXP (unspec, 1)))
-	{
+unspec = XEXP (unspec, 0);
-	  addend = XEXP (x, 1);
+if (GET_CODE (unspec) != UNSPEC
-	  x = XEXP (x, 0);
+|| (XINT (unspec, 1) != UNSPEC_RELOC16
-	}
+	  && XINT (unspec, 1) != UNSPEC_RELOC32))
+return orig_x;
-if (GET_CODE (x) == UNSPEC
+x = XVECEXP (unspec, 0, 0);
-	  && (XINT (x, 1) == UNSPEC_RELOC16
+gcc_assert (GET_CODE (x) == SYMBOL_REF || GET_CODE (x) == LABEL_REF);
-	      || XINT (x, 1) == UNSPEC_RELOC32))
+if (unspec != XEXP (addr.offset, 0))
-	{
+x = gen_rtx_PLUS (Pmode, x, XEXP (XEXP (addr.offset, 0), 1));
-	  result = XVECEXP (x, 0, 0);
+if (addr.index)
-	  if (addend)
+{
-	    {
+rtx idx = addr.index;
-	      if (GET_CODE (y) == PLUS)
+if (addr.scale != 1)
-		result = gen_rtx_PLUS (Pmode, result, addend);
+	idx = gen_rtx_MULT (Pmode, idx, GEN_INT (addr.scale));
-	      else
+x = gen_rtx_PLUS (Pmode, idx, x);
-		result = gen_rtx_MINUS (Pmode, result, addend);
+}
-	      result = gen_rtx_CONST (Pmode, result);
+if (addr.base)
-	    }
+x = gen_rtx_PLUS (Pmode, addr.base, x);
-	  return result;
+if (MEM_P (orig_x))
-	}
+x = replace_equiv_address_nv (orig_x, x);
-}
+return x;
-return orig_x;
 }
 /* A C compound statement to output to stdio stream STREAM the
 assembler syntax for an instruction operand that is a memory
 case OP_TYPE_IMM_L:
 return OPX_TYPE_IMM_L;
 default:
 gcc_unreachable ();
-return 0;
 }
 }
 /* Implement opy_type attribute.
 Return type of INSN's operand Y.
 case OP_TYPE_IMM_L:
 return OPY_TYPE_IMM_L;
 default:
 gcc_unreachable ();
-return 0;
 }
 }
 /* Return size of INSN as int.  */
 static int
 case 3:
 return SIZE_3;
 default:
 gcc_unreachable ();
-return 0;
 }
 }
 /* Return operand X or Y (depending on OPX_P) of INSN,
 if it is a MEM, or NULL overwise.  */
 	case OPX_TYPE_MEM6:
 	  return OP_TYPE_MEM6;
 	default:
 	  gcc_unreachable ();
-	  return 0;
 	}
 }
 else
 {
 switch (get_attr_opy_type (insn))
 	case OPY_TYPE_MEM6:
 	  return OP_TYPE_MEM6;
 	default:
 	  gcc_unreachable ();
-	  return 0;
 	}
 }
 }
 /* Implement op_mem attribute.  */
 	case OPX_ACCESS_RW:
 	  return OP_MEM_11;
 	default:
 	  gcc_unreachable ();
-	  return 0;
 	}
 }
 if (opy == OP_TYPE_RN && opx == OP_TYPE_MEM6)
 {
 	case OPX_ACCESS_RW:
 	  return OP_MEM_I1;
 	default:
 	  gcc_unreachable ();
-	  return 0;
 	}
 }
 if (opy == OP_TYPE_MEM1 && opx == OP_TYPE_RN)
 return OP_MEM_10;
 m68k_sched_first_cycle_multipass_dfa_lookahead (void)
 {
 return m68k_sched_issue_rate () - 1;
 }
-/* Implementation of targetm.sched.md_init_global () hook.
+/* Implementation of targetm.sched.init_global () hook.
 It is invoked once per scheduling pass and is used here
 to initialize scheduler constants.  */
 static void
 m68k_sched_md_init_global (FILE *sched_dump ATTRIBUTE_UNUSED,
 			   int sched_verbose ATTRIBUTE_UNUSED,
 free (sched_branch_type);
 sched_branch_type = NULL;
 }
-/* Implementation of targetm.sched.md_init () hook.
+/* Implementation of targetm.sched.init () hook.
 It is invoked each time scheduler starts on the new block (basic block or
 extended basic block).  */
 static void
 m68k_sched_md_init (FILE *sched_dump ATTRIBUTE_UNUSED,
 		    int sched_verbose ATTRIBUTE_UNUSED,
 emit_move_insn (mem, fnaddr);
 FINALIZE_TRAMPOLINE (XEXP (m_tramp, 0));
 }
+/* On the 68000, the RTS insn cannot pop anything.
+On the 68010, the RTD insn may be used to pop them if the number
+of args is fixed, but if the number is variable then the caller
+must pop them all.  RTD can't be used for library calls now
+because the library is compiled with the Unix compiler.
+Use of RTD is a selectable option, since it is incompatible with
+standard Unix calling sequences.  If the option is not selected,
+the caller must always pop the args.  */
+static int
+m68k_return_pops_args (tree fundecl, tree funtype, int size)
+{
+return ((TARGET_RTD
+	   && (!fundecl
+	       || TREE_CODE (fundecl) != IDENTIFIER_NODE)
+	   && (!stdarg_p (funtype)))
+	  ? size : 0);
+}
+/* Make sure everything's fine if we *don't* have a given processor.
+This assumes that putting a register in fixed_regs will keep the
+compiler's mitts completely off it.  We don't bother to zero it out
+of register classes.  */
+static void
+m68k_conditional_register_usage (void)
+{
+int i;
+HARD_REG_SET x;
+if (!TARGET_HARD_FLOAT)
+{
+COPY_HARD_REG_SET (x, reg_class_contents[(int)FP_REGS]);
+for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
+if (TEST_HARD_REG_BIT (x, i))
+	  fixed_regs[i] = call_used_regs[i] = 1;
+}
+if (flag_pic)
+fixed_regs[PIC_REG] = call_used_regs[PIC_REG] = 1;
+}
 #include "gt-m68k.h"

Mercurial > hg > CbC > CbC_gcc

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