* configure: Regenerated.
[official-gcc.git] / gcc / targhooks.c
blob36f998ac357cbcec1be64581e81bbf02d008461f
1 /* Default target hook functions.
2 Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011
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
10 version.
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
15 for more details.
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
29 take some time.
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
37 this point.
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. */
50 #include "config.h"
51 #include "system.h"
52 #include "coretypes.h"
53 #include "tm.h"
54 #include "machmode.h"
55 #include "rtl.h"
56 #include "tree.h"
57 #include "expr.h"
58 #include "output.h"
59 #include "diagnostic-core.h"
60 #include "function.h"
61 #include "target.h"
62 #include "tm_p.h"
63 #include "target-def.h"
64 #include "ggc.h"
65 #include "hard-reg-set.h"
66 #include "regs.h"
67 #include "reload.h"
68 #include "optabs.h"
69 #include "recog.h"
70 #include "intl.h"
71 #include "opts.h"
72 #include "tree-flow.h"
73 #include "tree-ssa-alias.h"
76 bool
77 default_legitimate_address_p (enum machine_mode mode ATTRIBUTE_UNUSED,
78 rtx addr ATTRIBUTE_UNUSED,
79 bool strict ATTRIBUTE_UNUSED)
81 #ifdef GO_IF_LEGITIMATE_ADDRESS
82 /* Defer to the old implementation using a goto. */
83 if (strict)
84 return strict_memory_address_p (mode, addr);
85 else
86 return memory_address_p (mode, addr);
87 #else
88 gcc_unreachable ();
89 #endif
92 void
93 default_external_libcall (rtx fun ATTRIBUTE_UNUSED)
95 #ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
96 ASM_OUTPUT_EXTERNAL_LIBCALL(asm_out_file, fun);
97 #endif
101 default_unspec_may_trap_p (const_rtx x, unsigned flags)
103 int i;
105 if (GET_CODE (x) == UNSPEC_VOLATILE
106 /* Any floating arithmetic may trap. */
107 || (SCALAR_FLOAT_MODE_P (GET_MODE (x))
108 && flag_trapping_math))
109 return 1;
111 for (i = 0; i < XVECLEN (x, 0); ++i)
113 if (may_trap_p_1 (XVECEXP (x, 0, i), flags))
114 return 1;
117 return 0;
120 enum machine_mode
121 default_promote_function_mode (const_tree type ATTRIBUTE_UNUSED,
122 enum machine_mode mode,
123 int *punsignedp ATTRIBUTE_UNUSED,
124 const_tree funtype ATTRIBUTE_UNUSED,
125 int for_return ATTRIBUTE_UNUSED)
127 if (type != NULL_TREE && for_return == 2)
128 return promote_mode (type, mode, punsignedp);
129 return mode;
132 enum machine_mode
133 default_promote_function_mode_always_promote (const_tree type,
134 enum machine_mode mode,
135 int *punsignedp,
136 const_tree funtype ATTRIBUTE_UNUSED,
137 int for_return ATTRIBUTE_UNUSED)
139 return promote_mode (type, mode, punsignedp);
143 enum machine_mode
144 default_cc_modes_compatible (enum machine_mode m1, enum machine_mode m2)
146 if (m1 == m2)
147 return m1;
148 return VOIDmode;
151 bool
152 default_return_in_memory (const_tree type,
153 const_tree fntype ATTRIBUTE_UNUSED)
155 return (TYPE_MODE (type) == BLKmode);
159 default_legitimize_address (rtx x, rtx orig_x ATTRIBUTE_UNUSED,
160 enum machine_mode mode ATTRIBUTE_UNUSED)
162 return x;
166 default_expand_builtin_saveregs (void)
168 error ("__builtin_saveregs not supported by this target");
169 return const0_rtx;
172 void
173 default_setup_incoming_varargs (cumulative_args_t ca ATTRIBUTE_UNUSED,
174 enum machine_mode mode ATTRIBUTE_UNUSED,
175 tree type ATTRIBUTE_UNUSED,
176 int *pretend_arg_size ATTRIBUTE_UNUSED,
177 int second_time ATTRIBUTE_UNUSED)
181 /* The default implementation of TARGET_BUILTIN_SETJMP_FRAME_VALUE. */
184 default_builtin_setjmp_frame_value (void)
186 return virtual_stack_vars_rtx;
189 /* Generic hook that takes a CUMULATIVE_ARGS pointer and returns false. */
191 bool
192 hook_bool_CUMULATIVE_ARGS_false (cumulative_args_t ca ATTRIBUTE_UNUSED)
194 return false;
197 bool
198 default_pretend_outgoing_varargs_named (cumulative_args_t ca ATTRIBUTE_UNUSED)
200 return (targetm.calls.setup_incoming_varargs
201 != default_setup_incoming_varargs);
204 enum machine_mode
205 default_eh_return_filter_mode (void)
207 return targetm.unwind_word_mode ();
210 enum machine_mode
211 default_libgcc_cmp_return_mode (void)
213 return word_mode;
216 enum machine_mode
217 default_libgcc_shift_count_mode (void)
219 return word_mode;
222 enum machine_mode
223 default_unwind_word_mode (void)
225 return word_mode;
228 /* The default implementation of TARGET_SHIFT_TRUNCATION_MASK. */
230 unsigned HOST_WIDE_INT
231 default_shift_truncation_mask (enum machine_mode mode)
233 return SHIFT_COUNT_TRUNCATED ? GET_MODE_BITSIZE (mode) - 1 : 0;
236 /* The default implementation of TARGET_MIN_DIVISIONS_FOR_RECIP_MUL. */
238 unsigned int
239 default_min_divisions_for_recip_mul (enum machine_mode mode ATTRIBUTE_UNUSED)
241 return have_insn_for (DIV, mode) ? 3 : 2;
244 /* The default implementation of TARGET_MODE_REP_EXTENDED. */
247 default_mode_rep_extended (enum machine_mode mode ATTRIBUTE_UNUSED,
248 enum machine_mode mode_rep ATTRIBUTE_UNUSED)
250 return UNKNOWN;
253 /* Generic hook that takes a CUMULATIVE_ARGS pointer and returns true. */
255 bool
256 hook_bool_CUMULATIVE_ARGS_true (cumulative_args_t a ATTRIBUTE_UNUSED)
258 return true;
261 /* Return machine mode for non-standard suffix
262 or VOIDmode if non-standard suffixes are unsupported. */
263 enum machine_mode
264 default_mode_for_suffix (char suffix ATTRIBUTE_UNUSED)
266 return VOIDmode;
269 /* The generic C++ ABI specifies this is a 64-bit value. */
270 tree
271 default_cxx_guard_type (void)
273 return long_long_integer_type_node;
277 /* Returns the size of the cookie to use when allocating an array
278 whose elements have the indicated TYPE. Assumes that it is already
279 known that a cookie is needed. */
281 tree
282 default_cxx_get_cookie_size (tree type)
284 tree cookie_size;
286 /* We need to allocate an additional max (sizeof (size_t), alignof
287 (true_type)) bytes. */
288 tree sizetype_size;
289 tree type_align;
291 sizetype_size = size_in_bytes (sizetype);
292 type_align = size_int (TYPE_ALIGN_UNIT (type));
293 if (INT_CST_LT_UNSIGNED (type_align, sizetype_size))
294 cookie_size = sizetype_size;
295 else
296 cookie_size = type_align;
298 return cookie_size;
301 /* Return true if a parameter must be passed by reference. This version
302 of the TARGET_PASS_BY_REFERENCE hook uses just MUST_PASS_IN_STACK. */
304 bool
305 hook_pass_by_reference_must_pass_in_stack (cumulative_args_t c ATTRIBUTE_UNUSED,
306 enum machine_mode mode ATTRIBUTE_UNUSED, const_tree type ATTRIBUTE_UNUSED,
307 bool named_arg ATTRIBUTE_UNUSED)
309 return targetm.calls.must_pass_in_stack (mode, type);
312 /* Return true if a parameter follows callee copies conventions. This
313 version of the hook is true for all named arguments. */
315 bool
316 hook_callee_copies_named (cumulative_args_t ca ATTRIBUTE_UNUSED,
317 enum machine_mode mode ATTRIBUTE_UNUSED,
318 const_tree type ATTRIBUTE_UNUSED, bool named)
320 return named;
323 /* Emit to STREAM the assembler syntax for insn operand X. */
325 void
326 default_print_operand (FILE *stream ATTRIBUTE_UNUSED, rtx x ATTRIBUTE_UNUSED,
327 int code ATTRIBUTE_UNUSED)
329 #ifdef PRINT_OPERAND
330 PRINT_OPERAND (stream, x, code);
331 #else
332 gcc_unreachable ();
333 #endif
336 /* Emit to STREAM the assembler syntax for an insn operand whose memory
337 address is X. */
339 void
340 default_print_operand_address (FILE *stream ATTRIBUTE_UNUSED,
341 rtx x ATTRIBUTE_UNUSED)
343 #ifdef PRINT_OPERAND_ADDRESS
344 PRINT_OPERAND_ADDRESS (stream, x);
345 #else
346 gcc_unreachable ();
347 #endif
350 /* Return true if CODE is a valid punctuation character for the
351 `print_operand' hook. */
353 bool
354 default_print_operand_punct_valid_p (unsigned char code ATTRIBUTE_UNUSED)
356 #ifdef PRINT_OPERAND_PUNCT_VALID_P
357 return PRINT_OPERAND_PUNCT_VALID_P (code);
358 #else
359 return false;
360 #endif
363 /* The default implementation of TARGET_MANGLE_ASSEMBLER_NAME. */
364 tree
365 default_mangle_assembler_name (const char *name ATTRIBUTE_UNUSED)
367 const char *skipped = name + (*name == '*' ? 1 : 0);
368 const char *stripped = targetm.strip_name_encoding (skipped);
369 if (*name != '*' && user_label_prefix[0])
370 stripped = ACONCAT ((user_label_prefix, stripped, NULL));
371 return get_identifier (stripped);
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. */
383 bool
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:
391 case MODE_INT:
392 if (precision == CHAR_TYPE_SIZE)
393 return true;
394 if (precision == SHORT_TYPE_SIZE)
395 return true;
396 if (precision == INT_TYPE_SIZE)
397 return true;
398 if (precision == LONG_TYPE_SIZE)
399 return true;
400 if (precision == LONG_LONG_TYPE_SIZE)
401 return true;
402 if (precision == 2 * BITS_PER_WORD)
403 return true;
404 return false;
406 case MODE_FLOAT:
407 if (precision == FLOAT_TYPE_SIZE)
408 return true;
409 if (precision == DOUBLE_TYPE_SIZE)
410 return true;
411 if (precision == LONG_DOUBLE_TYPE_SIZE)
412 return true;
413 return false;
415 case MODE_DECIMAL_FLOAT:
416 case MODE_FRACT:
417 case MODE_UFRACT:
418 case MODE_ACCUM:
419 case MODE_UACCUM:
420 return false;
422 default:
423 gcc_unreachable ();
427 /* Make some target macros useable by target-independent code. */
428 bool
429 targhook_words_big_endian (void)
431 return !!WORDS_BIG_ENDIAN;
434 bool
435 targhook_float_words_big_endian (void)
437 return !!FLOAT_WORDS_BIG_ENDIAN;
440 /* True if the target supports decimal floating point. */
442 bool
443 default_decimal_float_supported_p (void)
445 return ENABLE_DECIMAL_FLOAT;
448 /* True if the target supports fixed-point arithmetic. */
450 bool
451 default_fixed_point_supported_p (void)
453 return ENABLE_FIXED_POINT;
456 /* NULL if INSN insn is valid within a low-overhead loop, otherwise returns
457 an error message.
459 This function checks whether a given INSN is valid within a low-overhead
460 loop. If INSN is invalid it returns the reason for that, otherwise it
461 returns NULL. A called function may clobber any special registers required
462 for low-overhead looping. Additionally, some targets (eg, PPC) use the count
463 register for branch on table instructions. We reject the doloop pattern in
464 these cases. */
466 const char *
467 default_invalid_within_doloop (const_rtx insn)
469 if (CALL_P (insn))
470 return "Function call in loop.";
472 if (JUMP_TABLE_DATA_P (insn))
473 return "Computed branch in the loop.";
475 return NULL;
478 /* Mapping of builtin functions to vectorized variants. */
480 tree
481 default_builtin_vectorized_function (tree fndecl ATTRIBUTE_UNUSED,
482 tree type_out ATTRIBUTE_UNUSED,
483 tree type_in ATTRIBUTE_UNUSED)
485 return NULL_TREE;
488 /* Vectorized conversion. */
490 tree
491 default_builtin_vectorized_conversion (unsigned int code ATTRIBUTE_UNUSED,
492 tree dest_type ATTRIBUTE_UNUSED,
493 tree src_type ATTRIBUTE_UNUSED)
495 return NULL_TREE;
498 /* Default vectorizer cost model values. */
501 default_builtin_vectorization_cost (enum vect_cost_for_stmt type_of_cost,
502 tree vectype,
503 int misalign ATTRIBUTE_UNUSED)
505 unsigned elements;
507 switch (type_of_cost)
509 case scalar_stmt:
510 case scalar_load:
511 case scalar_store:
512 case vector_stmt:
513 case vector_load:
514 case vector_store:
515 case vec_to_scalar:
516 case scalar_to_vec:
517 case cond_branch_not_taken:
518 case vec_perm:
519 case vec_promote_demote:
520 return 1;
522 case unaligned_load:
523 case unaligned_store:
524 return 2;
526 case cond_branch_taken:
527 return 3;
529 case vec_construct:
530 elements = TYPE_VECTOR_SUBPARTS (vectype);
531 return elements / 2 + 1;
533 default:
534 gcc_unreachable ();
538 /* Reciprocal. */
540 tree
541 default_builtin_reciprocal (unsigned int fn ATTRIBUTE_UNUSED,
542 bool md_fn ATTRIBUTE_UNUSED,
543 bool sqrt ATTRIBUTE_UNUSED)
545 return NULL_TREE;
548 bool
549 hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false (
550 cumulative_args_t ca ATTRIBUTE_UNUSED,
551 enum machine_mode mode ATTRIBUTE_UNUSED,
552 const_tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
554 return false;
557 bool
558 hook_bool_CUMULATIVE_ARGS_mode_tree_bool_true (
559 cumulative_args_t ca ATTRIBUTE_UNUSED,
560 enum machine_mode mode ATTRIBUTE_UNUSED,
561 const_tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
563 return true;
567 hook_int_CUMULATIVE_ARGS_mode_tree_bool_0 (
568 cumulative_args_t ca ATTRIBUTE_UNUSED,
569 enum machine_mode mode ATTRIBUTE_UNUSED,
570 tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
572 return 0;
575 void
576 default_function_arg_advance (cumulative_args_t ca ATTRIBUTE_UNUSED,
577 enum machine_mode mode ATTRIBUTE_UNUSED,
578 const_tree type ATTRIBUTE_UNUSED,
579 bool named ATTRIBUTE_UNUSED)
581 gcc_unreachable ();
585 default_function_arg (cumulative_args_t ca ATTRIBUTE_UNUSED,
586 enum machine_mode mode ATTRIBUTE_UNUSED,
587 const_tree type ATTRIBUTE_UNUSED,
588 bool named ATTRIBUTE_UNUSED)
590 gcc_unreachable ();
594 default_function_incoming_arg (cumulative_args_t ca ATTRIBUTE_UNUSED,
595 enum machine_mode mode ATTRIBUTE_UNUSED,
596 const_tree type ATTRIBUTE_UNUSED,
597 bool named ATTRIBUTE_UNUSED)
599 gcc_unreachable ();
602 unsigned int
603 default_function_arg_boundary (enum machine_mode mode ATTRIBUTE_UNUSED,
604 const_tree type ATTRIBUTE_UNUSED)
606 return PARM_BOUNDARY;
609 unsigned int
610 default_function_arg_round_boundary (enum machine_mode mode ATTRIBUTE_UNUSED,
611 const_tree type ATTRIBUTE_UNUSED)
613 return PARM_BOUNDARY;
616 void
617 hook_void_bitmap (bitmap regs ATTRIBUTE_UNUSED)
621 const char *
622 hook_invalid_arg_for_unprototyped_fn (
623 const_tree typelist ATTRIBUTE_UNUSED,
624 const_tree funcdecl ATTRIBUTE_UNUSED,
625 const_tree val ATTRIBUTE_UNUSED)
627 return NULL;
630 /* Initialize the stack protection decls. */
632 /* Stack protection related decls living in libgcc. */
633 static GTY(()) tree stack_chk_guard_decl;
635 tree
636 default_stack_protect_guard (void)
638 tree t = stack_chk_guard_decl;
640 if (t == NULL)
642 rtx x;
644 t = build_decl (UNKNOWN_LOCATION,
645 VAR_DECL, get_identifier ("__stack_chk_guard"),
646 ptr_type_node);
647 TREE_STATIC (t) = 1;
648 TREE_PUBLIC (t) = 1;
649 DECL_EXTERNAL (t) = 1;
650 TREE_USED (t) = 1;
651 TREE_THIS_VOLATILE (t) = 1;
652 DECL_ARTIFICIAL (t) = 1;
653 DECL_IGNORED_P (t) = 1;
655 /* Do not share RTL as the declaration is visible outside of
656 current function. */
657 x = DECL_RTL (t);
658 RTX_FLAG (x, used) = 1;
660 stack_chk_guard_decl = t;
663 return t;
666 static GTY(()) tree stack_chk_fail_decl;
668 tree
669 default_external_stack_protect_fail (void)
671 tree t = stack_chk_fail_decl;
673 if (t == NULL_TREE)
675 t = build_function_type_list (void_type_node, NULL_TREE);
676 t = build_decl (UNKNOWN_LOCATION,
677 FUNCTION_DECL, get_identifier ("__stack_chk_fail"), t);
678 TREE_STATIC (t) = 1;
679 TREE_PUBLIC (t) = 1;
680 DECL_EXTERNAL (t) = 1;
681 TREE_USED (t) = 1;
682 TREE_THIS_VOLATILE (t) = 1;
683 TREE_NOTHROW (t) = 1;
684 DECL_ARTIFICIAL (t) = 1;
685 DECL_IGNORED_P (t) = 1;
686 DECL_VISIBILITY (t) = VISIBILITY_DEFAULT;
687 DECL_VISIBILITY_SPECIFIED (t) = 1;
689 stack_chk_fail_decl = t;
692 return build_call_expr (t, 0);
695 tree
696 default_hidden_stack_protect_fail (void)
698 #ifndef HAVE_GAS_HIDDEN
699 return default_external_stack_protect_fail ();
700 #else
701 tree t = stack_chk_fail_decl;
703 if (!flag_pic)
704 return default_external_stack_protect_fail ();
706 if (t == NULL_TREE)
708 t = build_function_type_list (void_type_node, NULL_TREE);
709 t = build_decl (UNKNOWN_LOCATION, FUNCTION_DECL,
710 get_identifier ("__stack_chk_fail_local"), t);
711 TREE_STATIC (t) = 1;
712 TREE_PUBLIC (t) = 1;
713 DECL_EXTERNAL (t) = 1;
714 TREE_USED (t) = 1;
715 TREE_THIS_VOLATILE (t) = 1;
716 TREE_NOTHROW (t) = 1;
717 DECL_ARTIFICIAL (t) = 1;
718 DECL_IGNORED_P (t) = 1;
719 DECL_VISIBILITY_SPECIFIED (t) = 1;
720 DECL_VISIBILITY (t) = VISIBILITY_HIDDEN;
722 stack_chk_fail_decl = t;
725 return build_call_expr (t, 0);
726 #endif
729 bool
730 hook_bool_const_rtx_commutative_p (const_rtx x,
731 int outer_code ATTRIBUTE_UNUSED)
733 return COMMUTATIVE_P (x);
737 default_function_value (const_tree ret_type ATTRIBUTE_UNUSED,
738 const_tree fn_decl_or_type,
739 bool outgoing ATTRIBUTE_UNUSED)
741 /* The old interface doesn't handle receiving the function type. */
742 if (fn_decl_or_type
743 && !DECL_P (fn_decl_or_type))
744 fn_decl_or_type = NULL;
746 #ifdef FUNCTION_VALUE
747 return FUNCTION_VALUE (ret_type, fn_decl_or_type);
748 #else
749 gcc_unreachable ();
750 #endif
754 default_libcall_value (enum machine_mode mode ATTRIBUTE_UNUSED,
755 const_rtx fun ATTRIBUTE_UNUSED)
757 #ifdef LIBCALL_VALUE
758 return LIBCALL_VALUE (mode);
759 #else
760 gcc_unreachable ();
761 #endif
764 /* The default hook for TARGET_FUNCTION_VALUE_REGNO_P. */
766 bool
767 default_function_value_regno_p (const unsigned int regno ATTRIBUTE_UNUSED)
769 #ifdef FUNCTION_VALUE_REGNO_P
770 return FUNCTION_VALUE_REGNO_P (regno);
771 #else
772 gcc_unreachable ();
773 #endif
777 default_internal_arg_pointer (void)
779 /* If the reg that the virtual arg pointer will be translated into is
780 not a fixed reg or is the stack pointer, make a copy of the virtual
781 arg pointer, and address parms via the copy. The frame pointer is
782 considered fixed even though it is not marked as such. */
783 if ((ARG_POINTER_REGNUM == STACK_POINTER_REGNUM
784 || ! (fixed_regs[ARG_POINTER_REGNUM]
785 || ARG_POINTER_REGNUM == FRAME_POINTER_REGNUM)))
786 return copy_to_reg (virtual_incoming_args_rtx);
787 else
788 return virtual_incoming_args_rtx;
792 default_static_chain (const_tree fndecl, bool incoming_p)
794 if (!DECL_STATIC_CHAIN (fndecl))
795 return NULL;
797 if (incoming_p)
799 #ifdef STATIC_CHAIN_INCOMING_REGNUM
800 return gen_rtx_REG (Pmode, STATIC_CHAIN_INCOMING_REGNUM);
801 #endif
804 #ifdef STATIC_CHAIN_REGNUM
805 return gen_rtx_REG (Pmode, STATIC_CHAIN_REGNUM);
806 #endif
809 static bool issued_error;
810 if (!issued_error)
812 issued_error = true;
813 sorry ("nested functions not supported on this target");
816 /* It really doesn't matter what we return here, so long at it
817 doesn't cause the rest of the compiler to crash. */
818 return gen_rtx_MEM (Pmode, stack_pointer_rtx);
822 void
823 default_trampoline_init (rtx ARG_UNUSED (m_tramp), tree ARG_UNUSED (t_func),
824 rtx ARG_UNUSED (r_chain))
826 sorry ("nested function trampolines not supported on this target");
830 default_return_pops_args (tree fundecl ATTRIBUTE_UNUSED,
831 tree funtype ATTRIBUTE_UNUSED,
832 int size ATTRIBUTE_UNUSED)
834 return 0;
837 reg_class_t
838 default_branch_target_register_class (void)
840 return NO_REGS;
843 reg_class_t
844 default_secondary_reload (bool in_p ATTRIBUTE_UNUSED, rtx x ATTRIBUTE_UNUSED,
845 reg_class_t reload_class_i ATTRIBUTE_UNUSED,
846 enum machine_mode reload_mode ATTRIBUTE_UNUSED,
847 secondary_reload_info *sri)
849 enum reg_class rclass = NO_REGS;
850 enum reg_class reload_class = (enum reg_class) reload_class_i;
852 if (sri->prev_sri && sri->prev_sri->t_icode != CODE_FOR_nothing)
854 sri->icode = sri->prev_sri->t_icode;
855 return NO_REGS;
857 #ifdef SECONDARY_INPUT_RELOAD_CLASS
858 if (in_p)
859 rclass = SECONDARY_INPUT_RELOAD_CLASS (reload_class, reload_mode, x);
860 #endif
861 #ifdef SECONDARY_OUTPUT_RELOAD_CLASS
862 if (! in_p)
863 rclass = SECONDARY_OUTPUT_RELOAD_CLASS (reload_class, reload_mode, x);
864 #endif
865 if (rclass != NO_REGS)
867 enum insn_code icode
868 = direct_optab_handler (in_p ? reload_in_optab : reload_out_optab,
869 reload_mode);
871 if (icode != CODE_FOR_nothing
872 && !insn_operand_matches (icode, in_p, x))
873 icode = CODE_FOR_nothing;
874 else if (icode != CODE_FOR_nothing)
876 const char *insn_constraint, *scratch_constraint;
877 char insn_letter, scratch_letter;
878 enum reg_class insn_class, scratch_class;
880 gcc_assert (insn_data[(int) icode].n_operands == 3);
881 insn_constraint = insn_data[(int) icode].operand[!in_p].constraint;
882 if (!*insn_constraint)
883 insn_class = ALL_REGS;
884 else
886 if (in_p)
888 gcc_assert (*insn_constraint == '=');
889 insn_constraint++;
891 insn_letter = *insn_constraint;
892 insn_class
893 = (insn_letter == 'r' ? GENERAL_REGS
894 : REG_CLASS_FROM_CONSTRAINT ((unsigned char) insn_letter,
895 insn_constraint));
896 gcc_assert (insn_class != NO_REGS);
899 scratch_constraint = insn_data[(int) icode].operand[2].constraint;
900 /* The scratch register's constraint must start with "=&",
901 except for an input reload, where only "=" is necessary,
902 and where it might be beneficial to re-use registers from
903 the input. */
904 gcc_assert (scratch_constraint[0] == '='
905 && (in_p || scratch_constraint[1] == '&'));
906 scratch_constraint++;
907 if (*scratch_constraint == '&')
908 scratch_constraint++;
909 scratch_letter = *scratch_constraint;
910 scratch_class
911 = (scratch_letter == 'r' ? GENERAL_REGS
912 : REG_CLASS_FROM_CONSTRAINT ((unsigned char) scratch_letter,
913 scratch_constraint));
915 if (reg_class_subset_p (reload_class, insn_class))
917 gcc_assert (scratch_class == rclass);
918 rclass = NO_REGS;
920 else
921 rclass = insn_class;
924 if (rclass == NO_REGS)
925 sri->icode = icode;
926 else
927 sri->t_icode = icode;
929 return rclass;
932 /* By default, if flag_pic is true, then neither local nor global relocs
933 should be placed in readonly memory. */
936 default_reloc_rw_mask (void)
938 return flag_pic ? 3 : 0;
941 /* By default, do no modification. */
942 tree default_mangle_decl_assembler_name (tree decl ATTRIBUTE_UNUSED,
943 tree id)
945 return id;
948 /* Default to natural alignment for vector types. */
949 HOST_WIDE_INT
950 default_vector_alignment (const_tree type)
952 return tree_low_cst (TYPE_SIZE (type), 0);
955 bool
956 default_builtin_vector_alignment_reachable (const_tree type, bool is_packed)
958 if (is_packed)
959 return false;
961 /* Assuming that types whose size is > pointer-size are not guaranteed to be
962 naturally aligned. */
963 if (tree_int_cst_compare (TYPE_SIZE (type), bitsize_int (POINTER_SIZE)) > 0)
964 return false;
966 /* Assuming that types whose size is <= pointer-size
967 are naturally aligned. */
968 return true;
971 /* By default, assume that a target supports any factor of misalignment
972 memory access if it supports movmisalign patten.
973 is_packed is true if the memory access is defined in a packed struct. */
974 bool
975 default_builtin_support_vector_misalignment (enum machine_mode mode,
976 const_tree type
977 ATTRIBUTE_UNUSED,
978 int misalignment
979 ATTRIBUTE_UNUSED,
980 bool is_packed
981 ATTRIBUTE_UNUSED)
983 if (optab_handler (movmisalign_optab, mode) != CODE_FOR_nothing)
984 return true;
985 return false;
988 /* By default, only attempt to parallelize bitwise operations, and
989 possibly adds/subtracts using bit-twiddling. */
991 enum machine_mode
992 default_preferred_simd_mode (enum machine_mode mode ATTRIBUTE_UNUSED)
994 return word_mode;
997 /* By default only the size derived from the preferred vector mode
998 is tried. */
1000 unsigned int
1001 default_autovectorize_vector_sizes (void)
1003 return 0;
1006 /* By default, the cost model accumulates three separate costs (prologue,
1007 loop body, and epilogue) for a vectorized loop or block. So allocate an
1008 array of three unsigned ints, set it to zero, and return its address. */
1010 void *
1011 default_init_cost (struct loop *loop_info ATTRIBUTE_UNUSED)
1013 unsigned *cost = XNEWVEC (unsigned, 3);
1014 cost[vect_prologue] = cost[vect_body] = cost[vect_epilogue] = 0;
1015 return cost;
1018 /* By default, the cost model looks up the cost of the given statement
1019 kind and mode, multiplies it by the occurrence count, accumulates
1020 it into the cost specified by WHERE, and returns the cost added. */
1022 unsigned
1023 default_add_stmt_cost (void *data, int count, enum vect_cost_for_stmt kind,
1024 struct _stmt_vec_info *stmt_info, int misalign,
1025 enum vect_cost_model_location where)
1027 unsigned *cost = (unsigned *) data;
1028 unsigned retval = 0;
1030 if (flag_vect_cost_model)
1032 tree vectype = stmt_info ? stmt_vectype (stmt_info) : NULL_TREE;
1033 int stmt_cost = default_builtin_vectorization_cost (kind, vectype,
1034 misalign);
1035 /* Statements in an inner loop relative to the loop being
1036 vectorized are weighted more heavily. The value here is
1037 arbitrary and could potentially be improved with analysis. */
1038 if (where == vect_body && stmt_info && stmt_in_inner_loop_p (stmt_info))
1039 count *= 50; /* FIXME. */
1041 retval = (unsigned) (count * stmt_cost);
1042 cost[where] += retval;
1045 return retval;
1048 /* By default, the cost model just returns the accumulated costs. */
1050 void
1051 default_finish_cost (void *data, unsigned *prologue_cost,
1052 unsigned *body_cost, unsigned *epilogue_cost)
1054 unsigned *cost = (unsigned *) data;
1055 *prologue_cost = cost[vect_prologue];
1056 *body_cost = cost[vect_body];
1057 *epilogue_cost = cost[vect_epilogue];
1060 /* Free the cost data. */
1062 void
1063 default_destroy_cost_data (void *data)
1065 free (data);
1068 /* Determine whether or not a pointer mode is valid. Assume defaults
1069 of ptr_mode or Pmode - can be overridden. */
1070 bool
1071 default_valid_pointer_mode (enum machine_mode mode)
1073 return (mode == ptr_mode || mode == Pmode);
1076 /* Determine whether the memory reference specified by REF may alias
1077 the C libraries errno location. */
1078 bool
1079 default_ref_may_alias_errno (ao_ref *ref)
1081 tree base = ao_ref_base (ref);
1082 /* The default implementation assumes the errno location is
1083 a declaration of type int or is always accessed via a
1084 pointer to int. We assume that accesses to errno are
1085 not deliberately obfuscated (even in conforming ways). */
1086 if (TYPE_UNSIGNED (TREE_TYPE (base))
1087 || TYPE_MODE (TREE_TYPE (base)) != TYPE_MODE (integer_type_node))
1088 return false;
1089 /* The default implementation assumes an errno location
1090 declaration is never defined in the current compilation unit. */
1091 if (DECL_P (base)
1092 && !TREE_STATIC (base))
1093 return true;
1094 else if (TREE_CODE (base) == MEM_REF
1095 && TREE_CODE (TREE_OPERAND (base, 0)) == SSA_NAME)
1097 struct ptr_info_def *pi = SSA_NAME_PTR_INFO (TREE_OPERAND (base, 0));
1098 return !pi || pi->pt.anything || pi->pt.nonlocal;
1100 return false;
1103 /* Return the mode for a pointer to a given ADDRSPACE, defaulting to ptr_mode
1104 for the generic address space only. */
1106 enum machine_mode
1107 default_addr_space_pointer_mode (addr_space_t addrspace ATTRIBUTE_UNUSED)
1109 gcc_assert (ADDR_SPACE_GENERIC_P (addrspace));
1110 return ptr_mode;
1113 /* Return the mode for an address in a given ADDRSPACE, defaulting to Pmode
1114 for the generic address space only. */
1116 enum machine_mode
1117 default_addr_space_address_mode (addr_space_t addrspace ATTRIBUTE_UNUSED)
1119 gcc_assert (ADDR_SPACE_GENERIC_P (addrspace));
1120 return Pmode;
1123 /* Named address space version of valid_pointer_mode. */
1125 bool
1126 default_addr_space_valid_pointer_mode (enum machine_mode mode, addr_space_t as)
1128 if (!ADDR_SPACE_GENERIC_P (as))
1129 return (mode == targetm.addr_space.pointer_mode (as)
1130 || mode == targetm.addr_space.address_mode (as));
1132 return targetm.valid_pointer_mode (mode);
1135 /* Some places still assume that all pointer or address modes are the
1136 standard Pmode and ptr_mode. These optimizations become invalid if
1137 the target actually supports multiple different modes. For now,
1138 we disable such optimizations on such targets, using this function. */
1140 bool
1141 target_default_pointer_address_modes_p (void)
1143 if (targetm.addr_space.address_mode != default_addr_space_address_mode)
1144 return false;
1145 if (targetm.addr_space.pointer_mode != default_addr_space_pointer_mode)
1146 return false;
1148 return true;
1151 /* Named address space version of legitimate_address_p. */
1153 bool
1154 default_addr_space_legitimate_address_p (enum machine_mode mode, rtx mem,
1155 bool strict, addr_space_t as)
1157 if (!ADDR_SPACE_GENERIC_P (as))
1158 gcc_unreachable ();
1160 return targetm.legitimate_address_p (mode, mem, strict);
1163 /* Named address space version of LEGITIMIZE_ADDRESS. */
1166 default_addr_space_legitimize_address (rtx x, rtx oldx,
1167 enum machine_mode mode, addr_space_t as)
1169 if (!ADDR_SPACE_GENERIC_P (as))
1170 return x;
1172 return targetm.legitimize_address (x, oldx, mode);
1175 /* The default hook for determining if one named address space is a subset of
1176 another and to return which address space to use as the common address
1177 space. */
1179 bool
1180 default_addr_space_subset_p (addr_space_t subset, addr_space_t superset)
1182 return (subset == superset);
1185 /* The default hook for TARGET_ADDR_SPACE_CONVERT. This hook should never be
1186 called for targets with only a generic address space. */
1189 default_addr_space_convert (rtx op ATTRIBUTE_UNUSED,
1190 tree from_type ATTRIBUTE_UNUSED,
1191 tree to_type ATTRIBUTE_UNUSED)
1193 gcc_unreachable ();
1196 bool
1197 default_hard_regno_scratch_ok (unsigned int regno ATTRIBUTE_UNUSED)
1199 return true;
1202 /* The default implementation of TARGET_MODE_DEPENDENT_ADDRESS_P. */
1204 bool
1205 default_mode_dependent_address_p (const_rtx addr ATTRIBUTE_UNUSED)
1207 return false;
1210 bool
1211 default_target_option_valid_attribute_p (tree ARG_UNUSED (fndecl),
1212 tree ARG_UNUSED (name),
1213 tree ARG_UNUSED (args),
1214 int ARG_UNUSED (flags))
1216 warning (OPT_Wattributes,
1217 "target attribute is not supported on this machine");
1219 return false;
1222 bool
1223 default_target_option_pragma_parse (tree ARG_UNUSED (args),
1224 tree ARG_UNUSED (pop_target))
1226 warning (OPT_Wpragmas,
1227 "#pragma GCC target is not supported for this machine");
1229 return false;
1232 bool
1233 default_target_can_inline_p (tree caller, tree callee)
1235 bool ret = false;
1236 tree callee_opts = DECL_FUNCTION_SPECIFIC_TARGET (callee);
1237 tree caller_opts = DECL_FUNCTION_SPECIFIC_TARGET (caller);
1239 /* If callee has no option attributes, then it is ok to inline */
1240 if (!callee_opts)
1241 ret = true;
1243 /* If caller has no option attributes, but callee does then it is not ok to
1244 inline */
1245 else if (!caller_opts)
1246 ret = false;
1248 /* If both caller and callee have attributes, assume that if the
1249 pointer is different, the two functions have different target
1250 options since build_target_option_node uses a hash table for the
1251 options. */
1252 else
1253 ret = (callee_opts == caller_opts);
1255 return ret;
1258 #ifndef HAVE_casesi
1259 # define HAVE_casesi 0
1260 #endif
1262 /* If the machine does not have a case insn that compares the bounds,
1263 this means extra overhead for dispatch tables, which raises the
1264 threshold for using them. */
1266 unsigned int
1267 default_case_values_threshold (void)
1269 return (HAVE_casesi ? 4 : 5);
1272 bool
1273 default_have_conditional_execution (void)
1275 #ifdef HAVE_conditional_execution
1276 return HAVE_conditional_execution;
1277 #else
1278 return false;
1279 #endif
1282 tree
1283 default_builtin_tm_load_store (tree ARG_UNUSED (type))
1285 return NULL_TREE;
1288 /* Compute cost of moving registers to/from memory. */
1291 default_memory_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED,
1292 reg_class_t rclass ATTRIBUTE_UNUSED,
1293 bool in ATTRIBUTE_UNUSED)
1295 #ifndef MEMORY_MOVE_COST
1296 return (4 + memory_move_secondary_cost (mode, (enum reg_class) rclass, in));
1297 #else
1298 return MEMORY_MOVE_COST (mode, (enum reg_class) rclass, in);
1299 #endif
1302 /* Compute cost of moving data from a register of class FROM to one of
1303 TO, using MODE. */
1306 default_register_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED,
1307 reg_class_t from ATTRIBUTE_UNUSED,
1308 reg_class_t to ATTRIBUTE_UNUSED)
1310 #ifndef REGISTER_MOVE_COST
1311 return 2;
1312 #else
1313 return REGISTER_MOVE_COST (mode, (enum reg_class) from, (enum reg_class) to);
1314 #endif
1317 bool
1318 default_profile_before_prologue (void)
1320 #ifdef PROFILE_BEFORE_PROLOGUE
1321 return true;
1322 #else
1323 return false;
1324 #endif
1327 /* The default implementation of TARGET_PREFERRED_RELOAD_CLASS. */
1329 reg_class_t
1330 default_preferred_reload_class (rtx x ATTRIBUTE_UNUSED,
1331 reg_class_t rclass)
1333 #ifdef PREFERRED_RELOAD_CLASS
1334 return (reg_class_t) PREFERRED_RELOAD_CLASS (x, (enum reg_class) rclass);
1335 #else
1336 return rclass;
1337 #endif
1340 /* The default implementation of TARGET_OUTPUT_PREFERRED_RELOAD_CLASS. */
1342 reg_class_t
1343 default_preferred_output_reload_class (rtx x ATTRIBUTE_UNUSED,
1344 reg_class_t rclass)
1346 return rclass;
1349 /* The default implementation of TARGET_PREFERRED_RENAME_CLASS. */
1350 reg_class_t
1351 default_preferred_rename_class (reg_class_t rclass ATTRIBUTE_UNUSED)
1353 return NO_REGS;
1356 /* The default implementation of TARGET_CLASS_LIKELY_SPILLED_P. */
1358 bool
1359 default_class_likely_spilled_p (reg_class_t rclass)
1361 return (reg_class_size[(int) rclass] == 1);
1364 /* The default implementation of TARGET_CLASS_MAX_NREGS. */
1366 unsigned char
1367 default_class_max_nregs (reg_class_t rclass ATTRIBUTE_UNUSED,
1368 enum machine_mode mode ATTRIBUTE_UNUSED)
1370 #ifdef CLASS_MAX_NREGS
1371 return (unsigned char) CLASS_MAX_NREGS ((enum reg_class) rclass, mode);
1372 #else
1373 return ((GET_MODE_SIZE (mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD);
1374 #endif
1377 /* Determine the debugging unwind mechanism for the target. */
1379 enum unwind_info_type
1380 default_debug_unwind_info (void)
1382 /* If the target wants to force the use of dwarf2 unwind info, let it. */
1383 /* ??? Change all users to the hook, then poison this. */
1384 #ifdef DWARF2_FRAME_INFO
1385 if (DWARF2_FRAME_INFO)
1386 return UI_DWARF2;
1387 #endif
1389 /* Otherwise, only turn it on if dwarf2 debugging is enabled. */
1390 #ifdef DWARF2_DEBUGGING_INFO
1391 if (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
1392 return UI_DWARF2;
1393 #endif
1395 return UI_NONE;
1398 /* To be used by targets where reg_raw_mode doesn't return the right
1399 mode for registers used in apply_builtin_return and apply_builtin_arg. */
1401 enum machine_mode
1402 default_get_reg_raw_mode(int regno)
1404 return reg_raw_mode[regno];
1407 /* Return true if the state of option OPTION should be stored in PCH files
1408 and checked by default_pch_valid_p. Store the option's current state
1409 in STATE if so. */
1411 static inline bool
1412 option_affects_pch_p (int option, struct cl_option_state *state)
1414 if ((cl_options[option].flags & CL_TARGET) == 0)
1415 return false;
1416 if (option_flag_var (option, &global_options) == &target_flags)
1417 if (targetm.check_pch_target_flags)
1418 return false;
1419 return get_option_state (&global_options, option, state);
1422 /* Default version of get_pch_validity.
1423 By default, every flag difference is fatal; that will be mostly right for
1424 most targets, but completely right for very few. */
1426 void *
1427 default_get_pch_validity (size_t *sz)
1429 struct cl_option_state state;
1430 size_t i;
1431 char *result, *r;
1433 *sz = 2;
1434 if (targetm.check_pch_target_flags)
1435 *sz += sizeof (target_flags);
1436 for (i = 0; i < cl_options_count; i++)
1437 if (option_affects_pch_p (i, &state))
1438 *sz += state.size;
1440 result = r = XNEWVEC (char, *sz);
1441 r[0] = flag_pic;
1442 r[1] = flag_pie;
1443 r += 2;
1444 if (targetm.check_pch_target_flags)
1446 memcpy (r, &target_flags, sizeof (target_flags));
1447 r += sizeof (target_flags);
1450 for (i = 0; i < cl_options_count; i++)
1451 if (option_affects_pch_p (i, &state))
1453 memcpy (r, state.data, state.size);
1454 r += state.size;
1457 return result;
1460 /* Return a message which says that a PCH file was created with a different
1461 setting of OPTION. */
1463 static const char *
1464 pch_option_mismatch (const char *option)
1466 char *r;
1468 asprintf (&r, _("created and used with differing settings of '%s'"), option);
1469 if (r == NULL)
1470 return _("out of memory");
1471 return r;
1474 /* Default version of pch_valid_p. */
1476 const char *
1477 default_pch_valid_p (const void *data_p, size_t len)
1479 struct cl_option_state state;
1480 const char *data = (const char *)data_p;
1481 size_t i;
1483 /* -fpic and -fpie also usually make a PCH invalid. */
1484 if (data[0] != flag_pic)
1485 return _("created and used with different settings of -fpic");
1486 if (data[1] != flag_pie)
1487 return _("created and used with different settings of -fpie");
1488 data += 2;
1490 /* Check target_flags. */
1491 if (targetm.check_pch_target_flags)
1493 int tf;
1494 const char *r;
1496 memcpy (&tf, data, sizeof (target_flags));
1497 data += sizeof (target_flags);
1498 len -= sizeof (target_flags);
1499 r = targetm.check_pch_target_flags (tf);
1500 if (r != NULL)
1501 return r;
1504 for (i = 0; i < cl_options_count; i++)
1505 if (option_affects_pch_p (i, &state))
1507 if (memcmp (data, state.data, state.size) != 0)
1508 return pch_option_mismatch (cl_options[i].opt_text);
1509 data += state.size;
1510 len -= state.size;
1513 return NULL;
1516 /* Default version of member_type_forces_blk. */
1518 bool
1519 default_member_type_forces_blk (const_tree, enum machine_mode)
1521 return false;
1524 #include "gt-targhooks.h"