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