1 /* Default target hook functions.
2 Copyright (C) 2003-2016 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"
56 #include "tree-ssa-alias.h"
57 #include "gimple-expr.h"
59 #include "stringpool.h"
61 #include "tree-ssanames.h"
65 #include "diagnostic-core.h"
66 #include "fold-const.h"
67 #include "stor-layout.h"
84 default_legitimate_address_p (machine_mode mode ATTRIBUTE_UNUSED
,
85 rtx addr ATTRIBUTE_UNUSED
,
86 bool strict ATTRIBUTE_UNUSED
)
88 #ifdef GO_IF_LEGITIMATE_ADDRESS
89 /* Defer to the old implementation using a goto. */
91 return strict_memory_address_p (mode
, addr
);
93 return memory_address_p (mode
, addr
);
100 default_external_libcall (rtx fun ATTRIBUTE_UNUSED
)
102 #ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
103 ASM_OUTPUT_EXTERNAL_LIBCALL (asm_out_file
, fun
);
108 default_unspec_may_trap_p (const_rtx x
, unsigned flags
)
112 /* Any floating arithmetic may trap. */
113 if ((SCALAR_FLOAT_MODE_P (GET_MODE (x
)) && flag_trapping_math
))
116 for (i
= 0; i
< XVECLEN (x
, 0); ++i
)
118 if (may_trap_p_1 (XVECEXP (x
, 0, i
), flags
))
126 default_promote_function_mode (const_tree type ATTRIBUTE_UNUSED
,
128 int *punsignedp ATTRIBUTE_UNUSED
,
129 const_tree funtype ATTRIBUTE_UNUSED
,
130 int for_return ATTRIBUTE_UNUSED
)
132 if (type
!= NULL_TREE
&& for_return
== 2)
133 return promote_mode (type
, mode
, punsignedp
);
138 default_promote_function_mode_always_promote (const_tree type
,
141 const_tree funtype ATTRIBUTE_UNUSED
,
142 int for_return ATTRIBUTE_UNUSED
)
144 return promote_mode (type
, mode
, punsignedp
);
148 default_cc_modes_compatible (machine_mode m1
, machine_mode m2
)
156 default_return_in_memory (const_tree type
,
157 const_tree fntype ATTRIBUTE_UNUSED
)
159 return (TYPE_MODE (type
) == BLKmode
);
163 default_legitimize_address (rtx x
, rtx orig_x ATTRIBUTE_UNUSED
,
164 machine_mode mode ATTRIBUTE_UNUSED
)
170 default_legitimize_address_displacement (rtx
*disp ATTRIBUTE_UNUSED
,
171 rtx
*offset ATTRIBUTE_UNUSED
,
172 machine_mode mode ATTRIBUTE_UNUSED
)
178 default_expand_builtin_saveregs (void)
180 error ("__builtin_saveregs not supported by this target");
185 default_setup_incoming_varargs (cumulative_args_t ca ATTRIBUTE_UNUSED
,
186 machine_mode mode ATTRIBUTE_UNUSED
,
187 tree type ATTRIBUTE_UNUSED
,
188 int *pretend_arg_size ATTRIBUTE_UNUSED
,
189 int second_time ATTRIBUTE_UNUSED
)
193 /* The default implementation of TARGET_BUILTIN_SETJMP_FRAME_VALUE. */
196 default_builtin_setjmp_frame_value (void)
198 return virtual_stack_vars_rtx
;
201 /* Generic hook that takes a CUMULATIVE_ARGS pointer and returns false. */
204 hook_bool_CUMULATIVE_ARGS_false (cumulative_args_t ca ATTRIBUTE_UNUSED
)
210 default_pretend_outgoing_varargs_named (cumulative_args_t ca ATTRIBUTE_UNUSED
)
212 return (targetm
.calls
.setup_incoming_varargs
213 != default_setup_incoming_varargs
);
217 default_eh_return_filter_mode (void)
219 return targetm
.unwind_word_mode ();
223 default_libgcc_cmp_return_mode (void)
229 default_libgcc_shift_count_mode (void)
235 default_unwind_word_mode (void)
240 /* The default implementation of TARGET_SHIFT_TRUNCATION_MASK. */
242 unsigned HOST_WIDE_INT
243 default_shift_truncation_mask (machine_mode mode
)
245 return SHIFT_COUNT_TRUNCATED
? GET_MODE_BITSIZE (mode
) - 1 : 0;
248 /* The default implementation of TARGET_MIN_DIVISIONS_FOR_RECIP_MUL. */
251 default_min_divisions_for_recip_mul (machine_mode mode ATTRIBUTE_UNUSED
)
253 return have_insn_for (DIV
, mode
) ? 3 : 2;
256 /* The default implementation of TARGET_MODE_REP_EXTENDED. */
259 default_mode_rep_extended (machine_mode mode ATTRIBUTE_UNUSED
,
260 machine_mode mode_rep ATTRIBUTE_UNUSED
)
265 /* Generic hook that takes a CUMULATIVE_ARGS pointer and returns true. */
268 hook_bool_CUMULATIVE_ARGS_true (cumulative_args_t a ATTRIBUTE_UNUSED
)
273 /* Return machine mode for non-standard suffix
274 or VOIDmode if non-standard suffixes are unsupported. */
276 default_mode_for_suffix (char suffix ATTRIBUTE_UNUSED
)
281 /* The generic C++ ABI specifies this is a 64-bit value. */
283 default_cxx_guard_type (void)
285 return long_long_integer_type_node
;
288 /* Returns the size of the cookie to use when allocating an array
289 whose elements have the indicated TYPE. Assumes that it is already
290 known that a cookie is needed. */
293 default_cxx_get_cookie_size (tree type
)
297 /* We need to allocate an additional max (sizeof (size_t), alignof
298 (true_type)) bytes. */
302 sizetype_size
= size_in_bytes (sizetype
);
303 type_align
= size_int (TYPE_ALIGN_UNIT (type
));
304 if (tree_int_cst_lt (type_align
, sizetype_size
))
305 cookie_size
= sizetype_size
;
307 cookie_size
= type_align
;
312 /* Return true if a parameter must be passed by reference. This version
313 of the TARGET_PASS_BY_REFERENCE hook uses just MUST_PASS_IN_STACK. */
316 hook_pass_by_reference_must_pass_in_stack (cumulative_args_t c ATTRIBUTE_UNUSED
,
317 machine_mode mode ATTRIBUTE_UNUSED
, const_tree type ATTRIBUTE_UNUSED
,
318 bool named_arg ATTRIBUTE_UNUSED
)
320 return targetm
.calls
.must_pass_in_stack (mode
, type
);
323 /* Return true if a parameter follows callee copies conventions. This
324 version of the hook is true for all named arguments. */
327 hook_callee_copies_named (cumulative_args_t ca ATTRIBUTE_UNUSED
,
328 machine_mode mode ATTRIBUTE_UNUSED
,
329 const_tree type ATTRIBUTE_UNUSED
, bool named
)
334 /* Emit to STREAM the assembler syntax for insn operand X. */
337 default_print_operand (FILE *stream ATTRIBUTE_UNUSED
, rtx x ATTRIBUTE_UNUSED
,
338 int code ATTRIBUTE_UNUSED
)
341 PRINT_OPERAND (stream
, x
, code
);
347 /* Emit to STREAM the assembler syntax for an insn operand whose memory
351 default_print_operand_address (FILE *stream ATTRIBUTE_UNUSED
,
352 machine_mode
/*mode*/,
353 rtx x ATTRIBUTE_UNUSED
)
355 #ifdef PRINT_OPERAND_ADDRESS
356 PRINT_OPERAND_ADDRESS (stream
, x
);
362 /* Return true if CODE is a valid punctuation character for the
363 `print_operand' hook. */
366 default_print_operand_punct_valid_p (unsigned char code ATTRIBUTE_UNUSED
)
368 #ifdef PRINT_OPERAND_PUNCT_VALID_P
369 return PRINT_OPERAND_PUNCT_VALID_P (code
);
375 /* The default implementation of TARGET_MANGLE_ASSEMBLER_NAME. */
377 default_mangle_assembler_name (const char *name ATTRIBUTE_UNUSED
)
379 const char *skipped
= name
+ (*name
== '*' ? 1 : 0);
380 const char *stripped
= targetm
.strip_name_encoding (skipped
);
381 if (*name
!= '*' && user_label_prefix
[0])
382 stripped
= ACONCAT ((user_label_prefix
, stripped
, NULL
));
383 return get_identifier (stripped
);
386 /* True if MODE is valid for the target. By "valid", we mean able to
387 be manipulated in non-trivial ways. In particular, this means all
388 the arithmetic is supported.
390 By default we guess this means that any C type is supported. If
391 we can't map the mode back to a type that would be available in C,
392 then reject it. Special case, here, is the double-word arithmetic
393 supported by optabs.c. */
396 default_scalar_mode_supported_p (machine_mode mode
)
398 int precision
= GET_MODE_PRECISION (mode
);
400 switch (GET_MODE_CLASS (mode
))
402 case MODE_PARTIAL_INT
:
404 if (precision
== CHAR_TYPE_SIZE
)
406 if (precision
== SHORT_TYPE_SIZE
)
408 if (precision
== INT_TYPE_SIZE
)
410 if (precision
== LONG_TYPE_SIZE
)
412 if (precision
== LONG_LONG_TYPE_SIZE
)
414 if (precision
== 2 * BITS_PER_WORD
)
419 if (precision
== FLOAT_TYPE_SIZE
)
421 if (precision
== DOUBLE_TYPE_SIZE
)
423 if (precision
== LONG_DOUBLE_TYPE_SIZE
)
427 case MODE_DECIMAL_FLOAT
:
439 /* Return true if libgcc supports floating-point mode MODE (known to
440 be supported as a scalar mode). */
443 default_libgcc_floating_mode_supported_p (machine_mode mode
)
466 /* Return the machine mode to use for the type _FloatN, if EXTENDED is
467 false, or _FloatNx, if EXTENDED is true, or VOIDmode if not
470 default_floatn_mode (int n
, bool extended
)
474 machine_mode cand1
= VOIDmode
, cand2
= VOIDmode
;
496 /* Those are the only valid _FloatNx types. */
499 if (cand1
!= VOIDmode
500 && REAL_MODE_FORMAT (cand1
)->ieee_bits
> n
501 && targetm
.scalar_mode_supported_p (cand1
)
502 && targetm
.libgcc_floating_mode_supported_p (cand1
))
504 if (cand2
!= VOIDmode
505 && REAL_MODE_FORMAT (cand2
)->ieee_bits
> n
506 && targetm
.scalar_mode_supported_p (cand2
)
507 && targetm
.libgcc_floating_mode_supported_p (cand2
))
512 machine_mode cand
= VOIDmode
;
516 /* We do not use HFmode for _Float16 by default because the
517 required excess precision support is not present and the
518 interactions with promotion of the older __fp16 need to
544 && REAL_MODE_FORMAT (cand
)->ieee_bits
== n
545 && targetm
.scalar_mode_supported_p (cand
)
546 && targetm
.libgcc_floating_mode_supported_p (cand
))
552 /* Make some target macros useable by target-independent code. */
554 targhook_words_big_endian (void)
556 return !!WORDS_BIG_ENDIAN
;
560 targhook_float_words_big_endian (void)
562 return !!FLOAT_WORDS_BIG_ENDIAN
;
565 /* True if the target supports floating-point exceptions and rounding
569 default_float_exceptions_rounding_supported_p (void)
578 /* True if the target supports decimal floating point. */
581 default_decimal_float_supported_p (void)
583 return ENABLE_DECIMAL_FLOAT
;
586 /* True if the target supports fixed-point arithmetic. */
589 default_fixed_point_supported_p (void)
591 return ENABLE_FIXED_POINT
;
594 /* True if the target supports GNU indirect functions. */
597 default_has_ifunc_p (void)
599 return HAVE_GNU_INDIRECT_FUNCTION
;
602 /* NULL if INSN insn is valid within a low-overhead loop, otherwise returns
605 This function checks whether a given INSN is valid within a low-overhead
606 loop. If INSN is invalid it returns the reason for that, otherwise it
607 returns NULL. A called function may clobber any special registers required
608 for low-overhead looping. Additionally, some targets (eg, PPC) use the count
609 register for branch on table instructions. We reject the doloop pattern in
613 default_invalid_within_doloop (const rtx_insn
*insn
)
616 return "Function call in loop.";
618 if (tablejump_p (insn
, NULL
, NULL
) || computed_jump_p (insn
))
619 return "Computed branch in the loop.";
624 /* Mapping of builtin functions to vectorized variants. */
627 default_builtin_vectorized_function (unsigned int, tree
, tree
)
632 /* Mapping of target builtin functions to vectorized variants. */
635 default_builtin_md_vectorized_function (tree
, tree
, tree
)
640 /* Vectorized conversion. */
643 default_builtin_vectorized_conversion (unsigned int code ATTRIBUTE_UNUSED
,
644 tree dest_type ATTRIBUTE_UNUSED
,
645 tree src_type ATTRIBUTE_UNUSED
)
650 /* Default vectorizer cost model values. */
653 default_builtin_vectorization_cost (enum vect_cost_for_stmt type_of_cost
,
655 int misalign ATTRIBUTE_UNUSED
)
657 switch (type_of_cost
)
667 case cond_branch_not_taken
:
669 case vec_promote_demote
:
673 case unaligned_store
:
676 case cond_branch_taken
:
680 return TYPE_VECTOR_SUBPARTS (vectype
) - 1;
690 default_builtin_reciprocal (tree
)
696 hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false (
697 cumulative_args_t ca ATTRIBUTE_UNUSED
,
698 machine_mode mode ATTRIBUTE_UNUSED
,
699 const_tree type ATTRIBUTE_UNUSED
, bool named ATTRIBUTE_UNUSED
)
705 hook_bool_CUMULATIVE_ARGS_mode_tree_bool_true (
706 cumulative_args_t ca ATTRIBUTE_UNUSED
,
707 machine_mode mode ATTRIBUTE_UNUSED
,
708 const_tree type ATTRIBUTE_UNUSED
, bool named ATTRIBUTE_UNUSED
)
714 hook_int_CUMULATIVE_ARGS_mode_tree_bool_0 (
715 cumulative_args_t ca ATTRIBUTE_UNUSED
,
716 machine_mode mode ATTRIBUTE_UNUSED
,
717 tree type ATTRIBUTE_UNUSED
, bool named ATTRIBUTE_UNUSED
)
723 default_function_arg_advance (cumulative_args_t ca ATTRIBUTE_UNUSED
,
724 machine_mode mode ATTRIBUTE_UNUSED
,
725 const_tree type ATTRIBUTE_UNUSED
,
726 bool named ATTRIBUTE_UNUSED
)
732 default_function_arg (cumulative_args_t ca ATTRIBUTE_UNUSED
,
733 machine_mode mode ATTRIBUTE_UNUSED
,
734 const_tree type ATTRIBUTE_UNUSED
,
735 bool named ATTRIBUTE_UNUSED
)
741 default_function_incoming_arg (cumulative_args_t ca ATTRIBUTE_UNUSED
,
742 machine_mode mode ATTRIBUTE_UNUSED
,
743 const_tree type ATTRIBUTE_UNUSED
,
744 bool named ATTRIBUTE_UNUSED
)
750 default_function_arg_boundary (machine_mode mode ATTRIBUTE_UNUSED
,
751 const_tree type ATTRIBUTE_UNUSED
)
753 return PARM_BOUNDARY
;
757 default_function_arg_round_boundary (machine_mode mode ATTRIBUTE_UNUSED
,
758 const_tree type ATTRIBUTE_UNUSED
)
760 return PARM_BOUNDARY
;
764 hook_void_bitmap (bitmap regs ATTRIBUTE_UNUSED
)
769 hook_invalid_arg_for_unprototyped_fn (
770 const_tree typelist ATTRIBUTE_UNUSED
,
771 const_tree funcdecl ATTRIBUTE_UNUSED
,
772 const_tree val ATTRIBUTE_UNUSED
)
777 /* Initialize the stack protection decls. */
779 /* Stack protection related decls living in libgcc. */
780 static GTY(()) tree stack_chk_guard_decl
;
783 default_stack_protect_guard (void)
785 tree t
= stack_chk_guard_decl
;
791 t
= build_decl (UNKNOWN_LOCATION
,
792 VAR_DECL
, get_identifier ("__stack_chk_guard"),
796 DECL_EXTERNAL (t
) = 1;
798 TREE_THIS_VOLATILE (t
) = 1;
799 DECL_ARTIFICIAL (t
) = 1;
800 DECL_IGNORED_P (t
) = 1;
802 /* Do not share RTL as the declaration is visible outside of
805 RTX_FLAG (x
, used
) = 1;
807 stack_chk_guard_decl
= t
;
813 static GTY(()) tree stack_chk_fail_decl
;
816 default_external_stack_protect_fail (void)
818 tree t
= stack_chk_fail_decl
;
822 t
= build_function_type_list (void_type_node
, NULL_TREE
);
823 t
= build_decl (UNKNOWN_LOCATION
,
824 FUNCTION_DECL
, get_identifier ("__stack_chk_fail"), t
);
827 DECL_EXTERNAL (t
) = 1;
829 TREE_THIS_VOLATILE (t
) = 1;
830 TREE_NOTHROW (t
) = 1;
831 DECL_ARTIFICIAL (t
) = 1;
832 DECL_IGNORED_P (t
) = 1;
833 DECL_VISIBILITY (t
) = VISIBILITY_DEFAULT
;
834 DECL_VISIBILITY_SPECIFIED (t
) = 1;
836 stack_chk_fail_decl
= t
;
839 return build_call_expr (t
, 0);
843 default_hidden_stack_protect_fail (void)
845 #ifndef HAVE_GAS_HIDDEN
846 return default_external_stack_protect_fail ();
848 tree t
= stack_chk_fail_decl
;
851 return default_external_stack_protect_fail ();
855 t
= build_function_type_list (void_type_node
, NULL_TREE
);
856 t
= build_decl (UNKNOWN_LOCATION
, FUNCTION_DECL
,
857 get_identifier ("__stack_chk_fail_local"), t
);
860 DECL_EXTERNAL (t
) = 1;
862 TREE_THIS_VOLATILE (t
) = 1;
863 TREE_NOTHROW (t
) = 1;
864 DECL_ARTIFICIAL (t
) = 1;
865 DECL_IGNORED_P (t
) = 1;
866 DECL_VISIBILITY_SPECIFIED (t
) = 1;
867 DECL_VISIBILITY (t
) = VISIBILITY_HIDDEN
;
869 stack_chk_fail_decl
= t
;
872 return build_call_expr (t
, 0);
877 hook_bool_const_rtx_commutative_p (const_rtx x
,
878 int outer_code ATTRIBUTE_UNUSED
)
880 return COMMUTATIVE_P (x
);
884 default_function_value (const_tree ret_type ATTRIBUTE_UNUSED
,
885 const_tree fn_decl_or_type
,
886 bool outgoing ATTRIBUTE_UNUSED
)
888 /* The old interface doesn't handle receiving the function type. */
890 && !DECL_P (fn_decl_or_type
))
891 fn_decl_or_type
= NULL
;
893 #ifdef FUNCTION_VALUE
894 return FUNCTION_VALUE (ret_type
, fn_decl_or_type
);
901 default_libcall_value (machine_mode mode ATTRIBUTE_UNUSED
,
902 const_rtx fun ATTRIBUTE_UNUSED
)
905 return LIBCALL_VALUE (mode
);
911 /* The default hook for TARGET_FUNCTION_VALUE_REGNO_P. */
914 default_function_value_regno_p (const unsigned int regno ATTRIBUTE_UNUSED
)
916 #ifdef FUNCTION_VALUE_REGNO_P
917 return FUNCTION_VALUE_REGNO_P (regno
);
924 default_internal_arg_pointer (void)
926 /* If the reg that the virtual arg pointer will be translated into is
927 not a fixed reg or is the stack pointer, make a copy of the virtual
928 arg pointer, and address parms via the copy. The frame pointer is
929 considered fixed even though it is not marked as such. */
930 if ((ARG_POINTER_REGNUM
== STACK_POINTER_REGNUM
931 || ! (fixed_regs
[ARG_POINTER_REGNUM
]
932 || ARG_POINTER_REGNUM
== FRAME_POINTER_REGNUM
)))
933 return copy_to_reg (virtual_incoming_args_rtx
);
935 return virtual_incoming_args_rtx
;
939 default_static_chain (const_tree
ARG_UNUSED (fndecl_or_type
), bool incoming_p
)
943 #ifdef STATIC_CHAIN_INCOMING_REGNUM
944 return gen_rtx_REG (Pmode
, STATIC_CHAIN_INCOMING_REGNUM
);
948 #ifdef STATIC_CHAIN_REGNUM
949 return gen_rtx_REG (Pmode
, STATIC_CHAIN_REGNUM
);
953 static bool issued_error
;
957 sorry ("nested functions not supported on this target");
960 /* It really doesn't matter what we return here, so long at it
961 doesn't cause the rest of the compiler to crash. */
962 return gen_rtx_MEM (Pmode
, stack_pointer_rtx
);
967 default_trampoline_init (rtx
ARG_UNUSED (m_tramp
), tree
ARG_UNUSED (t_func
),
968 rtx
ARG_UNUSED (r_chain
))
970 sorry ("nested function trampolines not supported on this target");
974 default_return_pops_args (tree fundecl ATTRIBUTE_UNUSED
,
975 tree funtype ATTRIBUTE_UNUSED
,
976 int size ATTRIBUTE_UNUSED
)
982 default_branch_target_register_class (void)
988 default_ira_change_pseudo_allocno_class (int regno ATTRIBUTE_UNUSED
,
990 reg_class_t best_cl ATTRIBUTE_UNUSED
)
1002 default_register_priority (int hard_regno ATTRIBUTE_UNUSED
)
1008 default_register_usage_leveling_p (void)
1014 default_different_addr_displacement_p (void)
1020 default_secondary_reload (bool in_p ATTRIBUTE_UNUSED
, rtx x ATTRIBUTE_UNUSED
,
1021 reg_class_t reload_class_i ATTRIBUTE_UNUSED
,
1022 machine_mode reload_mode ATTRIBUTE_UNUSED
,
1023 secondary_reload_info
*sri
)
1025 enum reg_class rclass
= NO_REGS
;
1026 enum reg_class reload_class
= (enum reg_class
) reload_class_i
;
1028 if (sri
->prev_sri
&& sri
->prev_sri
->t_icode
!= CODE_FOR_nothing
)
1030 sri
->icode
= sri
->prev_sri
->t_icode
;
1033 #ifdef SECONDARY_INPUT_RELOAD_CLASS
1035 rclass
= SECONDARY_INPUT_RELOAD_CLASS (reload_class
, reload_mode
, x
);
1037 #ifdef SECONDARY_OUTPUT_RELOAD_CLASS
1039 rclass
= SECONDARY_OUTPUT_RELOAD_CLASS (reload_class
, reload_mode
, x
);
1041 if (rclass
!= NO_REGS
)
1043 enum insn_code icode
1044 = direct_optab_handler (in_p
? reload_in_optab
: reload_out_optab
,
1047 if (icode
!= CODE_FOR_nothing
1048 && !insn_operand_matches (icode
, in_p
, x
))
1049 icode
= CODE_FOR_nothing
;
1050 else if (icode
!= CODE_FOR_nothing
)
1052 const char *insn_constraint
, *scratch_constraint
;
1053 enum reg_class insn_class
, scratch_class
;
1055 gcc_assert (insn_data
[(int) icode
].n_operands
== 3);
1056 insn_constraint
= insn_data
[(int) icode
].operand
[!in_p
].constraint
;
1057 if (!*insn_constraint
)
1058 insn_class
= ALL_REGS
;
1063 gcc_assert (*insn_constraint
== '=');
1066 insn_class
= (reg_class_for_constraint
1067 (lookup_constraint (insn_constraint
)));
1068 gcc_assert (insn_class
!= NO_REGS
);
1071 scratch_constraint
= insn_data
[(int) icode
].operand
[2].constraint
;
1072 /* The scratch register's constraint must start with "=&",
1073 except for an input reload, where only "=" is necessary,
1074 and where it might be beneficial to re-use registers from
1076 gcc_assert (scratch_constraint
[0] == '='
1077 && (in_p
|| scratch_constraint
[1] == '&'));
1078 scratch_constraint
++;
1079 if (*scratch_constraint
== '&')
1080 scratch_constraint
++;
1081 scratch_class
= (reg_class_for_constraint
1082 (lookup_constraint (scratch_constraint
)));
1084 if (reg_class_subset_p (reload_class
, insn_class
))
1086 gcc_assert (scratch_class
== rclass
);
1090 rclass
= insn_class
;
1093 if (rclass
== NO_REGS
)
1096 sri
->t_icode
= icode
;
1101 /* By default, if flag_pic is true, then neither local nor global relocs
1102 should be placed in readonly memory. */
1105 default_reloc_rw_mask (void)
1107 return flag_pic
? 3 : 0;
1110 /* By default, do no modification. */
1111 tree
default_mangle_decl_assembler_name (tree decl ATTRIBUTE_UNUSED
,
1117 /* Default to natural alignment for vector types. */
1119 default_vector_alignment (const_tree type
)
1121 HOST_WIDE_INT align
= tree_to_shwi (TYPE_SIZE (type
));
1122 if (align
> MAX_OFILE_ALIGNMENT
)
1123 align
= MAX_OFILE_ALIGNMENT
;
1128 default_builtin_vector_alignment_reachable (const_tree type
, bool is_packed
)
1133 /* Assuming that types whose size is > pointer-size are not guaranteed to be
1134 naturally aligned. */
1135 if (tree_int_cst_compare (TYPE_SIZE (type
), bitsize_int (POINTER_SIZE
)) > 0)
1138 /* Assuming that types whose size is <= pointer-size
1139 are naturally aligned. */
1143 /* By default, assume that a target supports any factor of misalignment
1144 memory access if it supports movmisalign patten.
1145 is_packed is true if the memory access is defined in a packed struct. */
1147 default_builtin_support_vector_misalignment (machine_mode mode
,
1155 if (optab_handler (movmisalign_optab
, mode
) != CODE_FOR_nothing
)
1160 /* By default, only attempt to parallelize bitwise operations, and
1161 possibly adds/subtracts using bit-twiddling. */
1164 default_preferred_simd_mode (machine_mode mode ATTRIBUTE_UNUSED
)
1169 /* By default only the size derived from the preferred vector mode
1173 default_autovectorize_vector_sizes (void)
1178 /* By defaults a vector of integers is used as a mask. */
1181 default_get_mask_mode (unsigned nunits
, unsigned vector_size
)
1183 unsigned elem_size
= vector_size
/ nunits
;
1184 machine_mode elem_mode
1185 = smallest_mode_for_size (elem_size
* BITS_PER_UNIT
, MODE_INT
);
1186 machine_mode vector_mode
;
1188 gcc_assert (elem_size
* nunits
== vector_size
);
1190 vector_mode
= mode_for_vector (elem_mode
, nunits
);
1191 if (!VECTOR_MODE_P (vector_mode
)
1192 || !targetm
.vector_mode_supported_p (vector_mode
))
1193 vector_mode
= BLKmode
;
1198 /* By default, the cost model accumulates three separate costs (prologue,
1199 loop body, and epilogue) for a vectorized loop or block. So allocate an
1200 array of three unsigned ints, set it to zero, and return its address. */
1203 default_init_cost (struct loop
*loop_info ATTRIBUTE_UNUSED
)
1205 unsigned *cost
= XNEWVEC (unsigned, 3);
1206 cost
[vect_prologue
] = cost
[vect_body
] = cost
[vect_epilogue
] = 0;
1210 /* By default, the cost model looks up the cost of the given statement
1211 kind and mode, multiplies it by the occurrence count, accumulates
1212 it into the cost specified by WHERE, and returns the cost added. */
1215 default_add_stmt_cost (void *data
, int count
, enum vect_cost_for_stmt kind
,
1216 struct _stmt_vec_info
*stmt_info
, int misalign
,
1217 enum vect_cost_model_location where
)
1219 unsigned *cost
= (unsigned *) data
;
1220 unsigned retval
= 0;
1222 tree vectype
= stmt_info
? stmt_vectype (stmt_info
) : NULL_TREE
;
1223 int stmt_cost
= targetm
.vectorize
.builtin_vectorization_cost (kind
, vectype
,
1225 /* Statements in an inner loop relative to the loop being
1226 vectorized are weighted more heavily. The value here is
1227 arbitrary and could potentially be improved with analysis. */
1228 if (where
== vect_body
&& stmt_info
&& stmt_in_inner_loop_p (stmt_info
))
1229 count
*= 50; /* FIXME. */
1231 retval
= (unsigned) (count
* stmt_cost
);
1232 cost
[where
] += retval
;
1237 /* By default, the cost model just returns the accumulated costs. */
1240 default_finish_cost (void *data
, unsigned *prologue_cost
,
1241 unsigned *body_cost
, unsigned *epilogue_cost
)
1243 unsigned *cost
= (unsigned *) data
;
1244 *prologue_cost
= cost
[vect_prologue
];
1245 *body_cost
= cost
[vect_body
];
1246 *epilogue_cost
= cost
[vect_epilogue
];
1249 /* Free the cost data. */
1252 default_destroy_cost_data (void *data
)
1257 /* Determine whether or not a pointer mode is valid. Assume defaults
1258 of ptr_mode or Pmode - can be overridden. */
1260 default_valid_pointer_mode (machine_mode mode
)
1262 return (mode
== ptr_mode
|| mode
== Pmode
);
1265 /* Determine whether the memory reference specified by REF may alias
1266 the C libraries errno location. */
1268 default_ref_may_alias_errno (ao_ref
*ref
)
1270 tree base
= ao_ref_base (ref
);
1271 /* The default implementation assumes the errno location is
1272 a declaration of type int or is always accessed via a
1273 pointer to int. We assume that accesses to errno are
1274 not deliberately obfuscated (even in conforming ways). */
1275 if (TYPE_UNSIGNED (TREE_TYPE (base
))
1276 || TYPE_MODE (TREE_TYPE (base
)) != TYPE_MODE (integer_type_node
))
1278 /* The default implementation assumes an errno location
1279 declaration is never defined in the current compilation unit. */
1281 && !TREE_STATIC (base
))
1283 else if (TREE_CODE (base
) == MEM_REF
1284 && TREE_CODE (TREE_OPERAND (base
, 0)) == SSA_NAME
)
1286 struct ptr_info_def
*pi
= SSA_NAME_PTR_INFO (TREE_OPERAND (base
, 0));
1287 return !pi
|| pi
->pt
.anything
|| pi
->pt
.nonlocal
;
1292 /* Return the mode for a pointer to a given ADDRSPACE,
1293 defaulting to ptr_mode for all address spaces. */
1296 default_addr_space_pointer_mode (addr_space_t addrspace ATTRIBUTE_UNUSED
)
1301 /* Return the mode for an address in a given ADDRSPACE,
1302 defaulting to Pmode for all address spaces. */
1305 default_addr_space_address_mode (addr_space_t addrspace ATTRIBUTE_UNUSED
)
1310 /* Named address space version of valid_pointer_mode.
1311 To match the above, the same modes apply to all address spaces. */
1314 default_addr_space_valid_pointer_mode (machine_mode mode
,
1315 addr_space_t as ATTRIBUTE_UNUSED
)
1317 return targetm
.valid_pointer_mode (mode
);
1320 /* Some places still assume that all pointer or address modes are the
1321 standard Pmode and ptr_mode. These optimizations become invalid if
1322 the target actually supports multiple different modes. For now,
1323 we disable such optimizations on such targets, using this function. */
1326 target_default_pointer_address_modes_p (void)
1328 if (targetm
.addr_space
.address_mode
!= default_addr_space_address_mode
)
1330 if (targetm
.addr_space
.pointer_mode
!= default_addr_space_pointer_mode
)
1336 /* Named address space version of legitimate_address_p.
1337 By default, all address spaces have the same form. */
1340 default_addr_space_legitimate_address_p (machine_mode mode
, rtx mem
,
1342 addr_space_t as ATTRIBUTE_UNUSED
)
1344 return targetm
.legitimate_address_p (mode
, mem
, strict
);
1347 /* Named address space version of LEGITIMIZE_ADDRESS.
1348 By default, all address spaces have the same form. */
1351 default_addr_space_legitimize_address (rtx x
, rtx oldx
, machine_mode mode
,
1352 addr_space_t as ATTRIBUTE_UNUSED
)
1354 return targetm
.legitimize_address (x
, oldx
, mode
);
1357 /* The default hook for determining if one named address space is a subset of
1358 another and to return which address space to use as the common address
1362 default_addr_space_subset_p (addr_space_t subset
, addr_space_t superset
)
1364 return (subset
== superset
);
1367 /* The default hook for determining if 0 within a named address
1368 space is a valid address. */
1371 default_addr_space_zero_address_valid (addr_space_t as ATTRIBUTE_UNUSED
)
1376 /* The default hook for debugging the address space is to return the
1377 address space number to indicate DW_AT_address_class. */
1379 default_addr_space_debug (addr_space_t as
)
1384 /* The default hook implementation for TARGET_ADDR_SPACE_DIAGNOSE_USAGE.
1385 Don't complain about any address space. */
1388 default_addr_space_diagnose_usage (addr_space_t
, location_t
)
1393 /* The default hook for TARGET_ADDR_SPACE_CONVERT. This hook should never be
1394 called for targets with only a generic address space. */
1397 default_addr_space_convert (rtx op ATTRIBUTE_UNUSED
,
1398 tree from_type ATTRIBUTE_UNUSED
,
1399 tree to_type ATTRIBUTE_UNUSED
)
1405 default_hard_regno_scratch_ok (unsigned int regno ATTRIBUTE_UNUSED
)
1410 /* The default implementation of TARGET_MODE_DEPENDENT_ADDRESS_P. */
1413 default_mode_dependent_address_p (const_rtx addr ATTRIBUTE_UNUSED
,
1414 addr_space_t addrspace ATTRIBUTE_UNUSED
)
1420 default_target_option_valid_attribute_p (tree
ARG_UNUSED (fndecl
),
1421 tree
ARG_UNUSED (name
),
1422 tree
ARG_UNUSED (args
),
1423 int ARG_UNUSED (flags
))
1425 warning (OPT_Wattributes
,
1426 "target attribute is not supported on this machine");
1432 default_target_option_pragma_parse (tree
ARG_UNUSED (args
),
1433 tree
ARG_UNUSED (pop_target
))
1435 /* If args is NULL the caller is handle_pragma_pop_options (). In that case,
1436 emit no warning because "#pragma GCC pop_target" is valid on targets that
1437 do not have the "target" pragma. */
1439 warning (OPT_Wpragmas
,
1440 "#pragma GCC target is not supported for this machine");
1446 default_target_can_inline_p (tree caller
, tree callee
)
1449 tree callee_opts
= DECL_FUNCTION_SPECIFIC_TARGET (callee
);
1450 tree caller_opts
= DECL_FUNCTION_SPECIFIC_TARGET (caller
);
1452 /* If callee has no option attributes, then it is ok to inline */
1456 /* If caller has no option attributes, but callee does then it is not ok to
1458 else if (!caller_opts
)
1461 /* If both caller and callee have attributes, assume that if the
1462 pointer is different, the two functions have different target
1463 options since build_target_option_node uses a hash table for the
1466 ret
= (callee_opts
== caller_opts
);
1471 /* If the machine does not have a case insn that compares the bounds,
1472 this means extra overhead for dispatch tables, which raises the
1473 threshold for using them. */
1476 default_case_values_threshold (void)
1478 return (targetm
.have_casesi () ? 4 : 5);
1482 default_have_conditional_execution (void)
1484 return HAVE_conditional_execution
;
1487 /* By default we assume that c99 functions are present at the runtime,
1488 but sincos is not. */
1490 default_libc_has_function (enum function_class fn_class
)
1492 if (fn_class
== function_c94
1493 || fn_class
== function_c99_misc
1494 || fn_class
== function_c99_math_complex
)
1501 gnu_libc_has_function (enum function_class fn_class ATTRIBUTE_UNUSED
)
1507 no_c99_libc_has_function (enum function_class fn_class ATTRIBUTE_UNUSED
)
1512 /* Return the format string to which "%p" corresponds. By default,
1513 assume it corresponds to the C99 "%zx" format and set *FLAGS to
1514 the empty string to indicate that format flags have no effect.
1515 An example of an implementation that matches this description
1519 default_printf_pointer_format (tree
, const char **flags
)
1527 default_builtin_tm_load_store (tree
ARG_UNUSED (type
))
1532 /* Compute cost of moving registers to/from memory. */
1535 default_memory_move_cost (machine_mode mode ATTRIBUTE_UNUSED
,
1536 reg_class_t rclass ATTRIBUTE_UNUSED
,
1537 bool in ATTRIBUTE_UNUSED
)
1539 #ifndef MEMORY_MOVE_COST
1540 return (4 + memory_move_secondary_cost (mode
, (enum reg_class
) rclass
, in
));
1542 return MEMORY_MOVE_COST (mode
, (enum reg_class
) rclass
, in
);
1546 /* Compute cost of moving data from a register of class FROM to one of
1550 default_register_move_cost (machine_mode mode ATTRIBUTE_UNUSED
,
1551 reg_class_t from ATTRIBUTE_UNUSED
,
1552 reg_class_t to ATTRIBUTE_UNUSED
)
1554 #ifndef REGISTER_MOVE_COST
1557 return REGISTER_MOVE_COST (mode
, (enum reg_class
) from
, (enum reg_class
) to
);
1561 /* For hooks which use the MOVE_RATIO macro, this gives the legacy default
1562 behavior. SPEED_P is true if we are compiling for speed. */
1565 get_move_ratio (bool speed_p ATTRIBUTE_UNUSED
)
1567 unsigned int move_ratio
;
1569 move_ratio
= (unsigned int) MOVE_RATIO (speed_p
);
1571 #if defined (HAVE_movmemqi) || defined (HAVE_movmemhi) || defined (HAVE_movmemsi) || defined (HAVE_movmemdi) || defined (HAVE_movmemti)
1573 #else /* No movmem patterns, pick a default. */
1574 move_ratio
= ((speed_p
) ? 15 : 3);
1580 /* Return TRUE if the move_by_pieces/set_by_pieces infrastructure should be
1581 used; return FALSE if the movmem/setmem optab should be expanded, or
1582 a call to memcpy emitted. */
1585 default_use_by_pieces_infrastructure_p (unsigned HOST_WIDE_INT size
,
1586 unsigned int alignment
,
1587 enum by_pieces_operation op
,
1590 unsigned int max_size
= 0;
1591 unsigned int ratio
= 0;
1595 case CLEAR_BY_PIECES
:
1596 max_size
= STORE_MAX_PIECES
;
1597 ratio
= CLEAR_RATIO (speed_p
);
1599 case MOVE_BY_PIECES
:
1600 max_size
= MOVE_MAX_PIECES
;
1601 ratio
= get_move_ratio (speed_p
);
1604 max_size
= STORE_MAX_PIECES
;
1605 ratio
= SET_RATIO (speed_p
);
1607 case STORE_BY_PIECES
:
1608 max_size
= STORE_MAX_PIECES
;
1609 ratio
= get_move_ratio (speed_p
);
1611 case COMPARE_BY_PIECES
:
1612 max_size
= COMPARE_MAX_PIECES
;
1613 /* Pick a likely default, just as in get_move_ratio. */
1614 ratio
= speed_p
? 15 : 3;
1618 return by_pieces_ninsns (size
, alignment
, max_size
+ 1, op
) < ratio
;
1621 /* This hook controls code generation for expanding a memcmp operation by
1622 pieces. Return 1 for the normal pattern of compare/jump after each pair
1623 of loads, or a higher number to reduce the number of branches. */
1626 default_compare_by_pieces_branch_ratio (machine_mode
)
1632 default_profile_before_prologue (void)
1634 #ifdef PROFILE_BEFORE_PROLOGUE
1641 /* The default implementation of TARGET_PREFERRED_RELOAD_CLASS. */
1644 default_preferred_reload_class (rtx x ATTRIBUTE_UNUSED
,
1647 #ifdef PREFERRED_RELOAD_CLASS
1648 return (reg_class_t
) PREFERRED_RELOAD_CLASS (x
, (enum reg_class
) rclass
);
1654 /* The default implementation of TARGET_OUTPUT_PREFERRED_RELOAD_CLASS. */
1657 default_preferred_output_reload_class (rtx x ATTRIBUTE_UNUSED
,
1663 /* The default implementation of TARGET_PREFERRED_RENAME_CLASS. */
1665 default_preferred_rename_class (reg_class_t rclass ATTRIBUTE_UNUSED
)
1670 /* The default implementation of TARGET_CLASS_LIKELY_SPILLED_P. */
1673 default_class_likely_spilled_p (reg_class_t rclass
)
1675 return (reg_class_size
[(int) rclass
] == 1);
1678 /* The default implementation of TARGET_CLASS_MAX_NREGS. */
1681 default_class_max_nregs (reg_class_t rclass ATTRIBUTE_UNUSED
,
1682 machine_mode mode ATTRIBUTE_UNUSED
)
1684 #ifdef CLASS_MAX_NREGS
1685 return (unsigned char) CLASS_MAX_NREGS ((enum reg_class
) rclass
, mode
);
1687 return ((GET_MODE_SIZE (mode
) + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
);
1691 /* Determine the debugging unwind mechanism for the target. */
1693 enum unwind_info_type
1694 default_debug_unwind_info (void)
1696 /* If the target wants to force the use of dwarf2 unwind info, let it. */
1697 /* ??? Change all users to the hook, then poison this. */
1698 #ifdef DWARF2_FRAME_INFO
1699 if (DWARF2_FRAME_INFO
)
1703 /* Otherwise, only turn it on if dwarf2 debugging is enabled. */
1704 #ifdef DWARF2_DEBUGGING_INFO
1705 if (write_symbols
== DWARF2_DEBUG
|| write_symbols
== VMS_AND_DWARF2_DEBUG
)
1712 /* Determine the correct mode for a Dwarf frame register that represents
1716 default_dwarf_frame_reg_mode (int regno
)
1718 machine_mode save_mode
= reg_raw_mode
[regno
];
1720 if (HARD_REGNO_CALL_PART_CLOBBERED (regno
, save_mode
))
1721 save_mode
= choose_hard_reg_mode (regno
, 1, true);
1725 /* To be used by targets where reg_raw_mode doesn't return the right
1726 mode for registers used in apply_builtin_return and apply_builtin_arg. */
1729 default_get_reg_raw_mode (int regno
)
1731 return reg_raw_mode
[regno
];
1734 /* Return true if a leaf function should stay leaf even with profiling
1738 default_keep_leaf_when_profiled ()
1743 /* Return true if the state of option OPTION should be stored in PCH files
1744 and checked by default_pch_valid_p. Store the option's current state
1748 option_affects_pch_p (int option
, struct cl_option_state
*state
)
1750 if ((cl_options
[option
].flags
& CL_TARGET
) == 0)
1752 if ((cl_options
[option
].flags
& CL_PCH_IGNORE
) != 0)
1754 if (option_flag_var (option
, &global_options
) == &target_flags
)
1755 if (targetm
.check_pch_target_flags
)
1757 return get_option_state (&global_options
, option
, state
);
1760 /* Default version of get_pch_validity.
1761 By default, every flag difference is fatal; that will be mostly right for
1762 most targets, but completely right for very few. */
1765 default_get_pch_validity (size_t *sz
)
1767 struct cl_option_state state
;
1772 if (targetm
.check_pch_target_flags
)
1773 *sz
+= sizeof (target_flags
);
1774 for (i
= 0; i
< cl_options_count
; i
++)
1775 if (option_affects_pch_p (i
, &state
))
1778 result
= r
= XNEWVEC (char, *sz
);
1782 if (targetm
.check_pch_target_flags
)
1784 memcpy (r
, &target_flags
, sizeof (target_flags
));
1785 r
+= sizeof (target_flags
);
1788 for (i
= 0; i
< cl_options_count
; i
++)
1789 if (option_affects_pch_p (i
, &state
))
1791 memcpy (r
, state
.data
, state
.size
);
1798 /* Return a message which says that a PCH file was created with a different
1799 setting of OPTION. */
1802 pch_option_mismatch (const char *option
)
1804 return xasprintf (_("created and used with differing settings of '%s'"),
1808 /* Default version of pch_valid_p. */
1811 default_pch_valid_p (const void *data_p
, size_t len
)
1813 struct cl_option_state state
;
1814 const char *data
= (const char *)data_p
;
1817 /* -fpic and -fpie also usually make a PCH invalid. */
1818 if (data
[0] != flag_pic
)
1819 return _("created and used with different settings of -fpic");
1820 if (data
[1] != flag_pie
)
1821 return _("created and used with different settings of -fpie");
1824 /* Check target_flags. */
1825 if (targetm
.check_pch_target_flags
)
1830 memcpy (&tf
, data
, sizeof (target_flags
));
1831 data
+= sizeof (target_flags
);
1832 len
-= sizeof (target_flags
);
1833 r
= targetm
.check_pch_target_flags (tf
);
1838 for (i
= 0; i
< cl_options_count
; i
++)
1839 if (option_affects_pch_p (i
, &state
))
1841 if (memcmp (data
, state
.data
, state
.size
) != 0)
1842 return pch_option_mismatch (cl_options
[i
].opt_text
);
1850 /* Default version of cstore_mode. */
1853 default_cstore_mode (enum insn_code icode
)
1855 return insn_data
[(int) icode
].operand
[0].mode
;
1858 /* Default version of member_type_forces_blk. */
1861 default_member_type_forces_blk (const_tree
, machine_mode
)
1867 default_load_bounds_for_arg (rtx addr ATTRIBUTE_UNUSED
,
1868 rtx ptr ATTRIBUTE_UNUSED
,
1869 rtx bnd ATTRIBUTE_UNUSED
)
1875 default_store_bounds_for_arg (rtx val ATTRIBUTE_UNUSED
,
1876 rtx addr ATTRIBUTE_UNUSED
,
1877 rtx bounds ATTRIBUTE_UNUSED
,
1878 rtx to ATTRIBUTE_UNUSED
)
1884 default_load_returned_bounds (rtx slot ATTRIBUTE_UNUSED
)
1890 default_store_returned_bounds (rtx slot ATTRIBUTE_UNUSED
,
1891 rtx bounds ATTRIBUTE_UNUSED
)
1896 /* Default version of canonicalize_comparison. */
1899 default_canonicalize_comparison (int *, rtx
*, rtx
*, bool)
1903 /* Default implementation of TARGET_ATOMIC_ASSIGN_EXPAND_FENV. */
1906 default_atomic_assign_expand_fenv (tree
*, tree
*, tree
*)
1910 #ifndef PAD_VARARGS_DOWN
1911 #define PAD_VARARGS_DOWN BYTES_BIG_ENDIAN
1914 /* Build an indirect-ref expression over the given TREE, which represents a
1915 piece of a va_arg() expansion. */
1917 build_va_arg_indirect_ref (tree addr
)
1919 addr
= build_simple_mem_ref_loc (EXPR_LOCATION (addr
), addr
);
1923 /* The "standard" implementation of va_arg: read the value from the
1924 current (padded) address and increment by the (padded) size. */
1927 std_gimplify_va_arg_expr (tree valist
, tree type
, gimple_seq
*pre_p
,
1930 tree addr
, t
, type_size
, rounded_size
, valist_tmp
;
1931 unsigned HOST_WIDE_INT align
, boundary
;
1934 /* All of the alignment and movement below is for args-grow-up machines.
1935 As of 2004, there are only 3 ARGS_GROW_DOWNWARD targets, and they all
1936 implement their own specialized gimplify_va_arg_expr routines. */
1937 if (ARGS_GROW_DOWNWARD
)
1940 indirect
= pass_by_reference (NULL
, TYPE_MODE (type
), type
, false);
1942 type
= build_pointer_type (type
);
1944 align
= PARM_BOUNDARY
/ BITS_PER_UNIT
;
1945 boundary
= targetm
.calls
.function_arg_boundary (TYPE_MODE (type
), type
);
1947 /* When we align parameter on stack for caller, if the parameter
1948 alignment is beyond MAX_SUPPORTED_STACK_ALIGNMENT, it will be
1949 aligned at MAX_SUPPORTED_STACK_ALIGNMENT. We will match callee
1950 here with caller. */
1951 if (boundary
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1952 boundary
= MAX_SUPPORTED_STACK_ALIGNMENT
;
1954 boundary
/= BITS_PER_UNIT
;
1956 /* Hoist the valist value into a temporary for the moment. */
1957 valist_tmp
= get_initialized_tmp_var (valist
, pre_p
, NULL
);
1959 /* va_list pointer is aligned to PARM_BOUNDARY. If argument actually
1960 requires greater alignment, we must perform dynamic alignment. */
1961 if (boundary
> align
1962 && !integer_zerop (TYPE_SIZE (type
)))
1964 t
= build2 (MODIFY_EXPR
, TREE_TYPE (valist
), valist_tmp
,
1965 fold_build_pointer_plus_hwi (valist_tmp
, boundary
- 1));
1966 gimplify_and_add (t
, pre_p
);
1968 t
= build2 (MODIFY_EXPR
, TREE_TYPE (valist
), valist_tmp
,
1969 fold_build2 (BIT_AND_EXPR
, TREE_TYPE (valist
),
1971 build_int_cst (TREE_TYPE (valist
), -boundary
)));
1972 gimplify_and_add (t
, pre_p
);
1977 /* If the actual alignment is less than the alignment of the type,
1978 adjust the type accordingly so that we don't assume strict alignment
1979 when dereferencing the pointer. */
1980 boundary
*= BITS_PER_UNIT
;
1981 if (boundary
< TYPE_ALIGN (type
))
1983 type
= build_variant_type_copy (type
);
1984 SET_TYPE_ALIGN (type
, boundary
);
1987 /* Compute the rounded size of the type. */
1988 type_size
= size_in_bytes (type
);
1989 rounded_size
= round_up (type_size
, align
);
1991 /* Reduce rounded_size so it's sharable with the postqueue. */
1992 gimplify_expr (&rounded_size
, pre_p
, post_p
, is_gimple_val
, fb_rvalue
);
1996 if (PAD_VARARGS_DOWN
&& !integer_zerop (rounded_size
))
1998 /* Small args are padded downward. */
1999 t
= fold_build2_loc (input_location
, GT_EXPR
, sizetype
,
2000 rounded_size
, size_int (align
));
2001 t
= fold_build3 (COND_EXPR
, sizetype
, t
, size_zero_node
,
2002 size_binop (MINUS_EXPR
, rounded_size
, type_size
));
2003 addr
= fold_build_pointer_plus (addr
, t
);
2006 /* Compute new value for AP. */
2007 t
= fold_build_pointer_plus (valist_tmp
, rounded_size
);
2008 t
= build2 (MODIFY_EXPR
, TREE_TYPE (valist
), valist
, t
);
2009 gimplify_and_add (t
, pre_p
);
2011 addr
= fold_convert (build_pointer_type (type
), addr
);
2014 addr
= build_va_arg_indirect_ref (addr
);
2016 return build_va_arg_indirect_ref (addr
);
2020 default_chkp_bound_type (void)
2022 tree res
= make_node (POINTER_BOUNDS_TYPE
);
2023 TYPE_PRECISION (res
) = TYPE_PRECISION (size_type_node
) * 2;
2024 TYPE_NAME (res
) = get_identifier ("__bounds_type");
2025 SET_TYPE_MODE (res
, targetm
.chkp_bound_mode ());
2031 default_chkp_bound_mode (void)
2037 default_builtin_chkp_function (unsigned int fcode ATTRIBUTE_UNUSED
)
2043 default_chkp_function_value_bounds (const_tree ret_type ATTRIBUTE_UNUSED
,
2044 const_tree fn_decl_or_type ATTRIBUTE_UNUSED
,
2045 bool outgoing ATTRIBUTE_UNUSED
)
2051 default_chkp_make_bounds_constant (HOST_WIDE_INT lb ATTRIBUTE_UNUSED
,
2052 HOST_WIDE_INT ub ATTRIBUTE_UNUSED
)
2058 default_chkp_initialize_bounds (tree var ATTRIBUTE_UNUSED
,
2059 tree lb ATTRIBUTE_UNUSED
,
2060 tree ub ATTRIBUTE_UNUSED
,
2061 tree
*stmts ATTRIBUTE_UNUSED
)
2067 default_setup_incoming_vararg_bounds (cumulative_args_t ca ATTRIBUTE_UNUSED
,
2068 enum machine_mode mode ATTRIBUTE_UNUSED
,
2069 tree type ATTRIBUTE_UNUSED
,
2070 int *pretend_arg_size ATTRIBUTE_UNUSED
,
2071 int second_time ATTRIBUTE_UNUSED
)
2075 /* An implementation of TARGET_CAN_USE_DOLOOP_P for targets that do
2076 not support nested low-overhead loops. */
2079 can_use_doloop_if_innermost (const widest_int
&, const widest_int
&,
2080 unsigned int loop_depth
, bool)
2082 return loop_depth
== 1;
2085 /* Default implementation of TARGET_OPTAB_SUPPORTED_P. */
2088 default_optab_supported_p (int, machine_mode
, machine_mode
, optimization_type
)
2093 /* Default implementation of TARGET_MAX_NOCE_IFCVT_SEQ_COST. */
2096 default_max_noce_ifcvt_seq_cost (edge e
)
2098 bool predictable_p
= predictable_edge_p (e
);
2100 enum compiler_param param
2102 ? PARAM_MAX_RTL_IF_CONVERSION_PREDICTABLE_COST
2103 : PARAM_MAX_RTL_IF_CONVERSION_UNPREDICTABLE_COST
);
2105 /* If we have a parameter set, use that, otherwise take a guess using
2107 if (global_options_set
.x_param_values
[param
])
2108 return PARAM_VALUE (param
);
2110 return BRANCH_COST (true, predictable_p
) * COSTS_N_INSNS (3);
2113 #include "gt-targhooks.h"