Branch data Line data Source code
1 : : /* Default target hook functions.
2 : : Copyright (C) 2003-2025 Free Software Foundation, Inc.
3 : :
4 : : This file is part of GCC.
5 : :
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
9 : : version.
10 : :
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
14 : : for more details.
15 : :
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/>. */
19 : :
20 : : /* The migration of target macros to target hooks works as follows:
21 : :
22 : : 1. Create a target hook that uses the existing target macros to
23 : : implement the same functionality.
24 : :
25 : : 2. Convert all the MI files to use the hook instead of the macro.
26 : :
27 : : 3. Repeat for a majority of the remaining target macros. This will
28 : : take some time.
29 : :
30 : : 4. Tell target maintainers to start migrating.
31 : :
32 : : 5. Eventually convert the backends to override the hook instead of
33 : : defining the macros. This will take some time too.
34 : :
35 : : 6. TBD when, poison the macros. Unmigrated targets will break at
36 : : this point.
37 : :
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.
41 : :
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.
44 : :
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. */
48 : :
49 : : #include "config.h"
50 : : #include "system.h"
51 : : #include "coretypes.h"
52 : : #include "target.h"
53 : : #include "function.h"
54 : : #include "rtl.h"
55 : : #include "tree.h"
56 : : #include "tree-ssa-alias.h"
57 : : #include "gimple-expr.h"
58 : : #include "memmodel.h"
59 : : #include "backend.h"
60 : : #include "emit-rtl.h"
61 : : #include "df.h"
62 : : #include "tm_p.h"
63 : : #include "stringpool.h"
64 : : #include "tree-vrp.h"
65 : : #include "tree-ssanames.h"
66 : : #include "profile-count.h"
67 : : #include "optabs.h"
68 : : #include "regs.h"
69 : : #include "recog.h"
70 : : #include "diagnostic-core.h"
71 : : #include "fold-const.h"
72 : : #include "stor-layout.h"
73 : : #include "varasm.h"
74 : : #include "flags.h"
75 : : #include "explow.h"
76 : : #include "expmed.h"
77 : : #include "calls.h"
78 : : #include "expr.h"
79 : : #include "output.h"
80 : : #include "common/common-target.h"
81 : : #include "reload.h"
82 : : #include "intl.h"
83 : : #include "opts.h"
84 : : #include "gimplify.h"
85 : : #include "predict.h"
86 : : #include "real.h"
87 : : #include "langhooks.h"
88 : : #include "sbitmap.h"
89 : : #include "function-abi.h"
90 : : #include "attribs.h"
91 : : #include "asan.h"
92 : : #include "emit-rtl.h"
93 : : #include "gimple.h"
94 : : #include "cfgloop.h"
95 : : #include "tree-vectorizer.h"
96 : : #include "options.h"
97 : : #include "case-cfn-macros.h"
98 : : #include "avoid-store-forwarding.h"
99 : :
100 : : bool
101 : 0 : default_legitimate_address_p (machine_mode mode ATTRIBUTE_UNUSED,
102 : : rtx addr ATTRIBUTE_UNUSED,
103 : : bool strict ATTRIBUTE_UNUSED,
104 : : code_helper ATTRIBUTE_UNUSED)
105 : : {
106 : : #ifdef GO_IF_LEGITIMATE_ADDRESS
107 : : /* Defer to the old implementation using a goto. */
108 : : if (strict)
109 : : return strict_memory_address_p (mode, addr);
110 : : else
111 : : return memory_address_p (mode, addr);
112 : : #else
113 : 0 : gcc_unreachable ();
114 : : #endif
115 : : }
116 : :
117 : : void
118 : 27064 : default_external_libcall (rtx fun ATTRIBUTE_UNUSED)
119 : : {
120 : : #ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
121 : 27064 : ASM_OUTPUT_EXTERNAL_LIBCALL (asm_out_file, fun);
122 : : #endif
123 : 27064 : }
124 : :
125 : : int
126 : 5664430 : default_unspec_may_trap_p (const_rtx x, unsigned flags)
127 : : {
128 : 5664430 : int i;
129 : :
130 : : /* Any floating arithmetic may trap. */
131 : 5664430 : if ((SCALAR_FLOAT_MODE_P (GET_MODE (x)) && flag_trapping_math))
132 : : return 1;
133 : :
134 : 9702432 : for (i = 0; i < XVECLEN (x, 0); ++i)
135 : : {
136 : 7101830 : if (may_trap_p_1 (XVECEXP (x, 0, i), flags))
137 : : return 1;
138 : : }
139 : :
140 : : return 0;
141 : : }
142 : :
143 : : machine_mode
144 : 15942042 : default_promote_function_mode (const_tree type ATTRIBUTE_UNUSED,
145 : : machine_mode mode,
146 : : int *punsignedp ATTRIBUTE_UNUSED,
147 : : const_tree funtype ATTRIBUTE_UNUSED,
148 : : int for_return ATTRIBUTE_UNUSED)
149 : : {
150 : 15942042 : if (type != NULL_TREE && for_return == 2)
151 : 3648926 : return promote_mode (type, mode, punsignedp);
152 : : return mode;
153 : : }
154 : :
155 : : machine_mode
156 : 0 : default_promote_function_mode_always_promote (const_tree type,
157 : : machine_mode mode,
158 : : int *punsignedp,
159 : : const_tree funtype ATTRIBUTE_UNUSED,
160 : : int for_return ATTRIBUTE_UNUSED)
161 : : {
162 : 0 : return promote_mode (type, mode, punsignedp);
163 : : }
164 : :
165 : : machine_mode
166 : 0 : default_cc_modes_compatible (machine_mode m1, machine_mode m2)
167 : : {
168 : 0 : if (m1 == m2)
169 : 0 : return m1;
170 : : return VOIDmode;
171 : : }
172 : :
173 : : bool
174 : 0 : default_return_in_memory (const_tree type,
175 : : const_tree fntype ATTRIBUTE_UNUSED)
176 : : {
177 : 0 : return (TYPE_MODE (type) == BLKmode);
178 : : }
179 : :
180 : : rtx
181 : 0 : default_legitimize_address (rtx x, rtx orig_x ATTRIBUTE_UNUSED,
182 : : machine_mode mode ATTRIBUTE_UNUSED)
183 : : {
184 : 0 : return x;
185 : : }
186 : :
187 : : bool
188 : 0 : default_legitimize_address_displacement (rtx *, rtx *, poly_int64,
189 : : machine_mode)
190 : : {
191 : 0 : return false;
192 : : }
193 : :
194 : : bool
195 : 0 : default_const_not_ok_for_debug_p (rtx x)
196 : : {
197 : 0 : if (GET_CODE (x) == UNSPEC)
198 : 0 : return true;
199 : : return false;
200 : : }
201 : :
202 : : rtx
203 : 0 : default_expand_builtin_saveregs (void)
204 : : {
205 : 0 : error ("%<__builtin_saveregs%> not supported by this target");
206 : 0 : return const0_rtx;
207 : : }
208 : :
209 : : void
210 : 0 : default_setup_incoming_varargs (cumulative_args_t,
211 : : const function_arg_info &, int *, int)
212 : : {
213 : 0 : }
214 : :
215 : : /* The default implementation of TARGET_BUILTIN_SETJMP_FRAME_VALUE. */
216 : :
217 : : rtx
218 : 0 : default_builtin_setjmp_frame_value (void)
219 : : {
220 : 0 : return virtual_stack_vars_rtx;
221 : : }
222 : :
223 : : /* Generic hook that takes a CUMULATIVE_ARGS pointer and returns false. */
224 : :
225 : : bool
226 : 0 : hook_bool_CUMULATIVE_ARGS_false (cumulative_args_t ca ATTRIBUTE_UNUSED)
227 : : {
228 : 0 : return false;
229 : : }
230 : :
231 : : bool
232 : 0 : default_pretend_outgoing_varargs_named (cumulative_args_t ca ATTRIBUTE_UNUSED)
233 : : {
234 : 0 : return (targetm.calls.setup_incoming_varargs
235 : 0 : != default_setup_incoming_varargs);
236 : : }
237 : :
238 : : scalar_int_mode
239 : 528992 : default_eh_return_filter_mode (void)
240 : : {
241 : 528992 : return targetm.unwind_word_mode ();
242 : : }
243 : :
244 : : scalar_int_mode
245 : 45112 : default_libgcc_cmp_return_mode (void)
246 : : {
247 : 45112 : return word_mode;
248 : : }
249 : :
250 : : scalar_int_mode
251 : 308 : default_libgcc_shift_count_mode (void)
252 : : {
253 : 308 : return word_mode;
254 : : }
255 : :
256 : : scalar_int_mode
257 : 753927 : default_unwind_word_mode (void)
258 : : {
259 : 753927 : return word_mode;
260 : : }
261 : :
262 : : /* The default implementation of TARGET_SHIFT_TRUNCATION_MASK. */
263 : :
264 : : unsigned HOST_WIDE_INT
265 : 1 : default_shift_truncation_mask (machine_mode mode)
266 : : {
267 : 1 : return SHIFT_COUNT_TRUNCATED ? GET_MODE_UNIT_BITSIZE (mode) - 1 : 0;
268 : : }
269 : :
270 : : /* The default implementation of TARGET_MIN_DIVISIONS_FOR_RECIP_MUL. */
271 : :
272 : : unsigned int
273 : 196537 : default_min_divisions_for_recip_mul (machine_mode mode ATTRIBUTE_UNUSED)
274 : : {
275 : 196537 : return have_insn_for (DIV, mode) ? 3 : 2;
276 : : }
277 : :
278 : : /* The default implementation of TARGET_MODE_REP_EXTENDED. */
279 : :
280 : : int
281 : 21224137 : default_mode_rep_extended (scalar_int_mode, scalar_int_mode)
282 : : {
283 : 21224137 : return UNKNOWN;
284 : : }
285 : :
286 : : /* Generic hook that takes a CUMULATIVE_ARGS pointer and returns true. */
287 : :
288 : : bool
289 : 5915345 : hook_bool_CUMULATIVE_ARGS_true (cumulative_args_t a ATTRIBUTE_UNUSED)
290 : : {
291 : 5915345 : return true;
292 : : }
293 : :
294 : : /* Return machine mode for non-standard suffix
295 : : or VOIDmode if non-standard suffixes are unsupported. */
296 : : machine_mode
297 : 0 : default_mode_for_suffix (char suffix ATTRIBUTE_UNUSED)
298 : : {
299 : 0 : return VOIDmode;
300 : : }
301 : :
302 : : /* Return machine mode for a floating type which is indicated
303 : : by the given enum tree_index. */
304 : :
305 : : machine_mode
306 : 2969244 : default_mode_for_floating_type (enum tree_index ti)
307 : : {
308 : 2969244 : if (ti == TI_FLOAT_TYPE)
309 : : return SFmode;
310 : 1465009 : gcc_assert (ti == TI_DOUBLE_TYPE || ti == TI_LONG_DOUBLE_TYPE);
311 : : return DFmode;
312 : : }
313 : :
314 : : /* The generic C++ ABI specifies this is a 64-bit value. */
315 : : tree
316 : 4690 : default_cxx_guard_type (void)
317 : : {
318 : 4690 : return long_long_integer_type_node;
319 : : }
320 : :
321 : : /* Returns the size of the cookie to use when allocating an array
322 : : whose elements have the indicated TYPE. Assumes that it is already
323 : : known that a cookie is needed. */
324 : :
325 : : tree
326 : 83309 : default_cxx_get_cookie_size (tree type)
327 : : {
328 : 83309 : tree cookie_size;
329 : :
330 : : /* We need to allocate an additional max (sizeof (size_t), alignof
331 : : (true_type)) bytes. */
332 : 83309 : tree sizetype_size;
333 : 83309 : tree type_align;
334 : :
335 : 83309 : sizetype_size = size_in_bytes (sizetype);
336 : 83309 : type_align = size_int (TYPE_ALIGN_UNIT (type));
337 : 83309 : if (tree_int_cst_lt (type_align, sizetype_size))
338 : : cookie_size = sizetype_size;
339 : : else
340 : 13836 : cookie_size = type_align;
341 : :
342 : 83309 : return cookie_size;
343 : : }
344 : :
345 : : /* Returns modified FUNCTION_TYPE for cdtor callabi. */
346 : :
347 : : tree
348 : 0 : default_cxx_adjust_cdtor_callabi_fntype (tree fntype)
349 : : {
350 : 0 : return fntype;
351 : : }
352 : :
353 : : /* Return true if a parameter must be passed by reference. This version
354 : : of the TARGET_PASS_BY_REFERENCE hook uses just MUST_PASS_IN_STACK. */
355 : :
356 : : bool
357 : 0 : hook_pass_by_reference_must_pass_in_stack (cumulative_args_t,
358 : : const function_arg_info &arg)
359 : : {
360 : 0 : return targetm.calls.must_pass_in_stack (arg);
361 : : }
362 : :
363 : : /* Return true if a parameter follows callee copies conventions. This
364 : : version of the hook is true for all named arguments. */
365 : :
366 : : bool
367 : 0 : hook_callee_copies_named (cumulative_args_t, const function_arg_info &arg)
368 : : {
369 : 0 : return arg.named;
370 : : }
371 : :
372 : : /* Emit to STREAM the assembler syntax for insn operand X. */
373 : :
374 : : void
375 : 0 : default_print_operand (FILE *stream ATTRIBUTE_UNUSED, rtx x ATTRIBUTE_UNUSED,
376 : : int code ATTRIBUTE_UNUSED)
377 : : {
378 : : #ifdef PRINT_OPERAND
379 : : PRINT_OPERAND (stream, x, code);
380 : : #else
381 : 0 : gcc_unreachable ();
382 : : #endif
383 : : }
384 : :
385 : : /* Emit to STREAM the assembler syntax for an insn operand whose memory
386 : : address is X. */
387 : :
388 : : void
389 : 0 : default_print_operand_address (FILE *stream ATTRIBUTE_UNUSED,
390 : : machine_mode /*mode*/,
391 : : rtx x ATTRIBUTE_UNUSED)
392 : : {
393 : : #ifdef PRINT_OPERAND_ADDRESS
394 : : PRINT_OPERAND_ADDRESS (stream, x);
395 : : #else
396 : 0 : gcc_unreachable ();
397 : : #endif
398 : : }
399 : :
400 : : /* Return true if CODE is a valid punctuation character for the
401 : : `print_operand' hook. */
402 : :
403 : : bool
404 : 0 : default_print_operand_punct_valid_p (unsigned char code ATTRIBUTE_UNUSED)
405 : : {
406 : : #ifdef PRINT_OPERAND_PUNCT_VALID_P
407 : : return PRINT_OPERAND_PUNCT_VALID_P (code);
408 : : #else
409 : 0 : return false;
410 : : #endif
411 : : }
412 : :
413 : : /* The default implementation of TARGET_MANGLE_ASSEMBLER_NAME. */
414 : : tree
415 : 539639 : default_mangle_assembler_name (const char *name ATTRIBUTE_UNUSED)
416 : : {
417 : 539639 : const char *skipped = name + (*name == '*' ? 1 : 0);
418 : 539639 : const char *stripped = targetm.strip_name_encoding (skipped);
419 : 539639 : if (*name != '*' && user_label_prefix[0])
420 : 0 : stripped = ACONCAT ((user_label_prefix, stripped, NULL));
421 : 539639 : return get_identifier (stripped);
422 : : }
423 : :
424 : : /* The default implementation of TARGET_TRANSLATE_MODE_ATTRIBUTE. */
425 : :
426 : : machine_mode
427 : 53771 : default_translate_mode_attribute (machine_mode mode)
428 : : {
429 : 53771 : return mode;
430 : : }
431 : :
432 : : /* True if MODE is valid for the target. By "valid", we mean able to
433 : : be manipulated in non-trivial ways. In particular, this means all
434 : : the arithmetic is supported.
435 : :
436 : : By default we guess this means that any C type is supported. If
437 : : we can't map the mode back to a type that would be available in C,
438 : : then reject it. Special case, here, is the double-word arithmetic
439 : : supported by optabs.cc. */
440 : :
441 : : bool
442 : 2697924 : default_scalar_mode_supported_p (scalar_mode mode)
443 : : {
444 : 2697924 : int precision = GET_MODE_PRECISION (mode);
445 : :
446 : 2697924 : switch (GET_MODE_CLASS (mode))
447 : : {
448 : 1474901 : case MODE_PARTIAL_INT:
449 : 1474901 : case MODE_INT:
450 : 1474901 : if (precision == CHAR_TYPE_SIZE)
451 : : return true;
452 : 1441408 : if (precision == SHORT_TYPE_SIZE)
453 : : return true;
454 : 1407215 : if (precision == INT_TYPE_SIZE)
455 : : return true;
456 : 1395828 : if (precision == LONG_TYPE_SIZE)
457 : : return true;
458 : 1298280 : if (precision == LONG_LONG_TYPE_SIZE)
459 : : return true;
460 : 1327824 : if (precision == 2 * BITS_PER_WORD)
461 : : return true;
462 : : return false;
463 : :
464 : 1223023 : case MODE_FLOAT:
465 : 1223023 : if (mode == targetm.c.mode_for_floating_type (TI_FLOAT_TYPE))
466 : : return true;
467 : 908912 : if (mode == targetm.c.mode_for_floating_type (TI_DOUBLE_TYPE))
468 : : return true;
469 : 313657 : if (mode == targetm.c.mode_for_floating_type (TI_LONG_DOUBLE_TYPE))
470 : : return true;
471 : : return false;
472 : :
473 : : case MODE_DECIMAL_FLOAT:
474 : : case MODE_FRACT:
475 : : case MODE_UFRACT:
476 : : case MODE_ACCUM:
477 : : case MODE_UACCUM:
478 : : return false;
479 : :
480 : 0 : default:
481 : 0 : gcc_unreachable ();
482 : : }
483 : : }
484 : :
485 : : /* Return true if libgcc supports floating-point mode MODE (known to
486 : : be supported as a scalar mode). */
487 : :
488 : : bool
489 : 1532224 : default_libgcc_floating_mode_supported_p (scalar_float_mode mode)
490 : : {
491 : 1532224 : switch (mode)
492 : : {
493 : : #ifdef HAVE_SFmode
494 : : case E_SFmode:
495 : : #endif
496 : : #ifdef HAVE_DFmode
497 : : case E_DFmode:
498 : : #endif
499 : : #ifdef HAVE_XFmode
500 : : case E_XFmode:
501 : : #endif
502 : : #ifdef HAVE_TFmode
503 : : case E_TFmode:
504 : : #endif
505 : : return true;
506 : :
507 : 0 : default:
508 : 0 : return false;
509 : : }
510 : : }
511 : :
512 : : /* Return the machine mode to use for the type _FloatN, if EXTENDED is
513 : : false, or _FloatNx, if EXTENDED is true, or VOIDmode if not
514 : : supported. */
515 : : opt_scalar_float_mode
516 : 1968064 : default_floatn_mode (int n, bool extended)
517 : : {
518 : 1968064 : if (extended)
519 : : {
520 : 843456 : opt_scalar_float_mode cand1, cand2;
521 : 843456 : scalar_float_mode mode;
522 : 843456 : switch (n)
523 : : {
524 : 281152 : case 32:
525 : : #ifdef HAVE_DFmode
526 : 281152 : cand1 = DFmode;
527 : : #endif
528 : 281152 : break;
529 : :
530 : 281152 : case 64:
531 : : #ifdef HAVE_XFmode
532 : 281152 : cand1 = XFmode;
533 : : #endif
534 : : #ifdef HAVE_TFmode
535 : 281152 : cand2 = TFmode;
536 : : #endif
537 : 281152 : break;
538 : :
539 : : case 128:
540 : : break;
541 : :
542 : 0 : default:
543 : : /* Those are the only valid _FloatNx types. */
544 : 0 : gcc_unreachable ();
545 : : }
546 : 843456 : if (cand1.exists (&mode)
547 : 562304 : && REAL_MODE_FORMAT (mode)->ieee_bits > n
548 : 562304 : && targetm.scalar_mode_supported_p (mode)
549 : 562282 : && targetm.libgcc_floating_mode_supported_p (mode))
550 : 562282 : return cand1;
551 : 281174 : if (cand2.exists (&mode)
552 : 22 : && REAL_MODE_FORMAT (mode)->ieee_bits > n
553 : 281174 : && targetm.scalar_mode_supported_p (mode)
554 : 22 : && targetm.libgcc_floating_mode_supported_p (mode))
555 : 22 : return cand2;
556 : : }
557 : : else
558 : : {
559 : 1124608 : opt_scalar_float_mode cand;
560 : 1124608 : scalar_float_mode mode;
561 : 1124608 : switch (n)
562 : : {
563 : : case 16:
564 : : /* Always enable _Float16 if we have basic support for the mode.
565 : : Targets can control the range and precision of operations on
566 : : the _Float16 type using TARGET_C_EXCESS_PRECISION. */
567 : : #ifdef HAVE_HFmode
568 : : cand = HFmode;
569 : : #endif
570 : : break;
571 : :
572 : : case 32:
573 : : #ifdef HAVE_SFmode
574 : : cand = SFmode;
575 : : #endif
576 : : break;
577 : :
578 : : case 64:
579 : : #ifdef HAVE_DFmode
580 : : cand = DFmode;
581 : : #endif
582 : : break;
583 : :
584 : : case 128:
585 : : #ifdef HAVE_TFmode
586 : : cand = TFmode;
587 : : #endif
588 : : break;
589 : :
590 : : default:
591 : : break;
592 : : }
593 : 1124608 : if (cand.exists (&mode)
594 : 1124608 : && REAL_MODE_FORMAT (mode)->ieee_bits == n
595 : 1124608 : && targetm.scalar_mode_supported_p (mode)
596 : 1124608 : && targetm.libgcc_floating_mode_supported_p (mode))
597 : 1124608 : return cand;
598 : : }
599 : 281152 : return opt_scalar_float_mode ();
600 : : }
601 : :
602 : : /* Define this to return true if the _Floatn and _Floatnx built-in functions
603 : : should implicitly enable the built-in function without the __builtin_ prefix
604 : : in addition to the normal built-in function with the __builtin_ prefix. The
605 : : default is to only enable built-in functions without the __builtin_ prefix
606 : : for the GNU C langauge. The argument FUNC is the enum builtin_in_function
607 : : id of the function to be enabled. */
608 : :
609 : : bool
610 : 130559996 : default_floatn_builtin_p (int func ATTRIBUTE_UNUSED)
611 : : {
612 : 130559996 : static bool first_time_p = true;
613 : 130559996 : static bool c_or_objective_c;
614 : :
615 : 130559996 : if (first_time_p)
616 : : {
617 : 224716 : first_time_p = false;
618 : 332018 : c_or_objective_c = lang_GNU_C () || lang_GNU_OBJC ();
619 : : }
620 : :
621 : 130559996 : return c_or_objective_c;
622 : : }
623 : :
624 : : /* Make some target macros useable by target-independent code. */
625 : : bool
626 : 0 : targhook_words_big_endian (void)
627 : : {
628 : 0 : return !!WORDS_BIG_ENDIAN;
629 : : }
630 : :
631 : : bool
632 : 204338 : targhook_float_words_big_endian (void)
633 : : {
634 : 204338 : return !!FLOAT_WORDS_BIG_ENDIAN;
635 : : }
636 : :
637 : : /* True if the target supports floating-point exceptions and rounding
638 : : modes. */
639 : :
640 : : bool
641 : 0 : default_float_exceptions_rounding_supported_p (void)
642 : : {
643 : : #ifdef HAVE_adddf3
644 : 0 : return HAVE_adddf3;
645 : : #else
646 : : return false;
647 : : #endif
648 : : }
649 : :
650 : : /* True if the target supports decimal floating point. */
651 : :
652 : : bool
653 : 1207896 : default_decimal_float_supported_p (void)
654 : : {
655 : 1207896 : return ENABLE_DECIMAL_FLOAT;
656 : : }
657 : :
658 : : /* True if the target supports fixed-point arithmetic. */
659 : :
660 : : bool
661 : 407030 : default_fixed_point_supported_p (void)
662 : : {
663 : 407030 : return ENABLE_FIXED_POINT;
664 : : }
665 : :
666 : : /* True if the target supports GNU indirect functions. */
667 : :
668 : : bool
669 : 565 : default_has_ifunc_p (void)
670 : : {
671 : 565 : return HAVE_GNU_INDIRECT_FUNCTION;
672 : : }
673 : :
674 : : /* Return true if we predict the loop LOOP will be transformed to a
675 : : low-overhead loop, otherwise return false.
676 : :
677 : : By default, false is returned, as this hook's applicability should be
678 : : verified for each target. Target maintainers should re-define the hook
679 : : if the target can take advantage of it. */
680 : :
681 : : bool
682 : 501775 : default_predict_doloop_p (class loop *loop ATTRIBUTE_UNUSED)
683 : : {
684 : 501775 : return false;
685 : : }
686 : :
687 : : /* By default, just use the input MODE itself. */
688 : :
689 : : machine_mode
690 : 0 : default_preferred_doloop_mode (machine_mode mode)
691 : : {
692 : 0 : return mode;
693 : : }
694 : :
695 : : /* NULL if INSN insn is valid within a low-overhead loop, otherwise returns
696 : : an error message.
697 : :
698 : : This function checks whether a given INSN is valid within a low-overhead
699 : : loop. If INSN is invalid it returns the reason for that, otherwise it
700 : : returns NULL. A called function may clobber any special registers required
701 : : for low-overhead looping. Additionally, some targets (eg, PPC) use the count
702 : : register for branch on table instructions. We reject the doloop pattern in
703 : : these cases. */
704 : :
705 : : const char *
706 : 0 : default_invalid_within_doloop (const rtx_insn *insn)
707 : : {
708 : 0 : if (CALL_P (insn))
709 : : return "Function call in loop.";
710 : :
711 : 0 : if (tablejump_p (insn, NULL, NULL) || computed_jump_p (insn))
712 : 0 : return "Computed branch in the loop.";
713 : :
714 : : return NULL;
715 : : }
716 : :
717 : : /* Mapping of builtin functions to vectorized variants. */
718 : :
719 : : tree
720 : 0 : default_builtin_vectorized_function (unsigned int, tree, tree)
721 : : {
722 : 0 : return NULL_TREE;
723 : : }
724 : :
725 : : /* Mapping of target builtin functions to vectorized variants. */
726 : :
727 : : tree
728 : 36 : default_builtin_md_vectorized_function (tree, tree, tree)
729 : : {
730 : 36 : return NULL_TREE;
731 : : }
732 : :
733 : : /* Default vectorizer cost model values. */
734 : :
735 : : int
736 : 0 : default_builtin_vectorization_cost (enum vect_cost_for_stmt type_of_cost,
737 : : tree vectype,
738 : : int misalign ATTRIBUTE_UNUSED)
739 : : {
740 : 0 : switch (type_of_cost)
741 : : {
742 : : case scalar_stmt:
743 : : case scalar_load:
744 : : case scalar_store:
745 : : case vector_stmt:
746 : : case vector_load:
747 : : case vector_store:
748 : : case vec_to_scalar:
749 : : case scalar_to_vec:
750 : : case cond_branch_not_taken:
751 : : case vec_perm:
752 : : case vec_promote_demote:
753 : : return 1;
754 : :
755 : 0 : case unaligned_load:
756 : 0 : case unaligned_store:
757 : 0 : return 2;
758 : :
759 : 0 : case cond_branch_taken:
760 : 0 : return 3;
761 : :
762 : 0 : case vec_construct:
763 : 0 : return estimated_poly_value (TYPE_VECTOR_SUBPARTS (vectype)) - 1;
764 : :
765 : 0 : default:
766 : 0 : gcc_unreachable ();
767 : : }
768 : : }
769 : :
770 : : /* Reciprocal. */
771 : :
772 : : tree
773 : 0 : default_builtin_reciprocal (tree)
774 : : {
775 : 0 : return NULL_TREE;
776 : : }
777 : :
778 : : void
779 : 0 : default_emit_support_tinfos (emit_support_tinfos_callback)
780 : : {
781 : 0 : }
782 : :
783 : : bool
784 : 5298 : hook_bool_CUMULATIVE_ARGS_arg_info_false (cumulative_args_t,
785 : : const function_arg_info &)
786 : : {
787 : 5298 : return false;
788 : : }
789 : :
790 : : bool
791 : 0 : hook_bool_CUMULATIVE_ARGS_arg_info_true (cumulative_args_t,
792 : : const function_arg_info &)
793 : : {
794 : 0 : return true;
795 : : }
796 : :
797 : : int
798 : 12435453 : hook_int_CUMULATIVE_ARGS_arg_info_0 (cumulative_args_t,
799 : : const function_arg_info &)
800 : : {
801 : 12435453 : return 0;
802 : : }
803 : :
804 : : void
805 : 12028536 : hook_void_CUMULATIVE_ARGS (cumulative_args_t)
806 : : {
807 : 12028536 : }
808 : :
809 : : void
810 : 0 : hook_void_CUMULATIVE_ARGS_tree (cumulative_args_t ca ATTRIBUTE_UNUSED,
811 : : tree ATTRIBUTE_UNUSED)
812 : : {
813 : 0 : }
814 : :
815 : : void
816 : 11793323 : hook_void_CUMULATIVE_ARGS_rtx_tree (cumulative_args_t, rtx, tree)
817 : : {
818 : 11793323 : }
819 : :
820 : : /* Default implementation of TARGET_PUSH_ARGUMENT. */
821 : :
822 : : bool
823 : 0 : default_push_argument (unsigned int)
824 : : {
825 : : #ifdef PUSH_ROUNDING
826 : 0 : return !ACCUMULATE_OUTGOING_ARGS;
827 : : #else
828 : : return false;
829 : : #endif
830 : : }
831 : :
832 : : void
833 : 0 : default_function_arg_advance (cumulative_args_t, const function_arg_info &)
834 : : {
835 : 0 : gcc_unreachable ();
836 : : }
837 : :
838 : : /* Default implementation of TARGET_FUNCTION_ARG_OFFSET. */
839 : :
840 : : HOST_WIDE_INT
841 : 5405167 : default_function_arg_offset (machine_mode, const_tree)
842 : : {
843 : 5405167 : return 0;
844 : : }
845 : :
846 : : /* Default implementation of TARGET_FUNCTION_ARG_PADDING: usually pad
847 : : upward, but pad short args downward on big-endian machines. */
848 : :
849 : : pad_direction
850 : 11990259 : default_function_arg_padding (machine_mode mode, const_tree type)
851 : : {
852 : 11990259 : if (!BYTES_BIG_ENDIAN)
853 : 11990259 : return PAD_UPWARD;
854 : :
855 : : unsigned HOST_WIDE_INT size;
856 : : if (mode == BLKmode)
857 : : {
858 : : if (!type || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
859 : : return PAD_UPWARD;
860 : : size = int_size_in_bytes (type);
861 : : }
862 : : else
863 : : /* Targets with variable-sized modes must override this hook
864 : : and handle variable-sized modes explicitly. */
865 : : size = GET_MODE_SIZE (mode).to_constant ();
866 : :
867 : : if (size < (PARM_BOUNDARY / BITS_PER_UNIT))
868 : : return PAD_DOWNWARD;
869 : :
870 : : return PAD_UPWARD;
871 : : }
872 : :
873 : : rtx
874 : 0 : default_function_arg (cumulative_args_t, const function_arg_info &)
875 : : {
876 : 0 : gcc_unreachable ();
877 : : }
878 : :
879 : : rtx
880 : 0 : default_function_incoming_arg (cumulative_args_t, const function_arg_info &)
881 : : {
882 : 0 : gcc_unreachable ();
883 : : }
884 : :
885 : : unsigned int
886 : 0 : default_function_arg_boundary (machine_mode mode ATTRIBUTE_UNUSED,
887 : : const_tree type ATTRIBUTE_UNUSED)
888 : : {
889 : 0 : return PARM_BOUNDARY;
890 : : }
891 : :
892 : : unsigned int
893 : 5405167 : default_function_arg_round_boundary (machine_mode mode ATTRIBUTE_UNUSED,
894 : : const_tree type ATTRIBUTE_UNUSED)
895 : : {
896 : 5405167 : return PARM_BOUNDARY;
897 : : }
898 : :
899 : : void
900 : 0 : hook_void_bitmap (bitmap regs ATTRIBUTE_UNUSED)
901 : : {
902 : 0 : }
903 : :
904 : : const char *
905 : 784130 : hook_invalid_arg_for_unprototyped_fn (
906 : : const_tree typelist ATTRIBUTE_UNUSED,
907 : : const_tree funcdecl ATTRIBUTE_UNUSED,
908 : : const_tree val ATTRIBUTE_UNUSED)
909 : : {
910 : 784130 : return NULL;
911 : : }
912 : :
913 : : /* Initialize the stack protection decls. */
914 : :
915 : : /* Stack protection related decls living in libgcc. */
916 : : static GTY(()) tree stack_chk_guard_decl;
917 : :
918 : : tree
919 : 3 : default_stack_protect_guard (void)
920 : : {
921 : 3 : tree t = stack_chk_guard_decl;
922 : :
923 : 3 : if (t == NULL)
924 : : {
925 : 1 : rtx x;
926 : :
927 : 1 : t = build_decl (UNKNOWN_LOCATION,
928 : : VAR_DECL, get_identifier ("__stack_chk_guard"),
929 : : ptr_type_node);
930 : 1 : TREE_STATIC (t) = 1;
931 : 1 : TREE_PUBLIC (t) = 1;
932 : 1 : DECL_EXTERNAL (t) = 1;
933 : 1 : TREE_USED (t) = 1;
934 : 1 : TREE_THIS_VOLATILE (t) = 1;
935 : 1 : DECL_ARTIFICIAL (t) = 1;
936 : 1 : DECL_IGNORED_P (t) = 1;
937 : :
938 : : /* Do not share RTL as the declaration is visible outside of
939 : : current function. */
940 : 1 : x = DECL_RTL (t);
941 : 1 : RTX_FLAG (x, used) = 1;
942 : :
943 : 1 : stack_chk_guard_decl = t;
944 : : }
945 : :
946 : 3 : return t;
947 : : }
948 : :
949 : : static GTY(()) tree stack_chk_fail_decl;
950 : :
951 : : tree
952 : 263 : default_external_stack_protect_fail (void)
953 : : {
954 : 263 : tree t = stack_chk_fail_decl;
955 : :
956 : 263 : if (t == NULL_TREE)
957 : : {
958 : 153 : t = build_function_type_list (void_type_node, NULL_TREE);
959 : 153 : t = build_decl (UNKNOWN_LOCATION,
960 : : FUNCTION_DECL, get_identifier ("__stack_chk_fail"), t);
961 : 153 : TREE_STATIC (t) = 1;
962 : 153 : TREE_PUBLIC (t) = 1;
963 : 153 : DECL_EXTERNAL (t) = 1;
964 : 153 : TREE_USED (t) = 1;
965 : 153 : TREE_THIS_VOLATILE (t) = 1;
966 : 153 : TREE_NOTHROW (t) = 1;
967 : 153 : DECL_ARTIFICIAL (t) = 1;
968 : 153 : DECL_IGNORED_P (t) = 1;
969 : 153 : DECL_VISIBILITY (t) = VISIBILITY_DEFAULT;
970 : 153 : DECL_VISIBILITY_SPECIFIED (t) = 1;
971 : :
972 : 153 : stack_chk_fail_decl = t;
973 : : }
974 : :
975 : 263 : return build_call_expr (t, 0);
976 : : }
977 : :
978 : : tree
979 : 1 : default_hidden_stack_protect_fail (void)
980 : : {
981 : : #ifndef HAVE_GAS_HIDDEN
982 : : return default_external_stack_protect_fail ();
983 : : #else
984 : 1 : tree t = stack_chk_fail_decl;
985 : :
986 : 1 : if (!flag_pic)
987 : 1 : return default_external_stack_protect_fail ();
988 : :
989 : 0 : if (t == NULL_TREE)
990 : : {
991 : 0 : t = build_function_type_list (void_type_node, NULL_TREE);
992 : 0 : t = build_decl (UNKNOWN_LOCATION, FUNCTION_DECL,
993 : : get_identifier ("__stack_chk_fail_local"), t);
994 : 0 : TREE_STATIC (t) = 1;
995 : 0 : TREE_PUBLIC (t) = 1;
996 : 0 : DECL_EXTERNAL (t) = 1;
997 : 0 : TREE_USED (t) = 1;
998 : 0 : TREE_THIS_VOLATILE (t) = 1;
999 : 0 : TREE_NOTHROW (t) = 1;
1000 : 0 : DECL_ARTIFICIAL (t) = 1;
1001 : 0 : DECL_IGNORED_P (t) = 1;
1002 : 0 : DECL_VISIBILITY_SPECIFIED (t) = 1;
1003 : 0 : DECL_VISIBILITY (t) = VISIBILITY_HIDDEN;
1004 : :
1005 : 0 : stack_chk_fail_decl = t;
1006 : : }
1007 : :
1008 : 0 : return build_call_expr (t, 0);
1009 : : #endif
1010 : : }
1011 : :
1012 : : bool
1013 : 71722093 : hook_bool_const_rtx_commutative_p (const_rtx x,
1014 : : int outer_code ATTRIBUTE_UNUSED)
1015 : : {
1016 : 71722093 : return COMMUTATIVE_P (x);
1017 : : }
1018 : :
1019 : : rtx
1020 : 0 : default_function_value (const_tree ret_type ATTRIBUTE_UNUSED,
1021 : : const_tree fn_decl_or_type,
1022 : : bool outgoing ATTRIBUTE_UNUSED)
1023 : : {
1024 : : /* The old interface doesn't handle receiving the function type. */
1025 : 0 : if (fn_decl_or_type
1026 : : && !DECL_P (fn_decl_or_type))
1027 : : fn_decl_or_type = NULL;
1028 : :
1029 : : #ifdef FUNCTION_VALUE
1030 : : return FUNCTION_VALUE (ret_type, fn_decl_or_type);
1031 : : #else
1032 : 0 : gcc_unreachable ();
1033 : : #endif
1034 : : }
1035 : :
1036 : : rtx
1037 : 107900 : default_libcall_value (machine_mode mode ATTRIBUTE_UNUSED,
1038 : : const_rtx fun ATTRIBUTE_UNUSED)
1039 : : {
1040 : : #ifdef LIBCALL_VALUE
1041 : 107900 : return LIBCALL_VALUE (MACRO_MODE (mode));
1042 : : #else
1043 : : gcc_unreachable ();
1044 : : #endif
1045 : : }
1046 : :
1047 : : /* The default hook for TARGET_FUNCTION_VALUE_REGNO_P. */
1048 : :
1049 : : bool
1050 : 0 : default_function_value_regno_p (const unsigned int regno ATTRIBUTE_UNUSED)
1051 : : {
1052 : : #ifdef FUNCTION_VALUE_REGNO_P
1053 : : return FUNCTION_VALUE_REGNO_P (regno);
1054 : : #else
1055 : 0 : gcc_unreachable ();
1056 : : #endif
1057 : : }
1058 : :
1059 : : /* Choose the mode and rtx to use to zero REGNO, storing tem in PMODE and
1060 : : PREGNO_RTX and returning TRUE if successful, otherwise returning FALSE. If
1061 : : the natural mode for REGNO doesn't work, attempt to group it with subsequent
1062 : : adjacent registers set in TOZERO. */
1063 : :
1064 : : static inline bool
1065 : 0 : zcur_select_mode_rtx (unsigned int regno, machine_mode *pmode,
1066 : : rtx *pregno_rtx, HARD_REG_SET tozero)
1067 : : {
1068 : 0 : rtx regno_rtx = regno_reg_rtx[regno];
1069 : 0 : machine_mode mode = GET_MODE (regno_rtx);
1070 : :
1071 : : /* If the natural mode doesn't work, try some wider mode. */
1072 : 0 : if (!targetm.hard_regno_mode_ok (regno, mode))
1073 : : {
1074 : : bool found = false;
1075 : 0 : for (int nregs = 2;
1076 : 0 : !found && nregs <= hard_regno_max_nregs
1077 : 0 : && regno + nregs <= FIRST_PSEUDO_REGISTER
1078 : 0 : && TEST_HARD_REG_BIT (tozero,
1079 : : regno + nregs - 1);
1080 : : nregs++)
1081 : : {
1082 : 0 : mode = choose_hard_reg_mode (regno, nregs, 0);
1083 : 0 : if (mode == E_VOIDmode)
1084 : 0 : continue;
1085 : 0 : gcc_checking_assert (targetm.hard_regno_mode_ok (regno, mode));
1086 : 0 : regno_rtx = gen_rtx_REG (mode, regno);
1087 : 0 : found = true;
1088 : : }
1089 : 0 : if (!found)
1090 : : return false;
1091 : : }
1092 : :
1093 : 0 : *pmode = mode;
1094 : 0 : *pregno_rtx = regno_rtx;
1095 : 0 : return true;
1096 : : }
1097 : :
1098 : : /* The default hook for TARGET_ZERO_CALL_USED_REGS. */
1099 : :
1100 : : HARD_REG_SET
1101 : 0 : default_zero_call_used_regs (HARD_REG_SET need_zeroed_hardregs)
1102 : : {
1103 : 0 : gcc_assert (!hard_reg_set_empty_p (need_zeroed_hardregs));
1104 : :
1105 : : HARD_REG_SET failed;
1106 : 0 : CLEAR_HARD_REG_SET (failed);
1107 : : bool progress = false;
1108 : :
1109 : : /* First, try to zero each register in need_zeroed_hardregs by
1110 : : loading a zero into it, taking note of any failures in
1111 : : FAILED. */
1112 : 0 : for (unsigned int regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1113 : 0 : if (TEST_HARD_REG_BIT (need_zeroed_hardregs, regno))
1114 : : {
1115 : 0 : rtx_insn *last_insn = get_last_insn ();
1116 : 0 : rtx regno_rtx;
1117 : 0 : machine_mode mode;
1118 : :
1119 : 0 : if (!zcur_select_mode_rtx (regno, &mode, ®no_rtx,
1120 : : need_zeroed_hardregs))
1121 : : {
1122 : 0 : SET_HARD_REG_BIT (failed, regno);
1123 : 0 : continue;
1124 : : }
1125 : :
1126 : 0 : rtx zero = CONST0_RTX (mode);
1127 : 0 : rtx_insn *insn = emit_move_insn (regno_rtx, zero);
1128 : 0 : if (!valid_insn_p (insn))
1129 : : {
1130 : 0 : SET_HARD_REG_BIT (failed, regno);
1131 : 0 : delete_insns_since (last_insn);
1132 : : }
1133 : : else
1134 : : {
1135 : 0 : progress = true;
1136 : 0 : regno += hard_regno_nregs (regno, mode) - 1;
1137 : : }
1138 : : }
1139 : :
1140 : : /* Now retry with copies from zeroed registers, as long as we've
1141 : : made some PROGRESS, and registers remain to be zeroed in
1142 : : FAILED. */
1143 : 0 : while (progress && !hard_reg_set_empty_p (failed))
1144 : : {
1145 : 0 : HARD_REG_SET retrying = failed;
1146 : :
1147 : 0 : CLEAR_HARD_REG_SET (failed);
1148 : : progress = false;
1149 : :
1150 : 0 : for (unsigned int regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1151 : 0 : if (TEST_HARD_REG_BIT (retrying, regno))
1152 : : {
1153 : 0 : rtx regno_rtx;
1154 : 0 : machine_mode mode;
1155 : :
1156 : : /* This might select registers we've already zeroed. If grouping
1157 : : with them is what it takes to get regno zeroed, so be it. */
1158 : 0 : if (!zcur_select_mode_rtx (regno, &mode, ®no_rtx,
1159 : : need_zeroed_hardregs))
1160 : : {
1161 : 0 : SET_HARD_REG_BIT (failed, regno);
1162 : 0 : continue;
1163 : : }
1164 : :
1165 : 0 : bool success = false;
1166 : : /* Look for a source. */
1167 : 0 : for (unsigned int src = 0; src < FIRST_PSEUDO_REGISTER; src++)
1168 : : {
1169 : : /* If SRC hasn't been zeroed (yet?), skip it. */
1170 : 0 : if (! TEST_HARD_REG_BIT (need_zeroed_hardregs, src))
1171 : 0 : continue;
1172 : 0 : if (TEST_HARD_REG_BIT (retrying, src))
1173 : 0 : continue;
1174 : :
1175 : : /* Check that SRC can hold MODE, and that any other
1176 : : registers needed to hold MODE in SRC have also been
1177 : : zeroed. */
1178 : 0 : if (!targetm.hard_regno_mode_ok (src, mode))
1179 : 0 : continue;
1180 : 0 : unsigned n = targetm.hard_regno_nregs (src, mode);
1181 : 0 : bool ok = true;
1182 : 0 : for (unsigned i = 1; ok && i < n; i++)
1183 : 0 : ok = (TEST_HARD_REG_BIT (need_zeroed_hardregs, src + i)
1184 : 0 : && !TEST_HARD_REG_BIT (retrying, src + i));
1185 : 0 : if (!ok)
1186 : 0 : continue;
1187 : :
1188 : : /* SRC is usable, try to copy from it. */
1189 : 0 : rtx_insn *last_insn = get_last_insn ();
1190 : 0 : rtx src_rtx = gen_rtx_REG (mode, src);
1191 : 0 : rtx_insn *insn = emit_move_insn (regno_rtx, src_rtx);
1192 : 0 : if (!valid_insn_p (insn))
1193 : : /* It didn't work, remove any inserts. We'll look
1194 : : for another SRC. */
1195 : 0 : delete_insns_since (last_insn);
1196 : : else
1197 : : {
1198 : : /* We're done for REGNO. */
1199 : : success = true;
1200 : : break;
1201 : : }
1202 : : }
1203 : :
1204 : : /* If nothing worked for REGNO this round, mark it to be
1205 : : retried if we get another round. */
1206 : 0 : if (!success)
1207 : 0 : SET_HARD_REG_BIT (failed, regno);
1208 : : else
1209 : : {
1210 : : /* Take note so as to enable another round if needed. */
1211 : 0 : progress = true;
1212 : 0 : regno += hard_regno_nregs (regno, mode) - 1;
1213 : : }
1214 : : }
1215 : : }
1216 : :
1217 : : /* If any register remained, report it. */
1218 : 0 : if (!progress)
1219 : : {
1220 : 0 : static bool issued_error;
1221 : 0 : if (!issued_error)
1222 : : {
1223 : 0 : const char *name = NULL;
1224 : 0 : for (unsigned int i = 0; zero_call_used_regs_opts[i].name != NULL;
1225 : : ++i)
1226 : 0 : if (flag_zero_call_used_regs == zero_call_used_regs_opts[i].flag)
1227 : : {
1228 : : name = zero_call_used_regs_opts[i].name;
1229 : : break;
1230 : : }
1231 : :
1232 : 0 : if (!name)
1233 : 0 : name = "";
1234 : :
1235 : 0 : issued_error = true;
1236 : 0 : sorry ("argument %qs is not supported for %qs on this target",
1237 : : name, "-fzero-call-used-regs");
1238 : : }
1239 : : }
1240 : :
1241 : 0 : return need_zeroed_hardregs;
1242 : : }
1243 : :
1244 : : rtx
1245 : 0 : default_internal_arg_pointer (void)
1246 : : {
1247 : : /* If the reg that the virtual arg pointer will be translated into is
1248 : : not a fixed reg or is the stack pointer, make a copy of the virtual
1249 : : arg pointer, and address parms via the copy. The frame pointer is
1250 : : considered fixed even though it is not marked as such. */
1251 : 0 : if ((ARG_POINTER_REGNUM == STACK_POINTER_REGNUM
1252 : 0 : || ! (fixed_regs[ARG_POINTER_REGNUM]
1253 : : || ARG_POINTER_REGNUM == FRAME_POINTER_REGNUM)))
1254 : 0 : return copy_to_reg (virtual_incoming_args_rtx);
1255 : : else
1256 : 0 : return virtual_incoming_args_rtx;
1257 : : }
1258 : :
1259 : : rtx
1260 : 0 : default_static_chain (const_tree ARG_UNUSED (fndecl_or_type), bool incoming_p)
1261 : : {
1262 : 0 : if (incoming_p)
1263 : : {
1264 : : #ifdef STATIC_CHAIN_INCOMING_REGNUM
1265 : : return gen_rtx_REG (Pmode, STATIC_CHAIN_INCOMING_REGNUM);
1266 : : #endif
1267 : : }
1268 : :
1269 : : #ifdef STATIC_CHAIN_REGNUM
1270 : : return gen_rtx_REG (Pmode, STATIC_CHAIN_REGNUM);
1271 : : #endif
1272 : :
1273 : 0 : {
1274 : 0 : static bool issued_error;
1275 : 0 : if (!issued_error)
1276 : : {
1277 : 0 : issued_error = true;
1278 : 0 : sorry ("nested functions not supported on this target");
1279 : : }
1280 : :
1281 : : /* It really doesn't matter what we return here, so long at it
1282 : : doesn't cause the rest of the compiler to crash. */
1283 : 0 : return gen_rtx_MEM (Pmode, stack_pointer_rtx);
1284 : : }
1285 : : }
1286 : :
1287 : : void
1288 : 0 : default_trampoline_init (rtx ARG_UNUSED (m_tramp), tree ARG_UNUSED (t_func),
1289 : : rtx ARG_UNUSED (r_chain))
1290 : : {
1291 : 0 : sorry ("nested function trampolines not supported on this target");
1292 : 0 : }
1293 : :
1294 : : poly_int64
1295 : 0 : default_return_pops_args (tree, tree, poly_int64)
1296 : : {
1297 : 0 : return 0;
1298 : : }
1299 : :
1300 : : reg_class_t
1301 : 49555498 : default_ira_change_pseudo_allocno_class (int regno ATTRIBUTE_UNUSED,
1302 : : reg_class_t cl,
1303 : : reg_class_t best_cl ATTRIBUTE_UNUSED)
1304 : : {
1305 : 49555498 : return cl;
1306 : : }
1307 : :
1308 : : int
1309 : 0 : default_ira_callee_saved_register_cost_scale (int)
1310 : : {
1311 : 0 : return (optimize_size
1312 : 0 : ? 1
1313 : 0 : : REG_FREQ_FROM_BB (ENTRY_BLOCK_PTR_FOR_FN (cfun)));
1314 : : }
1315 : :
1316 : : extern bool
1317 : 304707600 : default_lra_p (void)
1318 : : {
1319 : 304707600 : return true;
1320 : : }
1321 : :
1322 : : int
1323 : 0 : default_register_priority (int hard_regno ATTRIBUTE_UNUSED)
1324 : : {
1325 : 0 : return 0;
1326 : : }
1327 : :
1328 : : extern bool
1329 : 0 : default_register_usage_leveling_p (void)
1330 : : {
1331 : 0 : return false;
1332 : : }
1333 : :
1334 : : extern bool
1335 : 4838470 : default_different_addr_displacement_p (void)
1336 : : {
1337 : 4838470 : return false;
1338 : : }
1339 : :
1340 : : reg_class_t
1341 : 0 : default_secondary_reload (bool in_p ATTRIBUTE_UNUSED, rtx x ATTRIBUTE_UNUSED,
1342 : : reg_class_t reload_class_i ATTRIBUTE_UNUSED,
1343 : : machine_mode reload_mode ATTRIBUTE_UNUSED,
1344 : : secondary_reload_info *sri)
1345 : : {
1346 : 0 : enum reg_class rclass = NO_REGS;
1347 : 0 : enum reg_class reload_class = (enum reg_class) reload_class_i;
1348 : :
1349 : 0 : if (sri->prev_sri && sri->prev_sri->t_icode != CODE_FOR_nothing)
1350 : : {
1351 : 0 : sri->icode = sri->prev_sri->t_icode;
1352 : 0 : return NO_REGS;
1353 : : }
1354 : : #ifdef SECONDARY_INPUT_RELOAD_CLASS
1355 : : if (in_p)
1356 : : rclass = SECONDARY_INPUT_RELOAD_CLASS (reload_class,
1357 : : MACRO_MODE (reload_mode), x);
1358 : : #endif
1359 : : #ifdef SECONDARY_OUTPUT_RELOAD_CLASS
1360 : : if (! in_p)
1361 : : rclass = SECONDARY_OUTPUT_RELOAD_CLASS (reload_class,
1362 : : MACRO_MODE (reload_mode), x);
1363 : : #endif
1364 : : if (rclass != NO_REGS)
1365 : : {
1366 : : enum insn_code icode
1367 : : = direct_optab_handler (in_p ? reload_in_optab : reload_out_optab,
1368 : : reload_mode);
1369 : :
1370 : : if (icode != CODE_FOR_nothing
1371 : : && !insn_operand_matches (icode, in_p, x))
1372 : : icode = CODE_FOR_nothing;
1373 : : else if (icode != CODE_FOR_nothing)
1374 : : {
1375 : : const char *insn_constraint, *scratch_constraint;
1376 : : enum reg_class insn_class, scratch_class;
1377 : :
1378 : : gcc_assert (insn_data[(int) icode].n_operands == 3);
1379 : : insn_constraint = insn_data[(int) icode].operand[!in_p].constraint;
1380 : : if (!*insn_constraint)
1381 : : insn_class = ALL_REGS;
1382 : : else
1383 : : {
1384 : : if (in_p)
1385 : : {
1386 : : gcc_assert (*insn_constraint == '=');
1387 : : insn_constraint++;
1388 : : }
1389 : : insn_class = (reg_class_for_constraint
1390 : : (lookup_constraint (insn_constraint)));
1391 : : gcc_assert (insn_class != NO_REGS);
1392 : : }
1393 : :
1394 : : scratch_constraint = insn_data[(int) icode].operand[2].constraint;
1395 : : /* The scratch register's constraint must start with "=&",
1396 : : except for an input reload, where only "=" is necessary,
1397 : : and where it might be beneficial to re-use registers from
1398 : : the input. */
1399 : : gcc_assert (scratch_constraint[0] == '='
1400 : : && (in_p || scratch_constraint[1] == '&'));
1401 : : scratch_constraint++;
1402 : : if (*scratch_constraint == '&')
1403 : : scratch_constraint++;
1404 : : scratch_class = (reg_class_for_constraint
1405 : : (lookup_constraint (scratch_constraint)));
1406 : :
1407 : : if (reg_class_subset_p (reload_class, insn_class))
1408 : : {
1409 : : gcc_assert (scratch_class == rclass);
1410 : : rclass = NO_REGS;
1411 : : }
1412 : : else
1413 : : rclass = insn_class;
1414 : :
1415 : : }
1416 : : if (rclass == NO_REGS)
1417 : : sri->icode = icode;
1418 : : else
1419 : : sri->t_icode = icode;
1420 : : }
1421 : : return rclass;
1422 : : }
1423 : :
1424 : : /* The default implementation of TARGET_SECONDARY_MEMORY_NEEDED_MODE. */
1425 : :
1426 : : machine_mode
1427 : 0 : default_secondary_memory_needed_mode (machine_mode mode)
1428 : : {
1429 : 0 : if (!targetm.lra_p ()
1430 : 0 : && known_lt (GET_MODE_BITSIZE (mode), BITS_PER_WORD)
1431 : 0 : && INTEGRAL_MODE_P (mode))
1432 : 0 : return mode_for_size (BITS_PER_WORD, GET_MODE_CLASS (mode), 0).require ();
1433 : : return mode;
1434 : : }
1435 : :
1436 : : /* By default, if flag_pic is true, then neither local nor global relocs
1437 : : should be placed in readonly memory. */
1438 : :
1439 : : int
1440 : 0 : default_reloc_rw_mask (void)
1441 : : {
1442 : 0 : return flag_pic ? 3 : 0;
1443 : : }
1444 : :
1445 : : /* By default, address diff vectors are generated
1446 : : for jump tables when flag_pic is true. */
1447 : :
1448 : : bool
1449 : 19447 : default_generate_pic_addr_diff_vec (void)
1450 : : {
1451 : 19447 : return flag_pic;
1452 : : }
1453 : :
1454 : : /* Record an element in the table of global constructors. SYMBOL is
1455 : : a SYMBOL_REF of the function to be called; PRIORITY is a number
1456 : : between 0 and MAX_INIT_PRIORITY. */
1457 : :
1458 : : void
1459 : 0 : default_asm_out_constructor (rtx symbol ATTRIBUTE_UNUSED,
1460 : : int priority ATTRIBUTE_UNUSED)
1461 : : {
1462 : 0 : sorry ("global constructors not supported on this target");
1463 : 0 : }
1464 : :
1465 : : /* Likewise for global destructors. */
1466 : :
1467 : : void
1468 : 0 : default_asm_out_destructor (rtx symbol ATTRIBUTE_UNUSED,
1469 : : int priority ATTRIBUTE_UNUSED)
1470 : : {
1471 : 0 : sorry ("global destructors not supported on this target");
1472 : 0 : }
1473 : :
1474 : : /* By default, do no modification. */
1475 : 0 : tree default_mangle_decl_assembler_name (tree decl ATTRIBUTE_UNUSED,
1476 : : tree id)
1477 : : {
1478 : 0 : return id;
1479 : : }
1480 : :
1481 : : /* The default implementation of TARGET_STATIC_RTX_ALIGNMENT. */
1482 : :
1483 : : HOST_WIDE_INT
1484 : 0 : default_static_rtx_alignment (machine_mode mode)
1485 : : {
1486 : 0 : return GET_MODE_ALIGNMENT (mode);
1487 : : }
1488 : :
1489 : : /* The default implementation of TARGET_CONSTANT_ALIGNMENT. */
1490 : :
1491 : : HOST_WIDE_INT
1492 : 0 : default_constant_alignment (const_tree, HOST_WIDE_INT align)
1493 : : {
1494 : 0 : return align;
1495 : : }
1496 : :
1497 : : /* An implementation of TARGET_CONSTANT_ALIGNMENT that aligns strings
1498 : : to at least BITS_PER_WORD but otherwise makes no changes. */
1499 : :
1500 : : HOST_WIDE_INT
1501 : 0 : constant_alignment_word_strings (const_tree exp, HOST_WIDE_INT align)
1502 : : {
1503 : 0 : if (TREE_CODE (exp) == STRING_CST)
1504 : 0 : return MAX (align, BITS_PER_WORD);
1505 : : return align;
1506 : : }
1507 : :
1508 : : /* Default to natural alignment for vector types, bounded by
1509 : : MAX_OFILE_ALIGNMENT. */
1510 : :
1511 : : HOST_WIDE_INT
1512 : 69786840 : default_vector_alignment (const_tree type)
1513 : : {
1514 : 69786840 : unsigned HOST_WIDE_INT align = MAX_OFILE_ALIGNMENT;
1515 : 69786840 : tree size = TYPE_SIZE (type);
1516 : 69786840 : if (tree_fits_uhwi_p (size))
1517 : 69786840 : align = tree_to_uhwi (size);
1518 : 69786840 : if (align >= MAX_OFILE_ALIGNMENT)
1519 : : return MAX_OFILE_ALIGNMENT;
1520 : 69786833 : return MAX (align, GET_MODE_ALIGNMENT (TYPE_MODE (type)));
1521 : : }
1522 : :
1523 : : /* The default implementation of
1524 : : TARGET_VECTORIZE_PREFERRED_VECTOR_ALIGNMENT. */
1525 : :
1526 : : poly_uint64
1527 : 6681514 : default_preferred_vector_alignment (const_tree type)
1528 : : {
1529 : 6681514 : return TYPE_ALIGN (type);
1530 : : }
1531 : :
1532 : : /* The default implementation of
1533 : : TARGET_VECTORIZE_PREFERRED_DIV_AS_SHIFTS_OVER_MULT. */
1534 : :
1535 : : bool
1536 : 20992 : default_preferred_div_as_shifts_over_mult (const_tree type)
1537 : : {
1538 : 20992 : return !can_mult_highpart_p (TYPE_MODE (type), TYPE_UNSIGNED (type));
1539 : : }
1540 : :
1541 : : /* By default assume vectors of element TYPE require a multiple of the natural
1542 : : alignment of TYPE. TYPE is naturally aligned if IS_PACKED is false. */
1543 : : bool
1544 : 180002 : default_builtin_vector_alignment_reachable (const_tree /*type*/, bool is_packed)
1545 : : {
1546 : 180002 : return ! is_packed;
1547 : : }
1548 : :
1549 : : /* By default, assume that a target supports any factor of misalignment
1550 : : memory access if it supports movmisalign patten.
1551 : : is_packed is true if the memory access is defined in a packed struct. */
1552 : : bool
1553 : 1445366 : default_builtin_support_vector_misalignment (machine_mode mode,
1554 : : const_tree type
1555 : : ATTRIBUTE_UNUSED,
1556 : : int misalignment
1557 : : ATTRIBUTE_UNUSED,
1558 : : bool is_packed
1559 : : ATTRIBUTE_UNUSED,
1560 : : bool is_gather_scatter
1561 : : ATTRIBUTE_UNUSED)
1562 : : {
1563 : 1445366 : if (optab_handler (movmisalign_optab, mode) != CODE_FOR_nothing)
1564 : 1445189 : return true;
1565 : : return false;
1566 : : }
1567 : :
1568 : : /* By default, only attempt to parallelize bitwise operations, and
1569 : : possibly adds/subtracts using bit-twiddling. */
1570 : :
1571 : : machine_mode
1572 : 0 : default_preferred_simd_mode (scalar_mode)
1573 : : {
1574 : 0 : return word_mode;
1575 : : }
1576 : :
1577 : : /* By default do not split reductions further. */
1578 : :
1579 : : machine_mode
1580 : 0 : default_split_reduction (machine_mode mode)
1581 : : {
1582 : 0 : return mode;
1583 : : }
1584 : :
1585 : : /* By default only the preferred vector mode is tried. */
1586 : :
1587 : : unsigned int
1588 : 0 : default_autovectorize_vector_modes (vector_modes *, bool)
1589 : : {
1590 : 0 : return 0;
1591 : : }
1592 : :
1593 : : /* The default implementation of TARGET_VECTORIZE_RELATED_MODE. */
1594 : :
1595 : : opt_machine_mode
1596 : 33309094 : default_vectorize_related_mode (machine_mode vector_mode,
1597 : : scalar_mode element_mode,
1598 : : poly_uint64 nunits)
1599 : : {
1600 : 33309094 : machine_mode result_mode;
1601 : 33309094 : if ((maybe_ne (nunits, 0U)
1602 : 56739227 : || multiple_p (GET_MODE_SIZE (vector_mode),
1603 : 29363571 : GET_MODE_SIZE (element_mode), &nunits))
1604 : 31321179 : && mode_for_vector (element_mode, nunits).exists (&result_mode)
1605 : 31155014 : && VECTOR_MODE_P (result_mode)
1606 : 64462850 : && targetm.vector_mode_supported_p (result_mode))
1607 : 31144910 : return result_mode;
1608 : :
1609 : 2164184 : return opt_machine_mode ();
1610 : : }
1611 : :
1612 : : /* By default a vector of integers is used as a mask. */
1613 : :
1614 : : opt_machine_mode
1615 : 0 : default_get_mask_mode (machine_mode mode)
1616 : : {
1617 : 0 : return related_int_vector_mode (mode);
1618 : : }
1619 : :
1620 : : /* By default consider masked stores to be expensive. */
1621 : :
1622 : : bool
1623 : 7779 : default_conditional_operation_is_expensive (unsigned ifn)
1624 : : {
1625 : 7779 : return ifn == IFN_MASK_STORE;
1626 : : }
1627 : :
1628 : : /* By default consider masked stores to be expensive. */
1629 : :
1630 : : bool
1631 : 448 : default_empty_mask_is_expensive (unsigned ifn)
1632 : : {
1633 : 448 : return ifn == IFN_MASK_STORE;
1634 : : }
1635 : :
1636 : : /* By default, the cost model accumulates three separate costs (prologue,
1637 : : loop body, and epilogue) for a vectorized loop or block. So allocate an
1638 : : array of three unsigned ints, set it to zero, and return its address. */
1639 : :
1640 : : vector_costs *
1641 : 0 : default_vectorize_create_costs (vec_info *vinfo, bool costing_for_scalar)
1642 : : {
1643 : 0 : return new vector_costs (vinfo, costing_for_scalar);
1644 : : }
1645 : :
1646 : : /* Determine whether or not a pointer mode is valid. Assume defaults
1647 : : of ptr_mode or Pmode - can be overridden. */
1648 : : bool
1649 : 7425972 : default_valid_pointer_mode (scalar_int_mode mode)
1650 : : {
1651 : 7425972 : return (mode == ptr_mode || mode == Pmode);
1652 : : }
1653 : :
1654 : : /* Determine whether the memory reference specified by REF may alias
1655 : : the C libraries errno location. */
1656 : : bool
1657 : 1135300 : default_ref_may_alias_errno (ao_ref *ref)
1658 : : {
1659 : 1135300 : tree base = ao_ref_base (ref);
1660 : : /* The default implementation assumes the errno location is
1661 : : a declaration of type int or is always accessed via a
1662 : : pointer to int. We assume that accesses to errno are
1663 : : not deliberately obfuscated (even in conforming ways). */
1664 : 1135300 : if (TYPE_UNSIGNED (TREE_TYPE (base))
1665 : 1135300 : || TYPE_MODE (TREE_TYPE (base)) != TYPE_MODE (integer_type_node))
1666 : 989023 : return false;
1667 : : /* The default implementation assumes an errno location declaration
1668 : : is never defined in the current compilation unit and may not be
1669 : : aliased by a local variable. */
1670 : 146277 : if (DECL_P (base)
1671 : 107279 : && DECL_EXTERNAL (base)
1672 : 147626 : && !TREE_STATIC (base))
1673 : : return true;
1674 : 146188 : else if (TREE_CODE (base) == MEM_REF
1675 : 146188 : && TREE_CODE (TREE_OPERAND (base, 0)) == SSA_NAME)
1676 : : {
1677 : 36526 : struct ptr_info_def *pi = SSA_NAME_PTR_INFO (TREE_OPERAND (base, 0));
1678 : 53133 : return !pi || pi->pt.anything || pi->pt.nonlocal;
1679 : : }
1680 : : return false;
1681 : : }
1682 : :
1683 : : /* Return the mode for a pointer to a given ADDRSPACE,
1684 : : defaulting to ptr_mode for all address spaces. */
1685 : :
1686 : : scalar_int_mode
1687 : 2550115278 : default_addr_space_pointer_mode (addr_space_t addrspace ATTRIBUTE_UNUSED)
1688 : : {
1689 : 2550115278 : return ptr_mode;
1690 : : }
1691 : :
1692 : : /* Return the mode for an address in a given ADDRSPACE,
1693 : : defaulting to Pmode for all address spaces. */
1694 : :
1695 : : scalar_int_mode
1696 : 98775632 : default_addr_space_address_mode (addr_space_t addrspace ATTRIBUTE_UNUSED)
1697 : : {
1698 : 98775632 : return Pmode;
1699 : : }
1700 : :
1701 : : /* Named address space version of valid_pointer_mode.
1702 : : To match the above, the same modes apply to all address spaces. */
1703 : :
1704 : : bool
1705 : 7425972 : default_addr_space_valid_pointer_mode (scalar_int_mode mode,
1706 : : addr_space_t as ATTRIBUTE_UNUSED)
1707 : : {
1708 : 7425972 : return targetm.valid_pointer_mode (mode);
1709 : : }
1710 : :
1711 : : /* Some places still assume that all pointer or address modes are the
1712 : : standard Pmode and ptr_mode. These optimizations become invalid if
1713 : : the target actually supports multiple different modes. For now,
1714 : : we disable such optimizations on such targets, using this function. */
1715 : :
1716 : : bool
1717 : 689791550 : target_default_pointer_address_modes_p (void)
1718 : : {
1719 : 689791550 : if (targetm.addr_space.address_mode != default_addr_space_address_mode)
1720 : : return false;
1721 : 689791550 : if (targetm.addr_space.pointer_mode != default_addr_space_pointer_mode)
1722 : 0 : return false;
1723 : :
1724 : : return true;
1725 : : }
1726 : :
1727 : : /* Named address space version of legitimate_address_p.
1728 : : By default, all address spaces have the same form. */
1729 : :
1730 : : bool
1731 : 1519066081 : default_addr_space_legitimate_address_p (machine_mode mode, rtx mem,
1732 : : bool strict,
1733 : : addr_space_t as ATTRIBUTE_UNUSED,
1734 : : code_helper code)
1735 : : {
1736 : 1519066081 : return targetm.legitimate_address_p (mode, mem, strict, code);
1737 : : }
1738 : :
1739 : : /* Named address space version of LEGITIMIZE_ADDRESS.
1740 : : By default, all address spaces have the same form. */
1741 : :
1742 : : rtx
1743 : 632474 : default_addr_space_legitimize_address (rtx x, rtx oldx, machine_mode mode,
1744 : : addr_space_t as ATTRIBUTE_UNUSED)
1745 : : {
1746 : 632474 : return targetm.legitimize_address (x, oldx, mode);
1747 : : }
1748 : :
1749 : : /* The default hook for determining if one named address space is a subset of
1750 : : another and to return which address space to use as the common address
1751 : : space. */
1752 : :
1753 : : bool
1754 : 3 : default_addr_space_subset_p (addr_space_t subset, addr_space_t superset)
1755 : : {
1756 : 3 : return (subset == superset);
1757 : : }
1758 : :
1759 : : /* The default hook for determining if 0 within a named address
1760 : : space is a valid address. */
1761 : :
1762 : : bool
1763 : 0 : default_addr_space_zero_address_valid (addr_space_t as ATTRIBUTE_UNUSED)
1764 : : {
1765 : 0 : return false;
1766 : : }
1767 : :
1768 : : /* The default hook for debugging the address space is to return the
1769 : : address space number to indicate DW_AT_address_class. */
1770 : : int
1771 : 3 : default_addr_space_debug (addr_space_t as)
1772 : : {
1773 : 3 : return as;
1774 : : }
1775 : :
1776 : : /* The default hook implementation for TARGET_ADDR_SPACE_DIAGNOSE_USAGE.
1777 : : Don't complain about any address space. */
1778 : :
1779 : : void
1780 : 174 : default_addr_space_diagnose_usage (addr_space_t, location_t)
1781 : : {
1782 : 174 : }
1783 : :
1784 : :
1785 : : /* The default hook for TARGET_ADDR_SPACE_CONVERT. This hook should never be
1786 : : called for targets with only a generic address space. */
1787 : :
1788 : : rtx
1789 : 0 : default_addr_space_convert (rtx op ATTRIBUTE_UNUSED,
1790 : : tree from_type ATTRIBUTE_UNUSED,
1791 : : tree to_type ATTRIBUTE_UNUSED)
1792 : : {
1793 : 0 : gcc_unreachable ();
1794 : : }
1795 : :
1796 : : /* The defualt implementation of TARGET_HARD_REGNO_NREGS. */
1797 : :
1798 : : unsigned int
1799 : 0 : default_hard_regno_nregs (unsigned int, machine_mode mode)
1800 : : {
1801 : : /* Targets with variable-sized modes must provide their own definition
1802 : : of this hook. */
1803 : 0 : return CEIL (GET_MODE_SIZE (mode).to_constant (), UNITS_PER_WORD);
1804 : : }
1805 : :
1806 : : bool
1807 : 0 : default_hard_regno_scratch_ok (unsigned int regno ATTRIBUTE_UNUSED)
1808 : : {
1809 : 0 : return true;
1810 : : }
1811 : :
1812 : : /* The default implementation of TARGET_MODE_DEPENDENT_ADDRESS_P. */
1813 : :
1814 : : bool
1815 : 37125684 : default_mode_dependent_address_p (const_rtx addr ATTRIBUTE_UNUSED,
1816 : : addr_space_t addrspace ATTRIBUTE_UNUSED)
1817 : : {
1818 : 37125684 : return false;
1819 : : }
1820 : :
1821 : : extern bool default_new_address_profitable_p (rtx, rtx);
1822 : :
1823 : :
1824 : : /* The default implementation of TARGET_NEW_ADDRESS_PROFITABLE_P. */
1825 : :
1826 : : bool
1827 : 1097739 : default_new_address_profitable_p (rtx memref ATTRIBUTE_UNUSED,
1828 : : rtx_insn *insn ATTRIBUTE_UNUSED,
1829 : : rtx new_addr ATTRIBUTE_UNUSED)
1830 : : {
1831 : 1097739 : return true;
1832 : : }
1833 : :
1834 : : bool
1835 : 0 : default_target_option_valid_attribute_p (tree ARG_UNUSED (fndecl),
1836 : : tree ARG_UNUSED (name),
1837 : : tree ARG_UNUSED (args),
1838 : : int ARG_UNUSED (flags))
1839 : : {
1840 : 0 : warning (OPT_Wattributes,
1841 : : "%<target%> attribute is not supported on this machine");
1842 : :
1843 : 0 : return false;
1844 : : }
1845 : :
1846 : : bool
1847 : 0 : default_target_option_valid_version_attribute_p (tree ARG_UNUSED (fndecl),
1848 : : tree ARG_UNUSED (name),
1849 : : tree ARG_UNUSED (args),
1850 : : int ARG_UNUSED (flags))
1851 : : {
1852 : 0 : warning (OPT_Wattributes,
1853 : : "%<target_version%> attribute is not supported on this machine");
1854 : :
1855 : 0 : return false;
1856 : : }
1857 : :
1858 : : bool
1859 : 0 : default_target_option_pragma_parse (tree ARG_UNUSED (args),
1860 : : tree ARG_UNUSED (pop_target))
1861 : : {
1862 : : /* If args is NULL the caller is handle_pragma_pop_options (). In that case,
1863 : : emit no warning because "#pragma GCC pop_target" is valid on targets that
1864 : : do not have the "target" pragma. */
1865 : 0 : if (args)
1866 : 0 : warning (OPT_Wpragmas,
1867 : : "%<#pragma GCC target%> is not supported for this machine");
1868 : :
1869 : 0 : return false;
1870 : : }
1871 : :
1872 : : bool
1873 : 0 : default_target_can_inline_p (tree caller, tree callee)
1874 : : {
1875 : 0 : tree callee_opts = DECL_FUNCTION_SPECIFIC_TARGET (callee);
1876 : 0 : tree caller_opts = DECL_FUNCTION_SPECIFIC_TARGET (caller);
1877 : 0 : if (! callee_opts)
1878 : 0 : callee_opts = target_option_default_node;
1879 : 0 : if (! caller_opts)
1880 : 0 : caller_opts = target_option_default_node;
1881 : :
1882 : : /* If both caller and callee have attributes, assume that if the
1883 : : pointer is different, the two functions have different target
1884 : : options since build_target_option_node uses a hash table for the
1885 : : options. */
1886 : 0 : return callee_opts == caller_opts;
1887 : : }
1888 : :
1889 : : /* By default, return false to not need to collect any target information
1890 : : for inlining. Target maintainer should re-define the hook if the
1891 : : target want to take advantage of it. */
1892 : :
1893 : : bool
1894 : 5853885 : default_need_ipa_fn_target_info (const_tree, unsigned int &)
1895 : : {
1896 : 5853885 : return false;
1897 : : }
1898 : :
1899 : : bool
1900 : 0 : default_update_ipa_fn_target_info (unsigned int &, const gimple *)
1901 : : {
1902 : 0 : return false;
1903 : : }
1904 : :
1905 : : /* If the machine does not have a case insn that compares the bounds,
1906 : : this means extra overhead for dispatch tables, which raises the
1907 : : threshold for using them. */
1908 : :
1909 : : unsigned int
1910 : 6805497 : default_case_values_threshold (void)
1911 : : {
1912 : 6805497 : return (targetm.have_casesi () ? 4 : 5);
1913 : : }
1914 : :
1915 : : bool
1916 : 117894280 : default_have_conditional_execution (void)
1917 : : {
1918 : 117894280 : return HAVE_conditional_execution;
1919 : : }
1920 : :
1921 : : bool
1922 : 0 : default_have_ccmp (void)
1923 : : {
1924 : 0 : return targetm.gen_ccmp_first != NULL;
1925 : : }
1926 : :
1927 : : /* By default we assume that c99 functions are present at the runtime,
1928 : : but sincos is not. */
1929 : : bool
1930 : 0 : default_libc_has_function (enum function_class fn_class,
1931 : : tree type ATTRIBUTE_UNUSED)
1932 : : {
1933 : 0 : if (fn_class == function_c94
1934 : : || fn_class == function_c99_misc
1935 : : || fn_class == function_c99_math_complex)
1936 : 0 : return true;
1937 : :
1938 : : return false;
1939 : : }
1940 : :
1941 : : /* By default assume that libc has not a fast implementation. */
1942 : :
1943 : : bool
1944 : 0 : default_libc_has_fast_function (int fcode ATTRIBUTE_UNUSED)
1945 : : {
1946 : 0 : return false;
1947 : : }
1948 : :
1949 : : bool
1950 : 0 : gnu_libc_has_function (enum function_class fn_class ATTRIBUTE_UNUSED,
1951 : : tree type ATTRIBUTE_UNUSED)
1952 : : {
1953 : 0 : return true;
1954 : : }
1955 : :
1956 : : bool
1957 : 0 : no_c99_libc_has_function (enum function_class fn_class ATTRIBUTE_UNUSED,
1958 : : tree type ATTRIBUTE_UNUSED)
1959 : : {
1960 : 0 : return false;
1961 : : }
1962 : :
1963 : : /* Assume some c99 functions are present at the runtime including sincos. */
1964 : : bool
1965 : 0 : bsd_libc_has_function (enum function_class fn_class,
1966 : : tree type ATTRIBUTE_UNUSED)
1967 : : {
1968 : 0 : if (fn_class == function_c94
1969 : 0 : || fn_class == function_c99_misc
1970 : 0 : || fn_class == function_sincos)
1971 : : return true;
1972 : :
1973 : : return false;
1974 : : }
1975 : :
1976 : : /* By default, -fhardened will add -D_FORTIFY_SOURCE=2. */
1977 : :
1978 : : unsigned
1979 : 0 : default_fortify_source_default_level ()
1980 : : {
1981 : 0 : return 2;
1982 : : }
1983 : :
1984 : : unsigned
1985 : 134 : default_libm_function_max_error (unsigned, machine_mode, bool)
1986 : : {
1987 : 134 : return ~0U;
1988 : : }
1989 : :
1990 : : unsigned
1991 : 76967 : glibc_linux_libm_function_max_error (unsigned cfn, machine_mode mode,
1992 : : bool boundary_p)
1993 : : {
1994 : : /* Let's use
1995 : : https://www.gnu.org/software/libc/manual/2.22/html_node/Errors-in-Math-Functions.html
1996 : : https://www.gnu.org/software/libc/manual/html_node/Errors-in-Math-Functions.html
1997 : : with usual values recorded here and significant outliers handled in
1998 : : target CPU specific overriders. The tables only record default
1999 : : rounding to nearest, for -frounding-math let's add some extra ulps.
2000 : : For boundary_p values (say finite results outside of [-1.,1.] for
2001 : : sin/cos, or [-0.,+Inf] for sqrt etc. let's use custom random testers. */
2002 : 76967 : int rnd = flag_rounding_math ? 4 : 0;
2003 : 76967 : bool sf = (REAL_MODE_FORMAT (mode) == &ieee_single_format
2004 : 56438 : || REAL_MODE_FORMAT (mode) == &mips_single_format
2005 : 133405 : || REAL_MODE_FORMAT (mode) == &motorola_single_format);
2006 : 76967 : bool df = (REAL_MODE_FORMAT (mode) == &ieee_double_format
2007 : 39278 : || REAL_MODE_FORMAT (mode) == &mips_double_format
2008 : 116245 : || REAL_MODE_FORMAT (mode) == &motorola_double_format);
2009 : 76967 : bool xf = (REAL_MODE_FORMAT (mode) == &ieee_extended_intel_96_format
2010 : 73475 : || REAL_MODE_FORMAT (mode) == &ieee_extended_intel_128_format
2011 : 137477 : || REAL_MODE_FORMAT (mode) == &ieee_extended_motorola_format);
2012 : 76967 : bool tf = (REAL_MODE_FORMAT (mode) == &ieee_quad_format
2013 : 76967 : || REAL_MODE_FORMAT (mode) == &mips_quad_format);
2014 : :
2015 : 76967 : switch (cfn)
2016 : : {
2017 : 49778 : CASE_CFN_SQRT:
2018 : 49778 : CASE_CFN_SQRT_FN:
2019 : 49778 : if (boundary_p)
2020 : : /* https://gcc.gnu.org/pipermail/gcc-patches/2023-April/616595.html */
2021 : : return 0;
2022 : 24889 : if (sf || df || xf || tf)
2023 : 24755 : return 0 + rnd;
2024 : : break;
2025 : 8966 : CASE_CFN_COS:
2026 : 8966 : CASE_CFN_COS_FN:
2027 : : /* cos is generally errors like sin, but far more arches have 2ulps
2028 : : for double. */
2029 : 8966 : if (!boundary_p && df)
2030 : 1686 : return 2 + rnd;
2031 : 25503 : gcc_fallthrough ();
2032 : 25503 : CASE_CFN_SIN:
2033 : 25503 : CASE_CFN_SIN_FN:
2034 : 25503 : if (boundary_p)
2035 : : /* According to
2036 : : https://sourceware.org/pipermail/gcc-patches/2023-April/616315.html
2037 : : seems default rounding sin/cos stay strictly in [-1.,1.] range,
2038 : : with rounding to infinity it can be 1ulp larger/smaller. */
2039 : 29870 : return flag_rounding_math ? 1 : 0;
2040 : 10542 : if (sf || df)
2041 : 6671 : return 1 + rnd;
2042 : 3871 : if (xf || tf)
2043 : 3871 : return 2 + rnd;
2044 : : break;
2045 : : default:
2046 : : break;
2047 : : }
2048 : :
2049 : 134 : return default_libm_function_max_error (cfn, mode, boundary_p);
2050 : : }
2051 : :
2052 : : tree
2053 : 0 : default_builtin_tm_load_store (tree ARG_UNUSED (type))
2054 : : {
2055 : 0 : return NULL_TREE;
2056 : : }
2057 : :
2058 : : /* Compute cost of moving registers to/from memory. */
2059 : :
2060 : : int
2061 : 0 : default_memory_move_cost (machine_mode mode ATTRIBUTE_UNUSED,
2062 : : reg_class_t rclass ATTRIBUTE_UNUSED,
2063 : : bool in ATTRIBUTE_UNUSED)
2064 : : {
2065 : : #ifndef MEMORY_MOVE_COST
2066 : 0 : return (4 + memory_move_secondary_cost (mode, (enum reg_class) rclass, in));
2067 : : #else
2068 : : return MEMORY_MOVE_COST (MACRO_MODE (mode), (enum reg_class) rclass, in);
2069 : : #endif
2070 : : }
2071 : :
2072 : : /* Compute cost of moving data from a register of class FROM to one of
2073 : : TO, using MODE. */
2074 : :
2075 : : int
2076 : 0 : default_register_move_cost (machine_mode mode ATTRIBUTE_UNUSED,
2077 : : reg_class_t from ATTRIBUTE_UNUSED,
2078 : : reg_class_t to ATTRIBUTE_UNUSED)
2079 : : {
2080 : : #ifndef REGISTER_MOVE_COST
2081 : 0 : return 2;
2082 : : #else
2083 : : return REGISTER_MOVE_COST (MACRO_MODE (mode),
2084 : : (enum reg_class) from, (enum reg_class) to);
2085 : : #endif
2086 : : }
2087 : :
2088 : : /* The default implementation of TARGET_CALLEE_SAVE_COST. */
2089 : :
2090 : : int
2091 : 0 : default_callee_save_cost (spill_cost_type spill_type, unsigned int,
2092 : : machine_mode, unsigned int, int mem_cost,
2093 : : const HARD_REG_SET &callee_saved_regs,
2094 : : bool existing_spills_p)
2095 : : {
2096 : 0 : if (!existing_spills_p)
2097 : : {
2098 : 0 : auto frame_type = (spill_type == spill_cost_type::SAVE
2099 : 0 : ? frame_cost_type::ALLOCATION
2100 : : : frame_cost_type::DEALLOCATION);
2101 : 0 : mem_cost += targetm.frame_allocation_cost (frame_type,
2102 : : callee_saved_regs);
2103 : : }
2104 : 0 : return mem_cost;
2105 : : }
2106 : :
2107 : : /* The default implementation of TARGET_FRAME_ALLOCATION_COST. */
2108 : :
2109 : : int
2110 : 16100290 : default_frame_allocation_cost (frame_cost_type, const HARD_REG_SET &)
2111 : : {
2112 : 16100290 : return 0;
2113 : : }
2114 : :
2115 : : /* The default implementation of TARGET_SLOW_UNALIGNED_ACCESS. */
2116 : :
2117 : : bool
2118 : 3533944 : default_slow_unaligned_access (machine_mode, unsigned int)
2119 : : {
2120 : 3533944 : return STRICT_ALIGNMENT;
2121 : : }
2122 : :
2123 : : /* The default implementation of TARGET_ESTIMATED_POLY_VALUE. */
2124 : :
2125 : : HOST_WIDE_INT
2126 : 0 : default_estimated_poly_value (poly_int64 x, poly_value_estimate_kind)
2127 : : {
2128 : 0 : return x.coeffs[0];
2129 : : }
2130 : :
2131 : : /* For hooks which use the MOVE_RATIO macro, this gives the legacy default
2132 : : behavior. SPEED_P is true if we are compiling for speed. */
2133 : :
2134 : : unsigned int
2135 : 1760596 : get_move_ratio (bool speed_p ATTRIBUTE_UNUSED)
2136 : : {
2137 : 1760596 : unsigned int move_ratio;
2138 : : #ifdef MOVE_RATIO
2139 : 1760596 : move_ratio = (unsigned int) MOVE_RATIO (speed_p);
2140 : : #else
2141 : : #if defined (HAVE_cpymemqi) || defined (HAVE_cpymemhi) || defined (HAVE_cpymemsi) || defined (HAVE_cpymemdi) || defined (HAVE_cpymemti)
2142 : : move_ratio = 2;
2143 : : #else /* No cpymem patterns, pick a default. */
2144 : : move_ratio = ((speed_p) ? 15 : 3);
2145 : : #endif
2146 : : #endif
2147 : 1760596 : return move_ratio;
2148 : : }
2149 : :
2150 : : /* Return TRUE if the move_by_pieces/set_by_pieces infrastructure should be
2151 : : used; return FALSE if the cpymem/setmem optab should be expanded, or
2152 : : a call to memcpy emitted. */
2153 : :
2154 : : bool
2155 : 1165462 : default_use_by_pieces_infrastructure_p (unsigned HOST_WIDE_INT size,
2156 : : unsigned int alignment,
2157 : : enum by_pieces_operation op,
2158 : : bool speed_p)
2159 : : {
2160 : 1165462 : unsigned int max_size = 0;
2161 : 1165462 : unsigned int ratio = 0;
2162 : :
2163 : 1165462 : switch (op)
2164 : : {
2165 : 67060 : case CLEAR_BY_PIECES:
2166 : 67060 : max_size = STORE_MAX_PIECES;
2167 : 67060 : ratio = CLEAR_RATIO (speed_p);
2168 : : break;
2169 : 918281 : case MOVE_BY_PIECES:
2170 : 918281 : max_size = MOVE_MAX_PIECES;
2171 : 918281 : ratio = get_move_ratio (speed_p);
2172 : 918281 : break;
2173 : 49448 : case SET_BY_PIECES:
2174 : 49448 : max_size = STORE_MAX_PIECES;
2175 : 49448 : ratio = SET_RATIO (speed_p);
2176 : : break;
2177 : 92941 : case STORE_BY_PIECES:
2178 : 92941 : max_size = STORE_MAX_PIECES;
2179 : 92941 : ratio = get_move_ratio (speed_p);
2180 : 92941 : break;
2181 : 37732 : case COMPARE_BY_PIECES:
2182 : 37732 : max_size = COMPARE_MAX_PIECES;
2183 : : /* Pick a likely default, just as in get_move_ratio. */
2184 : 37732 : ratio = speed_p ? 15 : 3;
2185 : : break;
2186 : : }
2187 : :
2188 : 1165462 : return by_pieces_ninsns (size, alignment, max_size + 1, op) < ratio;
2189 : : }
2190 : :
2191 : : /* This hook controls code generation for expanding a memcmp operation by
2192 : : pieces. Return 1 for the normal pattern of compare/jump after each pair
2193 : : of loads, or a higher number to reduce the number of branches. */
2194 : :
2195 : : int
2196 : 99901 : default_compare_by_pieces_branch_ratio (machine_mode)
2197 : : {
2198 : 99901 : return 1;
2199 : : }
2200 : :
2201 : : /* Write PATCH_AREA_SIZE NOPs into the asm outfile FILE around a function
2202 : : entry. If RECORD_P is true and the target supports named sections,
2203 : : the location of the NOPs will be recorded in a special object section
2204 : : called "__patchable_function_entries". This routine may be called
2205 : : twice per function to put NOPs before and after the function
2206 : : entry. */
2207 : :
2208 : : void
2209 : 59 : default_print_patchable_function_entry (FILE *file,
2210 : : unsigned HOST_WIDE_INT patch_area_size,
2211 : : bool record_p)
2212 : : {
2213 : 59 : const char *nop_templ = 0;
2214 : 59 : int code_num;
2215 : 59 : rtx_insn *my_nop = make_insn_raw (gen_nop ());
2216 : :
2217 : : /* We use the template alone, relying on the (currently sane) assumption
2218 : : that the NOP template does not have variable operands. */
2219 : 59 : code_num = recog_memoized (my_nop);
2220 : 59 : nop_templ = get_insn_template (code_num, my_nop);
2221 : :
2222 : 59 : if (record_p && targetm_common.have_named_sections)
2223 : : {
2224 : 53 : char buf[256];
2225 : 53 : section *previous_section = in_section;
2226 : 53 : const char *asm_op = integer_asm_op (POINTER_SIZE_UNITS, false);
2227 : :
2228 : 53 : gcc_assert (asm_op != NULL);
2229 : : /* If SECTION_LINK_ORDER is supported, this internal label will
2230 : : be filled as the symbol for linked_to section. */
2231 : 53 : ASM_GENERATE_INTERNAL_LABEL (buf, "LPFE", current_function_funcdef_no);
2232 : :
2233 : 53 : unsigned int flags = SECTION_WRITE | SECTION_RELRO;
2234 : 53 : if (HAVE_GAS_SECTION_LINK_ORDER)
2235 : 53 : flags |= SECTION_LINK_ORDER;
2236 : :
2237 : 53 : section *sect = get_section ("__patchable_function_entries",
2238 : : flags, current_function_decl);
2239 : 53 : if (HAVE_COMDAT_GROUP && DECL_COMDAT_GROUP (current_function_decl))
2240 : 12 : switch_to_comdat_section (sect, current_function_decl);
2241 : : else
2242 : 41 : switch_to_section (sect);
2243 : 53 : assemble_align (POINTER_SIZE);
2244 : 53 : fputs (asm_op, file);
2245 : 53 : assemble_name_raw (file, buf);
2246 : 53 : fputc ('\n', file);
2247 : :
2248 : 53 : switch_to_section (previous_section);
2249 : 53 : ASM_OUTPUT_LABEL (file, buf);
2250 : : }
2251 : :
2252 : : unsigned i;
2253 : 136 : for (i = 0; i < patch_area_size; ++i)
2254 : 77 : output_asm_insn (nop_templ, NULL);
2255 : 59 : }
2256 : :
2257 : : bool
2258 : 0 : default_profile_before_prologue (void)
2259 : : {
2260 : : #ifdef PROFILE_BEFORE_PROLOGUE
2261 : : return true;
2262 : : #else
2263 : 0 : return false;
2264 : : #endif
2265 : : }
2266 : :
2267 : : /* The default implementation of TARGET_PREFERRED_RELOAD_CLASS. */
2268 : :
2269 : : reg_class_t
2270 : 0 : default_preferred_reload_class (rtx x ATTRIBUTE_UNUSED,
2271 : : reg_class_t rclass)
2272 : : {
2273 : : #ifdef PREFERRED_RELOAD_CLASS
2274 : : return (reg_class_t) PREFERRED_RELOAD_CLASS (x, (enum reg_class) rclass);
2275 : : #else
2276 : 0 : return rclass;
2277 : : #endif
2278 : : }
2279 : :
2280 : : /* The default implementation of TARGET_OUTPUT_PREFERRED_RELOAD_CLASS. */
2281 : :
2282 : : reg_class_t
2283 : 0 : default_preferred_output_reload_class (rtx x ATTRIBUTE_UNUSED,
2284 : : reg_class_t rclass)
2285 : : {
2286 : 0 : return rclass;
2287 : : }
2288 : :
2289 : : /* The default implementation of TARGET_PREFERRED_RENAME_CLASS. */
2290 : : reg_class_t
2291 : 959289 : default_preferred_rename_class (reg_class_t rclass ATTRIBUTE_UNUSED)
2292 : : {
2293 : 959289 : return NO_REGS;
2294 : : }
2295 : :
2296 : : /* The default implementation of TARGET_CLASS_LIKELY_SPILLED_P. */
2297 : :
2298 : : bool
2299 : 0 : default_class_likely_spilled_p (reg_class_t rclass)
2300 : : {
2301 : 0 : return (reg_class_size[(int) rclass] == 1);
2302 : : }
2303 : :
2304 : : /* The default implementation of TARGET_CLASS_MAX_NREGS. */
2305 : :
2306 : : unsigned char
2307 : 0 : default_class_max_nregs (reg_class_t rclass ATTRIBUTE_UNUSED,
2308 : : machine_mode mode ATTRIBUTE_UNUSED)
2309 : : {
2310 : : #ifdef CLASS_MAX_NREGS
2311 : : return (unsigned char) CLASS_MAX_NREGS ((enum reg_class) rclass,
2312 : : MACRO_MODE (mode));
2313 : : #else
2314 : : /* Targets with variable-sized modes must provide their own definition
2315 : : of this hook. */
2316 : 0 : unsigned int size = GET_MODE_SIZE (mode).to_constant ();
2317 : 0 : return (size + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
2318 : : #endif
2319 : : }
2320 : :
2321 : : /* The default implementation of TARGET_AVOID_STORE_FORWARDING_P. */
2322 : :
2323 : : bool
2324 : 13 : default_avoid_store_forwarding_p (vec<store_fwd_info>, rtx, int total_cost,
2325 : : bool)
2326 : : {
2327 : : /* Use a simple cost heurstic base on param_store_forwarding_max_distance.
2328 : : In general the distance should be somewhat correlated to the store
2329 : : forwarding penalty; if the penalty is large then it is justified to
2330 : : increase the window size. Use this to reject sequences that are clearly
2331 : : unprofitable.
2332 : : Skip the cost check if param_store_forwarding_max_distance is 0. */
2333 : 13 : int max_cost = COSTS_N_INSNS (param_store_forwarding_max_distance / 2);
2334 : 13 : const bool unlimited_cost = (param_store_forwarding_max_distance == 0);
2335 : 13 : if (!unlimited_cost && total_cost > max_cost && max_cost)
2336 : : {
2337 : 1 : if (dump_file)
2338 : 0 : fprintf (dump_file, "Not transformed due to cost: %d > %d.\n",
2339 : : total_cost, max_cost);
2340 : :
2341 : 1 : return false;
2342 : : }
2343 : :
2344 : : return true;
2345 : : }
2346 : :
2347 : : /* Determine the debugging unwind mechanism for the target. */
2348 : :
2349 : : enum unwind_info_type
2350 : 1278859 : default_debug_unwind_info (void)
2351 : : {
2352 : : /* If the target wants to force the use of dwarf2 unwind info, let it. */
2353 : : /* ??? Change all users to the hook, then poison this. */
2354 : : #ifdef DWARF2_FRAME_INFO
2355 : : if (DWARF2_FRAME_INFO)
2356 : : return UI_DWARF2;
2357 : : #endif
2358 : :
2359 : : /* Otherwise, only turn it on if dwarf2 debugging is enabled. */
2360 : : #ifdef DWARF2_DEBUGGING_INFO
2361 : 1278859 : if (dwarf_debuginfo_p ())
2362 : 667331 : return UI_DWARF2;
2363 : : #endif
2364 : :
2365 : : return UI_NONE;
2366 : : }
2367 : :
2368 : : /* Targets that set NUM_POLY_INT_COEFFS to something greater than 1
2369 : : must define this hook. */
2370 : :
2371 : : unsigned int
2372 : 0 : default_dwarf_poly_indeterminate_value (unsigned int, unsigned int *, int *)
2373 : : {
2374 : 0 : gcc_unreachable ();
2375 : : }
2376 : :
2377 : : /* Determine the correct mode for a Dwarf frame register that represents
2378 : : register REGNO. */
2379 : :
2380 : : machine_mode
2381 : 736 : default_dwarf_frame_reg_mode (int regno)
2382 : : {
2383 : 736 : machine_mode save_mode = reg_raw_mode[regno];
2384 : :
2385 : 736 : if (targetm.hard_regno_call_part_clobbered (eh_edge_abi.id (),
2386 : : regno, save_mode))
2387 : 0 : save_mode = choose_hard_reg_mode (regno, 1, &eh_edge_abi);
2388 : 736 : return save_mode;
2389 : : }
2390 : :
2391 : : /* To be used by targets where reg_raw_mode doesn't return the right
2392 : : mode for registers used in apply_builtin_return and apply_builtin_arg. */
2393 : :
2394 : : fixed_size_mode
2395 : 8240 : default_get_reg_raw_mode (int regno)
2396 : : {
2397 : : /* Targets must override this hook if the underlying register is
2398 : : variable-sized. */
2399 : 8240 : return as_a <fixed_size_mode> (reg_raw_mode[regno]);
2400 : : }
2401 : :
2402 : : /* Return true if a leaf function should stay leaf even with profiling
2403 : : enabled. */
2404 : :
2405 : : bool
2406 : 634 : default_keep_leaf_when_profiled ()
2407 : : {
2408 : 634 : return false;
2409 : : }
2410 : :
2411 : : /* Return true if the state of option OPTION should be stored in PCH files
2412 : : and checked by default_pch_valid_p. Store the option's current state
2413 : : in STATE if so. */
2414 : :
2415 : : static inline bool
2416 : 46292417 : option_affects_pch_p (int option, struct cl_option_state *state)
2417 : : {
2418 : 46292417 : if ((cl_options[option].flags & CL_TARGET) == 0)
2419 : : return false;
2420 : 3886386 : if ((cl_options[option].flags & CL_PCH_IGNORE) != 0)
2421 : : return false;
2422 : 3886386 : if (option_flag_var (option, &global_options) == &target_flags)
2423 : 667097 : if (targetm.check_pch_target_flags)
2424 : : return false;
2425 : 3886386 : return get_option_state (&global_options, option, state);
2426 : : }
2427 : :
2428 : : /* Default version of get_pch_validity.
2429 : : By default, every flag difference is fatal; that will be mostly right for
2430 : : most targets, but completely right for very few. */
2431 : :
2432 : : void *
2433 : 428 : default_get_pch_validity (size_t *sz)
2434 : : {
2435 : 428 : struct cl_option_state state;
2436 : 428 : size_t i;
2437 : 428 : char *result, *r;
2438 : :
2439 : 428 : *sz = 2;
2440 : 428 : if (targetm.check_pch_target_flags)
2441 : 0 : *sz += sizeof (target_flags);
2442 : 1046888 : for (i = 0; i < cl_options_count; i++)
2443 : 1046460 : if (option_affects_pch_p (i, &state))
2444 : 97156 : *sz += state.size;
2445 : :
2446 : 428 : result = r = XNEWVEC (char, *sz);
2447 : 428 : r[0] = flag_pic;
2448 : 428 : r[1] = flag_pie;
2449 : 428 : r += 2;
2450 : 428 : if (targetm.check_pch_target_flags)
2451 : : {
2452 : 0 : memcpy (r, &target_flags, sizeof (target_flags));
2453 : 0 : r += sizeof (target_flags);
2454 : : }
2455 : :
2456 : 1046888 : for (i = 0; i < cl_options_count; i++)
2457 : 1046460 : if (option_affects_pch_p (i, &state))
2458 : : {
2459 : 97156 : memcpy (r, state.data, state.size);
2460 : 97156 : r += state.size;
2461 : : }
2462 : :
2463 : 428 : return result;
2464 : : }
2465 : :
2466 : : /* Return a message which says that a PCH file was created with a different
2467 : : setting of OPTION. */
2468 : :
2469 : : static const char *
2470 : 19366 : pch_option_mismatch (const char *option)
2471 : : {
2472 : 19366 : return xasprintf (_("created and used with differing settings of '%s'"),
2473 : 19366 : option);
2474 : : }
2475 : :
2476 : : /* Default version of pch_valid_p. */
2477 : :
2478 : : const char *
2479 : 19725 : default_pch_valid_p (const void *data_p, size_t len ATTRIBUTE_UNUSED)
2480 : : {
2481 : 19725 : struct cl_option_state state;
2482 : 19725 : const char *data = (const char *)data_p;
2483 : 19725 : size_t i;
2484 : :
2485 : : /* -fpic and -fpie also usually make a PCH invalid. */
2486 : 19725 : if (data[0] != flag_pic)
2487 : 0 : return _("created and used with different settings of %<-fpic%>");
2488 : 19725 : if (data[1] != flag_pie)
2489 : 0 : return _("created and used with different settings of %<-fpie%>");
2490 : 19725 : data += 2;
2491 : :
2492 : : /* Check target_flags. */
2493 : 19725 : if (targetm.check_pch_target_flags)
2494 : : {
2495 : 0 : int tf;
2496 : 0 : const char *r;
2497 : :
2498 : 0 : memcpy (&tf, data, sizeof (target_flags));
2499 : 0 : data += sizeof (target_flags);
2500 : 0 : r = targetm.check_pch_target_flags (tf);
2501 : 0 : if (r != NULL)
2502 : : return r;
2503 : : }
2504 : :
2505 : 44199856 : for (i = 0; i < cl_options_count; i++)
2506 : 44199497 : if (option_affects_pch_p (i, &state))
2507 : : {
2508 : 3567373 : if (memcmp (data, state.data, state.size) != 0)
2509 : 19366 : return pch_option_mismatch (cl_options[i].opt_text);
2510 : 3548007 : data += state.size;
2511 : : }
2512 : :
2513 : : return NULL;
2514 : : }
2515 : :
2516 : : /* Default version of cstore_mode. */
2517 : :
2518 : : scalar_int_mode
2519 : 648999 : default_cstore_mode (enum insn_code icode)
2520 : : {
2521 : 648999 : return as_a <scalar_int_mode> (insn_data[(int) icode].operand[0].mode);
2522 : : }
2523 : :
2524 : : /* Default version of member_type_forces_blk. */
2525 : :
2526 : : bool
2527 : 0 : default_member_type_forces_blk (const_tree, machine_mode)
2528 : : {
2529 : 0 : return false;
2530 : : }
2531 : :
2532 : : /* Default version of canonicalize_comparison. */
2533 : :
2534 : : void
2535 : 0 : default_canonicalize_comparison (int *, rtx *, rtx *, bool)
2536 : : {
2537 : 0 : }
2538 : :
2539 : : /* Default implementation of TARGET_ATOMIC_ASSIGN_EXPAND_FENV. */
2540 : :
2541 : : void
2542 : 0 : default_atomic_assign_expand_fenv (tree *, tree *, tree *)
2543 : : {
2544 : 0 : }
2545 : :
2546 : : #ifndef PAD_VARARGS_DOWN
2547 : : #define PAD_VARARGS_DOWN BYTES_BIG_ENDIAN
2548 : : #endif
2549 : :
2550 : : /* Build an indirect-ref expression over the given TREE, which represents a
2551 : : piece of a va_arg() expansion. */
2552 : : tree
2553 : 54772 : build_va_arg_indirect_ref (tree addr)
2554 : : {
2555 : 54772 : addr = build_simple_mem_ref_loc (EXPR_LOCATION (addr), addr);
2556 : 54772 : return addr;
2557 : : }
2558 : :
2559 : : /* The "standard" implementation of va_arg: read the value from the
2560 : : current (padded) address and increment by the (padded) size. */
2561 : :
2562 : : tree
2563 : 260 : std_gimplify_va_arg_expr (tree valist, tree type, gimple_seq *pre_p,
2564 : : gimple_seq *post_p)
2565 : : {
2566 : 260 : tree addr, t, type_size, rounded_size, valist_tmp;
2567 : 260 : unsigned HOST_WIDE_INT align, boundary;
2568 : 260 : bool indirect;
2569 : :
2570 : : /* All of the alignment and movement below is for args-grow-up machines.
2571 : : As of 2004, there are only 3 ARGS_GROW_DOWNWARD targets, and they all
2572 : : implement their own specialized gimplify_va_arg_expr routines. */
2573 : 260 : if (ARGS_GROW_DOWNWARD)
2574 : : gcc_unreachable ();
2575 : :
2576 : 260 : indirect = pass_va_arg_by_reference (type);
2577 : 260 : if (indirect)
2578 : 33 : type = build_pointer_type (type);
2579 : :
2580 : 260 : if (targetm.calls.split_complex_arg
2581 : 0 : && TREE_CODE (type) == COMPLEX_TYPE
2582 : 260 : && targetm.calls.split_complex_arg (type))
2583 : : {
2584 : 0 : tree real_part, imag_part;
2585 : :
2586 : 0 : real_part = std_gimplify_va_arg_expr (valist,
2587 : 0 : TREE_TYPE (type), pre_p, NULL);
2588 : 0 : real_part = get_initialized_tmp_var (real_part, pre_p);
2589 : :
2590 : 0 : imag_part = std_gimplify_va_arg_expr (unshare_expr (valist),
2591 : 0 : TREE_TYPE (type), pre_p, NULL);
2592 : 0 : imag_part = get_initialized_tmp_var (imag_part, pre_p);
2593 : :
2594 : 0 : return build2 (COMPLEX_EXPR, type, real_part, imag_part);
2595 : : }
2596 : :
2597 : 260 : align = PARM_BOUNDARY / BITS_PER_UNIT;
2598 : 260 : boundary = targetm.calls.function_arg_boundary (TYPE_MODE (type), type);
2599 : :
2600 : : /* When we align parameter on stack for caller, if the parameter
2601 : : alignment is beyond MAX_SUPPORTED_STACK_ALIGNMENT, it will be
2602 : : aligned at MAX_SUPPORTED_STACK_ALIGNMENT. We will match callee
2603 : : here with caller. */
2604 : 260 : if (boundary > MAX_SUPPORTED_STACK_ALIGNMENT)
2605 : : boundary = MAX_SUPPORTED_STACK_ALIGNMENT;
2606 : :
2607 : 260 : boundary /= BITS_PER_UNIT;
2608 : :
2609 : : /* Hoist the valist value into a temporary for the moment. */
2610 : 260 : valist_tmp = get_initialized_tmp_var (valist, pre_p);
2611 : :
2612 : : /* va_list pointer is aligned to PARM_BOUNDARY. If argument actually
2613 : : requires greater alignment, we must perform dynamic alignment. */
2614 : 260 : if (boundary > align
2615 : 4 : && !TYPE_EMPTY_P (type)
2616 : 264 : && !integer_zerop (TYPE_SIZE (type)))
2617 : : {
2618 : 4 : t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
2619 : 4 : fold_build_pointer_plus_hwi (valist_tmp, boundary - 1));
2620 : 4 : gimplify_and_add (t, pre_p);
2621 : :
2622 : 8 : t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
2623 : 8 : fold_build2 (BIT_AND_EXPR, TREE_TYPE (valist),
2624 : : valist_tmp,
2625 : : build_int_cst (TREE_TYPE (valist), -boundary)));
2626 : 4 : gimplify_and_add (t, pre_p);
2627 : : }
2628 : : else
2629 : : boundary = align;
2630 : :
2631 : : /* If the actual alignment is less than the alignment of the type,
2632 : : adjust the type accordingly so that we don't assume strict alignment
2633 : : when dereferencing the pointer. */
2634 : 260 : boundary *= BITS_PER_UNIT;
2635 : 260 : if (boundary < TYPE_ALIGN (type))
2636 : : {
2637 : 22 : type = build_variant_type_copy (type);
2638 : 22 : SET_TYPE_ALIGN (type, boundary);
2639 : : }
2640 : :
2641 : : /* Compute the rounded size of the type. */
2642 : 260 : type_size = arg_size_in_bytes (type);
2643 : 260 : rounded_size = round_up (type_size, align);
2644 : :
2645 : : /* Reduce rounded_size so it's sharable with the postqueue. */
2646 : 260 : gimplify_expr (&rounded_size, pre_p, post_p, is_gimple_val, fb_rvalue);
2647 : :
2648 : : /* Get AP. */
2649 : 260 : addr = valist_tmp;
2650 : 260 : if (PAD_VARARGS_DOWN && !integer_zerop (rounded_size))
2651 : : {
2652 : : /* Small args are padded downward. */
2653 : : t = fold_build2_loc (input_location, GT_EXPR, sizetype,
2654 : : rounded_size, size_int (align));
2655 : : t = fold_build3 (COND_EXPR, sizetype, t, size_zero_node,
2656 : : size_binop (MINUS_EXPR, rounded_size, type_size));
2657 : : addr = fold_build_pointer_plus (addr, t);
2658 : : }
2659 : :
2660 : : /* Compute new value for AP. */
2661 : 260 : t = fold_build_pointer_plus (valist_tmp, rounded_size);
2662 : 260 : t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist, t);
2663 : 260 : gimplify_and_add (t, pre_p);
2664 : :
2665 : 260 : addr = fold_convert (build_pointer_type (type), addr);
2666 : :
2667 : 260 : if (indirect)
2668 : 33 : addr = build_va_arg_indirect_ref (addr);
2669 : :
2670 : 260 : return build_va_arg_indirect_ref (addr);
2671 : : }
2672 : :
2673 : : /* An implementation of TARGET_CAN_USE_DOLOOP_P for targets that do
2674 : : not support nested low-overhead loops. */
2675 : :
2676 : : bool
2677 : 0 : can_use_doloop_if_innermost (const widest_int &, const widest_int &,
2678 : : unsigned int loop_depth, bool)
2679 : : {
2680 : 0 : return loop_depth == 1;
2681 : : }
2682 : :
2683 : : /* Default implementation of TARGET_OPTAB_SUPPORTED_P. */
2684 : :
2685 : : bool
2686 : 0 : default_optab_supported_p (int, machine_mode, machine_mode, optimization_type)
2687 : : {
2688 : 0 : return true;
2689 : : }
2690 : :
2691 : : /* Default implementation of TARGET_MAX_NOCE_IFCVT_SEQ_COST. */
2692 : :
2693 : : unsigned int
2694 : 0 : default_max_noce_ifcvt_seq_cost (edge e)
2695 : : {
2696 : 0 : bool predictable_p = predictable_edge_p (e);
2697 : :
2698 : 0 : if (predictable_p)
2699 : : {
2700 : 0 : if (OPTION_SET_P (param_max_rtl_if_conversion_predictable_cost))
2701 : 0 : return param_max_rtl_if_conversion_predictable_cost;
2702 : : }
2703 : : else
2704 : : {
2705 : 0 : if (OPTION_SET_P (param_max_rtl_if_conversion_unpredictable_cost))
2706 : 0 : return param_max_rtl_if_conversion_unpredictable_cost;
2707 : : }
2708 : :
2709 : 0 : return BRANCH_COST (true, predictable_p) * COSTS_N_INSNS (3);
2710 : : }
2711 : :
2712 : : /* Default implementation of TARGET_MIN_ARITHMETIC_PRECISION. */
2713 : :
2714 : : unsigned int
2715 : 72630 : default_min_arithmetic_precision (void)
2716 : : {
2717 : 72630 : return WORD_REGISTER_OPERATIONS ? BITS_PER_WORD : BITS_PER_UNIT;
2718 : : }
2719 : :
2720 : : /* Default implementation of TARGET_C_EXCESS_PRECISION. */
2721 : :
2722 : : enum flt_eval_method
2723 : 0 : default_excess_precision (enum excess_precision_type ATTRIBUTE_UNUSED)
2724 : : {
2725 : 0 : return FLT_EVAL_METHOD_PROMOTE_TO_FLOAT;
2726 : : }
2727 : :
2728 : : /* Return true if _BitInt(N) is supported and fill details about it into
2729 : : *INFO. */
2730 : : bool
2731 : 0 : default_bitint_type_info (int, struct bitint_info *)
2732 : : {
2733 : 0 : return false;
2734 : : }
2735 : :
2736 : : /* Default implementation for
2737 : : TARGET_STACK_CLASH_PROTECTION_ALLOCA_PROBE_RANGE. */
2738 : : HOST_WIDE_INT
2739 : 16 : default_stack_clash_protection_alloca_probe_range (void)
2740 : : {
2741 : 16 : return 0;
2742 : : }
2743 : :
2744 : : /* The default implementation of TARGET_EARLY_REMAT_MODES. */
2745 : :
2746 : : void
2747 : 0 : default_select_early_remat_modes (sbitmap)
2748 : : {
2749 : 0 : }
2750 : :
2751 : : /* The default implementation of TARGET_PREFERRED_ELSE_VALUE. */
2752 : :
2753 : : tree
2754 : 519 : default_preferred_else_value (unsigned, tree type, unsigned, tree *)
2755 : : {
2756 : 519 : return build_zero_cst (type);
2757 : : }
2758 : :
2759 : : /* Default implementation of TARGET_HAVE_SPECULATION_SAFE_VALUE. */
2760 : : bool
2761 : 203268 : default_have_speculation_safe_value (bool active ATTRIBUTE_UNUSED)
2762 : : {
2763 : : #ifdef HAVE_speculation_barrier
2764 : 203268 : return active ? HAVE_speculation_barrier : true;
2765 : : #else
2766 : : return false;
2767 : : #endif
2768 : : }
2769 : : /* Alternative implementation of TARGET_HAVE_SPECULATION_SAFE_VALUE
2770 : : that can be used on targets that never have speculative execution. */
2771 : : bool
2772 : 0 : speculation_safe_value_not_needed (bool active)
2773 : : {
2774 : 0 : return !active;
2775 : : }
2776 : :
2777 : : /* Default implementation of the speculation-safe-load builtin. This
2778 : : implementation simply copies val to result and generates a
2779 : : speculation_barrier insn, if such a pattern is defined. */
2780 : : rtx
2781 : 34 : default_speculation_safe_value (machine_mode mode ATTRIBUTE_UNUSED,
2782 : : rtx result, rtx val,
2783 : : rtx failval ATTRIBUTE_UNUSED)
2784 : : {
2785 : 34 : emit_move_insn (result, val);
2786 : :
2787 : : #ifdef HAVE_speculation_barrier
2788 : : /* Assume the target knows what it is doing: if it defines a
2789 : : speculation barrier, but it is not enabled, then assume that one
2790 : : isn't needed. */
2791 : 34 : if (HAVE_speculation_barrier)
2792 : 34 : emit_insn (gen_speculation_barrier ());
2793 : : #endif
2794 : :
2795 : 34 : return result;
2796 : : }
2797 : :
2798 : : /* How many bits to shift in order to access the tag bits.
2799 : : The default is to store the tag in the top 8 bits of a 64 bit pointer, hence
2800 : : shifting 56 bits will leave just the tag. */
2801 : : #define HWASAN_SHIFT (GET_MODE_PRECISION (Pmode) - 8)
2802 : : #define HWASAN_SHIFT_RTX GEN_INT (HWASAN_SHIFT)
2803 : :
2804 : : bool
2805 : 0 : default_memtag_can_tag_addresses ()
2806 : : {
2807 : 0 : return false;
2808 : : }
2809 : :
2810 : : uint8_t
2811 : 0 : default_memtag_tag_size ()
2812 : : {
2813 : 0 : return 8;
2814 : : }
2815 : :
2816 : : uint8_t
2817 : 1247 : default_memtag_granule_size ()
2818 : : {
2819 : 1247 : return 16;
2820 : : }
2821 : :
2822 : : /* The default implementation of TARGET_MEMTAG_INSERT_RANDOM_TAG. */
2823 : : rtx
2824 : 65 : default_memtag_insert_random_tag (rtx untagged, rtx target)
2825 : : {
2826 : 65 : gcc_assert (param_hwasan_instrument_stack);
2827 : 65 : if (param_hwasan_random_frame_tag)
2828 : : {
2829 : 16 : rtx fn = init_one_libfunc ("__hwasan_generate_tag");
2830 : 16 : rtx new_tag = emit_library_call_value (fn, NULL_RTX, LCT_NORMAL, QImode);
2831 : 16 : return targetm.memtag.set_tag (untagged, new_tag, target);
2832 : : }
2833 : : else
2834 : : {
2835 : : /* NOTE: The kernel API does not have __hwasan_generate_tag exposed.
2836 : : In the future we may add the option emit random tags with inline
2837 : : instrumentation instead of function calls. This would be the same
2838 : : between the kernel and userland. */
2839 : : return untagged;
2840 : : }
2841 : : }
2842 : :
2843 : : /* The default implementation of TARGET_MEMTAG_ADD_TAG. */
2844 : : rtx
2845 : 0 : default_memtag_add_tag (rtx base, poly_int64 offset, uint8_t tag_offset)
2846 : : {
2847 : : /* Need to look into what the most efficient code sequence is.
2848 : : This is a code sequence that would be emitted *many* times, so we
2849 : : want it as small as possible.
2850 : :
2851 : : There are two places where tag overflow is a question:
2852 : : - Tagging the shadow stack.
2853 : : (both tagging and untagging).
2854 : : - Tagging addressable pointers.
2855 : :
2856 : : We need to ensure both behaviors are the same (i.e. that the tag that
2857 : : ends up in a pointer after "overflowing" the tag bits with a tag addition
2858 : : is the same that ends up in the shadow space).
2859 : :
2860 : : The aim is that the behavior of tag addition should follow modulo
2861 : : wrapping in both instances.
2862 : :
2863 : : The libhwasan code doesn't have any path that increments a pointer's tag,
2864 : : which means it has no opinion on what happens when a tag increment
2865 : : overflows (and hence we can choose our own behavior). */
2866 : :
2867 : 0 : offset += ((uint64_t)tag_offset << HWASAN_SHIFT);
2868 : 0 : return plus_constant (Pmode, base, offset);
2869 : : }
2870 : :
2871 : : /* The default implementation of TARGET_MEMTAG_SET_TAG. */
2872 : : rtx
2873 : 0 : default_memtag_set_tag (rtx untagged, rtx tag, rtx target)
2874 : : {
2875 : 0 : gcc_assert (GET_MODE (untagged) == Pmode && GET_MODE (tag) == QImode);
2876 : 0 : tag = expand_simple_binop (Pmode, ASHIFT, tag, HWASAN_SHIFT_RTX, NULL_RTX,
2877 : : /* unsignedp = */1, OPTAB_WIDEN);
2878 : 0 : rtx ret = expand_simple_binop (Pmode, IOR, untagged, tag, target,
2879 : : /* unsignedp = */1, OPTAB_DIRECT);
2880 : 0 : gcc_assert (ret);
2881 : 0 : return ret;
2882 : : }
2883 : :
2884 : : /* The default implementation of TARGET_MEMTAG_EXTRACT_TAG. */
2885 : : rtx
2886 : 0 : default_memtag_extract_tag (rtx tagged_pointer, rtx target)
2887 : : {
2888 : 0 : rtx tag = expand_simple_binop (Pmode, LSHIFTRT, tagged_pointer,
2889 : 0 : HWASAN_SHIFT_RTX, target,
2890 : : /* unsignedp = */0,
2891 : : OPTAB_DIRECT);
2892 : 0 : rtx ret = gen_lowpart (QImode, tag);
2893 : 0 : gcc_assert (ret);
2894 : 0 : return ret;
2895 : : }
2896 : :
2897 : : /* The default implementation of TARGET_MEMTAG_UNTAGGED_POINTER. */
2898 : : rtx
2899 : 0 : default_memtag_untagged_pointer (rtx tagged_pointer, rtx target)
2900 : : {
2901 : 0 : rtx tag_mask = gen_int_mode ((HOST_WIDE_INT_1U << HWASAN_SHIFT) - 1, Pmode);
2902 : 0 : rtx untagged_base = expand_simple_binop (Pmode, AND, tagged_pointer,
2903 : : tag_mask, target, true,
2904 : : OPTAB_DIRECT);
2905 : 0 : gcc_assert (untagged_base);
2906 : 0 : return untagged_base;
2907 : : }
2908 : :
2909 : : #include "gt-targhooks.h"
|
