| /* Default target hook functions. |
| Copyright (C) 2003, 2004 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 2, 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 COPYING. If not, write to the Free |
| Software Foundation, 59 Temple Place - Suite 330, Boston, MA |
| 02111-1307, USA. */ |
| |
| /* 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" |
| /* APPLE LOCAL mainline 2006-02-17 4356747 stack realign */ |
| #include "hard-reg-set.h" |
| /* APPLE LOCAL mainline */ |
| #include "ggc.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 (tree type, |
| tree fntype ATTRIBUTE_UNUSED) |
| { |
| #ifndef RETURN_IN_MEMORY |
| return (TYPE_MODE (type) == BLKmode); |
| #else |
| return RETURN_IN_MEMORY (type); |
| #endif |
| } |
| |
| /* APPLE LOCAL begin radar 4781080 */ |
| bool |
| default_objc_fpreturn_msgcall (tree type, bool no_long_double) |
| { |
| #ifndef OBJC_FPRETURN_MSGCALL |
| return type == NULL_TREE && no_long_double; |
| #else |
| return OBJC_FPRETURN_MSGCALL (type, no_long_double); |
| #endif |
| } |
| /* APPLE LOCAL end radar 4781080 */ |
| |
| 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); |
| } |
| |
| /* APPLE LOCAL begin Altivec */ |
| bool |
| default_skip_vec_args(tree type ATTRIBUTE_UNUSED, |
| int pass ATTRIBUTE_UNUSED, |
| int* last_pass ATTRIBUTE_UNUSED) |
| { |
| return false; |
| } |
| /* APPLE LOCAL end Altivec */ |
| |
| enum machine_mode |
| default_eh_return_filter_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; |
| } |
| |
| /* Generic hook that takes a CUMULATIVE_ARGS pointer and returns true. */ |
| |
| bool |
| hook_bool_CUMULATIVE_ARGS_true (CUMULATIVE_ARGS * a ATTRIBUTE_UNUSED) |
| { |
| return true; |
| } |
| |
| |
| /* 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, 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, |
| 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; |
| |
| default: |
| gcc_unreachable (); |
| } |
| } |
| |
| bool |
| hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false ( |
| CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED, |
| enum machine_mode mode ATTRIBUTE_UNUSED, |
| 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, |
| 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; |
| } |
| /* APPLE LOCAL begin mainline 2005-04-14 */ |
| |
| const char * |
| hook_invalid_arg_for_unprototyped_fn ( |
| tree typelist ATTRIBUTE_UNUSED, |
| tree funcdecl ATTRIBUTE_UNUSED, |
| tree val ATTRIBUTE_UNUSED) |
| { |
| return NULL; |
| } |
| /* APPLE LOCAL end mainline 2005-04-14 */ |
| /* APPLE LOCAL begin mainline */ |
| /* 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_function_call_expr (t, NULL_TREE); |
| } |
| |
| 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_function_call_expr (t, NULL_TREE); |
| #endif |
| } |
| |
| /* APPLE LOCAL end mainline */ |
| /* APPLE LOCAL begin 4375453 */ |
| bool |
| default_vector_alignment_reachable (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; |
| } |
| /* APPLE LOCAL end 4375453 */ |
| |
| /* APPLE LOCAL begin mainline 2006-02-17 4356747 stack realign */ |
| 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; |
| } |
| /* APPLE LOCAL end mainline 2006-02-17 4356747 stack realign */ |
| /* APPLE LOCAL mainline */ |
| #include "gt-targhooks.h" |