[thirdparty/gcc.git] / gcc / targhooks.c

/* Default target hook functions.
   Copyright (C) 2003, 2004, 2005, 2007 Free Software Foundation, Inc.

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/>.  */

/* The migration of target macros to target hooks works as follows:

   1. Create a target hook that uses the existing target macros to
      implement the same functionality.

   2. Convert all the MI files to use the hook instead of the macro.

   3. Repeat for a majority of the remaining target macros.  This will
      take some time.

   4. Tell target maintainers to start migrating.

   5. Eventually convert the backends to override the hook instead of
      defining the macros.  This will take some time too.

   6. TBD when, poison the macros.  Unmigrated targets will break at
      this point.

   Note that we expect steps 1-3 to be done by the people that
   understand what the MI does with each macro, and step 5 to be done
   by the target maintainers for their respective targets.

   Note that steps 1 and 2 don't have to be done together, but no
   target can override the new hook until step 2 is complete for it.

   Once the macros are poisoned, we will revert to the old migration
   rules - migrate the macro, callers, and targets all at once.  This
   comment can thus be removed at that point.  */

#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "machmode.h"
#include "rtl.h"
#include "tree.h"
#include "expr.h"
#include "output.h"
#include "toplev.h"
#include "function.h"
#include "target.h"
#include "tm_p.h"
#include "target-def.h"
#include "ggc.h"
#include "hard-reg-set.h"
#include "reload.h"
#include "optabs.h"
#include "recog.h"


void
default_external_libcall (rtx fun ATTRIBUTE_UNUSED)
{
#ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
  ASM_OUTPUT_EXTERNAL_LIBCALL(asm_out_file, fun);
#endif
}

enum machine_mode
default_cc_modes_compatible (enum machine_mode m1, enum machine_mode m2)
{
  if (m1 == m2)
    return m1;
  return VOIDmode;
}

bool
default_return_in_memory (const_tree type,
			  const_tree fntype ATTRIBUTE_UNUSED)
{
#ifndef RETURN_IN_MEMORY
  return (TYPE_MODE (type) == BLKmode);
#else
  return RETURN_IN_MEMORY (type);
#endif
}

rtx
default_expand_builtin_saveregs (void)
{
  error ("__builtin_saveregs not supported by this target");
  return const0_rtx;
}

void
default_setup_incoming_varargs (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
				enum machine_mode mode ATTRIBUTE_UNUSED,
				tree type ATTRIBUTE_UNUSED,
				int *pretend_arg_size ATTRIBUTE_UNUSED,
				int second_time ATTRIBUTE_UNUSED)
{
}

/* The default implementation of TARGET_BUILTIN_SETJMP_FRAME_VALUE.  */

rtx
default_builtin_setjmp_frame_value (void)
{
  return virtual_stack_vars_rtx;
}

/* Generic hook that takes a CUMULATIVE_ARGS pointer and returns false.  */

bool
hook_bool_CUMULATIVE_ARGS_false (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED)
{
  return false;
}

bool
default_pretend_outgoing_varargs_named (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED)
{
  return (targetm.calls.setup_incoming_varargs
	  != default_setup_incoming_varargs);
}

enum machine_mode
default_eh_return_filter_mode (void)
{
  return word_mode;
}

enum machine_mode
default_libgcc_cmp_return_mode (void)
{
  return word_mode;
}

enum machine_mode
default_libgcc_shift_count_mode (void)
{
  return word_mode;
}

/* The default implementation of TARGET_SHIFT_TRUNCATION_MASK.  */

unsigned HOST_WIDE_INT
default_shift_truncation_mask (enum machine_mode mode)
{
  return SHIFT_COUNT_TRUNCATED ? GET_MODE_BITSIZE (mode) - 1 : 0;
}

/* The default implementation of TARGET_MIN_DIVISIONS_FOR_RECIP_MUL.  */

unsigned int
default_min_divisions_for_recip_mul (enum machine_mode mode ATTRIBUTE_UNUSED)
{
  return have_insn_for (DIV, mode) ? 3 : 2;
}

/* The default implementation of TARGET_MODE_REP_EXTENDED.  */

int
default_mode_rep_extended (enum machine_mode mode ATTRIBUTE_UNUSED,
			   enum machine_mode mode_rep ATTRIBUTE_UNUSED)
{
  return UNKNOWN;
}

/* Generic hook that takes a CUMULATIVE_ARGS pointer and returns true.  */

bool
hook_bool_CUMULATIVE_ARGS_true (CUMULATIVE_ARGS * a ATTRIBUTE_UNUSED)
{
  return true;
}

/* Return machine mode for non-standard suffix
   or VOIDmode if non-standard suffixes are unsupported.  */
enum machine_mode
default_mode_for_suffix (char suffix ATTRIBUTE_UNUSED)
{
  return VOIDmode;
}

/* The generic C++ ABI specifies this is a 64-bit value.  */
tree
default_cxx_guard_type (void)
{
  return long_long_integer_type_node;
}


/* Returns the size of the cookie to use when allocating an array
   whose elements have the indicated TYPE.  Assumes that it is already
   known that a cookie is needed.  */

tree
default_cxx_get_cookie_size (tree type)
{
  tree cookie_size;

  /* We need to allocate an additional max (sizeof (size_t), alignof
     (true_type)) bytes.  */
  tree sizetype_size;
  tree type_align;

  sizetype_size = size_in_bytes (sizetype);
  type_align = size_int (TYPE_ALIGN_UNIT (type));
  if (INT_CST_LT_UNSIGNED (type_align, sizetype_size))
    cookie_size = sizetype_size;
  else
    cookie_size = type_align;

  return cookie_size;
}

/* Return true if a parameter must be passed by reference.  This version
   of the TARGET_PASS_BY_REFERENCE hook uses just MUST_PASS_IN_STACK.  */

