1 /* Default target hook functions.
2 Copyright (C) 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
4 This file is part of GCC.
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
8 Software Foundation; either version 3, or (at your option) any later
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
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
20 /* The migration of target macros to target hooks works as follows:
22 1. Create a target hook that uses the existing target macros to
23 implement the same functionality.
25 2. Convert all the MI files to use the hook instead of the macro.
27 3. Repeat for a majority of the remaining target macros. This will
30 4. Tell target maintainers to start migrating.
32 5. Eventually convert the backends to override the hook instead of
33 defining the macros. This will take some time too.
35 6. TBD when, poison the macros. Unmigrated targets will break at
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.
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.
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. */
51 #include "coretypes.h"
62 #include "target-def.h"
64 #include "hard-reg-set.h"
71 default_external_libcall (rtx fun ATTRIBUTE_UNUSED
)
73 #ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
74 ASM_OUTPUT_EXTERNAL_LIBCALL(asm_out_file
, fun
);
79 default_cc_modes_compatible (enum machine_mode m1
, enum machine_mode m2
)
87 default_return_in_memory (tree type
,
88 tree fntype ATTRIBUTE_UNUSED
)
90 #ifndef RETURN_IN_MEMORY
91 return (TYPE_MODE (type
) == BLKmode
);
93 return RETURN_IN_MEMORY (type
);
98 default_expand_builtin_saveregs (void)
100 error ("__builtin_saveregs not supported by this target");
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
)
113 /* The default implementation of TARGET_BUILTIN_SETJMP_FRAME_VALUE. */
116 default_builtin_setjmp_frame_value (void)
118 return virtual_stack_vars_rtx
;
121 /* Generic hook that takes a CUMULATIVE_ARGS pointer and returns false. */
124 hook_bool_CUMULATIVE_ARGS_false (CUMULATIVE_ARGS
*ca ATTRIBUTE_UNUSED
)
130 default_pretend_outgoing_varargs_named (CUMULATIVE_ARGS
*ca ATTRIBUTE_UNUSED
)
132 return (targetm
.calls
.setup_incoming_varargs
133 != default_setup_incoming_varargs
);
137 default_eh_return_filter_mode (void)
142 /* The default implementation of TARGET_SHIFT_TRUNCATION_MASK. */
144 unsigned HOST_WIDE_INT
145 default_shift_truncation_mask (enum machine_mode mode
)
147 return SHIFT_COUNT_TRUNCATED
? GET_MODE_BITSIZE (mode
) - 1 : 0;
150 /* The default implementation of TARGET_MIN_DIVISIONS_FOR_RECIP_MUL. */
153 default_min_divisions_for_recip_mul (enum machine_mode mode ATTRIBUTE_UNUSED
)
155 return have_insn_for (DIV
, mode
) ? 3 : 2;
158 /* The default implementation of TARGET_MODE_REP_EXTENDED. */
161 default_mode_rep_extended (enum machine_mode mode ATTRIBUTE_UNUSED
,
162 enum machine_mode mode_rep ATTRIBUTE_UNUSED
)
167 /* Generic hook that takes a CUMULATIVE_ARGS pointer and returns true. */
170 hook_bool_CUMULATIVE_ARGS_true (CUMULATIVE_ARGS
* a ATTRIBUTE_UNUSED
)
176 /* The generic C++ ABI specifies this is a 64-bit value. */
178 default_cxx_guard_type (void)
180 return long_long_integer_type_node
;
184 /* Returns the size of the cookie to use when allocating an array
185 whose elements have the indicated TYPE. Assumes that it is already
186 known that a cookie is needed. */
189 default_cxx_get_cookie_size (tree type
)
193 /* We need to allocate an additional max (sizeof (size_t), alignof
194 (true_type)) bytes. */
198 sizetype_size
= size_in_bytes (sizetype
);
199 type_align
= size_int (TYPE_ALIGN_UNIT (type
));
200 if (INT_CST_LT_UNSIGNED (type_align
, sizetype_size
))
201 cookie_size
= sizetype_size
;
203 cookie_size
= type_align
;
208 /* Return true if a parameter must be passed by reference. This version
209 of the TARGET_PASS_BY_REFERENCE hook uses just MUST_PASS_IN_STACK. */
212 hook_pass_by_reference_must_pass_in_stack (CUMULATIVE_ARGS
*c ATTRIBUTE_UNUSED
,
213 enum machine_mode mode ATTRIBUTE_UNUSED
, tree type ATTRIBUTE_UNUSED
,
214 bool named_arg ATTRIBUTE_UNUSED
)
216 return targetm
.calls
.must_pass_in_stack (mode
, type
);
219 /* Return true if a parameter follows callee copies conventions. This
220 version of the hook is true for all named arguments. */
223 hook_callee_copies_named (CUMULATIVE_ARGS
*ca ATTRIBUTE_UNUSED
,
224 enum machine_mode mode ATTRIBUTE_UNUSED
,
225 tree type ATTRIBUTE_UNUSED
, bool named
)
230 /* Emit any directives required to unwind this instruction. */
233 default_unwind_emit (FILE * stream ATTRIBUTE_UNUSED
,
234 rtx insn ATTRIBUTE_UNUSED
)
236 /* Should never happen. */
240 /* True if MODE is valid for the target. By "valid", we mean able to
241 be manipulated in non-trivial ways. In particular, this means all
242 the arithmetic is supported.
244 By default we guess this means that any C type is supported. If
245 we can't map the mode back to a type that would be available in C,
246 then reject it. Special case, here, is the double-word arithmetic
247 supported by optabs.c. */
250 default_scalar_mode_supported_p (enum machine_mode mode
)
252 int precision
= GET_MODE_PRECISION (mode
);
254 switch (GET_MODE_CLASS (mode
))
256 case MODE_PARTIAL_INT
:
258 if (precision
== CHAR_TYPE_SIZE
)
260 if (precision
== SHORT_TYPE_SIZE
)
262 if (precision
== INT_TYPE_SIZE
)
264 if (precision
== LONG_TYPE_SIZE
)
266 if (precision
== LONG_LONG_TYPE_SIZE
)
268 if (precision
== 2 * BITS_PER_WORD
)
273 if (precision
== FLOAT_TYPE_SIZE
)
275 if (precision
== DOUBLE_TYPE_SIZE
)
277 if (precision
== LONG_DOUBLE_TYPE_SIZE
)
281 case MODE_DECIMAL_FLOAT
:
289 /* True if the target supports decimal floating point. */
292 default_decimal_float_supported_p (void)
294 return ENABLE_DECIMAL_FLOAT
;
297 /* NULL if INSN insn is valid within a low-overhead loop, otherwise returns
300 This function checks whether a given INSN is valid within a low-overhead
301 loop. If INSN is invalid it returns the reason for that, otherwise it
302 returns NULL. A called function may clobber any special registers required
303 for low-overhead looping. Additionally, some targets (eg, PPC) use the count
304 register for branch on table instructions. We reject the doloop pattern in
308 default_invalid_within_doloop (rtx insn
)
311 return "Function call in loop.";
314 && (GET_CODE (PATTERN (insn
)) == ADDR_DIFF_VEC
315 || GET_CODE (PATTERN (insn
)) == ADDR_VEC
))
316 return "Computed branch in the loop.";
322 hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false (
323 CUMULATIVE_ARGS
*ca ATTRIBUTE_UNUSED
,
324 enum machine_mode mode ATTRIBUTE_UNUSED
,
325 tree type ATTRIBUTE_UNUSED
, bool named ATTRIBUTE_UNUSED
)
331 hook_bool_CUMULATIVE_ARGS_mode_tree_bool_true (
332 CUMULATIVE_ARGS
*ca ATTRIBUTE_UNUSED
,
333 enum machine_mode mode ATTRIBUTE_UNUSED
,
334 tree type ATTRIBUTE_UNUSED
, bool named ATTRIBUTE_UNUSED
)
340 hook_int_CUMULATIVE_ARGS_mode_tree_bool_0 (
341 CUMULATIVE_ARGS
*ca ATTRIBUTE_UNUSED
,
342 enum machine_mode mode ATTRIBUTE_UNUSED
,
343 tree type ATTRIBUTE_UNUSED
, bool named ATTRIBUTE_UNUSED
)
349 hook_void_bitmap (bitmap regs ATTRIBUTE_UNUSED
)
354 hook_invalid_arg_for_unprototyped_fn (
355 tree typelist ATTRIBUTE_UNUSED
,
356 tree funcdecl ATTRIBUTE_UNUSED
,
357 tree val ATTRIBUTE_UNUSED
)
362 /* Initialize the stack protection decls. */
364 /* Stack protection related decls living in libgcc. */
365 static GTY(()) tree stack_chk_guard_decl
;
368 default_stack_protect_guard (void)
370 tree t
= stack_chk_guard_decl
;
374 t
= build_decl (VAR_DECL
, get_identifier ("__stack_chk_guard"),
378 DECL_EXTERNAL (t
) = 1;
380 TREE_THIS_VOLATILE (t
) = 1;
381 DECL_ARTIFICIAL (t
) = 1;
382 DECL_IGNORED_P (t
) = 1;
384 stack_chk_guard_decl
= t
;
390 static GTY(()) tree stack_chk_fail_decl
;
393 default_external_stack_protect_fail (void)
395 tree t
= stack_chk_fail_decl
;
399 t
= build_function_type_list (void_type_node
, NULL_TREE
);
400 t
= build_decl (FUNCTION_DECL
, get_identifier ("__stack_chk_fail"), t
);
403 DECL_EXTERNAL (t
) = 1;
405 TREE_THIS_VOLATILE (t
) = 1;
406 TREE_NOTHROW (t
) = 1;
407 DECL_ARTIFICIAL (t
) = 1;
408 DECL_IGNORED_P (t
) = 1;
409 DECL_VISIBILITY (t
) = VISIBILITY_DEFAULT
;
410 DECL_VISIBILITY_SPECIFIED (t
) = 1;
412 stack_chk_fail_decl
= t
;
415 return build_function_call_expr (t
, NULL_TREE
);
419 default_hidden_stack_protect_fail (void)
421 #ifndef HAVE_GAS_HIDDEN
422 return default_external_stack_protect_fail ();
424 tree t
= stack_chk_fail_decl
;
427 return default_external_stack_protect_fail ();
431 t
= build_function_type_list (void_type_node
, NULL_TREE
);
432 t
= build_decl (FUNCTION_DECL
,
433 get_identifier ("__stack_chk_fail_local"), t
);
436 DECL_EXTERNAL (t
) = 1;
438 TREE_THIS_VOLATILE (t
) = 1;
439 TREE_NOTHROW (t
) = 1;
440 DECL_ARTIFICIAL (t
) = 1;
441 DECL_IGNORED_P (t
) = 1;
442 DECL_VISIBILITY_SPECIFIED (t
) = 1;
443 DECL_VISIBILITY (t
) = VISIBILITY_HIDDEN
;
445 stack_chk_fail_decl
= t
;
448 return build_function_call_expr (t
, NULL_TREE
);
453 hook_bool_rtx_commutative_p (rtx x
, int outer_code ATTRIBUTE_UNUSED
)
455 return COMMUTATIVE_P (x
);
459 default_function_value (tree ret_type ATTRIBUTE_UNUSED
,
460 tree fn_decl_or_type
,
461 bool outgoing ATTRIBUTE_UNUSED
)
463 /* The old interface doesn't handle receiving the function type. */
465 && !DECL_P (fn_decl_or_type
))
466 fn_decl_or_type
= NULL
;
468 #ifdef FUNCTION_OUTGOING_VALUE
470 return FUNCTION_OUTGOING_VALUE (ret_type
, fn_decl_or_type
);
473 #ifdef FUNCTION_VALUE
474 return FUNCTION_VALUE (ret_type
, fn_decl_or_type
);
481 default_internal_arg_pointer (void)
483 /* If the reg that the virtual arg pointer will be translated into is
484 not a fixed reg or is the stack pointer, make a copy of the virtual
485 arg pointer, and address parms via the copy. The frame pointer is
486 considered fixed even though it is not marked as such. */
487 if ((ARG_POINTER_REGNUM
== STACK_POINTER_REGNUM
488 || ! (fixed_regs
[ARG_POINTER_REGNUM
]
489 || ARG_POINTER_REGNUM
== FRAME_POINTER_REGNUM
)))
490 return copy_to_reg (virtual_incoming_args_rtx
);
492 return virtual_incoming_args_rtx
;
496 default_secondary_reload (bool in_p ATTRIBUTE_UNUSED
, rtx x ATTRIBUTE_UNUSED
,
497 enum reg_class reload_class ATTRIBUTE_UNUSED
,
498 enum machine_mode reload_mode ATTRIBUTE_UNUSED
,
499 secondary_reload_info
*sri
)
501 enum reg_class
class = NO_REGS
;
503 if (sri
->prev_sri
&& sri
->prev_sri
->t_icode
!= CODE_FOR_nothing
)
505 sri
->icode
= sri
->prev_sri
->t_icode
;
508 #ifdef SECONDARY_INPUT_RELOAD_CLASS
510 class = SECONDARY_INPUT_RELOAD_CLASS (reload_class
, reload_mode
, x
);
512 #ifdef SECONDARY_OUTPUT_RELOAD_CLASS
514 class = SECONDARY_OUTPUT_RELOAD_CLASS (reload_class
, reload_mode
, x
);
516 if (class != NO_REGS
)
518 enum insn_code icode
= (in_p
? reload_in_optab
[(int) reload_mode
]
519 : reload_out_optab
[(int) reload_mode
]);
521 if (icode
!= CODE_FOR_nothing
522 && insn_data
[(int) icode
].operand
[in_p
].predicate
523 && ! insn_data
[(int) icode
].operand
[in_p
].predicate (x
, reload_mode
))
524 icode
= CODE_FOR_nothing
;
525 else if (icode
!= CODE_FOR_nothing
)
527 const char *insn_constraint
, *scratch_constraint
;
528 char insn_letter
, scratch_letter
;
529 enum reg_class insn_class
, scratch_class
;
531 gcc_assert (insn_data
[(int) icode
].n_operands
== 3);
532 insn_constraint
= insn_data
[(int) icode
].operand
[!in_p
].constraint
;
533 if (!*insn_constraint
)
534 insn_class
= ALL_REGS
;
539 gcc_assert (*insn_constraint
== '=');
542 insn_letter
= *insn_constraint
;
544 = (insn_letter
== 'r' ? GENERAL_REGS
545 : REG_CLASS_FROM_CONSTRAINT ((unsigned char) insn_letter
,
547 gcc_assert (insn_class
!= NO_REGS
);
550 scratch_constraint
= insn_data
[(int) icode
].operand
[2].constraint
;
551 /* The scratch register's constraint must start with "=&",
552 except for an input reload, where only "=" is necessary,
553 and where it might be beneficial to re-use registers from
555 gcc_assert (scratch_constraint
[0] == '='
556 && (in_p
|| scratch_constraint
[1] == '&'));
557 scratch_constraint
++;
558 if (*scratch_constraint
== '&')
559 scratch_constraint
++;
560 scratch_letter
= *scratch_constraint
;
562 = (scratch_letter
== 'r' ? GENERAL_REGS
563 : REG_CLASS_FROM_CONSTRAINT ((unsigned char) scratch_letter
,
564 scratch_constraint
));
566 if (reg_class_subset_p (reload_class
, insn_class
))
568 gcc_assert (scratch_class
== class);
575 if (class == NO_REGS
)
578 sri
->t_icode
= icode
;
584 /* If STRICT_ALIGNMENT is true we use the container type for accessing
585 volatile bitfields. This is generally the preferred behavior for memory
586 mapped peripherals on RISC architectures.
587 If STRICT_ALIGNMENT is false we use the narrowest type possible. This
588 is typically used to avoid spurious page faults and extra memory accesses
589 due to unaligned accesses on CISC architectures. */
592 default_narrow_bitfield (void)
594 return !STRICT_ALIGNMENT
;
597 /* By default, if flag_pic is true, then neither local nor global relocs
598 should be placed in readonly memory. */
601 default_reloc_rw_mask (void)
603 return flag_pic
? 3 : 0;
607 default_builtin_vector_alignment_reachable (tree type
, bool is_packed
)
612 /* Assuming that types whose size is > pointer-size are not guaranteed to be
613 naturally aligned. */
614 if (tree_int_cst_compare (TYPE_SIZE (type
), bitsize_int (POINTER_SIZE
)) > 0)
617 /* Assuming that types whose size is <= pointer-size
618 are naturally aligned. */
622 #include "gt-targhooks.h"