1 /* Default target hook functions.
2 Copyright (C) 2003-2015 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"
61 #include "fold-const.h"
62 #include "stor-layout.h"
65 #include "hard-reg-set.h"
68 #include "statistics.h"
69 #include "insn-config.h"
78 #include "diagnostic-core.h"
81 #include "target-def.h"
84 #include "insn-codes.h"
89 #include "tree-ssa-alias.h"
90 #include "gimple-expr.h"
92 #include "stringpool.h"
93 #include "tree-ssanames.h"
97 default_legitimate_address_p (machine_mode mode ATTRIBUTE_UNUSED
,
98 rtx addr ATTRIBUTE_UNUSED
,
99 bool strict ATTRIBUTE_UNUSED
)
101 #ifdef GO_IF_LEGITIMATE_ADDRESS
102 /* Defer to the old implementation using a goto. */
104 return strict_memory_address_p (mode
, addr
);
106 return memory_address_p (mode
, addr
);
113 default_external_libcall (rtx fun ATTRIBUTE_UNUSED
)
115 #ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
116 ASM_OUTPUT_EXTERNAL_LIBCALL (asm_out_file
, fun
);
121 default_unspec_may_trap_p (const_rtx x
, unsigned flags
)
125 /* Any floating arithmetic may trap. */
126 if ((SCALAR_FLOAT_MODE_P (GET_MODE (x
)) && flag_trapping_math
))
129 for (i
= 0; i
< XVECLEN (x
, 0); ++i
)
131 if (may_trap_p_1 (XVECEXP (x
, 0, i
), flags
))
139 default_promote_function_mode (const_tree type ATTRIBUTE_UNUSED
,
141 int *punsignedp ATTRIBUTE_UNUSED
,
142 const_tree funtype ATTRIBUTE_UNUSED
,
143 int for_return ATTRIBUTE_UNUSED
)
145 if (type
!= NULL_TREE
&& for_return
== 2)
146 return promote_mode (type
, mode
, punsignedp
);
151 default_promote_function_mode_always_promote (const_tree type
,
154 const_tree funtype ATTRIBUTE_UNUSED
,
155 int for_return ATTRIBUTE_UNUSED
)
157 return promote_mode (type
, mode
, punsignedp
);
161 default_cc_modes_compatible (machine_mode m1
, machine_mode m2
)
169 default_return_in_memory (const_tree type
,
170 const_tree fntype ATTRIBUTE_UNUSED
)
172 return (TYPE_MODE (type
) == BLKmode
);
176 default_legitimize_address (rtx x
, rtx orig_x ATTRIBUTE_UNUSED
,
177 machine_mode mode ATTRIBUTE_UNUSED
)
183 default_legitimize_address_displacement (rtx
*disp ATTRIBUTE_UNUSED
,
184 rtx
*offset ATTRIBUTE_UNUSED
,
185 machine_mode mode ATTRIBUTE_UNUSED
)
191 default_expand_builtin_saveregs (void)
193 error ("__builtin_saveregs not supported by this target");
198 default_setup_incoming_varargs (cumulative_args_t ca ATTRIBUTE_UNUSED
,
199 machine_mode mode ATTRIBUTE_UNUSED
,
200 tree type ATTRIBUTE_UNUSED
,
201 int *pretend_arg_size ATTRIBUTE_UNUSED
,
202 int second_time ATTRIBUTE_UNUSED
)
206 /* The default implementation of TARGET_BUILTIN_SETJMP_FRAME_VALUE. */
209 default_builtin_setjmp_frame_value (void)
211 return virtual_stack_vars_rtx
;
214 /* Generic hook that takes a CUMULATIVE_ARGS pointer and returns false. */
217 hook_bool_CUMULATIVE_ARGS_false (cumulative_args_t ca ATTRIBUTE_UNUSED
)
223 default_pretend_outgoing_varargs_named (cumulative_args_t ca ATTRIBUTE_UNUSED
)
225 return (targetm
.calls
.setup_incoming_varargs
226 != default_setup_incoming_varargs
);
230 default_eh_return_filter_mode (void)
232 return targetm
.unwind_word_mode ();
236 default_libgcc_cmp_return_mode (void)
242 default_libgcc_shift_count_mode (void)
248 default_unwind_word_mode (void)
253 /* The default implementation of TARGET_SHIFT_TRUNCATION_MASK. */
255 unsigned HOST_WIDE_INT
256 default_shift_truncation_mask (machine_mode mode
)
258 return SHIFT_COUNT_TRUNCATED
? GET_MODE_BITSIZE (mode
) - 1 : 0;
261 /* The default implementation of TARGET_MIN_DIVISIONS_FOR_RECIP_MUL. */
264 default_min_divisions_for_recip_mul (machine_mode mode ATTRIBUTE_UNUSED
)
266 return have_insn_for (DIV
, mode
) ? 3 : 2;
269 /* The default implementation of TARGET_MODE_REP_EXTENDED. */
272 default_mode_rep_extended (machine_mode mode ATTRIBUTE_UNUSED
,
273 machine_mode mode_rep ATTRIBUTE_UNUSED
)
278 /* Generic hook that takes a CUMULATIVE_ARGS pointer and returns true. */
281 hook_bool_CUMULATIVE_ARGS_true (cumulative_args_t a ATTRIBUTE_UNUSED
)
286 /* Return machine mode for non-standard suffix
287 or VOIDmode if non-standard suffixes are unsupported. */
289 default_mode_for_suffix (char suffix ATTRIBUTE_UNUSED
)
294 /* The generic C++ ABI specifies this is a 64-bit value. */
296 default_cxx_guard_type (void)
298 return long_long_integer_type_node
;
301 /* Returns the size of the cookie to use when allocating an array
302 whose elements have the indicated TYPE. Assumes that it is already
303 known that a cookie is needed. */
306 default_cxx_get_cookie_size (tree type
)
310 /* We need to allocate an additional max (sizeof (size_t), alignof
311 (true_type)) bytes. */
315 sizetype_size
= size_in_bytes (sizetype
);
316 type_align
= size_int (TYPE_ALIGN_UNIT (type
));
317 if (tree_int_cst_lt (type_align
, sizetype_size
))
318 cookie_size
= sizetype_size
;
320 cookie_size
= type_align
;
325 /* Return true if a parameter must be passed by reference. This version
326 of the TARGET_PASS_BY_REFERENCE hook uses just MUST_PASS_IN_STACK. */
329 hook_pass_by_reference_must_pass_in_stack (cumulative_args_t c ATTRIBUTE_UNUSED
,
330 machine_mode mode ATTRIBUTE_UNUSED
, const_tree type ATTRIBUTE_UNUSED
,
331 bool named_arg ATTRIBUTE_UNUSED
)
333 return targetm
.calls
.must_pass_in_stack (mode
, type
);
336 /* Return true if a parameter follows callee copies conventions. This
337 version of the hook is true for all named arguments. */
340 hook_callee_copies_named (cumulative_args_t ca ATTRIBUTE_UNUSED
,
341 machine_mode mode ATTRIBUTE_UNUSED
,
342 const_tree type ATTRIBUTE_UNUSED
, bool named
)
347 /* Emit to STREAM the assembler syntax for insn operand X. */
350 default_print_operand (FILE *stream ATTRIBUTE_UNUSED
, rtx x ATTRIBUTE_UNUSED
,
351 int code ATTRIBUTE_UNUSED
)
354 PRINT_OPERAND (stream
, x
, code
);
360 /* Emit to STREAM the assembler syntax for an insn operand whose memory
364 default_print_operand_address (FILE *stream ATTRIBUTE_UNUSED
,
365 rtx x ATTRIBUTE_UNUSED
)
367 #ifdef PRINT_OPERAND_ADDRESS
368 PRINT_OPERAND_ADDRESS (stream
, x
);
374 /* Return true if CODE is a valid punctuation character for the
375 `print_operand' hook. */
378 default_print_operand_punct_valid_p (unsigned char code ATTRIBUTE_UNUSED
)
380 #ifdef PRINT_OPERAND_PUNCT_VALID_P
381 return PRINT_OPERAND_PUNCT_VALID_P (code
);
387 /* The default implementation of TARGET_MANGLE_ASSEMBLER_NAME. */
389 default_mangle_assembler_name (const char *name ATTRIBUTE_UNUSED
)
391 const char *skipped
= name
+ (*name
== '*' ? 1 : 0);
392 const char *stripped
= targetm
.strip_name_encoding (skipped
);
393 if (*name
!= '*' && user_label_prefix
[0])
394 stripped
= ACONCAT ((user_label_prefix
, stripped
, NULL
));
395 return get_identifier (stripped
);
398 /* True if MODE is valid for the target. By "valid", we mean able to
399 be manipulated in non-trivial ways. In particular, this means all
400 the arithmetic is supported.
402 By default we guess this means that any C type is supported. If
403 we can't map the mode back to a type that would be available in C,
404 then reject it. Special case, here, is the double-word arithmetic
405 supported by optabs.c. */
408 default_scalar_mode_supported_p (machine_mode mode
)
410 int precision
= GET_MODE_PRECISION (mode
);
412 switch (GET_MODE_CLASS (mode
))
414 case MODE_PARTIAL_INT
:
416 if (precision
== CHAR_TYPE_SIZE
)
418 if (precision
== SHORT_TYPE_SIZE
)
420 if (precision
== INT_TYPE_SIZE
)
422 if (precision
== LONG_TYPE_SIZE
)
424 if (precision
== LONG_LONG_TYPE_SIZE
)
426 if (precision
== 2 * BITS_PER_WORD
)
431 if (precision
== FLOAT_TYPE_SIZE
)
433 if (precision
== DOUBLE_TYPE_SIZE
)
435 if (precision
== LONG_DOUBLE_TYPE_SIZE
)
439 case MODE_DECIMAL_FLOAT
:
451 /* Return true if libgcc supports floating-point mode MODE (known to
452 be supported as a scalar mode). */
455 default_libgcc_floating_mode_supported_p (machine_mode mode
)
478 /* Make some target macros useable by target-independent code. */
480 targhook_words_big_endian (void)
482 return !!WORDS_BIG_ENDIAN
;
486 targhook_float_words_big_endian (void)
488 return !!FLOAT_WORDS_BIG_ENDIAN
;
491 /* True if the target supports floating-point exceptions and rounding
495 default_float_exceptions_rounding_supported_p (void)
504 /* True if the target supports decimal floating point. */
507 default_decimal_float_supported_p (void)
509 return ENABLE_DECIMAL_FLOAT
;
512 /* True if the target supports fixed-point arithmetic. */
515 default_fixed_point_supported_p (void)
517 return ENABLE_FIXED_POINT
;
520 /* True if the target supports GNU indirect functions. */
523 default_has_ifunc_p (void)
525 return HAVE_GNU_INDIRECT_FUNCTION
;
528 /* NULL if INSN insn is valid within a low-overhead loop, otherwise returns
531 This function checks whether a given INSN is valid within a low-overhead
532 loop. If INSN is invalid it returns the reason for that, otherwise it
533 returns NULL. A called function may clobber any special registers required
534 for low-overhead looping. Additionally, some targets (eg, PPC) use the count
535 register for branch on table instructions. We reject the doloop pattern in
539 default_invalid_within_doloop (const rtx_insn
*insn
)
542 return "Function call in loop.";
544 if (tablejump_p (insn
, NULL
, NULL
) || computed_jump_p (insn
))
545 return "Computed branch in the loop.";
550 /* Mapping of builtin functions to vectorized variants. */
553 default_builtin_vectorized_function (tree fndecl ATTRIBUTE_UNUSED
,
554 tree type_out ATTRIBUTE_UNUSED
,
555 tree type_in ATTRIBUTE_UNUSED
)
560 /* Vectorized conversion. */
563 default_builtin_vectorized_conversion (unsigned int code ATTRIBUTE_UNUSED
,
564 tree dest_type ATTRIBUTE_UNUSED
,
565 tree src_type ATTRIBUTE_UNUSED
)
570 /* Default vectorizer cost model values. */
573 default_builtin_vectorization_cost (enum vect_cost_for_stmt type_of_cost
,
575 int misalign ATTRIBUTE_UNUSED
)
579 switch (type_of_cost
)
589 case cond_branch_not_taken
:
591 case vec_promote_demote
:
595 case unaligned_store
:
598 case cond_branch_taken
:
602 elements
= TYPE_VECTOR_SUBPARTS (vectype
);
603 return elements
/ 2 + 1;
613 default_builtin_reciprocal (unsigned int fn ATTRIBUTE_UNUSED
,
614 bool md_fn ATTRIBUTE_UNUSED
,
615 bool sqrt ATTRIBUTE_UNUSED
)
621 hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false (
622 cumulative_args_t ca ATTRIBUTE_UNUSED
,
623 machine_mode mode ATTRIBUTE_UNUSED
,
624 const_tree type ATTRIBUTE_UNUSED
, bool named ATTRIBUTE_UNUSED
)
630 hook_bool_CUMULATIVE_ARGS_mode_tree_bool_true (
631 cumulative_args_t ca ATTRIBUTE_UNUSED
,
632 machine_mode mode ATTRIBUTE_UNUSED
,
633 const_tree type ATTRIBUTE_UNUSED
, bool named ATTRIBUTE_UNUSED
)
639 hook_int_CUMULATIVE_ARGS_mode_tree_bool_0 (
640 cumulative_args_t ca ATTRIBUTE_UNUSED
,
641 machine_mode mode ATTRIBUTE_UNUSED
,
642 tree type ATTRIBUTE_UNUSED
, bool named ATTRIBUTE_UNUSED
)
648 default_function_arg_advance (cumulative_args_t ca ATTRIBUTE_UNUSED
,
649 machine_mode mode ATTRIBUTE_UNUSED
,
650 const_tree type ATTRIBUTE_UNUSED
,
651 bool named ATTRIBUTE_UNUSED
)
657 default_function_arg (cumulative_args_t ca ATTRIBUTE_UNUSED
,
658 machine_mode mode ATTRIBUTE_UNUSED
,
659 const_tree type ATTRIBUTE_UNUSED
,
660 bool named ATTRIBUTE_UNUSED
)
666 default_function_incoming_arg (cumulative_args_t ca ATTRIBUTE_UNUSED
,
667 machine_mode mode ATTRIBUTE_UNUSED
,
668 const_tree type ATTRIBUTE_UNUSED
,
669 bool named ATTRIBUTE_UNUSED
)
675 default_function_arg_boundary (machine_mode mode ATTRIBUTE_UNUSED
,
676 const_tree type ATTRIBUTE_UNUSED
)
678 return PARM_BOUNDARY
;
682 default_function_arg_round_boundary (machine_mode mode ATTRIBUTE_UNUSED
,
683 const_tree type ATTRIBUTE_UNUSED
)
685 return PARM_BOUNDARY
;
689 hook_void_bitmap (bitmap regs ATTRIBUTE_UNUSED
)
694 hook_invalid_arg_for_unprototyped_fn (
695 const_tree typelist ATTRIBUTE_UNUSED
,
696 const_tree funcdecl ATTRIBUTE_UNUSED
,
697 const_tree val ATTRIBUTE_UNUSED
)
702 /* Initialize the stack protection decls. */
704 /* Stack protection related decls living in libgcc. */
705 static GTY(()) tree stack_chk_guard_decl
;
708 default_stack_protect_guard (void)
710 tree t
= stack_chk_guard_decl
;
716 t
= build_decl (UNKNOWN_LOCATION
,
717 VAR_DECL
, get_identifier ("__stack_chk_guard"),
721 DECL_EXTERNAL (t
) = 1;
723 TREE_THIS_VOLATILE (t
) = 1;
724 DECL_ARTIFICIAL (t
) = 1;
725 DECL_IGNORED_P (t
) = 1;
727 /* Do not share RTL as the declaration is visible outside of
730 RTX_FLAG (x
, used
) = 1;
732 stack_chk_guard_decl
= t
;
738 static GTY(()) tree stack_chk_fail_decl
;
741 default_external_stack_protect_fail (void)
743 tree t
= stack_chk_fail_decl
;
747 t
= build_function_type_list (void_type_node
, NULL_TREE
);
748 t
= build_decl (UNKNOWN_LOCATION
,
749 FUNCTION_DECL
, get_identifier ("__stack_chk_fail"), t
);
752 DECL_EXTERNAL (t
) = 1;
754 TREE_THIS_VOLATILE (t
) = 1;
755 TREE_NOTHROW (t
) = 1;
756 DECL_ARTIFICIAL (t
) = 1;
757 DECL_IGNORED_P (t
) = 1;
758 DECL_VISIBILITY (t
) = VISIBILITY_DEFAULT
;
759 DECL_VISIBILITY_SPECIFIED (t
) = 1;
761 stack_chk_fail_decl
= t
;
764 return build_call_expr (t
, 0);
768 default_hidden_stack_protect_fail (void)
770 #ifndef HAVE_GAS_HIDDEN
771 return default_external_stack_protect_fail ();
773 tree t
= stack_chk_fail_decl
;
776 return default_external_stack_protect_fail ();
780 t
= build_function_type_list (void_type_node
, NULL_TREE
);
781 t
= build_decl (UNKNOWN_LOCATION
, FUNCTION_DECL
,
782 get_identifier ("__stack_chk_fail_local"), t
);
785 DECL_EXTERNAL (t
) = 1;
787 TREE_THIS_VOLATILE (t
) = 1;
788 TREE_NOTHROW (t
) = 1;
789 DECL_ARTIFICIAL (t
) = 1;
790 DECL_IGNORED_P (t
) = 1;
791 DECL_VISIBILITY_SPECIFIED (t
) = 1;
792 DECL_VISIBILITY (t
) = VISIBILITY_HIDDEN
;
794 stack_chk_fail_decl
= t
;
797 return build_call_expr (t
, 0);
802 hook_bool_const_rtx_commutative_p (const_rtx x
,
803 int outer_code ATTRIBUTE_UNUSED
)
805 return COMMUTATIVE_P (x
);
809 default_function_value (const_tree ret_type ATTRIBUTE_UNUSED
,
810 const_tree fn_decl_or_type
,
811 bool outgoing ATTRIBUTE_UNUSED
)
813 /* The old interface doesn't handle receiving the function type. */
815 && !DECL_P (fn_decl_or_type
))
816 fn_decl_or_type
= NULL
;
818 #ifdef FUNCTION_VALUE
819 return FUNCTION_VALUE (ret_type
, fn_decl_or_type
);
826 default_libcall_value (machine_mode mode ATTRIBUTE_UNUSED
,
827 const_rtx fun ATTRIBUTE_UNUSED
)
830 return LIBCALL_VALUE (mode
);
836 /* The default hook for TARGET_FUNCTION_VALUE_REGNO_P. */
839 default_function_value_regno_p (const unsigned int regno ATTRIBUTE_UNUSED
)
841 #ifdef FUNCTION_VALUE_REGNO_P
842 return FUNCTION_VALUE_REGNO_P (regno
);
849 default_internal_arg_pointer (void)
851 /* If the reg that the virtual arg pointer will be translated into is
852 not a fixed reg or is the stack pointer, make a copy of the virtual
853 arg pointer, and address parms via the copy. The frame pointer is
854 considered fixed even though it is not marked as such. */
855 if ((ARG_POINTER_REGNUM
== STACK_POINTER_REGNUM
856 || ! (fixed_regs
[ARG_POINTER_REGNUM
]
857 || ARG_POINTER_REGNUM
== FRAME_POINTER_REGNUM
)))
858 return copy_to_reg (virtual_incoming_args_rtx
);
860 return virtual_incoming_args_rtx
;
864 default_static_chain (const_tree
ARG_UNUSED (fndecl_or_type
), bool incoming_p
)
868 #ifdef STATIC_CHAIN_INCOMING_REGNUM
869 return gen_rtx_REG (Pmode
, STATIC_CHAIN_INCOMING_REGNUM
);
873 #ifdef STATIC_CHAIN_REGNUM
874 return gen_rtx_REG (Pmode
, STATIC_CHAIN_REGNUM
);
878 static bool issued_error
;
882 sorry ("nested functions not supported on this target");
885 /* It really doesn't matter what we return here, so long at it
886 doesn't cause the rest of the compiler to crash. */
887 return gen_rtx_MEM (Pmode
, stack_pointer_rtx
);
892 default_trampoline_init (rtx
ARG_UNUSED (m_tramp
), tree
ARG_UNUSED (t_func
),
893 rtx
ARG_UNUSED (r_chain
))
895 sorry ("nested function trampolines not supported on this target");
899 default_return_pops_args (tree fundecl ATTRIBUTE_UNUSED
,
900 tree funtype ATTRIBUTE_UNUSED
,
901 int size ATTRIBUTE_UNUSED
)
907 default_branch_target_register_class (void)
913 default_ira_change_pseudo_allocno_class (int regno ATTRIBUTE_UNUSED
,
926 default_register_priority (int hard_regno ATTRIBUTE_UNUSED
)
932 default_register_usage_leveling_p (void)
938 default_different_addr_displacement_p (void)
944 default_secondary_reload (bool in_p ATTRIBUTE_UNUSED
, rtx x ATTRIBUTE_UNUSED
,
945 reg_class_t reload_class_i ATTRIBUTE_UNUSED
,
946 machine_mode reload_mode ATTRIBUTE_UNUSED
,
947 secondary_reload_info
*sri
)
949 enum reg_class rclass
= NO_REGS
;
950 enum reg_class reload_class
= (enum reg_class
) reload_class_i
;
952 if (sri
->prev_sri
&& sri
->prev_sri
->t_icode
!= CODE_FOR_nothing
)
954 sri
->icode
= sri
->prev_sri
->t_icode
;
957 #ifdef SECONDARY_INPUT_RELOAD_CLASS
959 rclass
= SECONDARY_INPUT_RELOAD_CLASS (reload_class
, reload_mode
, x
);
961 #ifdef SECONDARY_OUTPUT_RELOAD_CLASS
963 rclass
= SECONDARY_OUTPUT_RELOAD_CLASS (reload_class
, reload_mode
, x
);
965 if (rclass
!= NO_REGS
)
968 = direct_optab_handler (in_p
? reload_in_optab
: reload_out_optab
,
971 if (icode
!= CODE_FOR_nothing
972 && !insn_operand_matches (icode
, in_p
, x
))
973 icode
= CODE_FOR_nothing
;
974 else if (icode
!= CODE_FOR_nothing
)
976 const char *insn_constraint
, *scratch_constraint
;
977 enum reg_class insn_class
, scratch_class
;
979 gcc_assert (insn_data
[(int) icode
].n_operands
== 3);
980 insn_constraint
= insn_data
[(int) icode
].operand
[!in_p
].constraint
;
981 if (!*insn_constraint
)
982 insn_class
= ALL_REGS
;
987 gcc_assert (*insn_constraint
== '=');
990 insn_class
= (reg_class_for_constraint
991 (lookup_constraint (insn_constraint
)));
992 gcc_assert (insn_class
!= NO_REGS
);
995 scratch_constraint
= insn_data
[(int) icode
].operand
[2].constraint
;
996 /* The scratch register's constraint must start with "=&",
997 except for an input reload, where only "=" is necessary,
998 and where it might be beneficial to re-use registers from
1000 gcc_assert (scratch_constraint
[0] == '='
1001 && (in_p
|| scratch_constraint
[1] == '&'));
1002 scratch_constraint
++;
1003 if (*scratch_constraint
== '&')
1004 scratch_constraint
++;
1005 scratch_class
= (reg_class_for_constraint
1006 (lookup_constraint (scratch_constraint
)));
1008 if (reg_class_subset_p (reload_class
, insn_class
))
1010 gcc_assert (scratch_class
== rclass
);
1014 rclass
= insn_class
;
1017 if (rclass
== NO_REGS
)
1020 sri
->t_icode
= icode
;
1025 /* By default, if flag_pic is true, then neither local nor global relocs
1026 should be placed in readonly memory. */
1029 default_reloc_rw_mask (void)
1031 return flag_pic
? 3 : 0;
1034 /* By default, do no modification. */
1035 tree
default_mangle_decl_assembler_name (tree decl ATTRIBUTE_UNUSED
,
1041 /* Default to natural alignment for vector types. */
1043 default_vector_alignment (const_tree type
)
1045 return tree_to_shwi (TYPE_SIZE (type
));
1049 default_builtin_vector_alignment_reachable (const_tree type
, bool is_packed
)
1054 /* Assuming that types whose size is > pointer-size are not guaranteed to be
1055 naturally aligned. */
1056 if (tree_int_cst_compare (TYPE_SIZE (type
), bitsize_int (POINTER_SIZE
)) > 0)
1059 /* Assuming that types whose size is <= pointer-size
1060 are naturally aligned. */
1064 /* By default, assume that a target supports any factor of misalignment
1065 memory access if it supports movmisalign patten.
1066 is_packed is true if the memory access is defined in a packed struct. */
1068 default_builtin_support_vector_misalignment (machine_mode mode
,
1076 if (optab_handler (movmisalign_optab
, mode
) != CODE_FOR_nothing
)
1081 /* By default, only attempt to parallelize bitwise operations, and
1082 possibly adds/subtracts using bit-twiddling. */
1085 default_preferred_simd_mode (machine_mode mode ATTRIBUTE_UNUSED
)
1090 /* By default only the size derived from the preferred vector mode
1094 default_autovectorize_vector_sizes (void)
1099 /* By default, the cost model accumulates three separate costs (prologue,
1100 loop body, and epilogue) for a vectorized loop or block. So allocate an
1101 array of three unsigned ints, set it to zero, and return its address. */
1104 default_init_cost (struct loop
*loop_info ATTRIBUTE_UNUSED
)
1106 unsigned *cost
= XNEWVEC (unsigned, 3);
1107 cost
[vect_prologue
] = cost
[vect_body
] = cost
[vect_epilogue
] = 0;
1111 /* By default, the cost model looks up the cost of the given statement
1112 kind and mode, multiplies it by the occurrence count, accumulates
1113 it into the cost specified by WHERE, and returns the cost added. */
1116 default_add_stmt_cost (void *data
, int count
, enum vect_cost_for_stmt kind
,
1117 struct _stmt_vec_info
*stmt_info
, int misalign
,
1118 enum vect_cost_model_location where
)
1120 unsigned *cost
= (unsigned *) data
;
1121 unsigned retval
= 0;
1123 tree vectype
= stmt_info
? stmt_vectype (stmt_info
) : NULL_TREE
;
1124 int stmt_cost
= targetm
.vectorize
.builtin_vectorization_cost (kind
, vectype
,
1126 /* Statements in an inner loop relative to the loop being
1127 vectorized are weighted more heavily. The value here is
1128 arbitrary and could potentially be improved with analysis. */
1129 if (where
== vect_body
&& stmt_info
&& stmt_in_inner_loop_p (stmt_info
))
1130 count
*= 50; /* FIXME. */
1132 retval
= (unsigned) (count
* stmt_cost
);
1133 cost
[where
] += retval
;
1138 /* By default, the cost model just returns the accumulated costs. */
1141 default_finish_cost (void *data
, unsigned *prologue_cost
,
1142 unsigned *body_cost
, unsigned *epilogue_cost
)
1144 unsigned *cost
= (unsigned *) data
;
1145 *prologue_cost
= cost
[vect_prologue
];
1146 *body_cost
= cost
[vect_body
];
1147 *epilogue_cost
= cost
[vect_epilogue
];
1150 /* Free the cost data. */
1153 default_destroy_cost_data (void *data
)
1158 /* Determine whether or not a pointer mode is valid. Assume defaults
1159 of ptr_mode or Pmode - can be overridden. */
1161 default_valid_pointer_mode (machine_mode mode
)
1163 return (mode
== ptr_mode
|| mode
== Pmode
);
1166 /* Determine whether the memory reference specified by REF may alias
1167 the C libraries errno location. */
1169 default_ref_may_alias_errno (ao_ref
*ref
)
1171 tree base
= ao_ref_base (ref
);
1172 /* The default implementation assumes the errno location is
1173 a declaration of type int or is always accessed via a
1174 pointer to int. We assume that accesses to errno are
1175 not deliberately obfuscated (even in conforming ways). */
1176 if (TYPE_UNSIGNED (TREE_TYPE (base
))
1177 || TYPE_MODE (TREE_TYPE (base
)) != TYPE_MODE (integer_type_node
))
1179 /* The default implementation assumes an errno location
1180 declaration is never defined in the current compilation unit. */
1182 && !TREE_STATIC (base
))
1184 else if (TREE_CODE (base
) == MEM_REF
1185 && TREE_CODE (TREE_OPERAND (base
, 0)) == SSA_NAME
)
1187 struct ptr_info_def
*pi
= SSA_NAME_PTR_INFO (TREE_OPERAND (base
, 0));
1188 return !pi
|| pi
->pt
.anything
|| pi
->pt
.nonlocal
;
1193 /* Return the mode for a pointer to a given ADDRSPACE, defaulting to ptr_mode
1194 for the generic address space only. */
1197 default_addr_space_pointer_mode (addr_space_t addrspace ATTRIBUTE_UNUSED
)
1199 gcc_assert (ADDR_SPACE_GENERIC_P (addrspace
));
1203 /* Return the mode for an address in a given ADDRSPACE, defaulting to Pmode
1204 for the generic address space only. */
1207 default_addr_space_address_mode (addr_space_t addrspace ATTRIBUTE_UNUSED
)
1209 gcc_assert (ADDR_SPACE_GENERIC_P (addrspace
));
1213 /* Named address space version of valid_pointer_mode. */
1216 default_addr_space_valid_pointer_mode (machine_mode mode
, addr_space_t as
)
1218 if (!ADDR_SPACE_GENERIC_P (as
))
1219 return (mode
== targetm
.addr_space
.pointer_mode (as
)
1220 || mode
== targetm
.addr_space
.address_mode (as
));
1222 return targetm
.valid_pointer_mode (mode
);
1225 /* Some places still assume that all pointer or address modes are the
1226 standard Pmode and ptr_mode. These optimizations become invalid if
1227 the target actually supports multiple different modes. For now,
1228 we disable such optimizations on such targets, using this function. */
1231 target_default_pointer_address_modes_p (void)
1233 if (targetm
.addr_space
.address_mode
!= default_addr_space_address_mode
)
1235 if (targetm
.addr_space
.pointer_mode
!= default_addr_space_pointer_mode
)
1241 /* Named address space version of legitimate_address_p. */
1244 default_addr_space_legitimate_address_p (machine_mode mode
, rtx mem
,
1245 bool strict
, addr_space_t as
)
1247 if (!ADDR_SPACE_GENERIC_P (as
))
1250 return targetm
.legitimate_address_p (mode
, mem
, strict
);
1253 /* Named address space version of LEGITIMIZE_ADDRESS. */
1256 default_addr_space_legitimize_address (rtx x
, rtx oldx
,
1257 machine_mode mode
, addr_space_t as
)
1259 if (!ADDR_SPACE_GENERIC_P (as
))
1262 return targetm
.legitimize_address (x
, oldx
, mode
);
1265 /* The default hook for determining if one named address space is a subset of
1266 another and to return which address space to use as the common address
1270 default_addr_space_subset_p (addr_space_t subset
, addr_space_t superset
)
1272 return (subset
== superset
);
1275 /* The default hook for TARGET_ADDR_SPACE_CONVERT. This hook should never be
1276 called for targets with only a generic address space. */
1279 default_addr_space_convert (rtx op ATTRIBUTE_UNUSED
,
1280 tree from_type ATTRIBUTE_UNUSED
,
1281 tree to_type ATTRIBUTE_UNUSED
)
1287 default_hard_regno_scratch_ok (unsigned int regno ATTRIBUTE_UNUSED
)
1292 /* The default implementation of TARGET_MODE_DEPENDENT_ADDRESS_P. */
1295 default_mode_dependent_address_p (const_rtx addr ATTRIBUTE_UNUSED
,
1296 addr_space_t addrspace ATTRIBUTE_UNUSED
)
1302 default_target_option_valid_attribute_p (tree
ARG_UNUSED (fndecl
),
1303 tree
ARG_UNUSED (name
),
1304 tree
ARG_UNUSED (args
),
1305 int ARG_UNUSED (flags
))
1307 warning (OPT_Wattributes
,
1308 "target attribute is not supported on this machine");
1314 default_target_option_pragma_parse (tree
ARG_UNUSED (args
),
1315 tree
ARG_UNUSED (pop_target
))
1317 warning (OPT_Wpragmas
,
1318 "#pragma GCC target is not supported for this machine");
1324 default_target_can_inline_p (tree caller
, tree callee
)
1327 tree callee_opts
= DECL_FUNCTION_SPECIFIC_TARGET (callee
);
1328 tree caller_opts
= DECL_FUNCTION_SPECIFIC_TARGET (caller
);
1330 /* If callee has no option attributes, then it is ok to inline */
1334 /* If caller has no option attributes, but callee does then it is not ok to
1336 else if (!caller_opts
)
1339 /* If both caller and callee have attributes, assume that if the
1340 pointer is different, the two functions have different target
1341 options since build_target_option_node uses a hash table for the
1344 ret
= (callee_opts
== caller_opts
);
1350 # define HAVE_casesi 0
1353 /* If the machine does not have a case insn that compares the bounds,
1354 this means extra overhead for dispatch tables, which raises the
1355 threshold for using them. */
1358 default_case_values_threshold (void)
1360 return (HAVE_casesi
? 4 : 5);
1364 default_have_conditional_execution (void)
1366 #ifdef HAVE_conditional_execution
1367 return HAVE_conditional_execution
;
1373 /* By default we assume that c99 functions are present at the runtime,
1374 but sincos is not. */
1376 default_libc_has_function (enum function_class fn_class
)
1378 if (fn_class
== function_c94
1379 || fn_class
== function_c99_misc
1380 || fn_class
== function_c99_math_complex
)
1387 gnu_libc_has_function (enum function_class fn_class ATTRIBUTE_UNUSED
)
1393 no_c99_libc_has_function (enum function_class fn_class ATTRIBUTE_UNUSED
)
1399 default_builtin_tm_load_store (tree
ARG_UNUSED (type
))
1404 /* Compute cost of moving registers to/from memory. */
1407 default_memory_move_cost (machine_mode mode ATTRIBUTE_UNUSED
,
1408 reg_class_t rclass ATTRIBUTE_UNUSED
,
1409 bool in ATTRIBUTE_UNUSED
)
1411 #ifndef MEMORY_MOVE_COST
1412 return (4 + memory_move_secondary_cost (mode
, (enum reg_class
) rclass
, in
));
1414 return MEMORY_MOVE_COST (mode
, (enum reg_class
) rclass
, in
);
1418 /* Compute cost of moving data from a register of class FROM to one of
1422 default_register_move_cost (machine_mode mode ATTRIBUTE_UNUSED
,
1423 reg_class_t from ATTRIBUTE_UNUSED
,
1424 reg_class_t to ATTRIBUTE_UNUSED
)
1426 #ifndef REGISTER_MOVE_COST
1429 return REGISTER_MOVE_COST (mode
, (enum reg_class
) from
, (enum reg_class
) to
);
1433 /* For hooks which use the MOVE_RATIO macro, this gives the legacy default
1434 behaviour. SPEED_P is true if we are compiling for speed. */
1437 get_move_ratio (bool speed_p ATTRIBUTE_UNUSED
)
1439 unsigned int move_ratio
;
1441 move_ratio
= (unsigned int) MOVE_RATIO (speed_p
);
1443 #if defined (HAVE_movmemqi) || defined (HAVE_movmemhi) || defined (HAVE_movmemsi) || defined (HAVE_movmemdi) || defined (HAVE_movmemti)
1445 #else /* No movmem patterns, pick a default. */
1446 move_ratio
= ((speed_p
) ? 15 : 3);
1452 /* Return TRUE if the move_by_pieces/set_by_pieces infrastructure should be
1453 used; return FALSE if the movmem/setmem optab should be expanded, or
1454 a call to memcpy emitted. */
1457 default_use_by_pieces_infrastructure_p (unsigned HOST_WIDE_INT size
,
1458 unsigned int alignment
,
1459 enum by_pieces_operation op
,
1462 unsigned int max_size
= 0;
1463 unsigned int ratio
= 0;
1467 case CLEAR_BY_PIECES
:
1468 max_size
= STORE_MAX_PIECES
;
1469 ratio
= CLEAR_RATIO (speed_p
);
1471 case MOVE_BY_PIECES
:
1472 max_size
= MOVE_MAX_PIECES
;
1473 ratio
= get_move_ratio (speed_p
);
1476 max_size
= STORE_MAX_PIECES
;
1477 ratio
= SET_RATIO (speed_p
);
1479 case STORE_BY_PIECES
:
1480 max_size
= STORE_MAX_PIECES
;
1481 ratio
= get_move_ratio (speed_p
);
1485 return move_by_pieces_ninsns (size
, alignment
, max_size
+ 1) < ratio
;
1489 default_profile_before_prologue (void)
1491 #ifdef PROFILE_BEFORE_PROLOGUE
1498 /* The default implementation of TARGET_PREFERRED_RELOAD_CLASS. */
1501 default_preferred_reload_class (rtx x ATTRIBUTE_UNUSED
,
1504 #ifdef PREFERRED_RELOAD_CLASS
1505 return (reg_class_t
) PREFERRED_RELOAD_CLASS (x
, (enum reg_class
) rclass
);
1511 /* The default implementation of TARGET_OUTPUT_PREFERRED_RELOAD_CLASS. */
1514 default_preferred_output_reload_class (rtx x ATTRIBUTE_UNUSED
,
1520 /* The default implementation of TARGET_PREFERRED_RENAME_CLASS. */
1522 default_preferred_rename_class (reg_class_t rclass ATTRIBUTE_UNUSED
)
1527 /* The default implementation of TARGET_CLASS_LIKELY_SPILLED_P. */
1530 default_class_likely_spilled_p (reg_class_t rclass
)
1532 return (reg_class_size
[(int) rclass
] == 1);
1535 /* The default implementation of TARGET_CLASS_MAX_NREGS. */
1538 default_class_max_nregs (reg_class_t rclass ATTRIBUTE_UNUSED
,
1539 machine_mode mode ATTRIBUTE_UNUSED
)
1541 #ifdef CLASS_MAX_NREGS
1542 return (unsigned char) CLASS_MAX_NREGS ((enum reg_class
) rclass
, mode
);
1544 return ((GET_MODE_SIZE (mode
) + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
);
1548 /* Determine the debugging unwind mechanism for the target. */
1550 enum unwind_info_type
1551 default_debug_unwind_info (void)
1553 /* If the target wants to force the use of dwarf2 unwind info, let it. */
1554 /* ??? Change all users to the hook, then poison this. */
1555 #ifdef DWARF2_FRAME_INFO
1556 if (DWARF2_FRAME_INFO
)
1560 /* Otherwise, only turn it on if dwarf2 debugging is enabled. */
1561 #ifdef DWARF2_DEBUGGING_INFO
1562 if (write_symbols
== DWARF2_DEBUG
|| write_symbols
== VMS_AND_DWARF2_DEBUG
)
1569 /* Determine the correct mode for a Dwarf frame register that represents
1573 default_dwarf_frame_reg_mode (int regno
)
1575 machine_mode save_mode
= reg_raw_mode
[regno
];
1577 if (HARD_REGNO_CALL_PART_CLOBBERED (regno
, save_mode
))
1578 save_mode
= choose_hard_reg_mode (regno
, 1, true);
1582 /* To be used by targets where reg_raw_mode doesn't return the right
1583 mode for registers used in apply_builtin_return and apply_builtin_arg. */
1586 default_get_reg_raw_mode (int regno
)
1588 return reg_raw_mode
[regno
];
1591 /* Return true if a leaf function should stay leaf even with profiling
1595 default_keep_leaf_when_profiled ()
1600 /* Return true if the state of option OPTION should be stored in PCH files
1601 and checked by default_pch_valid_p. Store the option's current state
1605 option_affects_pch_p (int option
, struct cl_option_state
*state
)
1607 if ((cl_options
[option
].flags
& CL_TARGET
) == 0)
1609 if ((cl_options
[option
].flags
& CL_PCH_IGNORE
) != 0)
1611 if (option_flag_var (option
, &global_options
) == &target_flags
)
1612 if (targetm
.check_pch_target_flags
)
1614 return get_option_state (&global_options
, option
, state
);
1617 /* Default version of get_pch_validity.
1618 By default, every flag difference is fatal; that will be mostly right for
1619 most targets, but completely right for very few. */
1622 default_get_pch_validity (size_t *sz
)
1624 struct cl_option_state state
;
1629 if (targetm
.check_pch_target_flags
)
1630 *sz
+= sizeof (target_flags
);
1631 for (i
= 0; i
< cl_options_count
; i
++)
1632 if (option_affects_pch_p (i
, &state
))
1635 result
= r
= XNEWVEC (char, *sz
);
1639 if (targetm
.check_pch_target_flags
)
1641 memcpy (r
, &target_flags
, sizeof (target_flags
));
1642 r
+= sizeof (target_flags
);
1645 for (i
= 0; i
< cl_options_count
; i
++)
1646 if (option_affects_pch_p (i
, &state
))
1648 memcpy (r
, state
.data
, state
.size
);
1655 /* Return a message which says that a PCH file was created with a different
1656 setting of OPTION. */
1659 pch_option_mismatch (const char *option
)
1661 return xasprintf (_("created and used with differing settings of '%s'"),
1665 /* Default version of pch_valid_p. */
1668 default_pch_valid_p (const void *data_p
, size_t len
)
1670 struct cl_option_state state
;
1671 const char *data
= (const char *)data_p
;
1674 /* -fpic and -fpie also usually make a PCH invalid. */
1675 if (data
[0] != flag_pic
)
1676 return _("created and used with different settings of -fpic");
1677 if (data
[1] != flag_pie
)
1678 return _("created and used with different settings of -fpie");
1681 /* Check target_flags. */
1682 if (targetm
.check_pch_target_flags
)
1687 memcpy (&tf
, data
, sizeof (target_flags
));
1688 data
+= sizeof (target_flags
);
1689 len
-= sizeof (target_flags
);
1690 r
= targetm
.check_pch_target_flags (tf
);
1695 for (i
= 0; i
< cl_options_count
; i
++)
1696 if (option_affects_pch_p (i
, &state
))
1698 if (memcmp (data
, state
.data
, state
.size
) != 0)
1699 return pch_option_mismatch (cl_options
[i
].opt_text
);
1707 /* Default version of cstore_mode. */
1710 default_cstore_mode (enum insn_code icode
)
1712 return insn_data
[(int) icode
].operand
[0].mode
;
1715 /* Default version of member_type_forces_blk. */
1718 default_member_type_forces_blk (const_tree
, machine_mode
)
1724 default_load_bounds_for_arg (rtx addr ATTRIBUTE_UNUSED
,
1725 rtx ptr ATTRIBUTE_UNUSED
,
1726 rtx bnd ATTRIBUTE_UNUSED
)
1732 default_store_bounds_for_arg (rtx val ATTRIBUTE_UNUSED
,
1733 rtx addr ATTRIBUTE_UNUSED
,
1734 rtx bounds ATTRIBUTE_UNUSED
,
1735 rtx to ATTRIBUTE_UNUSED
)
1741 default_load_returned_bounds (rtx slot ATTRIBUTE_UNUSED
)
1747 default_store_returned_bounds (rtx slot ATTRIBUTE_UNUSED
,
1748 rtx bounds ATTRIBUTE_UNUSED
)
1753 /* Default version of canonicalize_comparison. */
1756 default_canonicalize_comparison (int *, rtx
*, rtx
*, bool)
1760 /* Default implementation of TARGET_ATOMIC_ASSIGN_EXPAND_FENV. */
1763 default_atomic_assign_expand_fenv (tree
*, tree
*, tree
*)
1767 #ifndef PAD_VARARGS_DOWN
1768 #define PAD_VARARGS_DOWN BYTES_BIG_ENDIAN
1771 /* Build an indirect-ref expression over the given TREE, which represents a
1772 piece of a va_arg() expansion. */
1774 build_va_arg_indirect_ref (tree addr
)
1776 addr
= build_simple_mem_ref_loc (EXPR_LOCATION (addr
), addr
);
1780 /* The "standard" implementation of va_arg: read the value from the
1781 current (padded) address and increment by the (padded) size. */
1784 std_gimplify_va_arg_expr (tree valist
, tree type
, gimple_seq
*pre_p
,
1787 tree addr
, t
, type_size
, rounded_size
, valist_tmp
;
1788 unsigned HOST_WIDE_INT align
, boundary
;
1791 /* All of the alignment and movement below is for args-grow-up machines.
1792 As of 2004, there are only 3 ARGS_GROW_DOWNWARD targets, and they all
1793 implement their own specialized gimplify_va_arg_expr routines. */
1794 if (ARGS_GROW_DOWNWARD
)
1797 indirect
= pass_by_reference (NULL
, TYPE_MODE (type
), type
, false);
1799 type
= build_pointer_type (type
);
1801 align
= PARM_BOUNDARY
/ BITS_PER_UNIT
;
1802 boundary
= targetm
.calls
.function_arg_boundary (TYPE_MODE (type
), type
);
1804 /* When we align parameter on stack for caller, if the parameter
1805 alignment is beyond MAX_SUPPORTED_STACK_ALIGNMENT, it will be
1806 aligned at MAX_SUPPORTED_STACK_ALIGNMENT. We will match callee
1807 here with caller. */
1808 if (boundary
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1809 boundary
= MAX_SUPPORTED_STACK_ALIGNMENT
;
1811 boundary
/= BITS_PER_UNIT
;
1813 /* Hoist the valist value into a temporary for the moment. */
1814 valist_tmp
= get_initialized_tmp_var (valist
, pre_p
, NULL
);
1816 /* va_list pointer is aligned to PARM_BOUNDARY. If argument actually
1817 requires greater alignment, we must perform dynamic alignment. */
1818 if (boundary
> align
1819 && !integer_zerop (TYPE_SIZE (type
)))
1821 t
= build2 (MODIFY_EXPR
, TREE_TYPE (valist
), valist_tmp
,
1822 fold_build_pointer_plus_hwi (valist_tmp
, boundary
- 1));
1823 gimplify_and_add (t
, pre_p
);
1825 t
= build2 (MODIFY_EXPR
, TREE_TYPE (valist
), valist_tmp
,
1826 fold_build2 (BIT_AND_EXPR
, TREE_TYPE (valist
),
1828 build_int_cst (TREE_TYPE (valist
), -boundary
)));
1829 gimplify_and_add (t
, pre_p
);
1834 /* If the actual alignment is less than the alignment of the type,
1835 adjust the type accordingly so that we don't assume strict alignment
1836 when dereferencing the pointer. */
1837 boundary
*= BITS_PER_UNIT
;
1838 if (boundary
< TYPE_ALIGN (type
))
1840 type
= build_variant_type_copy (type
);
1841 TYPE_ALIGN (type
) = boundary
;
1844 /* Compute the rounded size of the type. */
1845 type_size
= size_in_bytes (type
);
1846 rounded_size
= round_up (type_size
, align
);
1848 /* Reduce rounded_size so it's sharable with the postqueue. */
1849 gimplify_expr (&rounded_size
, pre_p
, post_p
, is_gimple_val
, fb_rvalue
);
1853 if (PAD_VARARGS_DOWN
&& !integer_zerop (rounded_size
))
1855 /* Small args are padded downward. */
1856 t
= fold_build2_loc (input_location
, GT_EXPR
, sizetype
,
1857 rounded_size
, size_int (align
));
1858 t
= fold_build3 (COND_EXPR
, sizetype
, t
, size_zero_node
,
1859 size_binop (MINUS_EXPR
, rounded_size
, type_size
));
1860 addr
= fold_build_pointer_plus (addr
, t
);
1863 /* Compute new value for AP. */
1864 t
= fold_build_pointer_plus (valist_tmp
, rounded_size
);
1865 t
= build2 (MODIFY_EXPR
, TREE_TYPE (valist
), valist
, t
);
1866 gimplify_and_add (t
, pre_p
);
1868 addr
= fold_convert (build_pointer_type (type
), addr
);
1871 addr
= build_va_arg_indirect_ref (addr
);
1873 return build_va_arg_indirect_ref (addr
);
1877 default_chkp_bound_type (void)
1879 tree res
= make_node (POINTER_BOUNDS_TYPE
);
1880 TYPE_PRECISION (res
) = TYPE_PRECISION (size_type_node
) * 2;
1881 TYPE_NAME (res
) = get_identifier ("__bounds_type");
1882 SET_TYPE_MODE (res
, targetm
.chkp_bound_mode ());
1888 default_chkp_bound_mode (void)
1894 default_builtin_chkp_function (unsigned int fcode ATTRIBUTE_UNUSED
)
1900 default_chkp_function_value_bounds (const_tree ret_type ATTRIBUTE_UNUSED
,
1901 const_tree fn_decl_or_type ATTRIBUTE_UNUSED
,
1902 bool outgoing ATTRIBUTE_UNUSED
)
1908 default_chkp_make_bounds_constant (HOST_WIDE_INT lb ATTRIBUTE_UNUSED
,
1909 HOST_WIDE_INT ub ATTRIBUTE_UNUSED
)
1915 default_chkp_initialize_bounds (tree var ATTRIBUTE_UNUSED
,
1916 tree lb ATTRIBUTE_UNUSED
,
1917 tree ub ATTRIBUTE_UNUSED
,
1918 tree
*stmts ATTRIBUTE_UNUSED
)
1924 default_setup_incoming_vararg_bounds (cumulative_args_t ca ATTRIBUTE_UNUSED
,
1925 enum machine_mode mode ATTRIBUTE_UNUSED
,
1926 tree type ATTRIBUTE_UNUSED
,
1927 int *pretend_arg_size ATTRIBUTE_UNUSED
,
1928 int second_time ATTRIBUTE_UNUSED
)
1932 /* An implementation of TARGET_CAN_USE_DOLOOP_P for targets that do
1933 not support nested low-overhead loops. */
1936 can_use_doloop_if_innermost (const widest_int
&, const widest_int
&,
1937 unsigned int loop_depth
, bool)
1939 return loop_depth
== 1;
1942 #include "gt-targhooks.h"