bool
hook_pass_by_reference_must_pass_in_stack (CUMULATIVE_ARGS *c ATTRIBUTE_UNUSED,
	enum machine_mode mode ATTRIBUTE_UNUSED, const_tree type ATTRIBUTE_UNUSED,
	bool named_arg ATTRIBUTE_UNUSED)
{
  return targetm.calls.must_pass_in_stack (mode, type);
}

/* Return true if a parameter follows callee copies conventions.  This
   version of the hook is true for all named arguments.  */

bool
hook_callee_copies_named (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
			  enum machine_mode mode ATTRIBUTE_UNUSED,
			  const_tree type ATTRIBUTE_UNUSED, bool named)
{
  return named;
}

/* Emit any directives required to unwind this instruction.  */

void
default_unwind_emit (FILE * stream ATTRIBUTE_UNUSED,
		     rtx insn ATTRIBUTE_UNUSED)
{
  /* Should never happen.  */
  gcc_unreachable ();
}

/* True if MODE is valid for the target.  By "valid", we mean able to
   be manipulated in non-trivial ways.  In particular, this means all
   the arithmetic is supported.

   By default we guess this means that any C type is supported.  If
   we can't map the mode back to a type that would be available in C,
   then reject it.  Special case, here, is the double-word arithmetic
   supported by optabs.c.  */

bool
default_scalar_mode_supported_p (enum machine_mode mode)
{
  int precision = GET_MODE_PRECISION (mode);

  switch (GET_MODE_CLASS (mode))
    {
    case MODE_PARTIAL_INT:
    case MODE_INT:
      if (precision == CHAR_TYPE_SIZE)
	return true;
      if (precision == SHORT_TYPE_SIZE)
	return true;
      if (precision == INT_TYPE_SIZE)
	return true;
      if (precision == LONG_TYPE_SIZE)
	return true;
      if (precision == LONG_LONG_TYPE_SIZE)
	return true;
      if (precision == 2 * BITS_PER_WORD)
	return true;
      return false;

    case MODE_FLOAT:
      if (precision == FLOAT_TYPE_SIZE)
	return true;
      if (precision == DOUBLE_TYPE_SIZE)
	return true;
      if (precision == LONG_DOUBLE_TYPE_SIZE)
	return true;
      return false;

    case MODE_DECIMAL_FLOAT:
    case MODE_FRACT:
    case MODE_UFRACT:
    case MODE_ACCUM:
    case MODE_UACCUM:
      return false;

    default:
      gcc_unreachable ();
    }
}

/* True if the target supports decimal floating point.  */

bool
default_decimal_float_supported_p (void)
{
  return ENABLE_DECIMAL_FLOAT;
}

/* True if the target supports fixed-point arithmetic.  */

bool
default_fixed_point_supported_p (void)
{
  return ENABLE_FIXED_POINT;
}

/* NULL if INSN insn is valid within a low-overhead loop, otherwise returns
   an error message.
  
   This function checks whether a given INSN is valid within a low-overhead
   loop.  If INSN is invalid it returns the reason for that, otherwise it
   returns NULL. A called function may clobber any special registers required
   for low-overhead looping. Additionally, some targets (eg, PPC) use the count
   register for branch on table instructions. We reject the doloop pattern in
   these cases.  */

const char *
default_invalid_within_doloop (const_rtx insn)
{
  if (CALL_P (insn))
    return "Function call in loop.";
  
  if (JUMP_P (insn)
      && (GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC
	  || GET_CODE (PATTERN (insn)) == ADDR_VEC))
    return "Computed branch in the loop.";
  
  return NULL;
}

/* Mapping of builtin functions to vectorized variants.  */

tree
default_builtin_vectorized_function (enum built_in_function fn ATTRIBUTE_UNUSED,
				     tree type_out ATTRIBUTE_UNUSED,
				     tree type_in ATTRIBUTE_UNUSED)
{
  return NULL_TREE;
}

/* Vectorized conversion.  */

tree
default_builtin_vectorized_conversion (enum tree_code code ATTRIBUTE_UNUSED,
				       tree type ATTRIBUTE_UNUSED)
{
  return NULL_TREE;
}

/* Reciprocal.  */

tree
default_builtin_reciprocal (enum built_in_function fn ATTRIBUTE_UNUSED,
			    bool md_fn ATTRIBUTE_UNUSED,
			    bool sqrt ATTRIBUTE_UNUSED)
{
  return NULL_TREE;
}

