/* Default target hook functions.
|
/* Default target hook functions.
|
Copyright (C) 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
|
Copyright (C) 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
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
|
the terms of the GNU General Public License as published by the Free
|
Software Foundation; either version 3, or (at your option) any later
|
Software Foundation; either version 3, or (at your option) any later
|
version.
|
version.
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
for more details.
|
for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with GCC; see the file COPYING3. If not see
|
along with GCC; see the file COPYING3. If not see
|
<http://www.gnu.org/licenses/>. */
|
<http://www.gnu.org/licenses/>. */
|
|
|
/* The migration of target macros to target hooks works as follows:
|
/* The migration of target macros to target hooks works as follows:
|
|
|
1. Create a target hook that uses the existing target macros to
|
1. Create a target hook that uses the existing target macros to
|
implement the same functionality.
|
implement the same functionality.
|
|
|
2. Convert all the MI files to use the hook instead of the macro.
|
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
|
3. Repeat for a majority of the remaining target macros. This will
|
take some time.
|
take some time.
|
|
|
4. Tell target maintainers to start migrating.
|
4. Tell target maintainers to start migrating.
|
|
|
5. Eventually convert the backends to override the hook instead of
|
5. Eventually convert the backends to override the hook instead of
|
defining the macros. This will take some time too.
|
defining the macros. This will take some time too.
|
|
|
6. TBD when, poison the macros. Unmigrated targets will break at
|
6. TBD when, poison the macros. Unmigrated targets will break at
|
this point.
|
this point.
|
|
|
Note that we expect steps 1-3 to be done by the people that
|
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
|
understand what the MI does with each macro, and step 5 to be done
|
by the target maintainers for their respective targets.
|
by the target maintainers for their respective targets.
|
|
|
Note that steps 1 and 2 don't have to be done together, but no
|
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.
|
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
|
Once the macros are poisoned, we will revert to the old migration
|
rules - migrate the macro, callers, and targets all at once. This
|
rules - migrate the macro, callers, and targets all at once. This
|
comment can thus be removed at that point. */
|
comment can thus be removed at that point. */
|
|
|
#include "config.h"
|
#include "config.h"
|
#include "system.h"
|
#include "system.h"
|
#include "coretypes.h"
|
#include "coretypes.h"
|
#include "tm.h"
|
#include "tm.h"
|
#include "machmode.h"
|
#include "machmode.h"
|
#include "rtl.h"
|
#include "rtl.h"
|
#include "tree.h"
|
#include "tree.h"
|
#include "expr.h"
|
#include "expr.h"
|
#include "output.h"
|
#include "output.h"
|
#include "toplev.h"
|
#include "toplev.h"
|
#include "function.h"
|
#include "function.h"
|
#include "target.h"
|
#include "target.h"
|
#include "tm_p.h"
|
#include "tm_p.h"
|
#include "target-def.h"
|
#include "target-def.h"
|
#include "ggc.h"
|
#include "ggc.h"
|
#include "hard-reg-set.h"
|
#include "hard-reg-set.h"
|
#include "reload.h"
|
#include "reload.h"
|
#include "optabs.h"
|
#include "optabs.h"
|
#include "recog.h"
|
#include "recog.h"
|
|
|
|
|
void
|
void
|
default_external_libcall (rtx fun ATTRIBUTE_UNUSED)
|
default_external_libcall (rtx fun ATTRIBUTE_UNUSED)
|
{
|
{
|
#ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
|
#ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
|
ASM_OUTPUT_EXTERNAL_LIBCALL(asm_out_file, fun);
|
ASM_OUTPUT_EXTERNAL_LIBCALL(asm_out_file, fun);
|
#endif
|
#endif
|
}
|
}
|
|
|
enum machine_mode
|
enum machine_mode
|
default_cc_modes_compatible (enum machine_mode m1, enum machine_mode m2)
|
default_cc_modes_compatible (enum machine_mode m1, enum machine_mode m2)
|
{
|
{
|
if (m1 == m2)
|
if (m1 == m2)
|
return m1;
|
return m1;
|
return VOIDmode;
|
return VOIDmode;
|
}
|
}
|
|
|
bool
|
bool
|
default_return_in_memory (tree type,
|
default_return_in_memory (tree type,
|
tree fntype ATTRIBUTE_UNUSED)
|
tree fntype ATTRIBUTE_UNUSED)
|
{
|
{
|
#ifndef RETURN_IN_MEMORY
|
#ifndef RETURN_IN_MEMORY
|
return (TYPE_MODE (type) == BLKmode);
|
return (TYPE_MODE (type) == BLKmode);
|
#else
|
#else
|
return RETURN_IN_MEMORY (type);
|
return RETURN_IN_MEMORY (type);
|
#endif
|
#endif
|
}
|
}
|
|
|
rtx
|
rtx
|
default_expand_builtin_saveregs (void)
|
default_expand_builtin_saveregs (void)
|
{
|
{
|
error ("__builtin_saveregs not supported by this target");
|
error ("__builtin_saveregs not supported by this target");
|
return const0_rtx;
|
return const0_rtx;
|
}
|
}
|
|
|
void
|
void
|
default_setup_incoming_varargs (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
|
default_setup_incoming_varargs (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
|
enum machine_mode mode ATTRIBUTE_UNUSED,
|
enum machine_mode mode ATTRIBUTE_UNUSED,
|
tree type ATTRIBUTE_UNUSED,
|
tree type ATTRIBUTE_UNUSED,
|
int *pretend_arg_size ATTRIBUTE_UNUSED,
|
int *pretend_arg_size ATTRIBUTE_UNUSED,
|
int second_time ATTRIBUTE_UNUSED)
|
int second_time ATTRIBUTE_UNUSED)
|
{
|
{
|
}
|
}
|
|
|
/* The default implementation of TARGET_BUILTIN_SETJMP_FRAME_VALUE. */
|
/* The default implementation of TARGET_BUILTIN_SETJMP_FRAME_VALUE. */
|
|
|
rtx
|
rtx
|
default_builtin_setjmp_frame_value (void)
|
default_builtin_setjmp_frame_value (void)
|
{
|
{
|
return virtual_stack_vars_rtx;
|
return virtual_stack_vars_rtx;
|
}
|
}
|
|
|
/* Generic hook that takes a CUMULATIVE_ARGS pointer and returns false. */
|
/* Generic hook that takes a CUMULATIVE_ARGS pointer and returns false. */
|
|
|
bool
|
bool
|
hook_bool_CUMULATIVE_ARGS_false (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED)
|
hook_bool_CUMULATIVE_ARGS_false (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED)
|
{
|
{
|
return false;
|
return false;
|
}
|
}
|
|
|
bool
|
bool
|
default_pretend_outgoing_varargs_named (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED)
|
default_pretend_outgoing_varargs_named (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED)
|
{
|
{
|
return (targetm.calls.setup_incoming_varargs
|
return (targetm.calls.setup_incoming_varargs
|
!= default_setup_incoming_varargs);
|
!= default_setup_incoming_varargs);
|
}
|
}
|
|
|
enum machine_mode
|
enum machine_mode
|
default_eh_return_filter_mode (void)
|
default_eh_return_filter_mode (void)
|
{
|
{
|
return word_mode;
|
return word_mode;
|
}
|
}
|
|
|
/* The default implementation of TARGET_SHIFT_TRUNCATION_MASK. */
|
/* The default implementation of TARGET_SHIFT_TRUNCATION_MASK. */
|
|
|
unsigned HOST_WIDE_INT
|
unsigned HOST_WIDE_INT
|
default_shift_truncation_mask (enum machine_mode mode)
|
default_shift_truncation_mask (enum machine_mode mode)
|
{
|
{
|
return SHIFT_COUNT_TRUNCATED ? GET_MODE_BITSIZE (mode) - 1 : 0;
|
return SHIFT_COUNT_TRUNCATED ? GET_MODE_BITSIZE (mode) - 1 : 0;
|
}
|
}
|
|
|
/* The default implementation of TARGET_MIN_DIVISIONS_FOR_RECIP_MUL. */
|
/* The default implementation of TARGET_MIN_DIVISIONS_FOR_RECIP_MUL. */
|
|
|
unsigned int
|
unsigned int
|
default_min_divisions_for_recip_mul (enum machine_mode mode ATTRIBUTE_UNUSED)
|
default_min_divisions_for_recip_mul (enum machine_mode mode ATTRIBUTE_UNUSED)
|
{
|
{
|
return have_insn_for (DIV, mode) ? 3 : 2;
|
return have_insn_for (DIV, mode) ? 3 : 2;
|
}
|
}
|
|
|
/* The default implementation of TARGET_MODE_REP_EXTENDED. */
|
/* The default implementation of TARGET_MODE_REP_EXTENDED. */
|
|
|
int
|
int
|
default_mode_rep_extended (enum machine_mode mode ATTRIBUTE_UNUSED,
|
default_mode_rep_extended (enum machine_mode mode ATTRIBUTE_UNUSED,
|
enum machine_mode mode_rep ATTRIBUTE_UNUSED)
|
enum machine_mode mode_rep ATTRIBUTE_UNUSED)
|
{
|
{
|
return UNKNOWN;
|
return UNKNOWN;
|
}
|
}
|
|
|
/* Generic hook that takes a CUMULATIVE_ARGS pointer and returns true. */
|
/* Generic hook that takes a CUMULATIVE_ARGS pointer and returns true. */
|
|
|
bool
|
bool
|
hook_bool_CUMULATIVE_ARGS_true (CUMULATIVE_ARGS * a ATTRIBUTE_UNUSED)
|
hook_bool_CUMULATIVE_ARGS_true (CUMULATIVE_ARGS * a ATTRIBUTE_UNUSED)
|
{
|
{
|
return true;
|
return true;
|
}
|
}
|
|
|
|
|
/* The generic C++ ABI specifies this is a 64-bit value. */
|
/* The generic C++ ABI specifies this is a 64-bit value. */
|
tree
|
tree
|
default_cxx_guard_type (void)
|
default_cxx_guard_type (void)
|
{
|
{
|
return long_long_integer_type_node;
|
return long_long_integer_type_node;
|
}
|
}
|
|
|
|
|
/* Returns the size of the cookie to use when allocating an array
|
/* Returns the size of the cookie to use when allocating an array
|
whose elements have the indicated TYPE. Assumes that it is already
|
whose elements have the indicated TYPE. Assumes that it is already
|
known that a cookie is needed. */
|
known that a cookie is needed. */
|
|
|
tree
|
tree
|
default_cxx_get_cookie_size (tree type)
|
default_cxx_get_cookie_size (tree type)
|
{
|
{
|
tree cookie_size;
|
tree cookie_size;
|
|
|
/* We need to allocate an additional max (sizeof (size_t), alignof
|
/* We need to allocate an additional max (sizeof (size_t), alignof
|
(true_type)) bytes. */
|
(true_type)) bytes. */
|
tree sizetype_size;
|
tree sizetype_size;
|
tree type_align;
|
tree type_align;
|
|
|
sizetype_size = size_in_bytes (sizetype);
|
sizetype_size = size_in_bytes (sizetype);
|
type_align = size_int (TYPE_ALIGN_UNIT (type));
|
type_align = size_int (TYPE_ALIGN_UNIT (type));
|
if (INT_CST_LT_UNSIGNED (type_align, sizetype_size))
|
if (INT_CST_LT_UNSIGNED (type_align, sizetype_size))
|
cookie_size = sizetype_size;
|
cookie_size = sizetype_size;
|
else
|
else
|
cookie_size = type_align;
|
cookie_size = type_align;
|
|
|
return cookie_size;
|
return cookie_size;
|
}
|
}
|
|
|
/* Return true if a parameter must be passed by reference. This version
|
/* 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. */
|
of the TARGET_PASS_BY_REFERENCE hook uses just MUST_PASS_IN_STACK. */
|
|
|
bool
|
bool
|
hook_pass_by_reference_must_pass_in_stack (CUMULATIVE_ARGS *c ATTRIBUTE_UNUSED,
|
hook_pass_by_reference_must_pass_in_stack (CUMULATIVE_ARGS *c ATTRIBUTE_UNUSED,
|
enum machine_mode mode ATTRIBUTE_UNUSED, tree type ATTRIBUTE_UNUSED,
|
enum machine_mode mode ATTRIBUTE_UNUSED, tree type ATTRIBUTE_UNUSED,
|
bool named_arg ATTRIBUTE_UNUSED)
|
bool named_arg ATTRIBUTE_UNUSED)
|
{
|
{
|
return targetm.calls.must_pass_in_stack (mode, type);
|
return targetm.calls.must_pass_in_stack (mode, type);
|
}
|
}
|
|
|
/* Return true if a parameter follows callee copies conventions. This
|
/* Return true if a parameter follows callee copies conventions. This
|
version of the hook is true for all named arguments. */
|
version of the hook is true for all named arguments. */
|
|
|
bool
|
bool
|
hook_callee_copies_named (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
|
hook_callee_copies_named (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
|
enum machine_mode mode ATTRIBUTE_UNUSED,
|
enum machine_mode mode ATTRIBUTE_UNUSED,
|
tree type ATTRIBUTE_UNUSED, bool named)
|
tree type ATTRIBUTE_UNUSED, bool named)
|
{
|
{
|
return named;
|
return named;
|
}
|
}
|
|
|
/* Emit any directives required to unwind this instruction. */
|
/* Emit any directives required to unwind this instruction. */
|
|
|
void
|
void
|
default_unwind_emit (FILE * stream ATTRIBUTE_UNUSED,
|
default_unwind_emit (FILE * stream ATTRIBUTE_UNUSED,
|
rtx insn ATTRIBUTE_UNUSED)
|
rtx insn ATTRIBUTE_UNUSED)
|
{
|
{
|
/* Should never happen. */
|
/* Should never happen. */
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
/* True if MODE is valid for the target. By "valid", we mean able to
|
/* 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
|
be manipulated in non-trivial ways. In particular, this means all
|
the arithmetic is supported.
|
the arithmetic is supported.
|
|
|
By default we guess this means that any C type is supported. If
|
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,
|
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
|
then reject it. Special case, here, is the double-word arithmetic
|
supported by optabs.c. */
|
supported by optabs.c. */
|
|
|
bool
|
bool
|
default_scalar_mode_supported_p (enum machine_mode mode)
|
default_scalar_mode_supported_p (enum machine_mode mode)
|
{
|
{
|
int precision = GET_MODE_PRECISION (mode);
|
int precision = GET_MODE_PRECISION (mode);
|
|
|
switch (GET_MODE_CLASS (mode))
|
switch (GET_MODE_CLASS (mode))
|
{
|
{
|
case MODE_PARTIAL_INT:
|
case MODE_PARTIAL_INT:
|
case MODE_INT:
|
case MODE_INT:
|
if (precision == CHAR_TYPE_SIZE)
|
if (precision == CHAR_TYPE_SIZE)
|
return true;
|
return true;
|
if (precision == SHORT_TYPE_SIZE)
|
if (precision == SHORT_TYPE_SIZE)
|
return true;
|
return true;
|
if (precision == INT_TYPE_SIZE)
|
if (precision == INT_TYPE_SIZE)
|
return true;
|
return true;
|
if (precision == LONG_TYPE_SIZE)
|
if (precision == LONG_TYPE_SIZE)
|
return true;
|
return true;
|
if (precision == LONG_LONG_TYPE_SIZE)
|
if (precision == LONG_LONG_TYPE_SIZE)
|
return true;
|
return true;
|
if (precision == 2 * BITS_PER_WORD)
|
if (precision == 2 * BITS_PER_WORD)
|
return true;
|
return true;
|
return false;
|
return false;
|
|
|
case MODE_FLOAT:
|
case MODE_FLOAT:
|
if (precision == FLOAT_TYPE_SIZE)
|
if (precision == FLOAT_TYPE_SIZE)
|
return true;
|
return true;
|
if (precision == DOUBLE_TYPE_SIZE)
|
if (precision == DOUBLE_TYPE_SIZE)
|
return true;
|
return true;
|
if (precision == LONG_DOUBLE_TYPE_SIZE)
|
if (precision == LONG_DOUBLE_TYPE_SIZE)
|
return true;
|
return true;
|
return false;
|
return false;
|
|
|
case MODE_DECIMAL_FLOAT:
|
case MODE_DECIMAL_FLOAT:
|
return false;
|
return false;
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
|
|
/* True if the target supports decimal floating point. */
|
/* True if the target supports decimal floating point. */
|
|
|
bool
|
bool
|
default_decimal_float_supported_p (void)
|
default_decimal_float_supported_p (void)
|
{
|
{
|
return ENABLE_DECIMAL_FLOAT;
|
return ENABLE_DECIMAL_FLOAT;
|
}
|
}
|
|
|
/* NULL if INSN insn is valid within a low-overhead loop, otherwise returns
|
/* NULL if INSN insn is valid within a low-overhead loop, otherwise returns
|
an error message.
|
an error message.
|
|
|
This function checks whether a given INSN is valid within a low-overhead
|
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
|
loop. If INSN is invalid it returns the reason for that, otherwise it
|
returns NULL. A called function may clobber any special registers required
|
returns NULL. A called function may clobber any special registers required
|
for low-overhead looping. Additionally, some targets (eg, PPC) use the count
|
for low-overhead looping. Additionally, some targets (eg, PPC) use the count
|
register for branch on table instructions. We reject the doloop pattern in
|
register for branch on table instructions. We reject the doloop pattern in
|
these cases. */
|
these cases. */
|
|
|
const char *
|
const char *
|
default_invalid_within_doloop (rtx insn)
|
default_invalid_within_doloop (rtx insn)
|
{
|
{
|
if (CALL_P (insn))
|
if (CALL_P (insn))
|
return "Function call in loop.";
|
return "Function call in loop.";
|
|
|
if (JUMP_P (insn)
|
if (JUMP_P (insn)
|
&& (GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC
|
&& (GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC
|
|| GET_CODE (PATTERN (insn)) == ADDR_VEC))
|
|| GET_CODE (PATTERN (insn)) == ADDR_VEC))
|
return "Computed branch in the loop.";
|
return "Computed branch in the loop.";
|
|
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
bool
|
bool
|
hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false (
|
hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false (
|
CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
|
CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
|
enum machine_mode mode ATTRIBUTE_UNUSED,
|
enum machine_mode mode ATTRIBUTE_UNUSED,
|
tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
|
tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
|
{
|
{
|
return false;
|
return false;
|
}
|
}
|
|
|
bool
|
bool
|
hook_bool_CUMULATIVE_ARGS_mode_tree_bool_true (
|
hook_bool_CUMULATIVE_ARGS_mode_tree_bool_true (
|
CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
|
CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
|
enum machine_mode mode ATTRIBUTE_UNUSED,
|
enum machine_mode mode ATTRIBUTE_UNUSED,
|
tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
|
tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
|
{
|
{
|
return true;
|
return true;
|
}
|
}
|
|
|
int
|
int
|
hook_int_CUMULATIVE_ARGS_mode_tree_bool_0 (
|
hook_int_CUMULATIVE_ARGS_mode_tree_bool_0 (
|
CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
|
CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
|
enum machine_mode mode ATTRIBUTE_UNUSED,
|
enum machine_mode mode ATTRIBUTE_UNUSED,
|
tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
|
tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
|
{
|
{
|
return 0;
|
return 0;
|
}
|
}
|
|
|
void
|
void
|
hook_void_bitmap (bitmap regs ATTRIBUTE_UNUSED)
|
hook_void_bitmap (bitmap regs ATTRIBUTE_UNUSED)
|
{
|
{
|
}
|
}
|
|
|
const char *
|
const char *
|
hook_invalid_arg_for_unprototyped_fn (
|
hook_invalid_arg_for_unprototyped_fn (
|
tree typelist ATTRIBUTE_UNUSED,
|
tree typelist ATTRIBUTE_UNUSED,
|
tree funcdecl ATTRIBUTE_UNUSED,
|
tree funcdecl ATTRIBUTE_UNUSED,
|
tree val ATTRIBUTE_UNUSED)
|
tree val ATTRIBUTE_UNUSED)
|
{
|
{
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
/* Initialize the stack protection decls. */
|
/* Initialize the stack protection decls. */
|
|
|
/* Stack protection related decls living in libgcc. */
|
/* Stack protection related decls living in libgcc. */
|
static GTY(()) tree stack_chk_guard_decl;
|
static GTY(()) tree stack_chk_guard_decl;
|
|
|
tree
|
tree
|
default_stack_protect_guard (void)
|
default_stack_protect_guard (void)
|
{
|
{
|
tree t = stack_chk_guard_decl;
|
tree t = stack_chk_guard_decl;
|
|
|
if (t == NULL)
|
if (t == NULL)
|
{
|
{
|
t = build_decl (VAR_DECL, get_identifier ("__stack_chk_guard"),
|
t = build_decl (VAR_DECL, get_identifier ("__stack_chk_guard"),
|
ptr_type_node);
|
ptr_type_node);
|
TREE_STATIC (t) = 1;
|
TREE_STATIC (t) = 1;
|
TREE_PUBLIC (t) = 1;
|
TREE_PUBLIC (t) = 1;
|
DECL_EXTERNAL (t) = 1;
|
DECL_EXTERNAL (t) = 1;
|
TREE_USED (t) = 1;
|
TREE_USED (t) = 1;
|
TREE_THIS_VOLATILE (t) = 1;
|
TREE_THIS_VOLATILE (t) = 1;
|
DECL_ARTIFICIAL (t) = 1;
|
DECL_ARTIFICIAL (t) = 1;
|
DECL_IGNORED_P (t) = 1;
|
DECL_IGNORED_P (t) = 1;
|
|
|
stack_chk_guard_decl = t;
|
stack_chk_guard_decl = t;
|
}
|
}
|
|
|
return t;
|
return t;
|
}
|
}
|
|
|
static GTY(()) tree stack_chk_fail_decl;
|
static GTY(()) tree stack_chk_fail_decl;
|
|
|
tree
|
tree
|
default_external_stack_protect_fail (void)
|
default_external_stack_protect_fail (void)
|
{
|
{
|
tree t = stack_chk_fail_decl;
|
tree t = stack_chk_fail_decl;
|
|
|
if (t == NULL_TREE)
|
if (t == NULL_TREE)
|
{
|
{
|
t = build_function_type_list (void_type_node, NULL_TREE);
|
t = build_function_type_list (void_type_node, NULL_TREE);
|
t = build_decl (FUNCTION_DECL, get_identifier ("__stack_chk_fail"), t);
|
t = build_decl (FUNCTION_DECL, get_identifier ("__stack_chk_fail"), t);
|
TREE_STATIC (t) = 1;
|
TREE_STATIC (t) = 1;
|
TREE_PUBLIC (t) = 1;
|
TREE_PUBLIC (t) = 1;
|
DECL_EXTERNAL (t) = 1;
|
DECL_EXTERNAL (t) = 1;
|
TREE_USED (t) = 1;
|
TREE_USED (t) = 1;
|
TREE_THIS_VOLATILE (t) = 1;
|
TREE_THIS_VOLATILE (t) = 1;
|
TREE_NOTHROW (t) = 1;
|
TREE_NOTHROW (t) = 1;
|
DECL_ARTIFICIAL (t) = 1;
|
DECL_ARTIFICIAL (t) = 1;
|
DECL_IGNORED_P (t) = 1;
|
DECL_IGNORED_P (t) = 1;
|
DECL_VISIBILITY (t) = VISIBILITY_DEFAULT;
|
DECL_VISIBILITY (t) = VISIBILITY_DEFAULT;
|
DECL_VISIBILITY_SPECIFIED (t) = 1;
|
DECL_VISIBILITY_SPECIFIED (t) = 1;
|
|
|
stack_chk_fail_decl = t;
|
stack_chk_fail_decl = t;
|
}
|
}
|
|
|
return build_function_call_expr (t, NULL_TREE);
|
return build_function_call_expr (t, NULL_TREE);
|
}
|
}
|
|
|
tree
|
tree
|
default_hidden_stack_protect_fail (void)
|
default_hidden_stack_protect_fail (void)
|
{
|
{
|
#ifndef HAVE_GAS_HIDDEN
|
#ifndef HAVE_GAS_HIDDEN
|
return default_external_stack_protect_fail ();
|
return default_external_stack_protect_fail ();
|
#else
|
#else
|
tree t = stack_chk_fail_decl;
|
tree t = stack_chk_fail_decl;
|
|
|
if (!flag_pic)
|
if (!flag_pic)
|
return default_external_stack_protect_fail ();
|
return default_external_stack_protect_fail ();
|
|
|
if (t == NULL_TREE)
|
if (t == NULL_TREE)
|
{
|
{
|
t = build_function_type_list (void_type_node, NULL_TREE);
|
t = build_function_type_list (void_type_node, NULL_TREE);
|
t = build_decl (FUNCTION_DECL,
|
t = build_decl (FUNCTION_DECL,
|
get_identifier ("__stack_chk_fail_local"), t);
|
get_identifier ("__stack_chk_fail_local"), t);
|
TREE_STATIC (t) = 1;
|
TREE_STATIC (t) = 1;
|
TREE_PUBLIC (t) = 1;
|
TREE_PUBLIC (t) = 1;
|
DECL_EXTERNAL (t) = 1;
|
DECL_EXTERNAL (t) = 1;
|
TREE_USED (t) = 1;
|
TREE_USED (t) = 1;
|
TREE_THIS_VOLATILE (t) = 1;
|
TREE_THIS_VOLATILE (t) = 1;
|
TREE_NOTHROW (t) = 1;
|
TREE_NOTHROW (t) = 1;
|
DECL_ARTIFICIAL (t) = 1;
|
DECL_ARTIFICIAL (t) = 1;
|
DECL_IGNORED_P (t) = 1;
|
DECL_IGNORED_P (t) = 1;
|
DECL_VISIBILITY_SPECIFIED (t) = 1;
|
DECL_VISIBILITY_SPECIFIED (t) = 1;
|
DECL_VISIBILITY (t) = VISIBILITY_HIDDEN;
|
DECL_VISIBILITY (t) = VISIBILITY_HIDDEN;
|
|
|
stack_chk_fail_decl = t;
|
stack_chk_fail_decl = t;
|
}
|
}
|
|
|
return build_function_call_expr (t, NULL_TREE);
|
return build_function_call_expr (t, NULL_TREE);
|
#endif
|
#endif
|
}
|
}
|
|
|
bool
|
bool
|
hook_bool_rtx_commutative_p (rtx x, int outer_code ATTRIBUTE_UNUSED)
|
hook_bool_rtx_commutative_p (rtx x, int outer_code ATTRIBUTE_UNUSED)
|
{
|
{
|
return COMMUTATIVE_P (x);
|
return COMMUTATIVE_P (x);
|
}
|
}
|
|
|
rtx
|
rtx
|
default_function_value (tree ret_type ATTRIBUTE_UNUSED,
|
default_function_value (tree ret_type ATTRIBUTE_UNUSED,
|
tree fn_decl_or_type,
|
tree fn_decl_or_type,
|
bool outgoing ATTRIBUTE_UNUSED)
|
bool outgoing ATTRIBUTE_UNUSED)
|
{
|
{
|
/* The old interface doesn't handle receiving the function type. */
|
/* The old interface doesn't handle receiving the function type. */
|
if (fn_decl_or_type
|
if (fn_decl_or_type
|
&& !DECL_P (fn_decl_or_type))
|
&& !DECL_P (fn_decl_or_type))
|
fn_decl_or_type = NULL;
|
fn_decl_or_type = NULL;
|
|
|
#ifdef FUNCTION_OUTGOING_VALUE
|
#ifdef FUNCTION_OUTGOING_VALUE
|
if (outgoing)
|
if (outgoing)
|
return FUNCTION_OUTGOING_VALUE (ret_type, fn_decl_or_type);
|
return FUNCTION_OUTGOING_VALUE (ret_type, fn_decl_or_type);
|
#endif
|
#endif
|
|
|
#ifdef FUNCTION_VALUE
|
#ifdef FUNCTION_VALUE
|
return FUNCTION_VALUE (ret_type, fn_decl_or_type);
|
return FUNCTION_VALUE (ret_type, fn_decl_or_type);
|
#else
|
#else
|
return NULL_RTX;
|
return NULL_RTX;
|
#endif
|
#endif
|
}
|
}
|
|
|
rtx
|
rtx
|
default_internal_arg_pointer (void)
|
default_internal_arg_pointer (void)
|
{
|
{
|
/* If the reg that the virtual arg pointer will be translated into is
|
/* 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
|
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
|
arg pointer, and address parms via the copy. The frame pointer is
|
considered fixed even though it is not marked as such. */
|
considered fixed even though it is not marked as such. */
|
if ((ARG_POINTER_REGNUM == STACK_POINTER_REGNUM
|
if ((ARG_POINTER_REGNUM == STACK_POINTER_REGNUM
|
|| ! (fixed_regs[ARG_POINTER_REGNUM]
|
|| ! (fixed_regs[ARG_POINTER_REGNUM]
|
|| ARG_POINTER_REGNUM == FRAME_POINTER_REGNUM)))
|
|| ARG_POINTER_REGNUM == FRAME_POINTER_REGNUM)))
|
return copy_to_reg (virtual_incoming_args_rtx);
|
return copy_to_reg (virtual_incoming_args_rtx);
|
else
|
else
|
return virtual_incoming_args_rtx;
|
return virtual_incoming_args_rtx;
|
}
|
}
|
|
|
enum reg_class
|
enum reg_class
|
default_secondary_reload (bool in_p ATTRIBUTE_UNUSED, rtx x ATTRIBUTE_UNUSED,
|
default_secondary_reload (bool in_p ATTRIBUTE_UNUSED, rtx x ATTRIBUTE_UNUSED,
|
enum reg_class reload_class ATTRIBUTE_UNUSED,
|
enum reg_class reload_class ATTRIBUTE_UNUSED,
|
enum machine_mode reload_mode ATTRIBUTE_UNUSED,
|
enum machine_mode reload_mode ATTRIBUTE_UNUSED,
|
secondary_reload_info *sri)
|
secondary_reload_info *sri)
|
{
|
{
|
enum reg_class class = NO_REGS;
|
enum reg_class class = NO_REGS;
|
|
|
if (sri->prev_sri && sri->prev_sri->t_icode != CODE_FOR_nothing)
|
if (sri->prev_sri && sri->prev_sri->t_icode != CODE_FOR_nothing)
|
{
|
{
|
sri->icode = sri->prev_sri->t_icode;
|
sri->icode = sri->prev_sri->t_icode;
|
return NO_REGS;
|
return NO_REGS;
|
}
|
}
|
#ifdef SECONDARY_INPUT_RELOAD_CLASS
|
#ifdef SECONDARY_INPUT_RELOAD_CLASS
|
if (in_p)
|
if (in_p)
|
class = SECONDARY_INPUT_RELOAD_CLASS (reload_class, reload_mode, x);
|
class = SECONDARY_INPUT_RELOAD_CLASS (reload_class, reload_mode, x);
|
#endif
|
#endif
|
#ifdef SECONDARY_OUTPUT_RELOAD_CLASS
|
#ifdef SECONDARY_OUTPUT_RELOAD_CLASS
|
if (! in_p)
|
if (! in_p)
|
class = SECONDARY_OUTPUT_RELOAD_CLASS (reload_class, reload_mode, x);
|
class = SECONDARY_OUTPUT_RELOAD_CLASS (reload_class, reload_mode, x);
|
#endif
|
#endif
|
if (class != NO_REGS)
|
if (class != NO_REGS)
|
{
|
{
|
enum insn_code icode = (in_p ? reload_in_optab[(int) reload_mode]
|
enum insn_code icode = (in_p ? reload_in_optab[(int) reload_mode]
|
: reload_out_optab[(int) reload_mode]);
|
: reload_out_optab[(int) reload_mode]);
|
|
|
if (icode != CODE_FOR_nothing
|
if (icode != CODE_FOR_nothing
|
&& insn_data[(int) icode].operand[in_p].predicate
|
&& insn_data[(int) icode].operand[in_p].predicate
|
&& ! insn_data[(int) icode].operand[in_p].predicate (x, reload_mode))
|
&& ! insn_data[(int) icode].operand[in_p].predicate (x, reload_mode))
|
icode = CODE_FOR_nothing;
|
icode = CODE_FOR_nothing;
|
else if (icode != CODE_FOR_nothing)
|
else if (icode != CODE_FOR_nothing)
|
{
|
{
|
const char *insn_constraint, *scratch_constraint;
|
const char *insn_constraint, *scratch_constraint;
|
char insn_letter, scratch_letter;
|
char insn_letter, scratch_letter;
|
enum reg_class insn_class, scratch_class;
|
enum reg_class insn_class, scratch_class;
|
|
|
gcc_assert (insn_data[(int) icode].n_operands == 3);
|
gcc_assert (insn_data[(int) icode].n_operands == 3);
|
insn_constraint = insn_data[(int) icode].operand[!in_p].constraint;
|
insn_constraint = insn_data[(int) icode].operand[!in_p].constraint;
|
if (!*insn_constraint)
|
if (!*insn_constraint)
|
insn_class = ALL_REGS;
|
insn_class = ALL_REGS;
|
else
|
else
|
{
|
{
|
if (in_p)
|
if (in_p)
|
{
|
{
|
gcc_assert (*insn_constraint == '=');
|
gcc_assert (*insn_constraint == '=');
|
insn_constraint++;
|
insn_constraint++;
|
}
|
}
|
insn_letter = *insn_constraint;
|
insn_letter = *insn_constraint;
|
insn_class
|
insn_class
|
= (insn_letter == 'r' ? GENERAL_REGS
|
= (insn_letter == 'r' ? GENERAL_REGS
|
: REG_CLASS_FROM_CONSTRAINT ((unsigned char) insn_letter,
|
: REG_CLASS_FROM_CONSTRAINT ((unsigned char) insn_letter,
|
insn_constraint));
|
insn_constraint));
|
gcc_assert (insn_class != NO_REGS);
|
gcc_assert (insn_class != NO_REGS);
|
}
|
}
|
|
|
scratch_constraint = insn_data[(int) icode].operand[2].constraint;
|
scratch_constraint = insn_data[(int) icode].operand[2].constraint;
|
/* The scratch register's constraint must start with "=&",
|
/* The scratch register's constraint must start with "=&",
|
except for an input reload, where only "=" is necessary,
|
except for an input reload, where only "=" is necessary,
|
and where it might be beneficial to re-use registers from
|
and where it might be beneficial to re-use registers from
|
the input. */
|
the input. */
|
gcc_assert (scratch_constraint[0] == '='
|
gcc_assert (scratch_constraint[0] == '='
|
&& (in_p || scratch_constraint[1] == '&'));
|
&& (in_p || scratch_constraint[1] == '&'));
|
scratch_constraint++;
|
scratch_constraint++;
|
if (*scratch_constraint == '&')
|
if (*scratch_constraint == '&')
|
scratch_constraint++;
|
scratch_constraint++;
|
scratch_letter = *scratch_constraint;
|
scratch_letter = *scratch_constraint;
|
scratch_class
|
scratch_class
|
= (scratch_letter == 'r' ? GENERAL_REGS
|
= (scratch_letter == 'r' ? GENERAL_REGS
|
: REG_CLASS_FROM_CONSTRAINT ((unsigned char) scratch_letter,
|
: REG_CLASS_FROM_CONSTRAINT ((unsigned char) scratch_letter,
|
scratch_constraint));
|
scratch_constraint));
|
|
|
if (reg_class_subset_p (reload_class, insn_class))
|
if (reg_class_subset_p (reload_class, insn_class))
|
{
|
{
|
gcc_assert (scratch_class == class);
|
gcc_assert (scratch_class == class);
|
class = NO_REGS;
|
class = NO_REGS;
|
}
|
}
|
else
|
else
|
class = insn_class;
|
class = insn_class;
|
|
|
}
|
}
|
if (class == NO_REGS)
|
if (class == NO_REGS)
|
sri->icode = icode;
|
sri->icode = icode;
|
else
|
else
|
sri->t_icode = icode;
|
sri->t_icode = icode;
|
}
|
}
|
return class;
|
return class;
|
}
|
}
|
|
|
|
|
/* If STRICT_ALIGNMENT is true we use the container type for accessing
|
/* If STRICT_ALIGNMENT is true we use the container type for accessing
|
volatile bitfields. This is generally the preferred behavior for memory
|
volatile bitfields. This is generally the preferred behavior for memory
|
mapped peripherals on RISC architectures.
|
mapped peripherals on RISC architectures.
|
If STRICT_ALIGNMENT is false we use the narrowest type possible. This
|
If STRICT_ALIGNMENT is false we use the narrowest type possible. This
|
is typically used to avoid spurious page faults and extra memory accesses
|
is typically used to avoid spurious page faults and extra memory accesses
|
due to unaligned accesses on CISC architectures. */
|
due to unaligned accesses on CISC architectures. */
|
|
|
bool
|
bool
|
default_narrow_bitfield (void)
|
default_narrow_bitfield (void)
|
{
|
{
|
return !STRICT_ALIGNMENT;
|
return !STRICT_ALIGNMENT;
|
}
|
}
|
|
|
/* By default, if flag_pic is true, then neither local nor global relocs
|
/* By default, if flag_pic is true, then neither local nor global relocs
|
should be placed in readonly memory. */
|
should be placed in readonly memory. */
|
|
|
int
|
int
|
default_reloc_rw_mask (void)
|
default_reloc_rw_mask (void)
|
{
|
{
|
return flag_pic ? 3 : 0;
|
return flag_pic ? 3 : 0;
|
}
|
}
|
|
|
bool
|
bool
|
default_builtin_vector_alignment_reachable (tree type, bool is_packed)
|
default_builtin_vector_alignment_reachable (tree type, bool is_packed)
|
{
|
{
|
if (is_packed)
|
if (is_packed)
|
return false;
|
return false;
|
|
|
/* Assuming that types whose size is > pointer-size are not guaranteed to be
|
/* Assuming that types whose size is > pointer-size are not guaranteed to be
|
naturally aligned. */
|
naturally aligned. */
|
if (tree_int_cst_compare (TYPE_SIZE (type), bitsize_int (POINTER_SIZE)) > 0)
|
if (tree_int_cst_compare (TYPE_SIZE (type), bitsize_int (POINTER_SIZE)) > 0)
|
return false;
|
return false;
|
|
|
/* Assuming that types whose size is <= pointer-size
|
/* Assuming that types whose size is <= pointer-size
|
are naturally aligned. */
|
are naturally aligned. */
|
return true;
|
return true;
|
}
|
}
|
|
|
#include "gt-targhooks.h"
|
#include "gt-targhooks.h"
|
|
|
