1 /* Default target hook functions.
2 Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009, 2010
3 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
21 /* The migration of target macros to target hooks works as follows:
23 1. Create a target hook that uses the existing target macros to
24 implement the same functionality.
26 2. Convert all the MI files to use the hook instead of the macro.
28 3. Repeat for a majority of the remaining target macros. This will
31 4. Tell target maintainers to start migrating.
33 5. Eventually convert the backends to override the hook instead of
34 defining the macros. This will take some time too.
36 6. TBD when, poison the macros. Unmigrated targets will break at
39 Note that we expect steps 1-3 to be done by the people that
40 understand what the MI does with each macro, and step 5 to be done
41 by the target maintainers for their respective targets.
43 Note that steps 1 and 2 don't have to be done together, but no
44 target can override the new hook until step 2 is complete for it.
46 Once the macros are poisoned, we will revert to the old migration
47 rules - migrate the macro, callers, and targets all at once. This
48 comment can thus be removed at that point. */
52 #include "coretypes.h"
59 #include "diagnostic-core.h"
64 #include "target-def.h"
66 #include "hard-reg-set.h"
73 default_legitimate_address_p (enum machine_mode mode ATTRIBUTE_UNUSED
,
74 rtx addr ATTRIBUTE_UNUSED
,
75 bool strict ATTRIBUTE_UNUSED
)
77 #ifdef GO_IF_LEGITIMATE_ADDRESS
78 /* Defer to the old implementation using a goto. */
80 return strict_memory_address_p (mode
, addr
);
82 return memory_address_p (mode
, addr
);
89 default_external_libcall (rtx fun ATTRIBUTE_UNUSED
)
91 #ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
92 ASM_OUTPUT_EXTERNAL_LIBCALL(asm_out_file
, fun
);
97 default_unspec_may_trap_p (const_rtx x
, unsigned flags
)
101 if (GET_CODE (x
) == UNSPEC_VOLATILE
102 /* Any floating arithmetic may trap. */
103 || (SCALAR_FLOAT_MODE_P (GET_MODE (x
))
104 && flag_trapping_math
))
107 for (i
= 0; i
< XVECLEN (x
, 0); ++i
)
109 if (may_trap_p_1 (XVECEXP (x
, 0, i
), flags
))
117 default_promote_function_mode (const_tree type ATTRIBUTE_UNUSED
,
118 enum machine_mode mode
,
119 int *punsignedp ATTRIBUTE_UNUSED
,
120 const_tree funtype ATTRIBUTE_UNUSED
,
121 int for_return ATTRIBUTE_UNUSED
)
124 return promote_mode (type
, mode
, punsignedp
);
129 default_promote_function_mode_always_promote (const_tree type
,
130 enum machine_mode mode
,
132 const_tree funtype ATTRIBUTE_UNUSED
,
133 int for_return ATTRIBUTE_UNUSED
)
135 return promote_mode (type
, mode
, punsignedp
);
140 default_cc_modes_compatible (enum machine_mode m1
, enum machine_mode m2
)
148 default_return_in_memory (const_tree type
,
149 const_tree fntype ATTRIBUTE_UNUSED
)
151 return (TYPE_MODE (type
) == BLKmode
);
155 default_legitimize_address (rtx x
, rtx orig_x ATTRIBUTE_UNUSED
,
156 enum machine_mode mode ATTRIBUTE_UNUSED
)
162 default_expand_builtin_saveregs (void)
164 error ("__builtin_saveregs not supported by this target");
169 default_setup_incoming_varargs (CUMULATIVE_ARGS
*ca ATTRIBUTE_UNUSED
,
170 enum machine_mode mode ATTRIBUTE_UNUSED
,
171 tree type ATTRIBUTE_UNUSED
,
172 int *pretend_arg_size ATTRIBUTE_UNUSED
,
173 int second_time ATTRIBUTE_UNUSED
)
177 /* The default implementation of TARGET_BUILTIN_SETJMP_FRAME_VALUE. */
180 default_builtin_setjmp_frame_value (void)
182 return virtual_stack_vars_rtx
;
185 /* Generic hook that takes a CUMULATIVE_ARGS pointer and returns false. */
188 hook_bool_CUMULATIVE_ARGS_false (CUMULATIVE_ARGS
*ca ATTRIBUTE_UNUSED
)
194 default_pretend_outgoing_varargs_named (CUMULATIVE_ARGS
*ca ATTRIBUTE_UNUSED
)
196 return (targetm
.calls
.setup_incoming_varargs
197 != default_setup_incoming_varargs
);
201 default_eh_return_filter_mode (void)
203 return targetm
.unwind_word_mode ();
207 default_libgcc_cmp_return_mode (void)
213 default_libgcc_shift_count_mode (void)
219 default_unwind_word_mode (void)
224 /* The default implementation of TARGET_SHIFT_TRUNCATION_MASK. */
226 unsigned HOST_WIDE_INT
227 default_shift_truncation_mask (enum machine_mode mode
)
229 return SHIFT_COUNT_TRUNCATED
? GET_MODE_BITSIZE (mode
) - 1 : 0;
232 /* The default implementation of TARGET_MIN_DIVISIONS_FOR_RECIP_MUL. */
235 default_min_divisions_for_recip_mul (enum machine_mode mode ATTRIBUTE_UNUSED
)
237 return have_insn_for (DIV
, mode
) ? 3 : 2;
240 /* The default implementation of TARGET_MODE_REP_EXTENDED. */
243 default_mode_rep_extended (enum machine_mode mode ATTRIBUTE_UNUSED
,
244 enum machine_mode mode_rep ATTRIBUTE_UNUSED
)
249 /* Generic hook that takes a CUMULATIVE_ARGS pointer and returns true. */
252 hook_bool_CUMULATIVE_ARGS_true (CUMULATIVE_ARGS
* a ATTRIBUTE_UNUSED
)
257 /* Return machine mode for non-standard suffix
258 or VOIDmode if non-standard suffixes are unsupported. */
260 default_mode_for_suffix (char suffix ATTRIBUTE_UNUSED
)
265 /* The generic C++ ABI specifies this is a 64-bit value. */
267 default_cxx_guard_type (void)
269 return long_long_integer_type_node
;
273 /* Returns the size of the cookie to use when allocating an array
274 whose elements have the indicated TYPE. Assumes that it is already
275 known that a cookie is needed. */
278 default_cxx_get_cookie_size (tree type
)
282 /* We need to allocate an additional max (sizeof (size_t), alignof
283 (true_type)) bytes. */
287 sizetype_size
= size_in_bytes (sizetype
);
288 type_align
= size_int (TYPE_ALIGN_UNIT (type
));
289 if (INT_CST_LT_UNSIGNED (type_align
, sizetype_size
))
290 cookie_size
= sizetype_size
;
292 cookie_size
= type_align
;
297 /* Return true if a parameter must be passed by reference. This version
298 of the TARGET_PASS_BY_REFERENCE hook uses just MUST_PASS_IN_STACK. */
301 hook_pass_by_reference_must_pass_in_stack (CUMULATIVE_ARGS
*c ATTRIBUTE_UNUSED
,
302 enum machine_mode mode ATTRIBUTE_UNUSED
, const_tree type ATTRIBUTE_UNUSED
,
303 bool named_arg ATTRIBUTE_UNUSED
)
305 return targetm
.calls
.must_pass_in_stack (mode
, type
);
308 /* Return true if a parameter follows callee copies conventions. This
309 version of the hook is true for all named arguments. */
312 hook_callee_copies_named (CUMULATIVE_ARGS
*ca ATTRIBUTE_UNUSED
,
313 enum machine_mode mode ATTRIBUTE_UNUSED
,
314 const_tree type ATTRIBUTE_UNUSED
, bool named
)
319 /* Emit to STREAM the assembler syntax for insn operand X. */
322 default_print_operand (FILE *stream ATTRIBUTE_UNUSED
, rtx x ATTRIBUTE_UNUSED
,
323 int code ATTRIBUTE_UNUSED
)
326 PRINT_OPERAND (stream
, x
, code
);
332 /* Emit to STREAM the assembler syntax for an insn operand whose memory
336 default_print_operand_address (FILE *stream ATTRIBUTE_UNUSED
,
337 rtx x ATTRIBUTE_UNUSED
)
339 #ifdef PRINT_OPERAND_ADDRESS
340 PRINT_OPERAND_ADDRESS (stream
, x
);
346 /* Return true if CODE is a valid punctuation character for the
347 `print_operand' hook. */
350 default_print_operand_punct_valid_p (unsigned char code ATTRIBUTE_UNUSED
)
352 #ifdef PRINT_OPERAND_PUNCT_VALID_P
353 return PRINT_OPERAND_PUNCT_VALID_P (code
);
359 /* The default implementation of TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA. */
362 default_asm_output_addr_const_extra (FILE *file ATTRIBUTE_UNUSED
,
363 rtx x ATTRIBUTE_UNUSED
)
365 #ifdef OUTPUT_ADDR_CONST_EXTRA
366 OUTPUT_ADDR_CONST_EXTRA (file
, x
, fail
);
374 /* True if MODE is valid for the target. By "valid", we mean able to
375 be manipulated in non-trivial ways. In particular, this means all
376 the arithmetic is supported.
378 By default we guess this means that any C type is supported. If
379 we can't map the mode back to a type that would be available in C,
380 then reject it. Special case, here, is the double-word arithmetic
381 supported by optabs.c. */
384 default_scalar_mode_supported_p (enum machine_mode mode
)
386 int precision
= GET_MODE_PRECISION (mode
);
388 switch (GET_MODE_CLASS (mode
))
390 case MODE_PARTIAL_INT
:
392 if (precision
== CHAR_TYPE_SIZE
)
394 if (precision
== SHORT_TYPE_SIZE
)
396 if (precision
== INT_TYPE_SIZE
)
398 if (precision
== LONG_TYPE_SIZE
)
400 if (precision
== LONG_LONG_TYPE_SIZE
)
402 if (precision
== 2 * BITS_PER_WORD
)
407 if (precision
== FLOAT_TYPE_SIZE
)
409 if (precision
== DOUBLE_TYPE_SIZE
)
411 if (precision
== LONG_DOUBLE_TYPE_SIZE
)
415 case MODE_DECIMAL_FLOAT
:
427 /* True if the target supports decimal floating point. */
430 default_decimal_float_supported_p (void)
432 return ENABLE_DECIMAL_FLOAT
;
435 /* True if the target supports fixed-point arithmetic. */
438 default_fixed_point_supported_p (void)
440 return ENABLE_FIXED_POINT
;
443 /* NULL if INSN insn is valid within a low-overhead loop, otherwise returns
446 This function checks whether a given INSN is valid within a low-overhead
447 loop. If INSN is invalid it returns the reason for that, otherwise it
448 returns NULL. A called function may clobber any special registers required
449 for low-overhead looping. Additionally, some targets (eg, PPC) use the count
450 register for branch on table instructions. We reject the doloop pattern in
454 default_invalid_within_doloop (const_rtx insn
)
457 return "Function call in loop.";
459 if (JUMP_TABLE_DATA_P (insn
))
460 return "Computed branch in the loop.";
465 /* Mapping of builtin functions to vectorized variants. */
468 default_builtin_vectorized_function (tree fndecl ATTRIBUTE_UNUSED
,
469 tree type_out ATTRIBUTE_UNUSED
,
470 tree type_in ATTRIBUTE_UNUSED
)
475 /* Vectorized conversion. */
478 default_builtin_vectorized_conversion (unsigned int code ATTRIBUTE_UNUSED
,
479 tree dest_type ATTRIBUTE_UNUSED
,
480 tree src_type ATTRIBUTE_UNUSED
)
485 /* Default vectorizer cost model values. */
488 default_builtin_vectorization_cost (enum vect_cost_for_stmt type_of_cost
,
489 tree vectype ATTRIBUTE_UNUSED
,
490 int misalign ATTRIBUTE_UNUSED
)
492 switch (type_of_cost
)
502 case cond_branch_not_taken
:
507 case unaligned_store
:
510 case cond_branch_taken
:
521 default_builtin_reciprocal (unsigned int fn ATTRIBUTE_UNUSED
,
522 bool md_fn ATTRIBUTE_UNUSED
,
523 bool sqrt ATTRIBUTE_UNUSED
)
529 hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false (
530 CUMULATIVE_ARGS
*ca ATTRIBUTE_UNUSED
,
531 enum machine_mode mode ATTRIBUTE_UNUSED
,
532 const_tree type ATTRIBUTE_UNUSED
, bool named ATTRIBUTE_UNUSED
)
538 hook_bool_CUMULATIVE_ARGS_mode_tree_bool_true (
539 CUMULATIVE_ARGS
*ca ATTRIBUTE_UNUSED
,
540 enum machine_mode mode ATTRIBUTE_UNUSED
,
541 const_tree type ATTRIBUTE_UNUSED
, bool named ATTRIBUTE_UNUSED
)
547 hook_int_CUMULATIVE_ARGS_mode_tree_bool_0 (
548 CUMULATIVE_ARGS
*ca ATTRIBUTE_UNUSED
,
549 enum machine_mode mode ATTRIBUTE_UNUSED
,
550 tree type ATTRIBUTE_UNUSED
, bool named ATTRIBUTE_UNUSED
)
556 default_function_arg_advance (CUMULATIVE_ARGS
*ca ATTRIBUTE_UNUSED
,
557 enum machine_mode mode ATTRIBUTE_UNUSED
,
558 const_tree type ATTRIBUTE_UNUSED
,
559 bool named ATTRIBUTE_UNUSED
)
561 #ifdef FUNCTION_ARG_ADVANCE
562 CUMULATIVE_ARGS args
= *ca
;
563 FUNCTION_ARG_ADVANCE (args
, mode
, CONST_CAST_TREE (type
), named
);
571 default_function_arg (CUMULATIVE_ARGS
*ca ATTRIBUTE_UNUSED
,
572 enum machine_mode mode ATTRIBUTE_UNUSED
,
573 const_tree type ATTRIBUTE_UNUSED
,
574 bool named ATTRIBUTE_UNUSED
)
577 return FUNCTION_ARG (*ca
, mode
, CONST_CAST_TREE (type
), named
);
584 default_function_incoming_arg (CUMULATIVE_ARGS
*ca ATTRIBUTE_UNUSED
,
585 enum machine_mode mode ATTRIBUTE_UNUSED
,
586 const_tree type ATTRIBUTE_UNUSED
,
587 bool named ATTRIBUTE_UNUSED
)
589 #ifdef FUNCTION_INCOMING_ARG
590 return FUNCTION_INCOMING_ARG (*ca
, mode
, CONST_CAST_TREE (type
), named
);
597 hook_void_bitmap (bitmap regs ATTRIBUTE_UNUSED
)
602 hook_invalid_arg_for_unprototyped_fn (
603 const_tree typelist ATTRIBUTE_UNUSED
,
604 const_tree funcdecl ATTRIBUTE_UNUSED
,
605 const_tree val ATTRIBUTE_UNUSED
)
610 /* Initialize the stack protection decls. */
612 /* Stack protection related decls living in libgcc. */
613 static GTY(()) tree stack_chk_guard_decl
;
616 default_stack_protect_guard (void)
618 tree t
= stack_chk_guard_decl
;
624 t
= build_decl (UNKNOWN_LOCATION
,
625 VAR_DECL
, get_identifier ("__stack_chk_guard"),
629 DECL_EXTERNAL (t
) = 1;
631 TREE_THIS_VOLATILE (t
) = 1;
632 DECL_ARTIFICIAL (t
) = 1;
633 DECL_IGNORED_P (t
) = 1;
635 /* Do not share RTL as the declaration is visible outside of
638 RTX_FLAG (x
, used
) = 1;
640 stack_chk_guard_decl
= t
;
646 static GTY(()) tree stack_chk_fail_decl
;
649 default_external_stack_protect_fail (void)
651 tree t
= stack_chk_fail_decl
;
655 t
= build_function_type_list (void_type_node
, NULL_TREE
);
656 t
= build_decl (UNKNOWN_LOCATION
,
657 FUNCTION_DECL
, get_identifier ("__stack_chk_fail"), t
);
660 DECL_EXTERNAL (t
) = 1;
662 TREE_THIS_VOLATILE (t
) = 1;
663 TREE_NOTHROW (t
) = 1;
664 DECL_ARTIFICIAL (t
) = 1;
665 DECL_IGNORED_P (t
) = 1;
666 DECL_VISIBILITY (t
) = VISIBILITY_DEFAULT
;
667 DECL_VISIBILITY_SPECIFIED (t
) = 1;
669 stack_chk_fail_decl
= t
;
672 return build_call_expr (t
, 0);
676 default_hidden_stack_protect_fail (void)
678 #ifndef HAVE_GAS_HIDDEN
679 return default_external_stack_protect_fail ();
681 tree t
= stack_chk_fail_decl
;
684 return default_external_stack_protect_fail ();
688 t
= build_function_type_list (void_type_node
, NULL_TREE
);
689 t
= build_decl (UNKNOWN_LOCATION
, FUNCTION_DECL
,
690 get_identifier ("__stack_chk_fail_local"), t
);
693 DECL_EXTERNAL (t
) = 1;
695 TREE_THIS_VOLATILE (t
) = 1;
696 TREE_NOTHROW (t
) = 1;
697 DECL_ARTIFICIAL (t
) = 1;
698 DECL_IGNORED_P (t
) = 1;
699 DECL_VISIBILITY_SPECIFIED (t
) = 1;
700 DECL_VISIBILITY (t
) = VISIBILITY_HIDDEN
;
702 stack_chk_fail_decl
= t
;
705 return build_call_expr (t
, 0);
710 hook_bool_const_rtx_commutative_p (const_rtx x
,
711 int outer_code ATTRIBUTE_UNUSED
)
713 return COMMUTATIVE_P (x
);
717 default_function_value (const_tree ret_type ATTRIBUTE_UNUSED
,
718 const_tree fn_decl_or_type
,
719 bool outgoing ATTRIBUTE_UNUSED
)
721 /* The old interface doesn't handle receiving the function type. */
723 && !DECL_P (fn_decl_or_type
))
724 fn_decl_or_type
= NULL
;
726 #ifdef FUNCTION_VALUE
727 return FUNCTION_VALUE (ret_type
, fn_decl_or_type
);
734 default_libcall_value (enum machine_mode mode ATTRIBUTE_UNUSED
,
735 const_rtx fun ATTRIBUTE_UNUSED
)
738 return LIBCALL_VALUE (mode
);
744 /* The default hook for TARGET_FUNCTION_VALUE_REGNO_P. */
747 default_function_value_regno_p (const unsigned int regno ATTRIBUTE_UNUSED
)
749 #ifdef FUNCTION_VALUE_REGNO_P
750 return FUNCTION_VALUE_REGNO_P (regno
);
757 default_internal_arg_pointer (void)
759 /* If the reg that the virtual arg pointer will be translated into is
760 not a fixed reg or is the stack pointer, make a copy of the virtual
761 arg pointer, and address parms via the copy. The frame pointer is
762 considered fixed even though it is not marked as such. */
763 if ((ARG_POINTER_REGNUM
== STACK_POINTER_REGNUM
764 || ! (fixed_regs
[ARG_POINTER_REGNUM
]
765 || ARG_POINTER_REGNUM
== FRAME_POINTER_REGNUM
)))
766 return copy_to_reg (virtual_incoming_args_rtx
);
768 return virtual_incoming_args_rtx
;
772 default_static_chain (const_tree fndecl
, bool incoming_p
)
774 if (!DECL_STATIC_CHAIN (fndecl
))
779 #ifdef STATIC_CHAIN_INCOMING_REGNUM
780 return gen_rtx_REG (Pmode
, STATIC_CHAIN_INCOMING_REGNUM
);
784 #ifdef STATIC_CHAIN_REGNUM
785 return gen_rtx_REG (Pmode
, STATIC_CHAIN_REGNUM
);
789 static bool issued_error
;
793 sorry ("nested functions not supported on this target");
796 /* It really doesn't matter what we return here, so long at it
797 doesn't cause the rest of the compiler to crash. */
798 return gen_rtx_MEM (Pmode
, stack_pointer_rtx
);
803 default_trampoline_init (rtx
ARG_UNUSED (m_tramp
), tree
ARG_UNUSED (t_func
),
804 rtx
ARG_UNUSED (r_chain
))
806 sorry ("nested function trampolines not supported on this target");
810 default_return_pops_args (tree fundecl ATTRIBUTE_UNUSED
,
811 tree funtype ATTRIBUTE_UNUSED
,
812 int size ATTRIBUTE_UNUSED
)
818 default_branch_target_register_class (void)
823 #ifdef IRA_COVER_CLASSES
825 default_ira_cover_classes (void)
827 static reg_class_t classes
[] = IRA_COVER_CLASSES
;
833 default_secondary_reload (bool in_p ATTRIBUTE_UNUSED
, rtx x ATTRIBUTE_UNUSED
,
834 reg_class_t reload_class_i ATTRIBUTE_UNUSED
,
835 enum machine_mode reload_mode ATTRIBUTE_UNUSED
,
836 secondary_reload_info
*sri
)
838 enum reg_class rclass
= NO_REGS
;
839 enum reg_class reload_class
= (enum reg_class
) reload_class_i
;
841 if (sri
->prev_sri
&& sri
->prev_sri
->t_icode
!= CODE_FOR_nothing
)
843 sri
->icode
= sri
->prev_sri
->t_icode
;
846 #ifdef SECONDARY_INPUT_RELOAD_CLASS
848 rclass
= SECONDARY_INPUT_RELOAD_CLASS (reload_class
, reload_mode
, x
);
850 #ifdef SECONDARY_OUTPUT_RELOAD_CLASS
852 rclass
= SECONDARY_OUTPUT_RELOAD_CLASS (reload_class
, reload_mode
, x
);
854 if (rclass
!= NO_REGS
)
857 = direct_optab_handler (in_p
? reload_in_optab
: reload_out_optab
,
860 if (icode
!= CODE_FOR_nothing
861 && insn_data
[(int) icode
].operand
[in_p
].predicate
862 && ! insn_data
[(int) icode
].operand
[in_p
].predicate (x
, reload_mode
))
863 icode
= CODE_FOR_nothing
;
864 else if (icode
!= CODE_FOR_nothing
)
866 const char *insn_constraint
, *scratch_constraint
;
867 char insn_letter
, scratch_letter
;
868 enum reg_class insn_class
, scratch_class
;
870 gcc_assert (insn_data
[(int) icode
].n_operands
== 3);
871 insn_constraint
= insn_data
[(int) icode
].operand
[!in_p
].constraint
;
872 if (!*insn_constraint
)
873 insn_class
= ALL_REGS
;
878 gcc_assert (*insn_constraint
== '=');
881 insn_letter
= *insn_constraint
;
883 = (insn_letter
== 'r' ? GENERAL_REGS
884 : REG_CLASS_FROM_CONSTRAINT ((unsigned char) insn_letter
,
886 gcc_assert (insn_class
!= NO_REGS
);
889 scratch_constraint
= insn_data
[(int) icode
].operand
[2].constraint
;
890 /* The scratch register's constraint must start with "=&",
891 except for an input reload, where only "=" is necessary,
892 and where it might be beneficial to re-use registers from
894 gcc_assert (scratch_constraint
[0] == '='
895 && (in_p
|| scratch_constraint
[1] == '&'));
896 scratch_constraint
++;
897 if (*scratch_constraint
== '&')
898 scratch_constraint
++;
899 scratch_letter
= *scratch_constraint
;
901 = (scratch_letter
== 'r' ? GENERAL_REGS
902 : REG_CLASS_FROM_CONSTRAINT ((unsigned char) scratch_letter
,
903 scratch_constraint
));
905 if (reg_class_subset_p (reload_class
, insn_class
))
907 gcc_assert (scratch_class
== rclass
);
914 if (rclass
== NO_REGS
)
917 sri
->t_icode
= icode
;
923 default_handle_c_option (size_t code ATTRIBUTE_UNUSED
,
924 const char *arg ATTRIBUTE_UNUSED
,
925 int value ATTRIBUTE_UNUSED
)
930 /* By default, if flag_pic is true, then neither local nor global relocs
931 should be placed in readonly memory. */
934 default_reloc_rw_mask (void)
936 return flag_pic
? 3 : 0;
939 /* By default, do no modification. */
940 tree
default_mangle_decl_assembler_name (tree decl ATTRIBUTE_UNUSED
,
947 default_builtin_vector_alignment_reachable (const_tree type
, bool is_packed
)
952 /* Assuming that types whose size is > pointer-size are not guaranteed to be
953 naturally aligned. */
954 if (tree_int_cst_compare (TYPE_SIZE (type
), bitsize_int (POINTER_SIZE
)) > 0)
957 /* Assuming that types whose size is <= pointer-size
958 are naturally aligned. */
962 /* By default, assume that a target supports any factor of misalignment
963 memory access if it supports movmisalign patten.
964 is_packed is true if the memory access is defined in a packed struct. */
966 default_builtin_support_vector_misalignment (enum machine_mode mode
,
974 if (optab_handler (movmisalign_optab
, mode
) != CODE_FOR_nothing
)
979 /* By default, only attempt to parallelize bitwise operations, and
980 possibly adds/subtracts using bit-twiddling. */
983 default_units_per_simd_word (enum machine_mode mode ATTRIBUTE_UNUSED
)
985 return UNITS_PER_WORD
;
988 /* Determine whether or not a pointer mode is valid. Assume defaults
989 of ptr_mode or Pmode - can be overridden. */
991 default_valid_pointer_mode (enum machine_mode mode
)
993 return (mode
== ptr_mode
|| mode
== Pmode
);
996 /* Return the mode for a pointer to a given ADDRSPACE, defaulting to ptr_mode
997 for the generic address space only. */
1000 default_addr_space_pointer_mode (addr_space_t addrspace ATTRIBUTE_UNUSED
)
1002 gcc_assert (ADDR_SPACE_GENERIC_P (addrspace
));
1006 /* Return the mode for an address in a given ADDRSPACE, defaulting to Pmode
1007 for the generic address space only. */
1010 default_addr_space_address_mode (addr_space_t addrspace ATTRIBUTE_UNUSED
)
1012 gcc_assert (ADDR_SPACE_GENERIC_P (addrspace
));
1016 /* Named address space version of valid_pointer_mode. */
1019 default_addr_space_valid_pointer_mode (enum machine_mode mode
, addr_space_t as
)
1021 if (!ADDR_SPACE_GENERIC_P (as
))
1022 return (mode
== targetm
.addr_space
.pointer_mode (as
)
1023 || mode
== targetm
.addr_space
.address_mode (as
));
1025 return targetm
.valid_pointer_mode (mode
);
1028 /* Some places still assume that all pointer or address modes are the
1029 standard Pmode and ptr_mode. These optimizations become invalid if
1030 the target actually supports multiple different modes. For now,
1031 we disable such optimizations on such targets, using this function. */
1034 target_default_pointer_address_modes_p (void)
1036 if (targetm
.addr_space
.address_mode
!= default_addr_space_address_mode
)
1038 if (targetm
.addr_space
.pointer_mode
!= default_addr_space_pointer_mode
)
1044 /* Named address space version of legitimate_address_p. */
1047 default_addr_space_legitimate_address_p (enum machine_mode mode
, rtx mem
,
1048 bool strict
, addr_space_t as
)
1050 if (!ADDR_SPACE_GENERIC_P (as
))
1053 return targetm
.legitimate_address_p (mode
, mem
, strict
);
1056 /* Named address space version of LEGITIMIZE_ADDRESS. */
1059 default_addr_space_legitimize_address (rtx x
, rtx oldx
,
1060 enum machine_mode mode
, addr_space_t as
)
1062 if (!ADDR_SPACE_GENERIC_P (as
))
1065 return targetm
.legitimize_address (x
, oldx
, mode
);
1068 /* The default hook for determining if one named address space is a subset of
1069 another and to return which address space to use as the common address
1073 default_addr_space_subset_p (addr_space_t subset
, addr_space_t superset
)
1075 return (subset
== superset
);
1078 /* The default hook for TARGET_ADDR_SPACE_CONVERT. This hook should never be
1079 called for targets with only a generic address space. */
1082 default_addr_space_convert (rtx op ATTRIBUTE_UNUSED
,
1083 tree from_type ATTRIBUTE_UNUSED
,
1084 tree to_type ATTRIBUTE_UNUSED
)
1090 default_hard_regno_scratch_ok (unsigned int regno ATTRIBUTE_UNUSED
)
1095 /* The default implementation of TARGET_MODE_DEPENDENT_ADDRESS_P. */
1098 default_mode_dependent_address_p (const_rtx addr ATTRIBUTE_UNUSED
)
1100 #ifdef GO_IF_MODE_DEPENDENT_ADDRESS
1102 GO_IF_MODE_DEPENDENT_ADDRESS (CONST_CAST_RTX (addr
), win
);
1104 /* Label `win' might (not) be used via GO_IF_MODE_DEPENDENT_ADDRESS. */
1105 win
: ATTRIBUTE_UNUSED_LABEL
1116 default_target_option_valid_attribute_p (tree
ARG_UNUSED (fndecl
),
1117 tree
ARG_UNUSED (name
),
1118 tree
ARG_UNUSED (args
),
1119 int ARG_UNUSED (flags
))
1121 warning (OPT_Wattributes
,
1122 "target attribute is not supported on this machine");
1128 default_target_option_pragma_parse (tree
ARG_UNUSED (args
),
1129 tree
ARG_UNUSED (pop_target
))
1131 warning (OPT_Wpragmas
,
1132 "#pragma GCC target is not supported for this machine");
1138 default_target_can_inline_p (tree caller
, tree callee
)
1141 tree callee_opts
= DECL_FUNCTION_SPECIFIC_TARGET (callee
);
1142 tree caller_opts
= DECL_FUNCTION_SPECIFIC_TARGET (caller
);
1144 /* If callee has no option attributes, then it is ok to inline */
1148 /* If caller has no option attributes, but callee does then it is not ok to
1150 else if (!caller_opts
)
1153 /* If both caller and callee have attributes, assume that if the pointer is
1154 different, the the two functions have different target options since
1155 build_target_option_node uses a hash table for the options. */
1157 ret
= (callee_opts
== caller_opts
);
1163 # define HAVE_casesi 0
1166 /* If the machine does not have a case insn that compares the bounds,
1167 this means extra overhead for dispatch tables, which raises the
1168 threshold for using them. */
1170 unsigned int default_case_values_threshold (void)
1172 return (HAVE_casesi
? 4 : 5);
1176 default_have_conditional_execution (void)
1178 #ifdef HAVE_conditional_execution
1179 return HAVE_conditional_execution
;
1185 /* Compute cost of moving registers to/from memory. */
1188 default_memory_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED
,
1189 reg_class_t rclass ATTRIBUTE_UNUSED
,
1190 bool in ATTRIBUTE_UNUSED
)
1192 #ifndef MEMORY_MOVE_COST
1193 return (4 + memory_move_secondary_cost (mode
, (enum reg_class
) rclass
, in
));
1195 return MEMORY_MOVE_COST (mode
, (enum reg_class
) rclass
, in
);
1199 /* Compute cost of moving data from a register of class FROM to one of
1203 default_register_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED
,
1204 reg_class_t from ATTRIBUTE_UNUSED
,
1205 reg_class_t to ATTRIBUTE_UNUSED
)
1207 #ifndef REGISTER_MOVE_COST
1210 return REGISTER_MOVE_COST (mode
, (enum reg_class
) from
, (enum reg_class
) to
);
1215 default_profile_before_prologue (void)
1217 #ifdef PROFILE_BEFORE_PROLOGUE
1224 /* The default implementation of TARGET_CLASS_LIKELY_SPILLED_P. */
1227 default_class_likely_spilled_p (reg_class_t rclass
)
1229 return (reg_class_size
[(int) rclass
] == 1);
1232 /* Determine the debugging unwind mechanism for the target. */
1234 enum unwind_info_type
1235 default_debug_unwind_info (void)
1237 /* If the target wants to force the use of dwarf2 unwind info, let it. */
1238 /* ??? Change all users to the hook, then poison this. */
1239 #ifdef DWARF2_FRAME_INFO
1240 if (DWARF2_FRAME_INFO
)
1244 /* Otherwise, only turn it on if dwarf2 debugging is enabled. */
1245 #ifdef DWARF2_DEBUGGING_INFO
1246 if (write_symbols
== DWARF2_DEBUG
|| write_symbols
== VMS_AND_DWARF2_DEBUG
)
1253 /* Determine the exception handling mechanism for the target. */
1255 enum unwind_info_type
1256 default_except_unwind_info (void)
1258 /* ??? Change the one user to the hook, then poison this. */
1259 #ifdef MUST_USE_SJLJ_EXCEPTIONS
1260 if (MUST_USE_SJLJ_EXCEPTIONS
)
1264 /* Obey the configure switch to turn on sjlj exceptions. */
1265 #ifdef CONFIG_SJLJ_EXCEPTIONS
1266 if (CONFIG_SJLJ_EXCEPTIONS
)
1270 /* ??? Change all users to the hook, then poison this. */
1271 #ifdef DWARF2_UNWIND_INFO
1272 if (DWARF2_UNWIND_INFO
)
1279 /* To be used by targets that force dwarf2 unwind enabled. */
1281 enum unwind_info_type
1282 dwarf2_except_unwind_info (void)
1284 /* Obey the configure switch to turn on sjlj exceptions. */
1285 #ifdef CONFIG_SJLJ_EXCEPTIONS
1286 if (CONFIG_SJLJ_EXCEPTIONS
)
1293 /* To be used by targets that force sjlj unwind enabled. */
1295 enum unwind_info_type
1296 sjlj_except_unwind_info (void)
1301 #include "gt-targhooks.h"