bool
hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false (
	CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
	enum machine_mode mode ATTRIBUTE_UNUSED,
	const_tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
{
  return false;
}

bool
hook_bool_CUMULATIVE_ARGS_mode_tree_bool_true (
	CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
	enum machine_mode mode ATTRIBUTE_UNUSED,
	const_tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
{
  return true;
}

int
hook_int_CUMULATIVE_ARGS_mode_tree_bool_0 (
	CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
	enum machine_mode mode ATTRIBUTE_UNUSED,
	tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
{
  return 0;
}

void 
hook_void_bitmap (bitmap regs ATTRIBUTE_UNUSED)
{
}

const char *
hook_invalid_arg_for_unprototyped_fn (
	const_tree typelist ATTRIBUTE_UNUSED,
	const_tree funcdecl ATTRIBUTE_UNUSED,
	const_tree val ATTRIBUTE_UNUSED)
{
  return NULL;
}

/* Initialize the stack protection decls.  */

/* Stack protection related decls living in libgcc.  */
static GTY(()) tree stack_chk_guard_decl;

tree
default_stack_protect_guard (void)
{
  tree t = stack_chk_guard_decl;

  if (t == NULL)
    {
      t = build_decl (VAR_DECL, get_identifier ("__stack_chk_guard"),
		      ptr_type_node);
      TREE_STATIC (t) = 1;
      TREE_PUBLIC (t) = 1;
      DECL_EXTERNAL (t) = 1;
      TREE_USED (t) = 1;
      TREE_THIS_VOLATILE (t) = 1;
      DECL_ARTIFICIAL (t) = 1;
      DECL_IGNORED_P (t) = 1;

      stack_chk_guard_decl = t;
    }

  return t;
}

static GTY(()) tree stack_chk_fail_decl;

tree 
default_external_stack_protect_fail (void)
{
  tree t = stack_chk_fail_decl;

  if (t == NULL_TREE)
    {
      t = build_function_type_list (void_type_node, NULL_TREE);
      t = build_decl (FUNCTION_DECL, get_identifier ("__stack_chk_fail"), t);
      TREE_STATIC (t) = 1;
      TREE_PUBLIC (t) = 1;
      DECL_EXTERNAL (t) = 1;
      TREE_USED (t) = 1;
      TREE_THIS_VOLATILE (t) = 1;
      TREE_NOTHROW (t) = 1;
      DECL_ARTIFICIAL (t) = 1;
      DECL_IGNORED_P (t) = 1;
      DECL_VISIBILITY (t) = VISIBILITY_DEFAULT;
      DECL_VISIBILITY_SPECIFIED (t) = 1;

      stack_chk_fail_decl = t;
    }

  return build_call_expr (t, 0);
}

tree
default_hidden_stack_protect_fail (void)
{
#ifndef HAVE_GAS_HIDDEN
  return default_external_stack_protect_fail ();
#else
  tree t = stack_chk_fail_decl;

  if (!flag_pic)
    return default_external_stack_protect_fail ();

  if (t == NULL_TREE)
    {
      t = build_function_type_list (void_type_node, NULL_TREE);
      t = build_decl (FUNCTION_DECL,
		      get_identifier ("__stack_chk_fail_local"), t);
      TREE_STATIC (t) = 1;
      TREE_PUBLIC (t) = 1;
      DECL_EXTERNAL (t) = 1;
      TREE_USED (t) = 1;
      TREE_THIS_VOLATILE (t) = 1;
      TREE_NOTHROW (t) = 1;
      DECL_ARTIFICIAL (t) = 1;
      DECL_IGNORED_P (t) = 1;
      DECL_VISIBILITY_SPECIFIED (t) = 1;
      DECL_VISIBILITY (t) = VISIBILITY_HIDDEN;

      stack_chk_fail_decl = t;
    }

  return build_call_expr (t, 0);
#endif
}

bool
hook_bool_const_rtx_commutative_p (const_rtx x,
				   int outer_code ATTRIBUTE_UNUSED)
{
  return COMMUTATIVE_P (x);
}

rtx
default_function_value (const_tree ret_type ATTRIBUTE_UNUSED,
			const_tree fn_decl_or_type,
			bool outgoing ATTRIBUTE_UNUSED)
{
  /* The old interface doesn't handle receiving the function type.  */
  if (fn_decl_or_type
      && !DECL_P (fn_decl_or_type))
    fn_decl_or_type = NULL;

#ifdef FUNCTION_OUTGOING_VALUE
  if (outgoing)
    return FUNCTION_OUTGOING_VALUE (ret_type, fn_decl_or_type);
#endif

#ifdef FUNCTION_VALUE
  return FUNCTION_VALUE (ret_type, fn_decl_or_type);
#else
  return NULL_RTX;
#endif
}

rtx
default_internal_arg_pointer (void)
{
  /* If the reg that the virtual arg pointer will be translated into is
     not a fixed reg or is the stack pointer, make a copy of the virtual
     arg pointer, and address parms via the copy.  The frame pointer is
     considered fixed even though it is not marked as such.  */
  if ((ARG_POINTER_REGNUM == STACK_POINTER_REGNUM
       || ! (fixed_regs[ARG_POINTER_REGNUM]
	     || ARG_POINTER_REGNUM == FRAME_POINTER_REGNUM)))
    return copy_to_reg (virtual_incoming_args_rtx);
  else
    return virtual_incoming_args_rtx;
}

enum reg_class
default_secondary_reload (bool in_p ATTRIBUTE_UNUSED, rtx x ATTRIBUTE_UNUSED,
			  enum reg_class reload_class ATTRIBUTE_UNUSED,
			  enum machine_mode reload_mode ATTRIBUTE_UNUSED,
			  secondary_reload_info *sri)
{
  enum reg_class class = NO_REGS;

  if (sri->prev_sri && sri->prev_sri->t_icode != CODE_FOR_nothing)
    {
      sri->icode = sri->prev_sri->t_icode;
      return NO_REGS;
    }
#ifdef SECONDARY_INPUT_RELOAD_CLASS
  if (in_p)
    class = SECONDARY_INPUT_RELOAD_CLASS (reload_class, reload_mode, x);
#endif
#ifdef SECONDARY_OUTPUT_RELOAD_CLASS
  if (! in_p)
    class = SECONDARY_OUTPUT_RELOAD_CLASS (reload_class, reload_mode, x);
#endif
  if (class != NO_REGS)
    {
      enum insn_code icode = (in_p ? reload_in_optab[(int) reload_mode]
			      : reload_out_optab[(int) reload_mode]);

      if (icode != CODE_FOR_nothing
	  && insn_data[(int) icode].operand[in_p].predicate
	  && ! insn_data[(int) icode].operand[in_p].predicate (x, reload_mode))
	icode = CODE_FOR_nothing;
      else if (icode != CODE_FOR_nothing)
	{
	  const char *insn_constraint, *scratch_constraint;
	  char insn_letter, scratch_letter;
	  enum reg_class insn_class, scratch_class;

	  gcc_assert (insn_data[(int) icode].n_operands == 3);
	  insn_constraint = insn_data[(int) icode].operand[!in_p].constraint;
	  if (!*insn_constraint)
	    insn_class = ALL_REGS;
	  else
	    {
	      if (in_p)
		{
		  gcc_assert (*insn_constraint == '=');
		  insn_constraint++;
		}
	      insn_letter = *insn_constraint;
	      insn_class
		= (insn_letter == 'r' ? GENERAL_REGS
		   : REG_CLASS_FROM_CONSTRAINT ((unsigned char) insn_letter,
						insn_constraint));
	      gcc_assert (insn_class != NO_REGS);
	    }

	  scratch_constraint = insn_data[(int) icode].operand[2].constraint;
	  /* The scratch register's constraint must start with "=&",
	     except for an input reload, where only "=" is necessary,
	     and where it might be beneficial to re-use registers from
	     the input.  */
	  gcc_assert (scratch_constraint[0] == '='
		      && (in_p || scratch_constraint[1] == '&'));
	  scratch_constraint++;
	  if (*scratch_constraint == '&')
	    scratch_constraint++;
	  scratch_letter = *scratch_constraint;
	  scratch_class
	    = (scratch_letter == 'r' ? GENERAL_REGS
	       : REG_CLASS_FROM_CONSTRAINT ((unsigned char) scratch_letter,
					    scratch_constraint));

	  if (reg_class_subset_p (reload_class, insn_class))
	    {
	      gcc_assert (scratch_class == class);
	      class = NO_REGS;
	    }
	  else
	    class = insn_class;

        }
      if (class == NO_REGS)
	sri->icode = icode;
      else
	sri->t_icode = icode;
    }
  return class;
}

bool
default_handle_c_option (size_t code ATTRIBUTE_UNUSED,
			 const char *arg ATTRIBUTE_UNUSED,
			 int value ATTRIBUTE_UNUSED)
{
  return false;
}

/* By default, if flag_pic is true, then neither local nor global relocs
   should be placed in readonly memory.  */

int
default_reloc_rw_mask (void)
{
  return flag_pic ? 3 : 0;
}

/* By default, do no modification. */
tree default_mangle_decl_assembler_name (tree decl ATTRIBUTE_UNUSED,
					 tree id)
{
   return id;
}

bool
default_builtin_vector_alignment_reachable (const_tree type, bool is_packed)
{
  if (is_packed)
    return false;

  /* Assuming that types whose size is > pointer-size are not guaranteed to be
     naturally aligned.  */
  if (tree_int_cst_compare (TYPE_SIZE (type), bitsize_int (POINTER_SIZE)) > 0)
    return false;

  /* Assuming that types whose size is <= pointer-size
     are naturally aligned.  */
  return true;
}

#include "gt-targhooks.h"
Commit	Line	Data
61f71b34	1	/* Default target hook functions.
9b580a0b	2	Copyright (C) 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
61f71b34 DD	3
	4	This file is part of GCC.
	5
	6	GCC is free software; you can redistribute it and/or modify it under
	7	the terms of the GNU General Public License as published by the Free
9dcd6f09	8	Software Foundation; either version 3, or (at your option) any later
61f71b34 DD	9	version.
	10
	11	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	12	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	for more details.
	15
	16	You should have received a copy of the GNU General Public License
9dcd6f09 NC	17	along with GCC; see the file COPYING3. If not see
9dcd6f09 NC	18	<http://www.gnu.org/licenses/>. */
61f71b34	19
dd37c5a0 DD	20	/* The migration of target macros to target hooks works as follows:
	21
	22	1. Create a target hook that uses the existing target macros to
	23	implement the same functionality.
	24
	25	2. Convert all the MI files to use the hook instead of the macro.
	26
	27	3. Repeat for a majority of the remaining target macros. This will
	28	take some time.
	29
	30	4. Tell target maintainers to start migrating.
	31
	32	5. Eventually convert the backends to override the hook instead of
	33	defining the macros. This will take some time too.
	34
	35	6. TBD when, poison the macros. Unmigrated targets will break at
	36	this point.
	37
	38	Note that we expect steps 1-3 to be done by the people that
	39	understand what the MI does with each macro, and step 5 to be done
	40	by the target maintainers for their respective targets.
	41
	42	Note that steps 1 and 2 don't have to be done together, but no
	43	target can override the new hook until step 2 is complete for it.
	44
	45	Once the macros are poisoned, we will revert to the old migration
	46	rules - migrate the macro, callers, and targets all at once. This
	47	comment can thus be removed at that point. */
	48
61f71b34 DD	49	#include "config.h"
	50	#include "system.h"
	51	#include "coretypes.h"
	52	#include "tm.h"
	53	#include "machmode.h"
	54	#include "rtl.h"
	55	#include "tree.h"
	56	#include "expr.h"
d84a4ef1	57	#include "output.h"
61f71b34 DD	58	#include "toplev.h"
	59	#include "function.h"
	60	#include "target.h"
	61	#include "tm_p.h"
	62	#include "target-def.h"
7d69de61	63	#include "ggc.h"
150cdc9e	64	#include "hard-reg-set.h"
8a99f6f9 R	65	#include "reload.h"
	66	#include "optabs.h"
	67	#include "recog.h"
61f71b34	68
6dd53648	69
6773a41c RO	70	void
	71	default_external_libcall (rtx fun ATTRIBUTE_UNUSED)
	72	{
	73	#ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
	74	ASM_OUTPUT_EXTERNAL_LIBCALL(asm_out_file, fun);
	75	#endif
	76	}
	77
e129d93a ILT	78	enum machine_mode
	79	default_cc_modes_compatible (enum machine_mode m1, enum machine_mode m2)
	80	{
	81	if (m1 == m2)
	82	return m1;
	83	return VOIDmode;
	84	}
	85
61f71b34	86	bool
586de218 KG	87	default_return_in_memory (const_tree type,
586de218 KG	88	const_tree fntype ATTRIBUTE_UNUSED)
61f71b34	89	{
be6acd4b	90	#ifndef RETURN_IN_MEMORY
33d05111	91	return (TYPE_MODE (type) == BLKmode);
be6acd4b EC	92	#else
	93	return RETURN_IN_MEMORY (type);
	94	#endif
61f71b34 DD	95	}
	96
	97	rtx
	98	default_expand_builtin_saveregs (void)
	99	{
61f71b34 DD	100	error ("__builtin_saveregs not supported by this target");
61f71b34 DD	101	return const0_rtx;
61f71b34 DD	102	}
	103
	104	void
	105	default_setup_incoming_varargs (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
	106	enum machine_mode mode ATTRIBUTE_UNUSED,
	107	tree type ATTRIBUTE_UNUSED,
	108	int *pretend_arg_size ATTRIBUTE_UNUSED,
	109	int second_time ATTRIBUTE_UNUSED)
	110	{
61f71b34 DD	111	}
61f71b34 DD	112
d6da68b9 KH	113	/* The default implementation of TARGET_BUILTIN_SETJMP_FRAME_VALUE. */
	114
	115	rtx
	116	default_builtin_setjmp_frame_value (void)
	117	{
	118	return virtual_stack_vars_rtx;
	119	}
	120
3a4d587b	121	/* Generic hook that takes a CUMULATIVE_ARGS pointer and returns false. */
8dfa8fcd	122
61f71b34	123	bool
8dfa8fcd	124	hook_bool_CUMULATIVE_ARGS_false (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED)
61f71b34	125	{
b602b7b6	126	return false;
61f71b34 DD	127	}
	128
	129	bool
3a4d587b	130	default_pretend_outgoing_varargs_named (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED)
61f71b34	131	{
3a4d587b AM	132	return (targetm.calls.setup_incoming_varargs
3a4d587b AM	133	!= default_setup_incoming_varargs);
61f71b34	134	}
c6e8c921	135
a1c496cb	136	enum machine_mode
93f90be6 FJ	137	default_eh_return_filter_mode (void)
	138	{
	139	return word_mode;
	140	}
	141
c7ff6e7a AK	142	enum machine_mode
	143	default_libgcc_cmp_return_mode (void)
	144	{
	145	return word_mode;
	146	}
	147
	148	enum machine_mode
	149	default_libgcc_shift_count_mode (void)
	150	{
	151	return word_mode;
	152	}
	153
273a2526 RS	154	/* The default implementation of TARGET_SHIFT_TRUNCATION_MASK. */
	155
	156	unsigned HOST_WIDE_INT
	157	default_shift_truncation_mask (enum machine_mode mode)
	158	{
	159	return SHIFT_COUNT_TRUNCATED ? GET_MODE_BITSIZE (mode) - 1 : 0;
	160	}
	161
bc23502b PB	162	/* The default implementation of TARGET_MIN_DIVISIONS_FOR_RECIP_MUL. */
	163
	164	unsigned int
	165	default_min_divisions_for_recip_mul (enum machine_mode mode ATTRIBUTE_UNUSED)
	166	{
	167	return have_insn_for (DIV, mode) ? 3 : 2;
	168	}
	169
b12cbf2c AN	170	/* The default implementation of TARGET_MODE_REP_EXTENDED. */
	171
	172	int
	173	default_mode_rep_extended (enum machine_mode mode ATTRIBUTE_UNUSED,
	174	enum machine_mode mode_rep ATTRIBUTE_UNUSED)
	175	{
	176	return UNKNOWN;
	177	}
	178
c6e8c921	179	/* Generic hook that takes a CUMULATIVE_ARGS pointer and returns true. */
0938c9e8	180
c6e8c921 GK	181	bool
	182	hook_bool_CUMULATIVE_ARGS_true (CUMULATIVE_ARGS * a ATTRIBUTE_UNUSED)
	183	{
	184	return true;
	185	}
4185ae53	186
c77cd3d1 UB	187	/* Return machine mode for non-standard suffix
	188	or VOIDmode if non-standard suffixes are unsupported. */
	189	enum machine_mode
	190	default_mode_for_suffix (char suffix ATTRIBUTE_UNUSED)
	191	{
	192	return VOIDmode;
	193	}
4185ae53 PB	194
	195	/* The generic C++ ABI specifies this is a 64-bit value. */
	196	tree
	197	default_cxx_guard_type (void)
	198	{
	199	return long_long_integer_type_node;
	200	}
46e995e0 PB	201
	202
	203	/* Returns the size of the cookie to use when allocating an array
	204	whose elements have the indicated TYPE. Assumes that it is already
	205	known that a cookie is needed. */
	206
	207	tree
	208	default_cxx_get_cookie_size (tree type)
	209	{
	210	tree cookie_size;
	211
	212	/* We need to allocate an additional max (sizeof (size_t), alignof
	213	(true_type)) bytes. */
	214	tree sizetype_size;
	215	tree type_align;
a1c496cb	216
46e995e0 PB	217	sizetype_size = size_in_bytes (sizetype);
	218	type_align = size_int (TYPE_ALIGN_UNIT (type));
	219	if (INT_CST_LT_UNSIGNED (type_align, sizetype_size))
	220	cookie_size = sizetype_size;
	221	else
	222	cookie_size = type_align;
	223
	224	return cookie_size;
	225	}
8cd5a4e0	226
8cd5a4e0 RH	227	/* Return true if a parameter must be passed by reference. This version
	228	of the TARGET_PASS_BY_REFERENCE hook uses just MUST_PASS_IN_STACK. */
	229
	230	bool
	231	hook_pass_by_reference_must_pass_in_stack (CUMULATIVE_ARGS *c ATTRIBUTE_UNUSED,
586de218	232	enum machine_mode mode ATTRIBUTE_UNUSED, const_tree type ATTRIBUTE_UNUSED,
8cd5a4e0 RH	233	bool named_arg ATTRIBUTE_UNUSED)
	234	{
	235	return targetm.calls.must_pass_in_stack (mode, type);
	236	}
951120ea	237
6cdd5672 RH	238	/* Return true if a parameter follows callee copies conventions. This
	239	version of the hook is true for all named arguments. */
	240
	241	bool
	242	hook_callee_copies_named (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
	243	enum machine_mode mode ATTRIBUTE_UNUSED,
586de218	244	const_tree type ATTRIBUTE_UNUSED, bool named)
6cdd5672 RH	245	{
	246	return named;
	247	}
951120ea PB	248
	249	/* Emit any directives required to unwind this instruction. */
	250
	251	void
	252	default_unwind_emit (FILE * stream ATTRIBUTE_UNUSED,
	253	rtx insn ATTRIBUTE_UNUSED)
	254	{
	255	/* Should never happen. */
1e128c5f	256	gcc_unreachable ();
951120ea	257	}
6dd53648 RH	258
	259	/* True if MODE is valid for the target. By "valid", we mean able to
	260	be manipulated in non-trivial ways. In particular, this means all
	261	the arithmetic is supported.
	262
	263	By default we guess this means that any C type is supported. If
	264	we can't map the mode back to a type that would be available in C,
	265	then reject it. Special case, here, is the double-word arithmetic
	266	supported by optabs.c. */
	267
	268	bool
	269	default_scalar_mode_supported_p (enum machine_mode mode)
	270	{
	271	int precision = GET_MODE_PRECISION (mode);
	272
	273	switch (GET_MODE_CLASS (mode))
	274	{
	275	case MODE_PARTIAL_INT:
	276	case MODE_INT:
	277	if (precision == CHAR_TYPE_SIZE)
	278	return true;
	279	if (precision == SHORT_TYPE_SIZE)
	280	return true;
	281	if (precision == INT_TYPE_SIZE)
	282	return true;
	283	if (precision == LONG_TYPE_SIZE)
	284	return true;
	285	if (precision == LONG_LONG_TYPE_SIZE)
	286	return true;
	287	if (precision == 2 * BITS_PER_WORD)
	288	return true;
	289	return false;
	290
	291	case MODE_FLOAT:
	292	if (precision == FLOAT_TYPE_SIZE)
	293	return true;
	294	if (precision == DOUBLE_TYPE_SIZE)
	295	return true;
	296	if (precision == LONG_DOUBLE_TYPE_SIZE)
	297	return true;
	298	return false;
	299
9a8ce21f	300	case MODE_DECIMAL_FLOAT:
ab22c1fa CF	301	case MODE_FRACT:
	302	case MODE_UFRACT:
	303	case MODE_ACCUM:
	304	case MODE_UACCUM:
9a8ce21f JG	305	return false;
9a8ce21f JG	306
6dd53648	307	default:
1e128c5f	308	gcc_unreachable ();
6dd53648 RH	309	}
6dd53648 RH	310	}
6cdd5672	311
0884546e BE	312	/* True if the target supports decimal floating point. */
	313
	314	bool
	315	default_decimal_float_supported_p (void)
	316	{
	317	return ENABLE_DECIMAL_FLOAT;
	318	}
	319
ab22c1fa CF	320	/* True if the target supports fixed-point arithmetic. */
	321
	322	bool
	323	default_fixed_point_supported_p (void)
	324	{
	325	return ENABLE_FIXED_POINT;
	326	}
	327
e7e64a25 AS	328	/* NULL if INSN insn is valid within a low-overhead loop, otherwise returns
e7e64a25 AS	329	an error message.
a71a498d	330
0fa2e4df	331	This function checks whether a given INSN is valid within a low-overhead
e7e64a25 AS	332	loop. If INSN is invalid it returns the reason for that, otherwise it
	333	returns NULL. A called function may clobber any special registers required
	334	for low-overhead looping. Additionally, some targets (eg, PPC) use the count
a71a498d AS	335	register for branch on table instructions. We reject the doloop pattern in
	336	these cases. */
	337
e7e64a25	338	const char *
3101faab	339	default_invalid_within_doloop (const_rtx insn)
a71a498d AS	340	{
a71a498d AS	341	if (CALL_P (insn))
e7e64a25	342	return "Function call in loop.";
a71a498d AS	343
	344	if (JUMP_P (insn)
	345	&& (GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC
	346	\|\| GET_CODE (PATTERN (insn)) == ADDR_VEC))
e7e64a25	347	return "Computed branch in the loop.";
a71a498d	348
e7e64a25	349	return NULL;
a71a498d AS	350	}
a71a498d AS	351
2505a3f2 RG	352	/* Mapping of builtin functions to vectorized variants. */
	353
	354	tree
	355	default_builtin_vectorized_function (enum built_in_function fn ATTRIBUTE_UNUSED,
b95becfc RG	356	tree type_out ATTRIBUTE_UNUSED,
b95becfc RG	357	tree type_in ATTRIBUTE_UNUSED)
2505a3f2 RG	358	{
	359	return NULL_TREE;
	360	}
	361
f57d17f1 TM	362	/* Vectorized conversion. */
	363
	364	tree
	365	default_builtin_vectorized_conversion (enum tree_code code ATTRIBUTE_UNUSED,
	366	tree type ATTRIBUTE_UNUSED)
	367	{
	368	return NULL_TREE;
	369	}
	370
cc2137be UB	371	/* Reciprocal. */
	372
	373	tree
	374	default_builtin_reciprocal (enum built_in_function fn ATTRIBUTE_UNUSED,
ac10986f	375	bool md_fn ATTRIBUTE_UNUSED,
cc2137be UB	376	bool sqrt ATTRIBUTE_UNUSED)
	377	{
	378	return NULL_TREE;
	379	}
	380
6cdd5672 RH	381	bool
	382	hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false (
	383	CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
	384	enum machine_mode mode ATTRIBUTE_UNUSED,
586de218	385	const_tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
6cdd5672 RH	386	{
	387	return false;
	388	}
	389
	390	bool
	391	hook_bool_CUMULATIVE_ARGS_mode_tree_bool_true (
	392	CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
	393	enum machine_mode mode ATTRIBUTE_UNUSED,
586de218	394	const_tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
6cdd5672 RH	395	{
	396	return true;
	397	}
78a52f11 RH	398
	399	int
	400	hook_int_CUMULATIVE_ARGS_mode_tree_bool_0 (
	401	CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
	402	enum machine_mode mode ATTRIBUTE_UNUSED,
	403	tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
	404	{
	405	return 0;
	406	}
4d3e6fae	407
912f2dac DB	408	void
	409	hook_void_bitmap (bitmap regs ATTRIBUTE_UNUSED)
	410	{
	411	}
	412
4d3e6fae FJ	413	const char *
4d3e6fae FJ	414	hook_invalid_arg_for_unprototyped_fn (
3101faab KG	415	const_tree typelist ATTRIBUTE_UNUSED,
	416	const_tree funcdecl ATTRIBUTE_UNUSED,
	417	const_tree val ATTRIBUTE_UNUSED)
4d3e6fae FJ	418	{
	419	return NULL;
	420	}
7d69de61 RH	421
	422	/* Initialize the stack protection decls. */
	423
	424	/* Stack protection related decls living in libgcc. */
	425	static GTY(()) tree stack_chk_guard_decl;
	426
	427	tree
	428	default_stack_protect_guard (void)
	429	{
	430	tree t = stack_chk_guard_decl;
	431
	432	if (t == NULL)
	433	{
	434	t = build_decl (VAR_DECL, get_identifier ("__stack_chk_guard"),
	435	ptr_type_node);
	436	TREE_STATIC (t) = 1;
	437	TREE_PUBLIC (t) = 1;
	438	DECL_EXTERNAL (t) = 1;
	439	TREE_USED (t) = 1;
	440	TREE_THIS_VOLATILE (t) = 1;
	441	DECL_ARTIFICIAL (t) = 1;
	442	DECL_IGNORED_P (t) = 1;
	443
	444	stack_chk_guard_decl = t;
	445	}
	446
	447	return t;
	448	}
	449
	450	static GTY(()) tree stack_chk_fail_decl;
	451
	452	tree
	453	default_external_stack_protect_fail (void)
	454	{
	455	tree t = stack_chk_fail_decl;
	456
	457	if (t == NULL_TREE)
	458	{
	459	t = build_function_type_list (void_type_node, NULL_TREE);
	460	t = build_decl (FUNCTION_DECL, get_identifier ("__stack_chk_fail"), t);
	461	TREE_STATIC (t) = 1;
	462	TREE_PUBLIC (t) = 1;
	463	DECL_EXTERNAL (t) = 1;
	464	TREE_USED (t) = 1;
	465	TREE_THIS_VOLATILE (t) = 1;
	466	TREE_NOTHROW (t) = 1;
	467	DECL_ARTIFICIAL (t) = 1;
	468	DECL_IGNORED_P (t) = 1;
5b5cba1f JM	469	DECL_VISIBILITY (t) = VISIBILITY_DEFAULT;
5b5cba1f JM	470	DECL_VISIBILITY_SPECIFIED (t) = 1;
7d69de61 RH	471
	472	stack_chk_fail_decl = t;
	473	}
	474
5039610b	475	return build_call_expr (t, 0);
7d69de61 RH	476	}
	477
	478	tree
	479	default_hidden_stack_protect_fail (void)
	480	{
7ce918c5 JJ	481	#ifndef HAVE_GAS_HIDDEN
	482	return default_external_stack_protect_fail ();
	483	#else
7d69de61 RH	484	tree t = stack_chk_fail_decl;
7d69de61 RH	485
7ce918c5 JJ	486	if (!flag_pic)
	487	return default_external_stack_protect_fail ();
	488
	489	if (t == NULL_TREE)
7d69de61 RH	490	{
	491	t = build_function_type_list (void_type_node, NULL_TREE);
	492	t = build_decl (FUNCTION_DECL,
	493	get_identifier ("__stack_chk_fail_local"), t);
	494	TREE_STATIC (t) = 1;
	495	TREE_PUBLIC (t) = 1;
	496	DECL_EXTERNAL (t) = 1;
	497	TREE_USED (t) = 1;
	498	TREE_THIS_VOLATILE (t) = 1;
	499	TREE_NOTHROW (t) = 1;
	500	DECL_ARTIFICIAL (t) = 1;
	501	DECL_IGNORED_P (t) = 1;
	502	DECL_VISIBILITY_SPECIFIED (t) = 1;
	503	DECL_VISIBILITY (t) = VISIBILITY_HIDDEN;
	504
	505	stack_chk_fail_decl = t;
	506	}
	507
5039610b	508	return build_call_expr (t, 0);
7ce918c5	509	#endif
7d69de61 RH	510	}
7d69de61 RH	511
8ddf681a	512	bool
3101faab KG	513	hook_bool_const_rtx_commutative_p (const_rtx x,
3101faab KG	514	int outer_code ATTRIBUTE_UNUSED)
8ddf681a R	515	{
	516	return COMMUTATIVE_P (x);
	517	}
	518
1d636cc6	519	rtx
586de218 KG	520	default_function_value (const_tree ret_type ATTRIBUTE_UNUSED,
586de218 KG	521	const_tree fn_decl_or_type,
1d636cc6 RG	522	bool outgoing ATTRIBUTE_UNUSED)
	523	{
	524	/* The old interface doesn't handle receiving the function type. */
	525	if (fn_decl_or_type
	526	&& !DECL_P (fn_decl_or_type))
	527	fn_decl_or_type = NULL;
	528
	529	#ifdef FUNCTION_OUTGOING_VALUE
	530	if (outgoing)
	531	return FUNCTION_OUTGOING_VALUE (ret_type, fn_decl_or_type);
	532	#endif
	533
	534	#ifdef FUNCTION_VALUE
	535	return FUNCTION_VALUE (ret_type, fn_decl_or_type);
	536	#else
	537	return NULL_RTX;
	538	#endif
	539	}
	540
150cdc9e RH	541	rtx
	542	default_internal_arg_pointer (void)
	543	{
	544	/* If the reg that the virtual arg pointer will be translated into is
	545	not a fixed reg or is the stack pointer, make a copy of the virtual
	546	arg pointer, and address parms via the copy. The frame pointer is
	547	considered fixed even though it is not marked as such. */
	548	if ((ARG_POINTER_REGNUM == STACK_POINTER_REGNUM
	549	\|\| ! (fixed_regs[ARG_POINTER_REGNUM]
	550	\|\| ARG_POINTER_REGNUM == FRAME_POINTER_REGNUM)))
	551	return copy_to_reg (virtual_incoming_args_rtx);
	552	else
	553	return virtual_incoming_args_rtx;
	554	}
	555
8a99f6f9 R	556	enum reg_class
	557	default_secondary_reload (bool in_p ATTRIBUTE_UNUSED, rtx x ATTRIBUTE_UNUSED,
	558	enum reg_class reload_class ATTRIBUTE_UNUSED,
	559	enum machine_mode reload_mode ATTRIBUTE_UNUSED,
	560	secondary_reload_info *sri)
	561	{
	562	enum reg_class class = NO_REGS;
	563
	564	if (sri->prev_sri && sri->prev_sri->t_icode != CODE_FOR_nothing)
	565	{
	566	sri->icode = sri->prev_sri->t_icode;
	567	return NO_REGS;
	568	}
	569	#ifdef SECONDARY_INPUT_RELOAD_CLASS
	570	if (in_p)
	571	class = SECONDARY_INPUT_RELOAD_CLASS (reload_class, reload_mode, x);
	572	#endif
	573	#ifdef SECONDARY_OUTPUT_RELOAD_CLASS
	574	if (! in_p)
	575	class = SECONDARY_OUTPUT_RELOAD_CLASS (reload_class, reload_mode, x);
	576	#endif
	577	if (class != NO_REGS)
	578	{
	579	enum insn_code icode = (in_p ? reload_in_optab[(int) reload_mode]
	580	: reload_out_optab[(int) reload_mode]);
	581
	582	if (icode != CODE_FOR_nothing
	583	&& insn_data[(int) icode].operand[in_p].predicate
	584	&& ! insn_data[(int) icode].operand[in_p].predicate (x, reload_mode))
	585	icode = CODE_FOR_nothing;
	586	else if (icode != CODE_FOR_nothing)
	587	{
	588	const char insn_constraint, scratch_constraint;
	589	char insn_letter, scratch_letter;
	590	enum reg_class insn_class, scratch_class;
	591
	592	gcc_assert (insn_data[(int) icode].n_operands == 3);
	593	insn_constraint = insn_data[(int) icode].operand[!in_p].constraint;
	594	if (!*insn_constraint)
	595	insn_class = ALL_REGS;
	596	else
	597	{
	598	if (in_p)
	599	{
	600	gcc_assert (*insn_constraint == '=');
	601	insn_constraint++;
	602	}
	603	insn_letter = *insn_constraint;
	604	insn_class
	605	= (insn_letter == 'r' ? GENERAL_REGS
	606	: REG_CLASS_FROM_CONSTRAINT ((unsigned char) insn_letter,
	607	insn_constraint));
	608	gcc_assert (insn_class != NO_REGS);
	609	}
	610
	611	scratch_constraint = insn_data[(int) icode].operand[2].constraint;
11e30dd8 HPN	612	/* The scratch register's constraint must start with "=&",
	613	except for an input reload, where only "=" is necessary,
	614	and where it might be beneficial to re-use registers from
	615	the input. */
8a99f6f9	616	gcc_assert (scratch_constraint[0] == '='
11e30dd8 HPN	617	&& (in_p \|\| scratch_constraint[1] == '&'));
	618	scratch_constraint++;
	619	if (*scratch_constraint == '&')
	620	scratch_constraint++;
8a99f6f9 R	621	scratch_letter = *scratch_constraint;
	622	scratch_class
	623	= (scratch_letter == 'r' ? GENERAL_REGS
	624	: REG_CLASS_FROM_CONSTRAINT ((unsigned char) scratch_letter,
	625	scratch_constraint));
	626
	627	if (reg_class_subset_p (reload_class, insn_class))
	628	{
	629	gcc_assert (scratch_class == class);
	630	class = NO_REGS;
	631	}
	632	else
	633	class = insn_class;
	634
	635	}
	636	if (class == NO_REGS)
	637	sri->icode = icode;
	638	else
	639	sri->t_icode = icode;
	640	}
	641	return class;
	642	}
	643
1f1d5130 MS	644	bool
	645	default_handle_c_option (size_t code ATTRIBUTE_UNUSED,
	646	const char *arg ATTRIBUTE_UNUSED,
	647	int value ATTRIBUTE_UNUSED)
	648	{
	649	return false;
	650	}
	651
9b580a0b RH	652	/* By default, if flag_pic is true, then neither local nor global relocs
	653	should be placed in readonly memory. */
	654
	655	int
	656	default_reloc_rw_mask (void)
	657	{
	658	return flag_pic ? 3 : 0;
	659	}
	660
5234b8f5 DS	661	/* By default, do no modification. */
	662	tree default_mangle_decl_assembler_name (tree decl ATTRIBUTE_UNUSED,
	663	tree id)
	664	{
	665	return id;
	666	}
	667
5b900a4c	668	bool
3101faab	669	default_builtin_vector_alignment_reachable (const_tree type, bool is_packed)
5b900a4c DN	670	{
	671	if (is_packed)
	672	return false;
	673
	674	/* Assuming that types whose size is > pointer-size are not guaranteed to be
	675	naturally aligned. */
	676	if (tree_int_cst_compare (TYPE_SIZE (type), bitsize_int (POINTER_SIZE)) > 0)
	677	return false;
	678
	679	/* Assuming that types whose size is <= pointer-size
	680	are naturally aligned. */
	681	return true;
	682	}
	683
7d69de61	684	#include "gt-targhooks.h"