/* Default target hook functions.
- Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009
+ Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009, 2010
Free Software Foundation, Inc.
This file is part of GCC.
/* 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
{
if (CALL_P (insn))
return "Function call in loop.";
-
+
if (JUMP_TABLE_DATA_P (insn))
return "Computed branch in the loop.";
-
+
return NULL;
}
/* Mapping of builtin functions to vectorized variants. */
tree
-default_builtin_vectorized_function (unsigned int fn ATTRIBUTE_UNUSED,
+default_builtin_vectorized_function (tree fndecl ATTRIBUTE_UNUSED,
tree type_out ATTRIBUTE_UNUSED,
tree type_in ATTRIBUTE_UNUSED)
{
tree
default_builtin_vectorized_conversion (unsigned int code ATTRIBUTE_UNUSED,
- tree type ATTRIBUTE_UNUSED)
+ tree dest_type ATTRIBUTE_UNUSED,
+ tree src_type ATTRIBUTE_UNUSED)
{
return NULL_TREE;
}
return 0;
}
-void
+void
hook_void_bitmap (bitmap regs ATTRIBUTE_UNUSED)
{
}
if (t == NULL)
{
+ rtx x;
+
t = build_decl (UNKNOWN_LOCATION,
VAR_DECL, get_identifier ("__stack_chk_guard"),
ptr_type_node);
DECL_ARTIFICIAL (t) = 1;
DECL_IGNORED_P (t) = 1;
+ /* Do not share RTL as the declaration is visible outside of
+ current function. */
+ x = DECL_RTL (t);
+ RTX_FLAG (x, used) = 1;
+
stack_chk_guard_decl = t;
}
static GTY(()) tree stack_chk_fail_decl;
-tree
+tree
default_external_stack_protect_fail (void)
{
tree t = stack_chk_fail_decl;
#ifdef FUNCTION_VALUE
return FUNCTION_VALUE (ret_type, fn_decl_or_type);
#else
- return NULL_RTX;
+ gcc_unreachable ();
#endif
}
rtx
-default_libcall_value (enum machine_mode mode, rtx fun ATTRIBUTE_UNUSED)
+default_libcall_value (enum machine_mode mode ATTRIBUTE_UNUSED,
+ const_rtx fun ATTRIBUTE_UNUSED)
{
+#ifdef LIBCALL_VALUE
return LIBCALL_VALUE (mode);
+#else
+ gcc_unreachable ();
+#endif
+}
+
+/* The default hook for TARGET_FUNCTION_VALUE_REGNO_P. */
+
+bool
+default_function_value_regno_p (const unsigned int regno ATTRIBUTE_UNUSED)
+{
+#ifdef FUNCTION_VALUE_REGNO_P
+ return FUNCTION_VALUE_REGNO_P (regno);
+#else
+ gcc_unreachable ();
+#endif
}
rtx
rtx
default_static_chain (const_tree fndecl, bool incoming_p)
{
- if (DECL_NO_STATIC_CHAIN (fndecl))
+ if (!DECL_STATIC_CHAIN (fndecl))
return NULL;
if (incoming_p)
{
-#ifdef STATIC_CHAIN_INCOMING
- return STATIC_CHAIN_INCOMING;
-#endif
#ifdef STATIC_CHAIN_INCOMING_REGNUM
return gen_rtx_REG (Pmode, STATIC_CHAIN_INCOMING_REGNUM);
#endif
}
-#ifdef STATIC_CHAIN
- return STATIC_CHAIN;
-#endif
#ifdef STATIC_CHAIN_REGNUM
return gen_rtx_REG (Pmode, STATIC_CHAIN_REGNUM);
#endif
- gcc_unreachable ();
+ {
+ static bool issued_error;
+ if (!issued_error)
+ {
+ issued_error = true;
+ sorry ("nested functions not supported on this target");
+ }
+
+ /* It really doesn't matter what we return here, so long at it
+ doesn't cause the rest of the compiler to crash. */
+ return gen_rtx_MEM (Pmode, stack_pointer_rtx);
+ }
}
-#ifdef TRAMPOLINE_TEMPLATE
-void
-default_asm_trampoline_template (FILE *f)
-{
- TRAMPOLINE_TEMPLATE (f);
-}
-#endif
-
void
default_trampoline_init (rtx ARG_UNUSED (m_tramp), tree ARG_UNUSED (t_func),
rtx ARG_UNUSED (r_chain))
{
-#ifdef INITIALIZE_TRAMPOLINE
- rtx r_tramp, r_func;
-
- if (targetm.asm_out.trampoline_template)
- emit_block_move (m_tramp, assemble_trampoline_template (),
- GEN_INT (TRAMPOLINE_SIZE), BLOCK_OP_NORMAL);
-
- r_func = XEXP (DECL_RTL (t_func), 0);
- r_tramp = XEXP (m_tramp, 0);
-
- INITIALIZE_TRAMPOLINE (r_tramp, r_func, r_chain);
-#else
sorry ("nested function trampolines not supported on this target");
-#endif
-}
-
-rtx
-default_trampoline_adjust_address (rtx addr)
-{
-#ifdef TRAMPOLINE_ADJUST_ADDRESS
- TRAMPOLINE_ADJUST_ADDRESS (addr);
-#endif
- return addr;
}
enum reg_class
}
/* By default, assume that a target supports any factor of misalignment
- memory access if it supports movmisalign patten.
+ memory access if it supports movmisalign patten.
is_packed is true if the memory access is defined in a packed struct. */
bool
default_builtin_support_vector_misalignment (enum machine_mode mode,
return false;
}
+/* Determine whether or not a pointer mode is valid. Assume defaults
+ of ptr_mode or Pmode - can be overridden. */
+bool
+default_valid_pointer_mode (enum machine_mode mode)
+{
+ return (mode == ptr_mode || mode == Pmode);
+}
+
+/* Return the mode for a pointer to a given ADDRSPACE, defaulting to ptr_mode
+ for the generic address space only. */
+
+enum machine_mode
+default_addr_space_pointer_mode (addr_space_t addrspace ATTRIBUTE_UNUSED)
+{
+ gcc_assert (ADDR_SPACE_GENERIC_P (addrspace));
+ return ptr_mode;
+}
+
+/* Return the mode for an address in a given ADDRSPACE, defaulting to Pmode
+ for the generic address space only. */
+
+enum machine_mode
+default_addr_space_address_mode (addr_space_t addrspace ATTRIBUTE_UNUSED)
+{
+ gcc_assert (ADDR_SPACE_GENERIC_P (addrspace));
+ return Pmode;
+}
+
+/* Named address space version of valid_pointer_mode. */
+
+bool
+default_addr_space_valid_pointer_mode (enum machine_mode mode, addr_space_t as)
+{
+ if (!ADDR_SPACE_GENERIC_P (as))
+ return (mode == targetm.addr_space.pointer_mode (as)
+ || mode == targetm.addr_space.address_mode (as));
+
+ return targetm.valid_pointer_mode (mode);
+}
+
+/* Some places still assume that all pointer or address modes are the
+ standard Pmode and ptr_mode. These optimizations become invalid if
+ the target actually supports multiple different modes. For now,
+ we disable such optimizations on such targets, using this function. */
+
+bool
+target_default_pointer_address_modes_p (void)
+{
+ if (targetm.addr_space.address_mode != default_addr_space_address_mode)
+ return false;
+ if (targetm.addr_space.pointer_mode != default_addr_space_pointer_mode)
+ return false;
+
+ return true;
+}
+
+/* Named address space version of legitimate_address_p. */
+
+bool
+default_addr_space_legitimate_address_p (enum machine_mode mode, rtx mem,
+ bool strict, addr_space_t as)
+{
+ if (!ADDR_SPACE_GENERIC_P (as))
+ gcc_unreachable ();
+
+ return targetm.legitimate_address_p (mode, mem, strict);
+}
+
+/* Named address space version of LEGITIMIZE_ADDRESS. */
+
+rtx
+default_addr_space_legitimize_address (rtx x, rtx oldx,
+ enum machine_mode mode, addr_space_t as)
+{
+ if (!ADDR_SPACE_GENERIC_P (as))
+ return x;
+
+ return targetm.legitimize_address (x, oldx, mode);
+}
+
+/* The default hook for determining if one named address space is a subset of
+ another and to return which address space to use as the common address
+ space. */
+
+bool
+default_addr_space_subset_p (addr_space_t subset, addr_space_t superset)
+{
+ return (subset == superset);
+}
+
+/* The default hook for TARGET_ADDR_SPACE_CONVERT. This hook should never be
+ called for targets with only a generic address space. */
+
+rtx
+default_addr_space_convert (rtx op ATTRIBUTE_UNUSED,
+ tree from_type ATTRIBUTE_UNUSED,
+ tree to_type ATTRIBUTE_UNUSED)
+{
+ gcc_unreachable ();
+}
+
bool
default_hard_regno_scratch_ok (unsigned int regno ATTRIBUTE_UNUSED)
{
return true;
}
+/* The default implementation of TARGET_MODE_DEPENDENT_ADDRESS_P. */
+
+bool
+default_mode_dependent_address_p (const_rtx addr ATTRIBUTE_UNUSED)
+{
+#ifdef GO_IF_MODE_DEPENDENT_ADDRESS
+
+ GO_IF_MODE_DEPENDENT_ADDRESS (CONST_CAST_RTX (addr), win);
+ return false;
+ /* Label `win' might (not) be used via GO_IF_MODE_DEPENDENT_ADDRESS. */
+ win: ATTRIBUTE_UNUSED_LABEL
+ return true;
+
+#else
+
+ return false;
+
+#endif
+}
+
bool
default_target_option_valid_attribute_p (tree ARG_UNUSED (fndecl),
tree ARG_UNUSED (name),
return (HAVE_casesi ? 4 : 5);
}
+bool
+default_have_conditional_execution (void)
+{
+#ifdef HAVE_conditional_execution
+ return HAVE_conditional_execution;
+#else
+ return false;
+#endif
+}
+
#include "gt-targhooks.h"