1/* Target hook definitions.
2 Copyright (C) 2001-2023 Free Software Foundation, Inc.
3
4 This program is free software; you can redistribute it and/or modify it
5 under the terms of the GNU General Public License as published by the
6 Free Software Foundation; either version 3, or (at your option) any
7 later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program; see the file COPYING3. If not see
16 <http://www.gnu.org/licenses/>.
17
18 In other words, you are welcome to use, share and improve this program.
19 You are forbidden to forbid anyone else to use, share and improve
20 what you give them. Help stamp out software-hoarding! */
21
22/* See target-hooks-macros.h for details of macros that should be
23 provided by the including file, and how to use them here. */
24#include "target-hooks-macros.h"
25
26#undef HOOK_TYPE
27#define HOOK_TYPE "Target Hook"
28
29HOOK_VECTOR (TARGET_INITIALIZER, gcc_target)
30
31/* Functions that output assembler for the target. */
32#define HOOK_PREFIX "TARGET_ASM_"
33HOOK_VECTOR (TARGET_ASM_OUT, asm_out)
34
35/* Opening and closing parentheses for asm expression grouping. */
36DEFHOOKPOD
37(open_paren,
38 "These target hooks are C string constants, describing the syntax in the\n\
39assembler for grouping arithmetic expressions. If not overridden, they\n\
40default to normal parentheses, which is correct for most assemblers.",
41 const char *, "(")
42DEFHOOKPODX (close_paren, const char *, ")")
43
44/* Assembler instructions for creating various kinds of integer object. */
45DEFHOOKPOD
46(byte_op,
47 "@deftypevrx {Target Hook} {const char *} TARGET_ASM_ALIGNED_HI_OP\n\
48@deftypevrx {Target Hook} {const char *} TARGET_ASM_ALIGNED_PSI_OP\n\
49@deftypevrx {Target Hook} {const char *} TARGET_ASM_ALIGNED_SI_OP\n\
50@deftypevrx {Target Hook} {const char *} TARGET_ASM_ALIGNED_PDI_OP\n\
51@deftypevrx {Target Hook} {const char *} TARGET_ASM_ALIGNED_DI_OP\n\
52@deftypevrx {Target Hook} {const char *} TARGET_ASM_ALIGNED_PTI_OP\n\
53@deftypevrx {Target Hook} {const char *} TARGET_ASM_ALIGNED_TI_OP\n\
54@deftypevrx {Target Hook} {const char *} TARGET_ASM_UNALIGNED_HI_OP\n\
55@deftypevrx {Target Hook} {const char *} TARGET_ASM_UNALIGNED_PSI_OP\n\
56@deftypevrx {Target Hook} {const char *} TARGET_ASM_UNALIGNED_SI_OP\n\
57@deftypevrx {Target Hook} {const char *} TARGET_ASM_UNALIGNED_PDI_OP\n\
58@deftypevrx {Target Hook} {const char *} TARGET_ASM_UNALIGNED_DI_OP\n\
59@deftypevrx {Target Hook} {const char *} TARGET_ASM_UNALIGNED_PTI_OP\n\
60@deftypevrx {Target Hook} {const char *} TARGET_ASM_UNALIGNED_TI_OP\n\
61These hooks specify assembly directives for creating certain kinds\n\
62of integer object. The @code{TARGET_ASM_BYTE_OP} directive creates a\n\
63byte-sized object, the @code{TARGET_ASM_ALIGNED_HI_OP} one creates an\n\
64aligned two-byte object, and so on. Any of the hooks may be\n\
65@code{NULL}, indicating that no suitable directive is available.\n\
66\n\
67The compiler will print these strings at the start of a new line,\n\
68followed immediately by the object's initial value. In most cases,\n\
69the string should contain a tab, a pseudo-op, and then another tab.",
70 const char *, "\t.byte\t")
71DEFHOOKPOD (aligned_op, "*", struct asm_int_op, TARGET_ASM_ALIGNED_INT_OP)
72DEFHOOKPOD (unaligned_op, "*", struct asm_int_op, TARGET_ASM_UNALIGNED_INT_OP)
73
74/* Try to output the assembler code for an integer object whose
75 value is given by X. SIZE is the size of the object in bytes and
76 ALIGNED_P indicates whether it is aligned. Return true if
77 successful. Only handles cases for which BYTE_OP, ALIGNED_OP
78 and UNALIGNED_OP are NULL. */
79DEFHOOK
80(integer,
81 "The @code{assemble_integer} function uses this hook to output an\n\
82integer object. @var{x} is the object's value, @var{size} is its size\n\
83in bytes and @var{aligned_p} indicates whether it is aligned. The\n\
84function should return @code{true} if it was able to output the\n\
85object. If it returns false, @code{assemble_integer} will try to\n\
86split the object into smaller parts.\n\
87\n\
88The default implementation of this hook will use the\n\
89@code{TARGET_ASM_BYTE_OP} family of strings, returning @code{false}\n\
90when the relevant string is @code{NULL}.",
91 /* Only handles cases for which BYTE_OP, ALIGNED_OP and UNALIGNED_OP are
92 NULL. */
93 bool, (rtx x, unsigned int size, int aligned_p),
94 default_assemble_integer)
95
96/* Assembly strings required after the .cfi_startproc label. */
97DEFHOOK
98(post_cfi_startproc,
99 "This target hook is used to emit assembly strings required by the target\n\
100after the .cfi_startproc directive. The first argument is the file stream to\n\
101write the strings to and the second argument is the function\'s declaration. The\n\
102expected use is to add more .cfi_* directives.\n\
103\n\
104The default is to not output any assembly strings.",
105 void, (FILE *, tree),
106 hook_void_FILEptr_tree)
107
108/* Notify the backend that we have completed emitting the data for a
109 decl. */
110DEFHOOK
111(decl_end,
112 "Define this hook if the target assembler requires a special marker to\n\
113terminate an initialized variable declaration.",
114 void, (void),
115 hook_void_void)
116
117/* Output code that will globalize a label. */
118DEFHOOK
119(globalize_label,
120 "This target hook is a function to output to the stdio stream\n\
121@var{stream} some commands that will make the label @var{name} global;\n\
122that is, available for reference from other files.\n\
123\n\
124The default implementation relies on a proper definition of\n\
125@code{GLOBAL_ASM_OP}.",
126 void, (FILE *stream, const char *name),
127 default_globalize_label)
128
129/* Output code that will globalize a declaration. */
130DEFHOOK
131(globalize_decl_name,
132 "This target hook is a function to output to the stdio stream\n\
133@var{stream} some commands that will make the name associated with @var{decl}\n\
134global; that is, available for reference from other files.\n\
135\n\
136The default implementation uses the TARGET_ASM_GLOBALIZE_LABEL target hook.",
137 void, (FILE *stream, tree decl), default_globalize_decl_name)
138
139/* Output code that will declare an external variable. */
140DEFHOOK
141(assemble_undefined_decl,
142 "This target hook is a function to output to the stdio stream\n\
143@var{stream} some commands that will declare the name associated with\n\
144@var{decl} which is not defined in the current translation unit. Most\n\
145assemblers do not require anything to be output in this case.",
146 void, (FILE *stream, const char *name, const_tree decl),
147 hook_void_FILEptr_constcharptr_const_tree)
148
149/* Output code that will emit a label for unwind info, if this
150 target requires such labels. Second argument is the decl the
151 unwind info is associated with, third is a boolean: true if
152 this is for exception handling, fourth is a boolean: true if
153 this is only a placeholder for an omitted FDE. */
154DEFHOOK
155(emit_unwind_label,
156 "This target hook emits a label at the beginning of each FDE@. It\n\
157should be defined on targets where FDEs need special labels, and it\n\
158should write the appropriate label, for the FDE associated with the\n\
159function declaration @var{decl}, to the stdio stream @var{stream}.\n\
160The third argument, @var{for_eh}, is a boolean: true if this is for an\n\
161exception table. The fourth argument, @var{empty}, is a boolean:\n\
162true if this is a placeholder label for an omitted FDE@.\n\
163\n\
164The default is that FDEs are not given nonlocal labels.",
165 void, (FILE *stream, tree decl, int for_eh, int empty),
166 default_emit_unwind_label)
167
168/* Output code that will emit a label to divide up the exception table. */
169DEFHOOK
170(emit_except_table_label,
171 "This target hook emits a label at the beginning of the exception table.\n\
172It should be defined on targets where it is desirable for the table\n\
173to be broken up according to function.\n\
174\n\
175The default is that no label is emitted.",
176 void, (FILE *stream),
177 default_emit_except_table_label)
178
179/* Emit a directive for setting the personality for the function. */
180DEFHOOK
181(emit_except_personality,
182 "If the target implements @code{TARGET_ASM_UNWIND_EMIT}, this hook may be\n\
183used to emit a directive to install a personality hook into the unwind\n\
184info. This hook should not be used if dwarf2 unwind info is used.",
185 void, (rtx personality),
186 NULL)
187
188/* If necessary, modify personality and LSDA references to handle
189 indirection. This is used when the assembler supports CFI directives. */
190DEFHOOK
191(make_eh_symbol_indirect,
192 "If necessary, modify personality and LSDA references to handle indirection.\n\
193The original symbol is in @code{origsymbol} and if @code{pubvis} is true\n\
194the symbol is visible outside the TU.",
195 rtx, (rtx origsymbol, bool pubvis),
196 NULL)
197
198/* Emit any directives required to unwind this instruction. */
199DEFHOOK
200(unwind_emit,
201 "This target hook emits assembly directives required to unwind the\n\
202given instruction. This is only used when @code{TARGET_EXCEPT_UNWIND_INFO}\n\
203returns @code{UI_TARGET}.",
204 void, (FILE *stream, rtx_insn *insn),
205 NULL)
206
207DEFHOOKPOD
208(unwind_emit_before_insn,
209 "True if the @code{TARGET_ASM_UNWIND_EMIT} hook should be called before\n\
210the assembly for @var{insn} has been emitted, false if the hook should\n\
211be called afterward.",
212 bool, true)
213
214/* Return true if the target needs extra instructions to restore the current
215 frame address after a DW_CFA_restore_state opcode. */
216DEFHOOK
217(should_restore_cfa_state,
218 "For DWARF-based unwind frames, two CFI instructions provide for save and\n\
219restore of register state. GCC maintains the current frame address (CFA)\n\
220separately from the register bank but the unwinder in libgcc preserves this\n\
221state along with the registers (and this is expected by the code that writes\n\
222the unwind frames). This hook allows the target to specify that the CFA data\n\
223is not saved/restored along with the registers by the target unwinder so that\n\
224suitable additional instructions should be emitted to restore it.",
225 bool, (void),
226 hook_bool_void_false)
227
228/* Generate an internal label.
229 For now this is just a wrapper for ASM_GENERATE_INTERNAL_LABEL. */
230DEFHOOK_UNDOC
231(generate_internal_label,
232 "",
233 void, (char *buf, const char *prefix, unsigned long labelno),
234 default_generate_internal_label)
235
236/* Output an internal label. */
237DEFHOOK
238(internal_label,
239 "A function to output to the stdio stream @var{stream} a label whose\n\
240name is made from the string @var{prefix} and the number @var{labelno}.\n\
241\n\
242It is absolutely essential that these labels be distinct from the labels\n\
243used for user-level functions and variables. Otherwise, certain programs\n\
244will have name conflicts with internal labels.\n\
245\n\
246It is desirable to exclude internal labels from the symbol table of the\n\
247object file. Most assemblers have a naming convention for labels that\n\
248should be excluded; on many systems, the letter @samp{L} at the\n\
249beginning of a label has this effect. You should find out what\n\
250convention your system uses, and follow it.\n\
251\n\
252The default version of this function utilizes @code{ASM_GENERATE_INTERNAL_LABEL}.",
253 void, (FILE *stream, const char *prefix, unsigned long labelno),
254 default_internal_label)
255
256/* Output label for the constant. */
257DEFHOOK
258(declare_constant_name,
259 "A target hook to output to the stdio stream @var{file} any text necessary\n\
260for declaring the name @var{name} of a constant which is being defined. This\n\
261target hook is responsible for outputting the label definition (perhaps using\n\
262@code{assemble_label}). The argument @var{exp} is the value of the constant,\n\
263and @var{size} is the size of the constant in bytes. The @var{name}\n\
264will be an internal label.\n\
265\n\
266The default version of this target hook, define the @var{name} in the\n\
267usual manner as a label (by means of @code{assemble_label}).\n\
268\n\
269You may wish to use @code{ASM_OUTPUT_TYPE_DIRECTIVE} in this target hook.",
270 void, (FILE *file, const char *name, const_tree expr, HOST_WIDE_INT size),
271 default_asm_declare_constant_name)
272
273/* Emit a ttype table reference to a typeinfo object. */
274DEFHOOK
275(ttype,
276 "This hook is used to output a reference from a frame unwinding table to\n\
277the type_info object identified by @var{sym}. It should return @code{true}\n\
278if the reference was output. Returning @code{false} will cause the\n\
279reference to be output using the normal Dwarf2 routines.",
280 bool, (rtx sym),
281 hook_bool_rtx_false)
282
283/* Emit an assembler directive to set visibility for the symbol
284 associated with the tree decl. */
285DEFHOOK
286(assemble_visibility,
287 "This target hook is a function to output to @var{asm_out_file} some\n\
288commands that will make the symbol(s) associated with @var{decl} have\n\
289hidden, protected or internal visibility as specified by @var{visibility}.",
290 void, (tree decl, int visibility),
291 default_assemble_visibility)
292
293DEFHOOK
294(print_patchable_function_entry,
295 "Generate a patchable area at the function start, consisting of\n\
296@var{patch_area_size} NOP instructions. If the target supports named\n\
297sections and if @var{record_p} is true, insert a pointer to the current\n\
298location in the table of patchable functions. The default implementation\n\
299of the hook places the table of pointers in the special section named\n\
300@code{__patchable_function_entries}.",
301 void, (FILE *file, unsigned HOST_WIDE_INT patch_area_size, bool record_p),
302 default_print_patchable_function_entry)
303
304/* Output the assembler code for entry to a function. */
305DEFHOOK
306(function_prologue,
307 "If defined, a function that outputs the assembler code for entry to a\n\
308function. The prologue is responsible for setting up the stack frame,\n\
309initializing the frame pointer register, saving registers that must be\n\
310saved, and allocating @var{size} additional bytes of storage for the\n\
311local variables. @var{file} is a stdio stream to which the assembler\n\
312code should be output.\n\
313\n\
314The label for the beginning of the function need not be output by this\n\
315macro. That has already been done when the macro is run.\n\
316\n\
317@findex regs_ever_live\n\
318To determine which registers to save, the macro can refer to the array\n\
319@code{regs_ever_live}: element @var{r} is nonzero if hard register\n\
320@var{r} is used anywhere within the function. This implies the function\n\
321prologue should save register @var{r}, provided it is not one of the\n\
322call-used registers. (@code{TARGET_ASM_FUNCTION_EPILOGUE} must likewise use\n\
323@code{regs_ever_live}.)\n\
324\n\
325On machines that have ``register windows'', the function entry code does\n\
326not save on the stack the registers that are in the windows, even if\n\
327they are supposed to be preserved by function calls; instead it takes\n\
328appropriate steps to ``push'' the register stack, if any non-call-used\n\
329registers are used in the function.\n\
330\n\
331@findex frame_pointer_needed\n\
332On machines where functions may or may not have frame-pointers, the\n\
333function entry code must vary accordingly; it must set up the frame\n\
334pointer if one is wanted, and not otherwise. To determine whether a\n\
335frame pointer is in wanted, the macro can refer to the variable\n\
336@code{frame_pointer_needed}. The variable's value will be 1 at run\n\
337time in a function that needs a frame pointer. @xref{Elimination}.\n\
338\n\
339The function entry code is responsible for allocating any stack space\n\
340required for the function. This stack space consists of the regions\n\
341listed below. In most cases, these regions are allocated in the\n\
342order listed, with the last listed region closest to the top of the\n\
343stack (the lowest address if @code{STACK_GROWS_DOWNWARD} is defined, and\n\
344the highest address if it is not defined). You can use a different order\n\
345for a machine if doing so is more convenient or required for\n\
346compatibility reasons. Except in cases where required by standard\n\
347or by a debugger, there is no reason why the stack layout used by GCC\n\
348need agree with that used by other compilers for a machine.",
349 void, (FILE *file),
350 default_function_pro_epilogue)
351
352/* Output the assembler code for end of prologue. */
353DEFHOOK
354(function_end_prologue,
355 "If defined, a function that outputs assembler code at the end of a\n\
356prologue. This should be used when the function prologue is being\n\
357emitted as RTL, and you have some extra assembler that needs to be\n\
358emitted. @xref{prologue instruction pattern}.",
359 void, (FILE *file),
360 no_asm_to_stream)
361
362/* Output the assembler code for start of epilogue. */
363DEFHOOK
364(function_begin_epilogue,
365 "If defined, a function that outputs assembler code at the start of an\n\
366epilogue. This should be used when the function epilogue is being\n\
367emitted as RTL, and you have some extra assembler that needs to be\n\
368emitted. @xref{epilogue instruction pattern}.",
369 void, (FILE *file),
370 no_asm_to_stream)
371
372/* Output the assembler code for function exit. */
373DEFHOOK
374(function_epilogue,
375 "If defined, a function that outputs the assembler code for exit from a\n\
376function. The epilogue is responsible for restoring the saved\n\
377registers and stack pointer to their values when the function was\n\
378called, and returning control to the caller. This macro takes the\n\
379same argument as the macro @code{TARGET_ASM_FUNCTION_PROLOGUE}, and the\n\
380registers to restore are determined from @code{regs_ever_live} and\n\
381@code{CALL_USED_REGISTERS} in the same way.\n\
382\n\
383On some machines, there is a single instruction that does all the work\n\
384of returning from the function. On these machines, give that\n\
385instruction the name @samp{return} and do not define the macro\n\
386@code{TARGET_ASM_FUNCTION_EPILOGUE} at all.\n\
387\n\
388Do not define a pattern named @samp{return} if you want the\n\
389@code{TARGET_ASM_FUNCTION_EPILOGUE} to be used. If you want the target\n\
390switches to control whether return instructions or epilogues are used,\n\
391define a @samp{return} pattern with a validity condition that tests the\n\
392target switches appropriately. If the @samp{return} pattern's validity\n\
393condition is false, epilogues will be used.\n\
394\n\
395On machines where functions may or may not have frame-pointers, the\n\
396function exit code must vary accordingly. Sometimes the code for these\n\
397two cases is completely different. To determine whether a frame pointer\n\
398is wanted, the macro can refer to the variable\n\
399@code{frame_pointer_needed}. The variable's value will be 1 when compiling\n\
400a function that needs a frame pointer.\n\
401\n\
402Normally, @code{TARGET_ASM_FUNCTION_PROLOGUE} and\n\
403@code{TARGET_ASM_FUNCTION_EPILOGUE} must treat leaf functions specially.\n\
404The C variable @code{current_function_is_leaf} is nonzero for such a\n\
405function. @xref{Leaf Functions}.\n\
406\n\
407On some machines, some functions pop their arguments on exit while\n\
408others leave that for the caller to do. For example, the 68020 when\n\
409given @option{-mrtd} pops arguments in functions that take a fixed\n\
410number of arguments.\n\
411\n\
412@findex pops_args\n\
413@findex crtl->args.pops_args\n\
414Your definition of the macro @code{RETURN_POPS_ARGS} decides which\n\
415functions pop their own arguments. @code{TARGET_ASM_FUNCTION_EPILOGUE}\n\
416needs to know what was decided. The number of bytes of the current\n\
417function's arguments that this function should pop is available in\n\
418@code{crtl->args.pops_args}. @xref{Scalar Return}.",
419 void, (FILE *file),
420 default_function_pro_epilogue)
421
422/* Initialize target-specific sections. */
423DEFHOOK
424(init_sections,
425 "Define this hook if you need to do something special to set up the\n\
426@file{varasm.cc} sections, or if your target has some special sections\n\
427of its own that you need to create.\n\
428\n\
429GCC calls this hook after processing the command line, but before writing\n\
430any assembly code, and before calling any of the section-returning hooks\n\
431described below.",
432 void, (void),
433 hook_void_void)
434
435/* Tell assembler to change to section NAME with attributes FLAGS.
436 If DECL is non-NULL, it is the VAR_DECL or FUNCTION_DECL with
437 which this section is associated. */
438DEFHOOK
439(named_section,
440 "Output assembly directives to switch to section @var{name}. The section\n\
441should have attributes as specified by @var{flags}, which is a bit mask\n\
442of the @code{SECTION_*} flags defined in @file{output.h}. If @var{decl}\n\
443is non-NULL, it is the @code{VAR_DECL} or @code{FUNCTION_DECL} with which\n\
444this section is associated.",
445 void, (const char *name, unsigned int flags, tree decl),
446 default_no_named_section)
447
448/* Tell assembler what section attributes to assign this elf section
449 declaration, using their numerical value. */
450DEFHOOK
451(elf_flags_numeric,
452 "This hook can be used to encode ELF section flags for which no letter\n\
453code has been defined in the assembler. It is called by\n\
454@code{default_asm_named_section} whenever the section flags need to be\n\
455emitted in the assembler output. If the hook returns true, then the\n\
456numerical value for ELF section flags should be calculated from\n\
457@var{flags} and saved in @var{*num}; the value is printed out instead of the\n\
458normal sequence of letter codes. If the hook is not defined, or if it\n\
459returns false, then @var{num} is ignored and the traditional letter sequence\n\
460is emitted.",
461 bool, (unsigned int flags, unsigned int *num),
462 hook_bool_uint_uintp_false)
463
464/* Return preferred text (sub)section for function DECL.
465 Main purpose of this function is to separate cold, normal and hot
466 functions. STARTUP is true when function is known to be used only
467 at startup (from static constructors or it is main()).
468 EXIT is true when function is known to be used only at exit
469 (from static destructors).
470 Return NULL if function should go to default text section. */
471DEFHOOK
472(function_section,
473 "Return preferred text (sub)section for function @var{decl}.\n\
474Main purpose of this function is to separate cold, normal and hot\n\
475functions. @var{startup} is true when function is known to be used only\n\
476at startup (from static constructors or it is @code{main()}).\n\
477@var{exit} is true when function is known to be used only at exit\n\
478(from static destructors).\n\
479Return NULL if function should go to default text section.",
480 section *, (tree decl, enum node_frequency freq, bool startup, bool exit),
481 default_function_section)
482
483/* Output the assembler code for function exit. */
484DEFHOOK
485(function_switched_text_sections,
486 "Used by the target to emit any assembler directives or additional\n\
487labels needed when a function is partitioned between different\n\
488sections. Output should be written to @var{file}. The function\n\
489decl is available as @var{decl} and the new section is `cold' if\n\
490@var{new_is_cold} is @code{true}.",
491 void, (FILE *file, tree decl, bool new_is_cold),
492 default_function_switched_text_sections)
493
494/* Return a mask describing how relocations should be treated when
495 selecting sections. Bit 1 should be set if global relocations
496 should be placed in a read-write section; bit 0 should be set if
497 local relocations should be placed in a read-write section. */
498DEFHOOK
499(reloc_rw_mask,
500 "Return a mask describing how relocations should be treated when\n\
501selecting sections. Bit 1 should be set if global relocations\n\
502should be placed in a read-write section; bit 0 should be set if\n\
503local relocations should be placed in a read-write section.\n\
504\n\
505The default version of this function returns 3 when @option{-fpic}\n\
506is in effect, and 0 otherwise. The hook is typically redefined\n\
507when the target cannot support (some kinds of) dynamic relocations\n\
508in read-only sections even in executables.",
509 int, (void),
510 default_reloc_rw_mask)
511
512 /* Return a flag for either generating ADDR_DIF_VEC table
513 or ADDR_VEC table for jumps in case of -fPIC/-fPIE. */
514DEFHOOK
515(generate_pic_addr_diff_vec,
516"Return true to generate ADDR_DIF_VEC table\n\
517or false to generate ADDR_VEC table for jumps in case of -fPIC.\n\
518\n\
519The default version of this function returns true if flag_pic\n\
520equals true and false otherwise",
521 bool, (void),
522 default_generate_pic_addr_diff_vec)
523
524 /* Return a section for EXP. It may be a DECL or a constant. RELOC
525 is nonzero if runtime relocations must be applied; bit 1 will be
526 set if the runtime relocations require non-local name resolution.
527 ALIGN is the required alignment of the data. */
528DEFHOOK
529(select_section,
530 "Return the section into which @var{exp} should be placed. You can\n\
531assume that @var{exp} is either a @code{VAR_DECL} node or a constant of\n\
532some sort. @var{reloc} indicates whether the initial value of @var{exp}\n\
533requires link-time relocations. Bit 0 is set when variable contains\n\
534local relocations only, while bit 1 is set for global relocations.\n\
535@var{align} is the constant alignment in bits.\n\
536\n\
537The default version of this function takes care of putting read-only\n\
538variables in @code{readonly_data_section}.\n\
539\n\
540See also @var{USE_SELECT_SECTION_FOR_FUNCTIONS}.",
541 section *, (tree exp, int reloc, unsigned HOST_WIDE_INT align),
542 default_select_section)
543
544/* Return a section for X. MODE is X's mode and ALIGN is its
545 alignment in bits. */
546DEFHOOK
547(select_rtx_section,
548 "Return the section into which a constant @var{x}, of mode @var{mode},\n\
549should be placed. You can assume that @var{x} is some kind of\n\
550constant in RTL@. The argument @var{mode} is redundant except in the\n\
551case of a @code{const_int} rtx. @var{align} is the constant alignment\n\
552in bits.\n\
553\n\
554The default version of this function takes care of putting symbolic\n\
555constants in @code{flag_pic} mode in @code{data_section} and everything\n\
556else in @code{readonly_data_section}.",
557 section *, (machine_mode mode, rtx x, unsigned HOST_WIDE_INT align),
558 default_select_rtx_section)
559
560/* Select a unique section name for DECL. RELOC is the same as
561 for SELECT_SECTION. */
562DEFHOOK
563(unique_section,
564 "Build up a unique section name, expressed as a @code{STRING_CST} node,\n\
565and assign it to @samp{DECL_SECTION_NAME (@var{decl})}.\n\
566As with @code{TARGET_ASM_SELECT_SECTION}, @var{reloc} indicates whether\n\
567the initial value of @var{exp} requires link-time relocations.\n\
568\n\
569The default version of this function appends the symbol name to the\n\
570ELF section name that would normally be used for the symbol. For\n\
571example, the function @code{foo} would be placed in @code{.text.foo}.\n\
572Whatever the actual target object format, this is often good enough.",
573 void, (tree decl, int reloc),
574 default_unique_section)
575
576/* Return the readonly data or relocated readonly data section
577 associated with function DECL. */
578DEFHOOK
579(function_rodata_section,
580 "Return the readonly data or reloc readonly data section associated with\n\
581@samp{DECL_SECTION_NAME (@var{decl})}. @var{relocatable} selects the latter\n\
582over the former.\n\
583The default version of this function selects @code{.gnu.linkonce.r.name} if\n\
584the function's section is @code{.gnu.linkonce.t.name}, @code{.rodata.name}\n\
585or @code{.data.rel.ro.name} if function is in @code{.text.name}, and\n\
586the normal readonly-data or reloc readonly data section otherwise.",
587 section *, (tree decl, bool relocatable),
588 default_function_rodata_section)
589
590/* Nonnull if the target wants to override the default ".rodata" prefix
591 for mergeable data sections. */
592DEFHOOKPOD
593(mergeable_rodata_prefix,
594 "Usually, the compiler uses the prefix @code{\".rodata\"} to construct\n\
595section names for mergeable constant data. Define this macro to override\n\
596the string if a different section name should be used.",
597 const char *, ".rodata")
598
599/* Return the section to be used for transactional memory clone tables. */
600DEFHOOK
601(tm_clone_table_section,
602 "Return the section that should be used for transactional memory clone\n\
603tables.",
604 section *, (void), default_clone_table_section)
605
606/* Output a constructor for a symbol with a given priority. */
607DEFHOOK
608(constructor,
609 "If defined, a function that outputs assembler code to arrange to call\n\
610the function referenced by @var{symbol} at initialization time.\n\
611\n\
612Assume that @var{symbol} is a @code{SYMBOL_REF} for a function taking\n\
613no arguments and with no return value. If the target supports initialization\n\
614priorities, @var{priority} is a value between 0 and @code{MAX_INIT_PRIORITY};\n\
615otherwise it must be @code{DEFAULT_INIT_PRIORITY}.\n\
616\n\
617If this macro is not defined by the target, a suitable default will\n\
618be chosen if (1) the target supports arbitrary section names, (2) the\n\
619target defines @code{CTORS_SECTION_ASM_OP}, or (3) @code{USE_COLLECT2}\n\
620is not defined.",
621 void, (rtx symbol, int priority), NULL)
622
623/* Output a destructor for a symbol with a given priority. */
624DEFHOOK
625(destructor,
626 "This is like @code{TARGET_ASM_CONSTRUCTOR} but used for termination\n\
627functions rather than initialization functions.",
628 void, (rtx symbol, int priority), NULL)
629
630/* Output the assembler code for a thunk function. THUNK_DECL is the
631 declaration for the thunk function itself, FUNCTION is the decl for
632 the target function. DELTA is an immediate constant offset to be
633 added to THIS. If VCALL_OFFSET is nonzero, the word at
634 *(*this + vcall_offset) should be added to THIS. */
635DEFHOOK
636(output_mi_thunk,
637 "A function that outputs the assembler code for a thunk\n\
638function, used to implement C++ virtual function calls with multiple\n\
639inheritance. The thunk acts as a wrapper around a virtual function,\n\
640adjusting the implicit object parameter before handing control off to\n\
641the real function.\n\
642\n\
643First, emit code to add the integer @var{delta} to the location that\n\
644contains the incoming first argument. Assume that this argument\n\
645contains a pointer, and is the one used to pass the @code{this} pointer\n\
646in C++. This is the incoming argument @emph{before} the function prologue,\n\
647e.g.@: @samp{%o0} on a sparc. The addition must preserve the values of\n\
648all other incoming arguments.\n\
649\n\
650Then, if @var{vcall_offset} is nonzero, an additional adjustment should be\n\
651made after adding @code{delta}. In particular, if @var{p} is the\n\
652adjusted pointer, the following adjustment should be made:\n\
653\n\
654@smallexample\n\
655p += (*((ptrdiff_t **)p))[vcall_offset/sizeof(ptrdiff_t)]\n\
656@end smallexample\n\
657\n\
658After the additions, emit code to jump to @var{function}, which is a\n\
659@code{FUNCTION_DECL}. This is a direct pure jump, not a call, and does\n\
660not touch the return address. Hence returning from @var{FUNCTION} will\n\
661return to whoever called the current @samp{thunk}.\n\
662\n\
663The effect must be as if @var{function} had been called directly with\n\
664the adjusted first argument. This macro is responsible for emitting all\n\
665of the code for a thunk function; @code{TARGET_ASM_FUNCTION_PROLOGUE}\n\
666and @code{TARGET_ASM_FUNCTION_EPILOGUE} are not invoked.\n\
667\n\
668The @var{thunk_fndecl} is redundant. (@var{delta} and @var{function}\n\
669have already been extracted from it.) It might possibly be useful on\n\
670some targets, but probably not.\n\
671\n\
672If you do not define this macro, the target-independent code in the C++\n\
673front end will generate a less efficient heavyweight thunk that calls\n\
674@var{function} instead of jumping to it. The generic approach does\n\
675not support varargs.",
676 void, (FILE *file, tree thunk_fndecl, HOST_WIDE_INT delta,
677 HOST_WIDE_INT vcall_offset, tree function),
678 NULL)
679
680/* Determine whether output_mi_thunk would succeed. */
681/* ??? Ideally, this hook would not exist, and success or failure
682 would be returned from output_mi_thunk directly. But there's
683 too much undo-able setup involved in invoking output_mi_thunk.
684 Could be fixed by making output_mi_thunk emit rtl instead of
685 text to the output file. */
686DEFHOOK
687(can_output_mi_thunk,
688 "A function that returns true if TARGET_ASM_OUTPUT_MI_THUNK would be able\n\
689to output the assembler code for the thunk function specified by the\n\
690arguments it is passed, and false otherwise. In the latter case, the\n\
691generic approach will be used by the C++ front end, with the limitations\n\
692previously exposed.",
693 bool, (const_tree thunk_fndecl, HOST_WIDE_INT delta,
694 HOST_WIDE_INT vcall_offset, const_tree function),
695 hook_bool_const_tree_hwi_hwi_const_tree_false)
696
697/* Output any boilerplate text needed at the beginning of a
698 translation unit. */
699DEFHOOK
700(file_start,
701 "Output to @code{asm_out_file} any text which the assembler expects to\n\
702find at the beginning of a file. The default behavior is controlled\n\
703by two flags, documented below. Unless your target's assembler is\n\
704quite unusual, if you override the default, you should call\n\
705@code{default_file_start} at some point in your target hook. This\n\
706lets other target files rely on these variables.",
707 void, (void),
708 default_file_start)
709
710/* Output any boilerplate text needed at the end of a translation unit. */
711DEFHOOK
712(file_end,
713 "Output to @code{asm_out_file} any text which the assembler expects\n\
714to find at the end of a file. The default is to output nothing.",
715 void, (void),
716 hook_void_void)
717
718/* Output any boilerplate text needed at the beginning of an
719 LTO output stream. */
720DEFHOOK
721(lto_start,
722 "Output to @code{asm_out_file} any text which the assembler expects\n\
723to find at the start of an LTO section. The default is to output\n\
724nothing.",
725 void, (void),
726 hook_void_void)
727
728/* Output any boilerplate text needed at the end of an
729 LTO output stream. */
730DEFHOOK
731(lto_end,
732 "Output to @code{asm_out_file} any text which the assembler expects\n\
733to find at the end of an LTO section. The default is to output\n\
734nothing.",
735 void, (void),
736 hook_void_void)
737
738/* Output any boilerplace text needed at the end of a
739 translation unit before debug and unwind info is emitted. */
740DEFHOOK
741(code_end,
742 "Output to @code{asm_out_file} any text which is needed before emitting\n\
743unwind info and debug info at the end of a file. Some targets emit\n\
744here PIC setup thunks that cannot be emitted at the end of file,\n\
745because they couldn't have unwind info then. The default is to output\n\
746nothing.",
747 void, (void),
748 hook_void_void)
749
750/* Output an assembler pseudo-op to declare a library function name
751 external. */
752DEFHOOK
753(external_libcall,
754 "This target hook is a function to output to @var{asm_out_file} an assembler\n\
755pseudo-op to declare a library function name external. The name of the\n\
756library function is given by @var{symref}, which is a @code{symbol_ref}.",
757 void, (rtx symref),
758 default_external_libcall)
759
760/* Output an assembler directive to mark decl live. This instructs
761 linker to not dead code strip this symbol. */
762DEFHOOK
763(mark_decl_preserved,
764 "This target hook is a function to output to @var{asm_out_file} an assembler\n\
765directive to annotate @var{symbol} as used. The Darwin target uses the\n\
766.no_dead_code_strip directive.",
767 void, (const char *symbol),
768 hook_void_constcharptr)
769
770/* Output a record of the command line switches that have been passed. */
771DEFHOOK
772(record_gcc_switches,
773 "Provides the target with the ability to record the gcc command line\n\
774switches provided as argument.\n\
775\n\
776By default this hook is set to NULL, but an example implementation is\n\
777provided for ELF based targets. Called @var{elf_record_gcc_switches},\n\
778it records the switches as ASCII text inside a new, string mergeable\n\
779section in the assembler output file. The name of the new section is\n\
780provided by the @code{TARGET_ASM_RECORD_GCC_SWITCHES_SECTION} target\n\
781hook.",
782 void, (const char *),
783 NULL)
784
785/* The name of the section that the example ELF implementation of
786 record_gcc_switches will use to store the information. Target
787 specific versions of record_gcc_switches may or may not use
788 this information. */
789DEFHOOKPOD
790(record_gcc_switches_section,
791 "This is the name of the section that will be created by the example\n\
792ELF implementation of the @code{TARGET_ASM_RECORD_GCC_SWITCHES} target\n\
793hook.",
794 const char *, ".GCC.command.line")
795
796/* Output the definition of a section anchor. */
797DEFHOOK
798(output_anchor,
799 "Write the assembly code to define section anchor @var{x}, which is a\n\
800@code{SYMBOL_REF} for which @samp{SYMBOL_REF_ANCHOR_P (@var{x})} is true.\n\
801The hook is called with the assembly output position set to the beginning\n\
802of @code{SYMBOL_REF_BLOCK (@var{x})}.\n\
803\n\
804If @code{ASM_OUTPUT_DEF} is available, the hook's default definition uses\n\
805it to define the symbol as @samp{. + SYMBOL_REF_BLOCK_OFFSET (@var{x})}.\n\
806If @code{ASM_OUTPUT_DEF} is not available, the hook's default definition\n\
807is @code{NULL}, which disables the use of section anchors altogether.",
808 void, (rtx x),
809 default_asm_output_anchor)
810
811DEFHOOK
812(output_ident,
813 "Output a string based on @var{name}, suitable for the @samp{#ident}\n\
814directive, or the equivalent directive or pragma in non-C-family languages.\n\
815If this hook is not defined, nothing is output for the @samp{#ident}\n\
816directive.",
817 void, (const char *name),
818 hook_void_constcharptr)
819
820/* Output a DTP-relative reference to a TLS symbol. */
821DEFHOOK
822(output_dwarf_dtprel,
823 "If defined, this target hook is a function which outputs a DTP-relative\n\
824reference to the given TLS symbol of the specified size.",
825 void, (FILE *file, int size, rtx x),
826 NULL)
827
828/* Some target machines need to postscan each insn after it is output. */
829DEFHOOK
830(final_postscan_insn,
831 "If defined, this target hook is a function which is executed just after the\n\
832output of assembler code for @var{insn}, to change the mode of the assembler\n\
833if necessary.\n\
834\n\
835Here the argument @var{opvec} is the vector containing the operands\n\
836extracted from @var{insn}, and @var{noperands} is the number of\n\
837elements of the vector which contain meaningful data for this insn.\n\
838The contents of this vector are what was used to convert the insn\n\
839template into assembler code, so you can change the assembler mode\n\
840by checking the contents of the vector.",
841 void, (FILE *file, rtx_insn *insn, rtx *opvec, int noperands),
842 NULL)
843
844/* Emit the trampoline template. This hook may be NULL. */
845DEFHOOK
846(trampoline_template,
847 "This hook is called by @code{assemble_trampoline_template} to output,\n\
848on the stream @var{f}, assembler code for a block of data that contains\n\
849the constant parts of a trampoline. This code should not include a\n\
850label---the label is taken care of automatically.\n\
851\n\
852If you do not define this hook, it means no template is needed\n\
853for the target. Do not define this hook on systems where the block move\n\
854code to copy the trampoline into place would be larger than the code\n\
855to generate it on the spot.",
856 void, (FILE *f),
857 NULL)
858
859DEFHOOK
860(output_source_filename,
861 "Output DWARF debugging information which indicates that filename\n\
862@var{name} is the current source file to the stdio stream @var{file}.\n\
863\n\
864This target hook need not be defined if the standard form of output\n\
865for the file format in use is appropriate.",
866 void ,(FILE *file, const char *name),
867 default_asm_output_source_filename)
868
869DEFHOOK
870(output_addr_const_extra,
871 "A target hook to recognize @var{rtx} patterns that @code{output_addr_const}\n\
872can't deal with, and output assembly code to @var{file} corresponding to\n\
873the pattern @var{x}. This may be used to allow machine-dependent\n\
874@code{UNSPEC}s to appear within constants.\n\
875\n\
876If target hook fails to recognize a pattern, it must return @code{false},\n\
877so that a standard error message is printed. If it prints an error message\n\
878itself, by calling, for example, @code{output_operand_lossage}, it may just\n\
879return @code{true}.",
880 bool, (FILE *file, rtx x),
881 hook_bool_FILEptr_rtx_false)
882
883/* ??? The TARGET_PRINT_OPERAND* hooks are part of the asm_out struct,
884 even though that is not reflected in the macro name to override their
885 initializers. */
886#undef HOOK_PREFIX
887#define HOOK_PREFIX "TARGET_"
888
889/* Emit a machine-specific insn operand. */
890/* ??? tm.texi only documents the old macro PRINT_OPERAND,
891 not this hook, and uses a different name for the argument FILE. */
892DEFHOOK_UNDOC
893(print_operand,
894 "",
895 void, (FILE *file, rtx x, int code),
896 default_print_operand)
897
898/* Emit a machine-specific memory address. */
899/* ??? tm.texi only documents the old macro PRINT_OPERAND_ADDRESS,
900 not this hook, and uses different argument names. */
901DEFHOOK_UNDOC
902(print_operand_address,
903 "",
904 void, (FILE *file, machine_mode mode, rtx addr),
905 default_print_operand_address)
906
907/* Determine whether CODE is a valid punctuation character for the
908 `print_operand' hook. */
909/* ??? tm.texi only documents the old macro PRINT_OPERAND_PUNCT_VALID_P,
910 not this hook. */
911DEFHOOK_UNDOC
912(print_operand_punct_valid_p,
913 "",
914 bool ,(unsigned char code),
915 default_print_operand_punct_valid_p)
916
917/* Given a symbol name, perform same mangling as assemble_name and
918 ASM_OUTPUT_LABELREF, returning result as an IDENTIFIER_NODE. */
919DEFHOOK
920(mangle_assembler_name,
921 "Given a symbol @var{name}, perform same mangling as @code{varasm.cc}'s\n\
922@code{assemble_name}, but in memory rather than to a file stream, returning\n\
923result as an @code{IDENTIFIER_NODE}. Required for correct LTO symtabs. The\n\
924default implementation calls the @code{TARGET_STRIP_NAME_ENCODING} hook and\n\
925then prepends the @code{USER_LABEL_PREFIX}, if any.",
926 tree, (const char *name),
927 default_mangle_assembler_name)
928
929HOOK_VECTOR_END (asm_out)
930
931/* Functions relating to instruction scheduling. All of these
932 default to null pointers, which haifa-sched.cc looks for and handles. */
933#undef HOOK_PREFIX
934#define HOOK_PREFIX "TARGET_SCHED_"
935HOOK_VECTOR (TARGET_SCHED, sched)
936
937/* Given the current cost, COST, of an insn, INSN, calculate and
938 return a new cost based on its relationship to DEP_INSN through
939 the dependence LINK. The default is to make no adjustment. */
940DEFHOOK
941(adjust_cost,
942 "This function corrects the value of @var{cost} based on the\n\
943relationship between @var{insn} and @var{dep_insn} through a\n\
944dependence of type dep_type, and strength @var{dw}. It should return the new\n\
945value. The default is to make no adjustment to @var{cost}. This can be\n\
946used for example to specify to the scheduler using the traditional pipeline\n\
947description that an output- or anti-dependence does not incur the same cost\n\
948as a data-dependence. If the scheduler using the automaton based pipeline\n\
949description, the cost of anti-dependence is zero and the cost of\n\
950output-dependence is maximum of one and the difference of latency\n\
951times of the first and the second insns. If these values are not\n\
952acceptable, you could use the hook to modify them too. See also\n\
953@pxref{Processor pipeline description}.",
954 int, (rtx_insn *insn, int dep_type1, rtx_insn *dep_insn, int cost,
955 unsigned int dw),
956 NULL)
957
958/* Adjust the priority of an insn as you see fit. Returns the new priority. */
959DEFHOOK
960(adjust_priority,
961 "This hook adjusts the integer scheduling priority @var{priority} of\n\
962@var{insn}. It should return the new priority. Increase the priority to\n\
963execute @var{insn} earlier, reduce the priority to execute @var{insn}\n\
964later. Do not define this hook if you do not need to adjust the\n\
965scheduling priorities of insns.",
966 int, (rtx_insn *insn, int priority), NULL)
967
968/* Function which returns the maximum number of insns that can be
969 scheduled in the same machine cycle. This must be constant
970 over an entire compilation. The default is 1. */
971DEFHOOK
972(issue_rate,
973 "This hook returns the maximum number of instructions that can ever\n\
974issue at the same time on the target machine. The default is one.\n\
975Although the insn scheduler can define itself the possibility of issue\n\
976an insn on the same cycle, the value can serve as an additional\n\
977constraint to issue insns on the same simulated processor cycle (see\n\
978hooks @samp{TARGET_SCHED_REORDER} and @samp{TARGET_SCHED_REORDER2}).\n\
979This value must be constant over the entire compilation. If you need\n\
980it to vary depending on what the instructions are, you must use\n\
981@samp{TARGET_SCHED_VARIABLE_ISSUE}.",
982 int, (void), NULL)
983
984/* Calculate how much this insn affects how many more insns we
985 can emit this cycle. Default is they all cost the same. */
986DEFHOOK
987(variable_issue,
988 "This hook is executed by the scheduler after it has scheduled an insn\n\
989from the ready list. It should return the number of insns which can\n\
990still be issued in the current cycle. The default is\n\
991@samp{@w{@var{more} - 1}} for insns other than @code{CLOBBER} and\n\
992@code{USE}, which normally are not counted against the issue rate.\n\
993You should define this hook if some insns take more machine resources\n\
994than others, so that fewer insns can follow them in the same cycle.\n\
995@var{file} is either a null pointer, or a stdio stream to write any\n\
996debug output to. @var{verbose} is the verbose level provided by\n\
997@option{-fsched-verbose-@var{n}}. @var{insn} is the instruction that\n\
998was scheduled.",
999 int, (FILE *file, int verbose, rtx_insn *insn, int more), NULL)
1000
1001/* Initialize machine-dependent scheduling code. */
1002DEFHOOK
1003(init,
1004 "This hook is executed by the scheduler at the beginning of each block of\n\
1005instructions that are to be scheduled. @var{file} is either a null\n\
1006pointer, or a stdio stream to write any debug output to. @var{verbose}\n\
1007is the verbose level provided by @option{-fsched-verbose-@var{n}}.\n\
1008@var{max_ready} is the maximum number of insns in the current scheduling\n\
1009region that can be live at the same time. This can be used to allocate\n\
1010scratch space if it is needed, e.g.@: by @samp{TARGET_SCHED_REORDER}.",
1011 void, (FILE *file, int verbose, int max_ready), NULL)
1012
1013/* Finalize machine-dependent scheduling code. */
1014DEFHOOK
1015(finish,
1016 "This hook is executed by the scheduler at the end of each block of\n\
1017instructions that are to be scheduled. It can be used to perform\n\
1018cleanup of any actions done by the other scheduling hooks. @var{file}\n\
1019is either a null pointer, or a stdio stream to write any debug output\n\
1020to. @var{verbose} is the verbose level provided by\n\
1021@option{-fsched-verbose-@var{n}}.",
1022 void, (FILE *file, int verbose), NULL)
1023
1024 /* Initialize machine-dependent function wide scheduling code. */
1025DEFHOOK
1026(init_global,
1027 "This hook is executed by the scheduler after function level initializations.\n\
1028@var{file} is either a null pointer, or a stdio stream to write any debug output to.\n\
1029@var{verbose} is the verbose level provided by @option{-fsched-verbose-@var{n}}.\n\
1030@var{old_max_uid} is the maximum insn uid when scheduling begins.",
1031 void, (FILE *file, int verbose, int old_max_uid), NULL)
1032
1033/* Finalize machine-dependent function wide scheduling code. */
1034DEFHOOK
1035(finish_global,
1036 "This is the cleanup hook corresponding to @code{TARGET_SCHED_INIT_GLOBAL}.\n\
1037@var{file} is either a null pointer, or a stdio stream to write any debug output to.\n\
1038@var{verbose} is the verbose level provided by @option{-fsched-verbose-@var{n}}.",
1039 void, (FILE *file, int verbose), NULL)
1040
1041/* Reorder insns in a machine-dependent fashion, in two different
1042 places. Default does nothing. */
1043DEFHOOK
1044(reorder,
1045 "This hook is executed by the scheduler after it has scheduled the ready\n\
1046list, to allow the machine description to reorder it (for example to\n\
1047combine two small instructions together on @samp{VLIW} machines).\n\
1048@var{file} is either a null pointer, or a stdio stream to write any\n\
1049debug output to. @var{verbose} is the verbose level provided by\n\
1050@option{-fsched-verbose-@var{n}}. @var{ready} is a pointer to the ready\n\
1051list of instructions that are ready to be scheduled. @var{n_readyp} is\n\
1052a pointer to the number of elements in the ready list. The scheduler\n\
1053reads the ready list in reverse order, starting with\n\
1054@var{ready}[@var{*n_readyp} @minus{} 1] and going to @var{ready}[0]. @var{clock}\n\
1055is the timer tick of the scheduler. You may modify the ready list and\n\
1056the number of ready insns. The return value is the number of insns that\n\
1057can issue this cycle; normally this is just @code{issue_rate}. See also\n\
1058@samp{TARGET_SCHED_REORDER2}.",
1059 int, (FILE *file, int verbose, rtx_insn **ready, int *n_readyp, int clock), NULL)
1060
1061DEFHOOK
1062(reorder2,
1063 "Like @samp{TARGET_SCHED_REORDER}, but called at a different time. That\n\
1064function is called whenever the scheduler starts a new cycle. This one\n\
1065is called once per iteration over a cycle, immediately after\n\
1066@samp{TARGET_SCHED_VARIABLE_ISSUE}; it can reorder the ready list and\n\
1067return the number of insns to be scheduled in the same cycle. Defining\n\
1068this hook can be useful if there are frequent situations where\n\
1069scheduling one insn causes other insns to become ready in the same\n\
1070cycle. These other insns can then be taken into account properly.",
1071 int, (FILE *file, int verbose, rtx_insn **ready, int *n_readyp, int clock), NULL)
1072
1073DEFHOOK
1074(macro_fusion_p,
1075 "This hook is used to check whether target platform supports macro fusion.",
1076 bool, (void), NULL)
1077
1078DEFHOOK
1079(macro_fusion_pair_p,
1080 "This hook is used to check whether two insns should be macro fused for\n\
1081a target microarchitecture. If this hook returns true for the given insn pair\n\
1082(@var{prev} and @var{curr}), the scheduler will put them into a sched\n\
1083group, and they will not be scheduled apart. The two insns will be either\n\
1084two SET insns or a compare and a conditional jump and this hook should\n\
1085validate any dependencies needed to fuse the two insns together.",
1086 bool, (rtx_insn *prev, rtx_insn *curr), NULL)
1087
1088/* The following member value is a pointer to a function called
1089 after evaluation forward dependencies of insns in chain given
1090 by two parameter values (head and tail correspondingly). */
1091DEFHOOK
1092(dependencies_evaluation_hook,
1093 "This hook is called after evaluation forward dependencies of insns in\n\
1094chain given by two parameter values (@var{head} and @var{tail}\n\
1095correspondingly) but before insns scheduling of the insn chain. For\n\
1096example, it can be used for better insn classification if it requires\n\
1097analysis of dependencies. This hook can use backward and forward\n\
1098dependencies of the insn scheduler because they are already\n\
1099calculated.",
1100 void, (rtx_insn *head, rtx_insn *tail), NULL)
1101
1102/* The values of the following four members are pointers to functions
1103 used to simplify the automaton descriptions. dfa_pre_cycle_insn and
1104 dfa_post_cycle_insn give functions returning insns which are used to
1105 change the pipeline hazard recognizer state when the new simulated
1106 processor cycle correspondingly starts and finishes. The function
1107 defined by init_dfa_pre_cycle_insn and init_dfa_post_cycle_insn are
1108 used to initialize the corresponding insns. The default values of
1109 the members result in not changing the automaton state when the
1110 new simulated processor cycle correspondingly starts and finishes. */
1111
1112DEFHOOK
1113(init_dfa_pre_cycle_insn,
1114 "The hook can be used to initialize data used by the previous hook.",
1115 void, (void), NULL)
1116
1117DEFHOOK
1118(dfa_pre_cycle_insn,
1119 "The hook returns an RTL insn. The automaton state used in the\n\
1120pipeline hazard recognizer is changed as if the insn were scheduled\n\
1121when the new simulated processor cycle starts. Usage of the hook may\n\
1122simplify the automaton pipeline description for some @acronym{VLIW}\n\
1123processors. If the hook is defined, it is used only for the automaton\n\
1124based pipeline description. The default is not to change the state\n\
1125when the new simulated processor cycle starts.",
1126 rtx, (void), NULL)
1127
1128DEFHOOK
1129(init_dfa_post_cycle_insn,
1130 "The hook is analogous to @samp{TARGET_SCHED_INIT_DFA_PRE_CYCLE_INSN} but\n\
1131used to initialize data used by the previous hook.",
1132 void, (void), NULL)
1133
1134DEFHOOK
1135(dfa_post_cycle_insn,
1136 "The hook is analogous to @samp{TARGET_SCHED_DFA_PRE_CYCLE_INSN} but used\n\
1137to changed the state as if the insn were scheduled when the new\n\
1138simulated processor cycle finishes.",
1139 rtx_insn *, (void), NULL)
1140
1141/* The values of the following two members are pointers to
1142 functions used to simplify the automaton descriptions.
1143 dfa_pre_advance_cycle and dfa_post_advance_cycle are getting called
1144 immediately before and after cycle is advanced. */
1145
1146DEFHOOK
1147(dfa_pre_advance_cycle,
1148 "The hook to notify target that the current simulated cycle is about to finish.\n\
1149The hook is analogous to @samp{TARGET_SCHED_DFA_PRE_CYCLE_INSN} but used\n\
1150to change the state in more complicated situations - e.g., when advancing\n\
1151state on a single insn is not enough.",
1152 void, (void), NULL)
1153
1154DEFHOOK
1155(dfa_post_advance_cycle,
1156 "The hook to notify target that new simulated cycle has just started.\n\
1157The hook is analogous to @samp{TARGET_SCHED_DFA_POST_CYCLE_INSN} but used\n\
1158to change the state in more complicated situations - e.g., when advancing\n\
1159state on a single insn is not enough.",
1160 void, (void), NULL)
1161
1162/* The following member value is a pointer to a function returning value
1163 which defines how many insns in queue `ready' will we try for
1164 multi-pass scheduling. If the member value is nonzero and the
1165 function returns positive value, the DFA based scheduler will make
1166 multi-pass scheduling for the first cycle. In other words, we will
1167 try to choose ready insn which permits to start maximum number of
1168 insns on the same cycle. */
1169DEFHOOK
1170(first_cycle_multipass_dfa_lookahead,
1171 "This hook controls better choosing an insn from the ready insn queue\n\
1172for the @acronym{DFA}-based insn scheduler. Usually the scheduler\n\
1173chooses the first insn from the queue. If the hook returns a positive\n\
1174value, an additional scheduler code tries all permutations of\n\
1175@samp{TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD ()}\n\
1176subsequent ready insns to choose an insn whose issue will result in\n\
1177maximal number of issued insns on the same cycle. For the\n\
1178@acronym{VLIW} processor, the code could actually solve the problem of\n\
1179packing simple insns into the @acronym{VLIW} insn. Of course, if the\n\
1180rules of @acronym{VLIW} packing are described in the automaton.\n\
1181\n\
1182This code also could be used for superscalar @acronym{RISC}\n\
1183processors. Let us consider a superscalar @acronym{RISC} processor\n\
1184with 3 pipelines. Some insns can be executed in pipelines @var{A} or\n\
1185@var{B}, some insns can be executed only in pipelines @var{B} or\n\
1186@var{C}, and one insn can be executed in pipeline @var{B}. The\n\
1187processor may issue the 1st insn into @var{A} and the 2nd one into\n\
1188@var{B}. In this case, the 3rd insn will wait for freeing @var{B}\n\
1189until the next cycle. If the scheduler issues the 3rd insn the first,\n\
1190the processor could issue all 3 insns per cycle.\n\
1191\n\
1192Actually this code demonstrates advantages of the automaton based\n\
1193pipeline hazard recognizer. We try quickly and easy many insn\n\
1194schedules to choose the best one.\n\
1195\n\
1196The default is no multipass scheduling.",
1197 int, (void), NULL)
1198
1199/* The following member value is pointer to a function controlling
1200 what insns from the ready insn queue will be considered for the
1201 multipass insn scheduling. If the hook returns zero for insn
1202 passed as the parameter, the insn will be not chosen to be issued. */
1203DEFHOOK
1204(first_cycle_multipass_dfa_lookahead_guard,
1205 "\n\
1206This hook controls what insns from the ready insn queue will be\n\
1207considered for the multipass insn scheduling. If the hook returns\n\
1208zero for @var{insn}, the insn will be considered in multipass scheduling.\n\
1209Positive return values will remove @var{insn} from consideration on\n\
1210the current round of multipass scheduling.\n\
1211Negative return values will remove @var{insn} from consideration for given\n\
1212number of cycles.\n\
1213Backends should be careful about returning non-zero for highest priority\n\
1214instruction at position 0 in the ready list. @var{ready_index} is passed\n\
1215to allow backends make correct judgements.\n\
1216\n\
1217The default is that any ready insns can be chosen to be issued.",
1218 int, (rtx_insn *insn, int ready_index), NULL)
1219
1220/* This hook prepares the target for a new round of multipass
1221 scheduling.
1222 DATA is a pointer to target-specific data used for multipass scheduling.
1223 READY_TRY and N_READY represent the current state of search in the
1224 optimization space. The target can filter out instructions that
1225 should not be tried during current round by setting corresponding
1226 elements in READY_TRY to non-zero.
1227 FIRST_CYCLE_INSN_P is true if this is the first round of multipass
1228 scheduling on current cycle. */
1229DEFHOOK
1230(first_cycle_multipass_begin,
1231 "This hook prepares the target backend for a new round of multipass\n\
1232scheduling.",
1233 void, (void *data, signed char *ready_try, int n_ready, bool first_cycle_insn_p),
1234 NULL)
1235
1236/* This hook is called when multipass scheduling evaluates instruction INSN.
1237 DATA is a pointer to target-specific data that can be used to record effects
1238 of INSN on CPU that are not described in DFA.
1239 READY_TRY and N_READY represent the current state of search in the
1240 optimization space. The target can filter out instructions that
1241 should not be tried after issuing INSN by setting corresponding
1242 elements in READY_TRY to non-zero.
1243 INSN is the instruction being evaluated.
1244 PREV_DATA is a pointer to target-specific data corresponding
1245 to a state before issuing INSN. */
1246DEFHOOK
1247(first_cycle_multipass_issue,
1248 "This hook is called when multipass scheduling evaluates instruction INSN.",
1249 void, (void *data, signed char *ready_try, int n_ready, rtx_insn *insn,
1250 const void *prev_data), NULL)
1251
1252/* This hook is called when multipass scheduling backtracks from evaluation of
1253 instruction corresponding to DATA.
1254 DATA is a pointer to target-specific data that stores the effects
1255 of instruction from which the algorithm backtracks on CPU that are not
1256 described in DFA.
1257 READY_TRY and N_READY represent the current state of search in the
1258 optimization space. The target can filter out instructions that
1259 should not be tried after issuing INSN by setting corresponding
1260 elements in READY_TRY to non-zero. */
1261DEFHOOK
1262(first_cycle_multipass_backtrack,
1263 "This is called when multipass scheduling backtracks from evaluation of\n\
1264an instruction.",
1265 void, (const void *data, signed char *ready_try, int n_ready), NULL)
1266
1267/* This hook notifies the target about the result of the concluded current
1268 round of multipass scheduling.
1269 DATA is a pointer.
1270 If DATA is non-NULL it points to target-specific data used for multipass
1271 scheduling which corresponds to instruction at the start of the chain of
1272 the winning solution. DATA is NULL when multipass scheduling cannot find
1273 a good enough solution on current cycle and decides to retry later,
1274 usually after advancing the cycle count. */
1275DEFHOOK
1276(first_cycle_multipass_end,
1277 "This hook notifies the target about the result of the concluded current\n\
1278round of multipass scheduling.",
1279 void, (const void *data), NULL)
1280
1281/* This hook is called to initialize target-specific data for multipass
1282 scheduling after it has been allocated.
1283 DATA is a pointer to target-specific data that stores the effects
1284 of instruction from which the algorithm backtracks on CPU that are not
1285 described in DFA. */
1286DEFHOOK
1287(first_cycle_multipass_init,
1288 "This hook initializes target-specific data used in multipass scheduling.",
1289 void, (void *data), NULL)
1290
1291/* This hook is called to finalize target-specific data for multipass
1292 scheduling before it is deallocated.
1293 DATA is a pointer to target-specific data that stores the effects
1294 of instruction from which the algorithm backtracks on CPU that are not
1295 described in DFA. */
1296DEFHOOK
1297(first_cycle_multipass_fini,
1298 "This hook finalizes target-specific data used in multipass scheduling.",
1299 void, (void *data), NULL)
1300
1301/* The following member value is pointer to a function called by
1302 the insn scheduler before issuing insn passed as the third
1303 parameter on given cycle. If the hook returns nonzero, the
1304 insn is not issued on given processors cycle. Instead of that,
1305 the processor cycle is advanced. If the value passed through
1306 the last parameter is zero, the insn ready queue is not sorted
1307 on the new cycle start as usually. The first parameter passes
1308 file for debugging output. The second one passes the scheduler
1309 verbose level of the debugging output. The forth and the fifth
1310 parameter values are correspondingly processor cycle on which
1311 the previous insn has been issued and the current processor cycle. */
1312DEFHOOK
1313(dfa_new_cycle,
1314 "This hook is called by the insn scheduler before issuing @var{insn}\n\
1315on cycle @var{clock}. If the hook returns nonzero,\n\
1316@var{insn} is not issued on this processor cycle. Instead,\n\
1317the processor cycle is advanced. If *@var{sort_p}\n\
1318is zero, the insn ready queue is not sorted on the new cycle\n\
1319start as usually. @var{dump} and @var{verbose} specify the file and\n\
1320verbosity level to use for debugging output.\n\
1321@var{last_clock} and @var{clock} are, respectively, the\n\
1322processor cycle on which the previous insn has been issued,\n\
1323and the current processor cycle.",
1324 int, (FILE *dump, int verbose, rtx_insn *insn, int last_clock,
1325 int clock, int *sort_p),
1326 NULL)
1327
1328/* The following member value is a pointer to a function called by the
1329 insn scheduler. It should return true if there exists a dependence
1330 which is considered costly by the target, between the insn
1331 DEP_PRO (&_DEP), and the insn DEP_CON (&_DEP). The first parameter is
1332 the dep that represents the dependence between the two insns. The
1333 second argument is the cost of the dependence as estimated by
1334 the scheduler. The last argument is the distance in cycles
1335 between the already scheduled insn (first parameter) and the
1336 second insn (second parameter). */
1337DEFHOOK
1338(is_costly_dependence,
1339 "This hook is used to define which dependences are considered costly by\n\
1340the target, so costly that it is not advisable to schedule the insns that\n\
1341are involved in the dependence too close to one another. The parameters\n\
1342to this hook are as follows: The first parameter @var{_dep} is the dependence\n\
1343being evaluated. The second parameter @var{cost} is the cost of the\n\
1344dependence as estimated by the scheduler, and the third\n\
1345parameter @var{distance} is the distance in cycles between the two insns.\n\
1346The hook returns @code{true} if considering the distance between the two\n\
1347insns the dependence between them is considered costly by the target,\n\
1348and @code{false} otherwise.\n\
1349\n\
1350Defining this hook can be useful in multiple-issue out-of-order machines,\n\
1351where (a) it's practically hopeless to predict the actual data/resource\n\
1352delays, however: (b) there's a better chance to predict the actual grouping\n\
1353that will be formed, and (c) correctly emulating the grouping can be very\n\
1354important. In such targets one may want to allow issuing dependent insns\n\
1355closer to one another---i.e., closer than the dependence distance; however,\n\
1356not in cases of ``costly dependences'', which this hooks allows to define.",
1357 bool, (struct _dep *_dep, int cost, int distance), NULL)
1358
1359/* The following member value is a pointer to a function called
1360 by the insn scheduler. This hook is called to notify the backend
1361 that new instructions were emitted. */
1362DEFHOOK
1363(h_i_d_extended,
1364 "This hook is called by the insn scheduler after emitting a new instruction to\n\
1365the instruction stream. The hook notifies a target backend to extend its\n\
1366per instruction data structures.",
1367 void, (void), NULL)
1368
1369/* Next 5 functions are for multi-point scheduling. */
1370
1371/* Allocate memory for scheduler context. */
1372DEFHOOK
1373(alloc_sched_context,
1374 "Return a pointer to a store large enough to hold target scheduling context.",
1375 void *, (void), NULL)
1376
1377/* Fills the context from the local machine scheduler context. */
1378DEFHOOK
1379(init_sched_context,
1380 "Initialize store pointed to by @var{tc} to hold target scheduling context.\n\
1381It @var{clean_p} is true then initialize @var{tc} as if scheduler is at the\n\
1382beginning of the block. Otherwise, copy the current context into @var{tc}.",
1383 void, (void *tc, bool clean_p), NULL)
1384
1385/* Sets local machine scheduler context to a saved value. */
1386DEFHOOK
1387(set_sched_context,
1388 "Copy target scheduling context pointed to by @var{tc} to the current context.",
1389 void, (void *tc), NULL)
1390
1391/* Clears a scheduler context so it becomes like after init. */
1392DEFHOOK
1393(clear_sched_context,
1394 "Deallocate internal data in target scheduling context pointed to by @var{tc}.",
1395 void, (void *tc), NULL)
1396
1397/* Frees the scheduler context. */
1398DEFHOOK
1399(free_sched_context,
1400 "Deallocate a store for target scheduling context pointed to by @var{tc}.",
1401 void, (void *tc), NULL)
1402
1403/* The following member value is a pointer to a function called
1404 by the insn scheduler.
1405 The first parameter is an instruction, the second parameter is the type
1406 of the requested speculation, and the third parameter is a pointer to the
1407 speculative pattern of the corresponding type (set if return value == 1).
1408 It should return
1409 -1, if there is no pattern, that will satisfy the requested speculation type,
1410 0, if current pattern satisfies the requested speculation type,
1411 1, if pattern of the instruction should be changed to the newly
1412 generated one. */
1413DEFHOOK
1414(speculate_insn,
1415 "This hook is called by the insn scheduler when @var{insn} has only\n\
1416speculative dependencies and therefore can be scheduled speculatively.\n\
1417The hook is used to check if the pattern of @var{insn} has a speculative\n\
1418version and, in case of successful check, to generate that speculative\n\
1419pattern. The hook should return 1, if the instruction has a speculative form,\n\
1420or @minus{}1, if it doesn't. @var{request} describes the type of requested\n\
1421speculation. If the return value equals 1 then @var{new_pat} is assigned\n\
1422the generated speculative pattern.",
1423 int, (rtx_insn *insn, unsigned int dep_status, rtx *new_pat), NULL)
1424
1425/* The following member value is a pointer to a function called
1426 by the insn scheduler. It should return true if the check instruction
1427 passed as the parameter needs a recovery block. */
1428DEFHOOK
1429(needs_block_p,
1430 "This hook is called by the insn scheduler during generation of recovery code\n\
1431for @var{insn}. It should return @code{true}, if the corresponding check\n\
1432instruction should branch to recovery code, or @code{false} otherwise.",
1433 bool, (unsigned int dep_status), NULL)
1434
1435/* The following member value is a pointer to a function called
1436 by the insn scheduler. It should return a pattern for the check
1437 instruction.
1438 The first parameter is a speculative instruction, the second parameter
1439 is the label of the corresponding recovery block (or null, if it is a
1440 simple check). The third parameter is the kind of speculation that
1441 is being performed. */
1442DEFHOOK
1443(gen_spec_check,
1444 "This hook is called by the insn scheduler to generate a pattern for recovery\n\
1445check instruction. If @var{mutate_p} is zero, then @var{insn} is a\n\
1446speculative instruction for which the check should be generated.\n\
1447@var{label} is either a label of a basic block, where recovery code should\n\
1448be emitted, or a null pointer, when requested check doesn't branch to\n\
1449recovery code (a simple check). If @var{mutate_p} is nonzero, then\n\
1450a pattern for a branchy check corresponding to a simple check denoted by\n\
1451@var{insn} should be generated. In this case @var{label} can't be null.",
1452 rtx, (rtx_insn *insn, rtx_insn *label, unsigned int ds), NULL)
1453
1454/* The following member value is a pointer to a function that provides
1455 information about the speculation capabilities of the target.
1456 The parameter is a pointer to spec_info variable. */
1457DEFHOOK
1458(set_sched_flags,
1459 "This hook is used by the insn scheduler to find out what features should be\n\
1460enabled/used.\n\
1461The structure *@var{spec_info} should be filled in by the target.\n\
1462The structure describes speculation types that can be used in the scheduler.",
1463 void, (struct spec_info_def *spec_info), NULL)
1464
1465DEFHOOK_UNDOC
1466(get_insn_spec_ds,
1467 "Return speculation types of instruction @var{insn}.",
1468 unsigned int, (rtx_insn *insn), NULL)
1469
1470DEFHOOK_UNDOC
1471(get_insn_checked_ds,
1472 "Return speculation types that are checked for instruction @var{insn}",
1473 unsigned int, (rtx_insn *insn), NULL)
1474
1475DEFHOOK
1476(can_speculate_insn,
1477 "Some instructions should never be speculated by the schedulers, usually\n\
1478 because the instruction is too expensive to get this wrong. Often such\n\
1479 instructions have long latency, and often they are not fully modeled in the\n\
1480 pipeline descriptions. This hook should return @code{false} if @var{insn}\n\
1481 should not be speculated.",
1482 bool, (rtx_insn *insn), hook_bool_rtx_insn_true)
1483
1484DEFHOOK_UNDOC
1485(skip_rtx_p,
1486 "Return bool if rtx scanning should just skip current layer and\
1487 advance to the inner rtxes.",
1488 bool, (const_rtx x), NULL)
1489
1490/* The following member value is a pointer to a function that provides
1491 information about the target resource-based lower bound which is
1492 used by the swing modulo scheduler. The parameter is a pointer
1493 to ddg variable. */
1494DEFHOOK
1495(sms_res_mii,
1496 "This hook is called by the swing modulo scheduler to calculate a\n\
1497resource-based lower bound which is based on the resources available in\n\
1498the machine and the resources required by each instruction. The target\n\
1499backend can use @var{g} to calculate such bound. A very simple lower\n\
1500bound will be used in case this hook is not implemented: the total number\n\
1501of instructions divided by the issue rate.",
1502 int, (struct ddg *g), NULL)
1503
1504/* The following member value is a function that initializes dispatch
1505 schedling and adds instructions to dispatch window according to its
1506 parameters. */
1507DEFHOOK
1508(dispatch_do,
1509"This hook is called by Haifa Scheduler. It performs the operation specified\n\
1510in its second parameter.",
1511void, (rtx_insn *insn, int x),
1512hook_void_rtx_insn_int)
1513
1514/* The following member value is a function that returns true is
1515 dispatch schedling is supported in hardware and condition passed
1516 as the second parameter is true. */
1517DEFHOOK
1518(dispatch,
1519"This hook is called by Haifa Scheduler. It returns true if dispatch scheduling\n\
1520is supported in hardware and the condition specified in the parameter is true.",
1521bool, (rtx_insn *insn, int x),
1522hook_bool_rtx_insn_int_false)
1523
1524DEFHOOKPOD
1525(exposed_pipeline,
1526"True if the processor has an exposed pipeline, which means that not just\n\
1527the order of instructions is important for correctness when scheduling, but\n\
1528also the latencies of operations.",
1529bool, false)
1530
1531/* The following member value is a function that returns number
1532 of operations reassociator should try to put in parallel for
1533 statements of the given type. By default 1 is used. */
1534DEFHOOK
1535(reassociation_width,
1536"This hook is called by tree reassociator to determine a level of\n\
1537parallelism required in output calculations chain.",
1538int, (unsigned int opc, machine_mode mode),
1539hook_int_uint_mode_1)
1540
1541/* The following member value is a function that returns priority for
1542 fusion of each instruction via pointer parameters. */
1543DEFHOOK
1544(fusion_priority,
1545"This hook is called by scheduling fusion pass. It calculates fusion\n\
1546priorities for each instruction passed in by parameter. The priorities\n\
1547are returned via pointer parameters.\n\
1548\n\
1549@var{insn} is the instruction whose priorities need to be calculated.\n\
1550@var{max_pri} is the maximum priority can be returned in any cases.\n\
1551@var{fusion_pri} is the pointer parameter through which @var{insn}'s\n\
1552fusion priority should be calculated and returned.\n\
1553@var{pri} is the pointer parameter through which @var{insn}'s priority\n\
1554should be calculated and returned.\n\
1555\n\
1556Same @var{fusion_pri} should be returned for instructions which should\n\
1557be scheduled together. Different @var{pri} should be returned for\n\
1558instructions with same @var{fusion_pri}. @var{fusion_pri} is the major\n\
1559sort key, @var{pri} is the minor sort key. All instructions will be\n\
1560scheduled according to the two priorities. All priorities calculated\n\
1561should be between 0 (exclusive) and @var{max_pri} (inclusive). To avoid\n\
1562false dependencies, @var{fusion_pri} of instructions which need to be\n\
1563scheduled together should be smaller than @var{fusion_pri} of irrelevant\n\
1564instructions.\n\
1565\n\
1566Given below example:\n\
1567\n\
1568@smallexample\n\
1569 ldr r10, [r1, 4]\n\
1570 add r4, r4, r10\n\
1571 ldr r15, [r2, 8]\n\
1572 sub r5, r5, r15\n\
1573 ldr r11, [r1, 0]\n\
1574 add r4, r4, r11\n\
1575 ldr r16, [r2, 12]\n\
1576 sub r5, r5, r16\n\
1577@end smallexample\n\
1578\n\
1579On targets like ARM/AArch64, the two pairs of consecutive loads should be\n\
1580merged. Since peephole2 pass can't help in this case unless consecutive\n\
1581loads are actually next to each other in instruction flow. That's where\n\
1582this scheduling fusion pass works. This hook calculates priority for each\n\
1583instruction based on its fustion type, like:\n\
1584\n\
1585@smallexample\n\
1586 ldr r10, [r1, 4] ; fusion_pri=99, pri=96\n\
1587 add r4, r4, r10 ; fusion_pri=100, pri=100\n\
1588 ldr r15, [r2, 8] ; fusion_pri=98, pri=92\n\
1589 sub r5, r5, r15 ; fusion_pri=100, pri=100\n\
1590 ldr r11, [r1, 0] ; fusion_pri=99, pri=100\n\
1591 add r4, r4, r11 ; fusion_pri=100, pri=100\n\
1592 ldr r16, [r2, 12] ; fusion_pri=98, pri=88\n\
1593 sub r5, r5, r16 ; fusion_pri=100, pri=100\n\
1594@end smallexample\n\
1595\n\
1596Scheduling fusion pass then sorts all ready to issue instructions according\n\
1597to the priorities. As a result, instructions of same fusion type will be\n\
1598pushed together in instruction flow, like:\n\
1599\n\
1600@smallexample\n\
1601 ldr r11, [r1, 0]\n\
1602 ldr r10, [r1, 4]\n\
1603 ldr r15, [r2, 8]\n\
1604 ldr r16, [r2, 12]\n\
1605 add r4, r4, r10\n\
1606 sub r5, r5, r15\n\
1607 add r4, r4, r11\n\
1608 sub r5, r5, r16\n\
1609@end smallexample\n\
1610\n\
1611Now peephole2 pass can simply merge the two pairs of loads.\n\
1612\n\
1613Since scheduling fusion pass relies on peephole2 to do real fusion\n\
1614work, it is only enabled by default when peephole2 is in effect.\n\
1615\n\
1616This is firstly introduced on ARM/AArch64 targets, please refer to\n\
1617the hook implementation for how different fusion types are supported.",
1618void, (rtx_insn *insn, int max_pri, int *fusion_pri, int *pri), NULL)
1619
1620HOOK_VECTOR_END (sched)
1621
1622/* Functions relating to OpenMP SIMD and __attribute__((simd)) clones. */
1623#undef HOOK_PREFIX
1624#define HOOK_PREFIX "TARGET_SIMD_CLONE_"
1625HOOK_VECTOR (TARGET_SIMD_CLONE, simd_clone)
1626
1627DEFHOOK
1628(compute_vecsize_and_simdlen,
1629"This hook should set @var{vecsize_mangle}, @var{vecsize_int}, @var{vecsize_float}\n\
1630fields in @var{simd_clone} structure pointed by @var{clone_info} argument and also\n\
1631@var{simdlen} field if it was previously 0.\n\
1632@var{vecsize_mangle} is a marker for the backend only. @var{vecsize_int} and\n\
1633@var{vecsize_float} should be left zero on targets where the number of lanes is\n\
1634not determined by the bitsize (in which case @var{simdlen} is always used).\n\
1635The hook should return 0 if SIMD clones shouldn't be emitted,\n\
1636or number of @var{vecsize_mangle} variants that should be emitted.",
1637int, (struct cgraph_node *, struct cgraph_simd_clone *, tree, int, bool), NULL)
1638
1639DEFHOOK
1640(adjust,
1641"This hook should add implicit @code{attribute(target(\"...\"))} attribute\n\
1642to SIMD clone @var{node} if needed.",
1643void, (struct cgraph_node *), NULL)
1644
1645DEFHOOK
1646(usable,
1647"This hook should return -1 if SIMD clone @var{node} shouldn't be used\n\
1648in vectorized loops in current function, or non-negative number if it is\n\
1649usable. In that case, the smaller the number is, the more desirable it is\n\
1650to use it.",
1651int, (struct cgraph_node *), NULL)
1652
1653HOOK_VECTOR_END (simd_clone)
1654
1655/* Functions relating to OpenMP SIMT vectorization transform. */
1656#undef HOOK_PREFIX
1657#define HOOK_PREFIX "TARGET_SIMT_"
1658HOOK_VECTOR (TARGET_SIMT, simt)
1659
1660DEFHOOK
1661(vf,
1662"Return number of threads in SIMT thread group on the target.",
1663int, (void), NULL)
1664
1665HOOK_VECTOR_END (simt)
1666
1667/* Functions relating to OpenMP. */
1668#undef HOOK_PREFIX
1669#define HOOK_PREFIX "TARGET_OMP_"
1670HOOK_VECTOR (TARGET_OMP, omp)
1671
1672DEFHOOK
1673(device_kind_arch_isa,
1674"Return 1 if @var{trait} @var{name} is present in the OpenMP context's\n\
1675device trait set, return 0 if not present in any OpenMP context in the\n\
1676whole translation unit, or -1 if not present in the current OpenMP context\n\
1677but might be present in another OpenMP context in the same TU.",
1678int, (enum omp_device_kind_arch_isa trait, const char *name), NULL)
1679
1680HOOK_VECTOR_END (omp)
1681
1682/* Functions relating to openacc. */
1683#undef HOOK_PREFIX
1684#define HOOK_PREFIX "TARGET_GOACC_"
1685HOOK_VECTOR (TARGET_GOACC, goacc)
1686
1687DEFHOOK
1688(validate_dims,
1689"This hook should check the launch dimensions provided for an OpenACC\n\
1690compute region, or routine. Defaulted values are represented as -1\n\
1691and non-constant values as 0. The @var{fn_level} is negative for the\n\
1692function corresponding to the compute region. For a routine it is the\n\
1693outermost level at which partitioned execution may be spawned. The hook\n\
1694should verify non-default values. If DECL is NULL, global defaults\n\
1695are being validated and unspecified defaults should be filled in.\n\
1696Diagnostics should be issued as appropriate. Return\n\
1697true, if changes have been made. You must override this hook to\n\
1698provide dimensions larger than 1.",
1699bool, (tree decl, int *dims, int fn_level, unsigned used),
1700default_goacc_validate_dims)
1701
1702DEFHOOK
1703(dim_limit,
1704"This hook should return the maximum size of a particular dimension,\n\
1705or zero if unbounded.",
1706int, (int axis),
1707default_goacc_dim_limit)
1708
1709DEFHOOK
1710(fork_join,
1711"This hook can be used to convert IFN_GOACC_FORK and IFN_GOACC_JOIN\n\
1712function calls to target-specific gimple, or indicate whether they\n\
1713should be retained. It is executed during the oacc_device_lower pass.\n\
1714It should return true, if the call should be retained. It should\n\
1715return false, if it is to be deleted (either because target-specific\n\
1716gimple has been inserted before it, or there is no need for it).\n\
1717The default hook returns false, if there are no RTL expanders for them.",
1718bool, (gcall *call, const int *dims, bool is_fork),
1719default_goacc_fork_join)
1720
1721DEFHOOK
1722(reduction,
1723"This hook is used by the oacc_transform pass to expand calls to the\n\
1724@var{GOACC_REDUCTION} internal function, into a sequence of gimple\n\
1725instructions. @var{call} is gimple statement containing the call to\n\
1726the function. This hook removes statement @var{call} after the\n\
1727expanded sequence has been inserted. This hook is also responsible\n\
1728for allocating any storage for reductions when necessary.",
1729void, (gcall *call),
1730default_goacc_reduction)
1731
1732DEFHOOK
1733(adjust_private_decl,
1734"This hook, if defined, is used by accelerator target back-ends to adjust\n\
1735OpenACC variable declarations that should be made private to the given\n\
1736parallelism level (i.e. @code{GOMP_DIM_GANG}, @code{GOMP_DIM_WORKER} or\n\
1737@code{GOMP_DIM_VECTOR}). A typical use for this hook is to force variable\n\
1738declarations at the @code{gang} level to reside in GPU shared memory.\n\
1739@var{loc} may be used for diagnostic purposes.\n\
1740\n\
1741You may also use the @code{TARGET_GOACC_EXPAND_VAR_DECL} hook if the\n\
1742adjusted variable declaration needs to be expanded to RTL in a non-standard\n\
1743way.",
1744tree, (location_t loc, tree var, int level),
1745NULL)
1746
1747DEFHOOK
1748(expand_var_decl,
1749"This hook, if defined, is used by accelerator target back-ends to expand\n\
1750specially handled kinds of @code{VAR_DECL} expressions. A particular use is\n\
1751to place variables with specific attributes inside special accelarator\n\
1752memories. A return value of @code{NULL} indicates that the target does not\n\
1753handle this @code{VAR_DECL}, and normal RTL expanding is resumed.\n\
1754\n\
1755Only define this hook if your accelerator target needs to expand certain\n\
1756@code{VAR_DECL} nodes in a way that differs from the default. You can also adjust\n\
1757private variables at OpenACC device-lowering time using the\n\
1758@code{TARGET_GOACC_ADJUST_PRIVATE_DECL} target hook.",
1759rtx, (tree var),
1760NULL)
1761
1762DEFHOOK
1763(create_worker_broadcast_record,
1764"Create a record used to propagate local-variable state from an active\n\
1765worker to other workers. A possible implementation might adjust the type\n\
1766of REC to place the new variable in shared GPU memory.\n\
1767\n\
1768Presence of this target hook indicates that middle end neutering/broadcasting\n\
1769be used.",
1770tree, (tree rec, bool sender, const char *name, unsigned HOST_WIDE_INT offset),
1771NULL)
1772
1773DEFHOOK
1774(shared_mem_layout,
1775"Lay out a fixed shared-memory region on the target. The LO and HI\n\
1776arguments should be set to a range of addresses that can be used for worker\n\
1777broadcasting. The dimensions, reduction size and gang-private size\n\
1778arguments are for the current offload region.",
1779void, (unsigned HOST_WIDE_INT *, unsigned HOST_WIDE_INT *, int[],
1780 unsigned HOST_WIDE_INT[], unsigned HOST_WIDE_INT[]),
1781NULL)
1782
1783HOOK_VECTOR_END (goacc)
1784
1785/* Functions relating to vectorization. */
1786#undef HOOK_PREFIX
1787#define HOOK_PREFIX "TARGET_VECTORIZE_"
1788HOOK_VECTOR (TARGET_VECTORIZE, vectorize)
1789
1790/* The following member value is a pointer to a function called
1791 by the vectorizer, and return the decl of the target builtin
1792 function. */
1793DEFHOOK
1794(builtin_mask_for_load,
1795 "This hook should return the DECL of a function @var{f} that given an\n\
1796address @var{addr} as an argument returns a mask @var{m} that can be\n\
1797used to extract from two vectors the relevant data that resides in\n\
1798@var{addr} in case @var{addr} is not properly aligned.\n\
1799\n\
1800The autovectorizer, when vectorizing a load operation from an address\n\
1801@var{addr} that may be unaligned, will generate two vector loads from\n\
1802the two aligned addresses around @var{addr}. It then generates a\n\
1803@code{REALIGN_LOAD} operation to extract the relevant data from the\n\
1804two loaded vectors. The first two arguments to @code{REALIGN_LOAD},\n\
1805@var{v1} and @var{v2}, are the two vectors, each of size @var{VS}, and\n\
1806the third argument, @var{OFF}, defines how the data will be extracted\n\
1807from these two vectors: if @var{OFF} is 0, then the returned vector is\n\
1808@var{v2}; otherwise, the returned vector is composed from the last\n\
1809@var{VS}-@var{OFF} elements of @var{v1} concatenated to the first\n\
1810@var{OFF} elements of @var{v2}.\n\
1811\n\
1812If this hook is defined, the autovectorizer will generate a call\n\
1813to @var{f} (using the DECL tree that this hook returns) and will\n\
1814use the return value of @var{f} as the argument @var{OFF} to\n\
1815@code{REALIGN_LOAD}. Therefore, the mask @var{m} returned by @var{f}\n\
1816should comply with the semantics expected by @code{REALIGN_LOAD}\n\
1817described above.\n\
1818If this hook is not defined, then @var{addr} will be used as\n\
1819the argument @var{OFF} to @code{REALIGN_LOAD}, in which case the low\n\
1820log2(@var{VS}) @minus{} 1 bits of @var{addr} will be considered.",
1821 tree, (void), NULL)
1822
1823/* Returns a built-in function that realizes the vectorized version of
1824 a target-independent function, or NULL_TREE if not available. */
1825DEFHOOK
1826(builtin_vectorized_function,
1827 "This hook should return the decl of a function that implements the\n\
1828vectorized variant of the function with the @code{combined_fn} code\n\
1829@var{code} or @code{NULL_TREE} if such a function is not available.\n\
1830The return type of the vectorized function shall be of vector type\n\
1831@var{vec_type_out} and the argument types should be @var{vec_type_in}.",
1832 tree, (unsigned code, tree vec_type_out, tree vec_type_in),
1833 default_builtin_vectorized_function)
1834
1835/* Returns a built-in function that realizes the vectorized version of
1836 a target-specific function, or NULL_TREE if not available. */
1837DEFHOOK
1838(builtin_md_vectorized_function,
1839 "This hook should return the decl of a function that implements the\n\
1840vectorized variant of target built-in function @code{fndecl}. The\n\
1841return type of the vectorized function shall be of vector type\n\
1842@var{vec_type_out} and the argument types should be @var{vec_type_in}.",
1843 tree, (tree fndecl, tree vec_type_out, tree vec_type_in),
1844 default_builtin_md_vectorized_function)
1845
1846/* Cost of different vector/scalar statements in vectorization cost
1847 model. In case of misaligned vector loads and stores the cost depends
1848 on the data type and misalignment value. */
1849DEFHOOK
1850(builtin_vectorization_cost,
1851 "Returns cost of different scalar or vector statements for vectorization cost model.\n\
1852For vector memory operations the cost may depend on type (@var{vectype}) and\n\
1853misalignment value (@var{misalign}).",
1854 int, (enum vect_cost_for_stmt type_of_cost, tree vectype, int misalign),
1855 default_builtin_vectorization_cost)
1856
1857DEFHOOK
1858(preferred_vector_alignment,
1859 "This hook returns the preferred alignment in bits for accesses to\n\
1860vectors of type @var{type} in vectorized code. This might be less than\n\
1861or greater than the ABI-defined value returned by\n\
1862@code{TARGET_VECTOR_ALIGNMENT}. It can be equal to the alignment of\n\
1863a single element, in which case the vectorizer will not try to optimize\n\
1864for alignment.\n\
1865\n\
1866The default hook returns @code{TYPE_ALIGN (@var{type})}, which is\n\
1867correct for most targets.",
1868 poly_uint64, (const_tree type),
1869 default_preferred_vector_alignment)
1870
1871/* Returns whether the target has a preference for decomposing divisions using
1872 shifts rather than multiplies. */
1873DEFHOOK
1874(preferred_div_as_shifts_over_mult,
1875 "Sometimes it is possible to implement a vector division using a sequence\n\
1876of two addition-shift pairs, giving four instructions in total.\n\
1877Return true if taking this approach for @var{vectype} is likely\n\
1878to be better than using a sequence involving highpart multiplication.\n\
1879Default is false if @code{can_mult_highpart_p}, otherwise true.",
1880 bool, (const_tree type),
1881 default_preferred_div_as_shifts_over_mult)
1882
1883/* Return true if vector alignment is reachable (by peeling N
1884 iterations) for the given scalar type. */
1885DEFHOOK
1886(vector_alignment_reachable,
1887 "Return true if vector alignment is reachable (by peeling N iterations)\n\
1888for the given scalar type @var{type}. @var{is_packed} is false if the scalar\n\
1889access using @var{type} is known to be naturally aligned.",
1890 bool, (const_tree type, bool is_packed),
1891 default_builtin_vector_alignment_reachable)
1892
1893DEFHOOK
1894(vec_perm_const,
1895 "This hook is used to test whether the target can permute up to two\n\
1896vectors of mode @var{op_mode} using the permutation vector @code{sel},\n\
1897producing a vector of mode @var{mode}. The hook is also used to emit such\n\
1898a permutation.\n\
1899\n\
1900When the hook is being used to test whether the target supports a permutation,\n\
1901@var{in0}, @var{in1}, and @var{out} are all null. When the hook is being used\n\
1902to emit a permutation, @var{in0} and @var{in1} are the source vectors of mode\n\
1903@var{op_mode} and @var{out} is the destination vector of mode @var{mode}.\n\
1904@var{in1} is the same as @var{in0} if @var{sel} describes a permutation on one\n\
1905vector instead of two.\n\
1906\n\
1907Return true if the operation is possible, emitting instructions for it\n\
1908if rtxes are provided.\n\
1909\n\
1910@cindex @code{vec_perm@var{m}} instruction pattern\n\
1911If the hook returns false for a mode with multibyte elements, GCC will\n\
1912try the equivalent byte operation. If that also fails, it will try forcing\n\
1913the selector into a register and using the @var{vec_perm@var{mode}}\n\
1914instruction pattern. There is no need for the hook to handle these two\n\
1915implementation approaches itself.",
1916 bool, (machine_mode mode, machine_mode op_mode, rtx output, rtx in0, rtx in1,
1917 const vec_perm_indices &sel),
1918 NULL)
1919
1920/* Return true if the target supports misaligned store/load of a
1921 specific factor denoted in the third parameter. The last parameter
1922 is true if the access is defined in a packed struct. */
1923DEFHOOK
1924(support_vector_misalignment,
1925 "This hook should return true if the target supports misaligned vector\n\
1926store/load of a specific factor denoted in the @var{misalignment}\n\
1927parameter. The vector store/load should be of machine mode @var{mode} and\n\
1928the elements in the vectors should be of type @var{type}. @var{is_packed}\n\
1929parameter is true if the memory access is defined in a packed struct.",
1930 bool,
1931 (machine_mode mode, const_tree type, int misalignment, bool is_packed),
1932 default_builtin_support_vector_misalignment)
1933
1934/* Returns the preferred mode for SIMD operations for the specified
1935 scalar mode. */
1936DEFHOOK
1937(preferred_simd_mode,
1938 "This hook should return the preferred mode for vectorizing scalar\n\
1939mode @var{mode}. The default is\n\
1940equal to @code{word_mode}, because the vectorizer can do some\n\
1941transformations even in absence of specialized @acronym{SIMD} hardware.",
1942 machine_mode,
1943 (scalar_mode mode),
1944 default_preferred_simd_mode)
1945
1946/* Returns the preferred mode for splitting SIMD reductions to. */
1947DEFHOOK
1948(split_reduction,
1949 "This hook should return the preferred mode to split the final reduction\n\
1950step on @var{mode} to. The reduction is then carried out reducing upper\n\
1951against lower halves of vectors recursively until the specified mode is\n\
1952reached. The default is @var{mode} which means no splitting.",
1953 machine_mode,
1954 (machine_mode),
1955 default_split_reduction)
1956
1957/* Returns a mask of vector sizes to iterate over when auto-vectorizing
1958 after processing the preferred one derived from preferred_simd_mode. */
1959DEFHOOK
1960(autovectorize_vector_modes,
1961 "If using the mode returned by @code{TARGET_VECTORIZE_PREFERRED_SIMD_MODE}\n\
1962is not the only approach worth considering, this hook should add one mode to\n\
1963@var{modes} for each useful alternative approach. These modes are then\n\
1964passed to @code{TARGET_VECTORIZE_RELATED_MODE} to obtain the vector mode\n\
1965for a given element mode.\n\
1966\n\
1967The modes returned in @var{modes} should use the smallest element mode\n\
1968possible for the vectorization approach that they represent, preferring\n\
1969integer modes over floating-poing modes in the event of a tie. The first\n\
1970mode should be the @code{TARGET_VECTORIZE_PREFERRED_SIMD_MODE} for its\n\
1971element mode.\n\
1972\n\
1973If @var{all} is true, add suitable vector modes even when they are generally\n\
1974not expected to be worthwhile.\n\
1975\n\
1976The hook returns a bitmask of flags that control how the modes in\n\
1977@var{modes} are used. The flags are:\n\
1978@table @code\n\
1979@item VECT_COMPARE_COSTS\n\
1980Tells the loop vectorizer to try all the provided modes and pick the one\n\
1981with the lowest cost. By default the vectorizer will choose the first\n\
1982mode that works.\n\
1983@end table\n\
1984\n\
1985The hook does not need to do anything if the vector returned by\n\
1986@code{TARGET_VECTORIZE_PREFERRED_SIMD_MODE} is the only one relevant\n\
1987for autovectorization. The default implementation adds no modes and\n\
1988returns 0.",
1989 unsigned int,
1990 (vector_modes *modes, bool all),
1991 default_autovectorize_vector_modes)
1992
1993DEFHOOK
1994(related_mode,
1995 "If a piece of code is using vector mode @var{vector_mode} and also wants\n\
1996to operate on elements of mode @var{element_mode}, return the vector mode\n\
1997it should use for those elements. If @var{nunits} is nonzero, ensure that\n\
1998the mode has exactly @var{nunits} elements, otherwise pick whichever vector\n\
1999size pairs the most naturally with @var{vector_mode}. Return an empty\n\
2000@code{opt_machine_mode} if there is no supported vector mode with the\n\
2001required properties.\n\
2002\n\
2003There is no prescribed way of handling the case in which @var{nunits}\n\
2004is zero. One common choice is to pick a vector mode with the same size\n\
2005as @var{vector_mode}; this is the natural choice if the target has a\n\
2006fixed vector size. Another option is to choose a vector mode with the\n\
2007same number of elements as @var{vector_mode}; this is the natural choice\n\
2008if the target has a fixed number of elements. Alternatively, the hook\n\
2009might choose a middle ground, such as trying to keep the number of\n\
2010elements as similar as possible while applying maximum and minimum\n\
2011vector sizes.\n\
2012\n\
2013The default implementation uses @code{mode_for_vector} to find the\n\
2014requested mode, returning a mode with the same size as @var{vector_mode}\n\
2015when @var{nunits} is zero. This is the correct behavior for most targets.",
2016 opt_machine_mode,
2017 (machine_mode vector_mode, scalar_mode element_mode, poly_uint64 nunits),
2018 default_vectorize_related_mode)
2019
2020/* Function to get a target mode for a vector mask. */
2021DEFHOOK
2022(get_mask_mode,
2023 "Return the mode to use for a vector mask that holds one boolean\n\
2024result for each element of vector mode @var{mode}. The returned mask mode\n\
2025can be a vector of integers (class @code{MODE_VECTOR_INT}), a vector of\n\
2026booleans (class @code{MODE_VECTOR_BOOL}) or a scalar integer (class\n\
2027@code{MODE_INT}). Return an empty @code{opt_machine_mode} if no such\n\
2028mask mode exists.\n\
2029\n\
2030The default implementation returns a @code{MODE_VECTOR_INT} with the\n\
2031same size and number of elements as @var{mode}, if such a mode exists.",
2032 opt_machine_mode,
2033 (machine_mode mode),
2034 default_get_mask_mode)
2035
2036/* Function to say whether a masked operation is expensive when the
2037 mask is all zeros. */
2038DEFHOOK
2039(empty_mask_is_expensive,
2040 "This hook returns true if masked internal function @var{ifn} (really of\n\
2041type @code{internal_fn}) should be considered expensive when the mask is\n\
2042all zeros. GCC can then try to branch around the instruction instead.",
2043 bool,
2044 (unsigned ifn),
2045 default_empty_mask_is_expensive)
2046
2047/* Target builtin that implements vector gather operation. */
2048DEFHOOK
2049(builtin_gather,
2050 "Target builtin that implements vector gather operation. @var{mem_vectype}\n\
2051is the vector type of the load and @var{index_type} is scalar type of\n\
2052the index, scaled by @var{scale}.\n\
2053The default is @code{NULL_TREE} which means to not vectorize gather\n\
2054loads.",
2055 tree,
2056 (const_tree mem_vectype, const_tree index_type, int scale),
2057 NULL)
2058
2059/* Target builtin that implements vector scatter operation. */
2060DEFHOOK
2061(builtin_scatter,
2062"Target builtin that implements vector scatter operation. @var{vectype}\n\
2063is the vector type of the store and @var{index_type} is scalar type of\n\
2064the index, scaled by @var{scale}.\n\
2065The default is @code{NULL_TREE} which means to not vectorize scatter\n\
2066stores.",
2067 tree,
2068 (const_tree vectype, const_tree index_type, int scale),
2069 NULL)
2070
2071/* Target function to initialize the cost model for a loop or block. */
2072DEFHOOK
2073(create_costs,
2074 "This hook should initialize target-specific data structures in preparation\n\
2075for modeling the costs of vectorizing a loop or basic block. The default\n\
2076allocates three unsigned integers for accumulating costs for the prologue,\n\
2077body, and epilogue of the loop or basic block. If @var{loop_info} is\n\
2078non-NULL, it identifies the loop being vectorized; otherwise a single block\n\
2079is being vectorized. If @var{costing_for_scalar} is true, it indicates the\n\
2080current cost model is for the scalar version of a loop or block; otherwise\n\
2081it is for the vector version.",
2082 class vector_costs *,
2083 (vec_info *vinfo, bool costing_for_scalar),
2084 default_vectorize_create_costs)
2085
2086HOOK_VECTOR_END (vectorize)
2087
2088#undef HOOK_PREFIX
2089#define HOOK_PREFIX "TARGET_"
2090
2091DEFHOOK
2092(preferred_else_value,
2093 "This hook returns the target's preferred final argument for a call\n\
2094to conditional internal function @var{ifn} (really of type\n\
2095@code{internal_fn}). @var{type} specifies the return type of the\n\
2096function and @var{ops} are the operands to the conditional operation,\n\
2097of which there are @var{nops}.\n\
2098\n\
2099For example, if @var{ifn} is @code{IFN_COND_ADD}, the hook returns\n\
2100a value of type @var{type} that should be used when @samp{@var{ops}[0]}\n\
2101and @samp{@var{ops}[1]} are conditionally added together.\n\
2102\n\
2103This hook is only relevant if the target supports conditional patterns\n\
2104like @code{cond_add@var{m}}. The default implementation returns a zero\n\
2105constant of type @var{type}.",
2106 tree,
2107 (unsigned ifn, tree type, unsigned nops, tree *ops),
2108 default_preferred_else_value)
2109
2110DEFHOOK
2111(record_offload_symbol,
2112 "Used when offloaded functions are seen in the compilation unit and no named\n\
2113sections are available. It is called once for each symbol that must be\n\
2114recorded in the offload function and variable table.",
2115 void, (tree),
2116 hook_void_tree)
2117
2118DEFHOOKPOD
2119(absolute_biggest_alignment,
2120 "If defined, this target hook specifies the absolute biggest alignment\n\
2121that a type or variable can have on this machine, otherwise,\n\
2122@code{BIGGEST_ALIGNMENT} is used.",
2123 HOST_WIDE_INT, BIGGEST_ALIGNMENT)
2124
2125/* Allow target specific overriding of option settings after options have
2126 been changed by an attribute or pragma or when it is reset at the
2127 end of the code affected by an attribute or pragma. */
2128DEFHOOK
2129(override_options_after_change,
2130 "This target function is similar to the hook @code{TARGET_OPTION_OVERRIDE}\n\
2131but is called when the optimize level is changed via an attribute or\n\
2132pragma or when it is reset at the end of the code affected by the\n\
2133attribute or pragma. It is not called at the beginning of compilation\n\
2134when @code{TARGET_OPTION_OVERRIDE} is called so if you want to perform these\n\
2135actions then, you should have @code{TARGET_OPTION_OVERRIDE} call\n\
2136@code{TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE}.",
2137 void, (void),
2138 hook_void_void)
2139
2140DEFHOOK
2141(offload_options,
2142 "Used when writing out the list of options into an LTO file. It should\n\
2143translate any relevant target-specific options (such as the ABI in use)\n\
2144into one of the @option{-foffload} options that exist as a common interface\n\
2145to express such options. It should return a string containing these options,\n\
2146separated by spaces, which the caller will free.\n",
2147char *, (void), hook_charptr_void_null)
2148
2149DEFHOOK_UNDOC
2150(eh_return_filter_mode,
2151 "Return machine mode for filter value.",
2152 scalar_int_mode, (void),
2153 default_eh_return_filter_mode)
2154
2155/* Return machine mode for libgcc expanded cmp instructions. */
2156DEFHOOK
2157(libgcc_cmp_return_mode,
2158 "This target hook should return the mode to be used for the return value\n\
2159of compare instructions expanded to libgcc calls. If not defined\n\
2160@code{word_mode} is returned which is the right choice for a majority of\n\
2161targets.",
2162 scalar_int_mode, (void),
2163 default_libgcc_cmp_return_mode)
2164
2165/* Return machine mode for libgcc expanded shift instructions. */
2166DEFHOOK
2167(libgcc_shift_count_mode,
2168 "This target hook should return the mode to be used for the shift count operand\n\
2169of shift instructions expanded to libgcc calls. If not defined\n\
2170@code{word_mode} is returned which is the right choice for a majority of\n\
2171targets.",
2172 scalar_int_mode, (void),
2173 default_libgcc_shift_count_mode)
2174
2175/* Return machine mode to be used for _Unwind_Word type. */
2176DEFHOOK
2177(unwind_word_mode,
2178 "Return machine mode to be used for @code{_Unwind_Word} type.\n\
2179The default is to use @code{word_mode}.",
2180 scalar_int_mode, (void),
2181 default_unwind_word_mode)
2182
2183/* Given two decls, merge their attributes and return the result. */
2184DEFHOOK
2185(merge_decl_attributes,
2186 "Define this target hook if the merging of decl attributes needs special\n\
2187handling. If defined, the result is a list of the combined\n\
2188@code{DECL_ATTRIBUTES} of @var{olddecl} and @var{newdecl}.\n\
2189@var{newdecl} is a duplicate declaration of @var{olddecl}. Examples of\n\
2190when this is needed are when one attribute overrides another, or when an\n\
2191attribute is nullified by a subsequent definition. This function may\n\
2192call @code{merge_attributes} to handle machine-independent merging.\n\
2193\n\
2194@findex TARGET_DLLIMPORT_DECL_ATTRIBUTES\n\
2195If the only target-specific handling you require is @samp{dllimport}\n\
2196for Microsoft Windows targets, you should define the macro\n\
2197@code{TARGET_DLLIMPORT_DECL_ATTRIBUTES} to @code{1}. The compiler\n\
2198will then define a function called\n\
2199@code{merge_dllimport_decl_attributes} which can then be defined as\n\
2200the expansion of @code{TARGET_MERGE_DECL_ATTRIBUTES}. You can also\n\
2201add @code{handle_dll_attribute} in the attribute table for your port\n\
2202to perform initial processing of the @samp{dllimport} and\n\
2203@samp{dllexport} attributes. This is done in @file{i386/cygwin.h} and\n\
2204@file{i386/i386.cc}, for example.",
2205 tree, (tree olddecl, tree newdecl),
2206 merge_decl_attributes)
2207
2208/* Given two types, merge their attributes and return the result. */
2209DEFHOOK
2210(merge_type_attributes,
2211 "Define this target hook if the merging of type attributes needs special\n\
2212handling. If defined, the result is a list of the combined\n\
2213@code{TYPE_ATTRIBUTES} of @var{type1} and @var{type2}. It is assumed\n\
2214that @code{comptypes} has already been called and returned 1. This\n\
2215function may call @code{merge_attributes} to handle machine-independent\n\
2216merging.",
2217 tree, (tree type1, tree type2),
2218 merge_type_attributes)
2219
2220/* Table of machine attributes and functions to handle them.
2221 Ignored if NULL. */
2222DEFHOOKPOD
2223(attribute_table,
2224 "If defined, this target hook points to an array of @samp{struct\n\
2225attribute_spec} (defined in @file{tree-core.h}) specifying the machine\n\
2226specific attributes for this target and some of the restrictions on the\n\
2227entities to which these attributes are applied and the arguments they\n\
2228take.",
2229 const struct attribute_spec *, NULL)
2230
2231/* Return true iff attribute NAME expects a plain identifier as its first
2232 argument. */
2233DEFHOOK
2234(attribute_takes_identifier_p,
2235 "If defined, this target hook is a function which returns true if the\n\
2236machine-specific attribute named @var{name} expects an identifier\n\
2237given as its first argument to be passed on as a plain identifier, not\n\
2238subjected to name lookup. If this is not defined, the default is\n\
2239false for all machine-specific attributes.",
2240 bool, (const_tree name),
2241 hook_bool_const_tree_false)
2242
2243/* Return zero if the attributes on TYPE1 and TYPE2 are incompatible,
2244 one if they are compatible and two if they are nearly compatible
2245 (which causes a warning to be generated). */
2246DEFHOOK
2247(comp_type_attributes,
2248 "If defined, this target hook is a function which returns zero if the attributes on\n\
2249@var{type1} and @var{type2} are incompatible, one if they are compatible,\n\
2250and two if they are nearly compatible (which causes a warning to be\n\
2251generated). If this is not defined, machine-specific attributes are\n\
2252supposed always to be compatible.",
2253 int, (const_tree type1, const_tree type2),
2254 hook_int_const_tree_const_tree_1)
2255
2256/* Assign default attributes to the newly defined TYPE. */
2257DEFHOOK
2258(set_default_type_attributes,
2259 "If defined, this target hook is a function which assigns default attributes to\n\
2260the newly defined @var{type}.",
2261 void, (tree type),
2262 hook_void_tree)
2263
2264/* Insert attributes on the newly created DECL. */
2265DEFHOOK
2266(insert_attributes,
2267 "Define this target hook if you want to be able to add attributes to a decl\n\
2268when it is being created. This is normally useful for back ends which\n\
2269wish to implement a pragma by using the attributes which correspond to\n\
2270the pragma's effect. The @var{node} argument is the decl which is being\n\
2271created. The @var{attr_ptr} argument is a pointer to the attribute list\n\
2272for this decl. The list itself should not be modified, since it may be\n\
2273shared with other decls, but attributes may be chained on the head of\n\
2274the list and @code{*@var{attr_ptr}} modified to point to the new\n\
2275attributes, or a copy of the list may be made if further changes are\n\
2276needed.",
2277 void, (tree node, tree *attr_ptr),
2278 hook_void_tree_treeptr)
2279
2280/* Perform additional target-specific processing of generic attributes. */
2281DEFHOOK
2282(handle_generic_attribute,
2283 "Define this target hook if you want to be able to perform additional\n\
2284target-specific processing of an attribute which is handled generically\n\
2285by a front end. The arguments are the same as those which are passed to\n\
2286attribute handlers. So far this only affects the @var{noinit} and\n\
2287@var{section} attribute.",
2288 tree, (tree *node, tree name, tree args, int flags, bool *no_add_attrs),
2289 hook_tree_treeptr_tree_tree_int_boolptr_null)
2290
2291/* Return true if FNDECL (which has at least one machine attribute)
2292 can be inlined despite its machine attributes, false otherwise. */
2293DEFHOOK
2294(function_attribute_inlinable_p,
2295 "@cindex inlining\n\
2296This target hook returns @code{true} if it is OK to inline @var{fndecl}\n\
2297into the current function, despite its having target-specific\n\
2298attributes, @code{false} otherwise. By default, if a function has a\n\
2299target specific attribute attached to it, it will not be inlined.",
2300 bool, (const_tree fndecl),
2301 hook_bool_const_tree_false)
2302
2303/* Return true if bitfields in RECORD_TYPE should follow the
2304 Microsoft Visual C++ bitfield layout rules. */
2305DEFHOOK
2306(ms_bitfield_layout_p,
2307 "This target hook returns @code{true} if bit-fields in the given\n\
2308@var{record_type} are to be laid out following the rules of Microsoft\n\
2309Visual C/C++, namely: (i) a bit-field won't share the same storage\n\
2310unit with the previous bit-field if their underlying types have\n\
2311different sizes, and the bit-field will be aligned to the highest\n\
2312alignment of the underlying types of itself and of the previous\n\
2313bit-field; (ii) a zero-sized bit-field will affect the alignment of\n\
2314the whole enclosing structure, even if it is unnamed; except that\n\
2315(iii) a zero-sized bit-field will be disregarded unless it follows\n\
2316another bit-field of nonzero size. If this hook returns @code{true},\n\
2317other macros that control bit-field layout are ignored.\n\
2318\n\
2319When a bit-field is inserted into a packed record, the whole size\n\
2320of the underlying type is used by one or more same-size adjacent\n\
2321bit-fields (that is, if its long:3, 32 bits is used in the record,\n\
2322and any additional adjacent long bit-fields are packed into the same\n\
2323chunk of 32 bits. However, if the size changes, a new field of that\n\
2324size is allocated). In an unpacked record, this is the same as using\n\
2325alignment, but not equivalent when packing.\n\
2326\n\
2327If both MS bit-fields and @samp{__attribute__((packed))} are used,\n\
2328the latter will take precedence. If @samp{__attribute__((packed))} is\n\
2329used on a single field when MS bit-fields are in use, it will take\n\
2330precedence for that field, but the alignment of the rest of the structure\n\
2331may affect its placement.",
2332 bool, (const_tree record_type),
2333 hook_bool_const_tree_false)
2334
2335/* For now this is only an interface to WORDS_BIG_ENDIAN for
2336 target-independent code like the front ends, need performance testing
2337 before switching completely to the target hook. */
2338DEFHOOK_UNDOC
2339(words_big_endian,
2340 "",
2341 bool, (void),
2342 targhook_words_big_endian)
2343
2344/* Likewise for FLOAT_WORDS_BIG_ENDIAN. */
2345DEFHOOK_UNDOC
2346(float_words_big_endian,
2347 "",
2348 bool, (void),
2349 targhook_float_words_big_endian)
2350
2351DEFHOOK
2352(float_exceptions_rounding_supported_p,
2353 "Returns true if the target supports IEEE 754 floating-point exceptions\n\
2354and rounding modes, false otherwise. This is intended to relate to the\n\
2355@code{float} and @code{double} types, but not necessarily @code{long double}.\n\
2356By default, returns true if the @code{adddf3} instruction pattern is\n\
2357available and false otherwise, on the assumption that hardware floating\n\
2358point supports exceptions and rounding modes but software floating point\n\
2359does not.",
2360 bool, (void),
2361 default_float_exceptions_rounding_supported_p)
2362
2363/* True if the target supports decimal floating point. */
2364DEFHOOK
2365(decimal_float_supported_p,
2366 "Returns true if the target supports decimal floating point.",
2367 bool, (void),
2368 default_decimal_float_supported_p)
2369
2370/* True if the target supports fixed-point. */
2371DEFHOOK
2372(fixed_point_supported_p,
2373 "Returns true if the target supports fixed-point arithmetic.",
2374 bool, (void),
2375 default_fixed_point_supported_p)
2376
2377/* Return true if anonymous bitfields affect structure alignment. */
2378DEFHOOK
2379(align_anon_bitfield,
2380 "When @code{PCC_BITFIELD_TYPE_MATTERS} is true this hook will determine\n\
2381whether unnamed bitfields affect the alignment of the containing\n\
2382structure. The hook should return true if the structure should inherit\n\
2383the alignment requirements of an unnamed bitfield's type.",
2384 bool, (void),
2385 hook_bool_void_false)
2386
2387/* Return true if volatile bitfields should use the narrowest type possible.
2388 Return false if they should use the container type. */
2389DEFHOOK
2390(narrow_volatile_bitfield,
2391 "This target hook should return @code{true} if accesses to volatile bitfields\n\
2392should use the narrowest mode possible. It should return @code{false} if\n\
2393these accesses should use the bitfield container type.\n\
2394\n\
2395The default is @code{false}.",
2396 bool, (void),
2397 hook_bool_void_false)
2398
2399/* Set up target-specific built-in functions. */
2400DEFHOOK
2401(init_builtins,
2402 "Define this hook if you have any machine-specific built-in functions\n\
2403that need to be defined. It should be a function that performs the\n\
2404necessary setup.\n\
2405\n\
2406Machine specific built-in functions can be useful to expand special machine\n\
2407instructions that would otherwise not normally be generated because\n\
2408they have no equivalent in the source language (for example, SIMD vector\n\
2409instructions or prefetch instructions).\n\
2410\n\
2411To create a built-in function, call the function\n\
2412@code{lang_hooks.builtin_function}\n\
2413which is defined by the language front end. You can use any type nodes set\n\
2414up by @code{build_common_tree_nodes};\n\
2415only language front ends that use those two functions will call\n\
2416@samp{TARGET_INIT_BUILTINS}.",
2417 void, (void),
2418 hook_void_void)
2419
2420/* Initialize (if INITIALIZE_P is true) and return the target-specific
2421 built-in function decl for CODE.
2422 Return NULL if that is not possible. Return error_mark_node if CODE
2423 is outside of the range of valid target builtin function codes. */
2424DEFHOOK
2425(builtin_decl,
2426 "Define this hook if you have any machine-specific built-in functions\n\
2427that need to be defined. It should be a function that returns the\n\
2428builtin function declaration for the builtin function code @var{code}.\n\
2429If there is no such builtin and it cannot be initialized at this time\n\
2430if @var{initialize_p} is true the function should return @code{NULL_TREE}.\n\
2431If @var{code} is out of range the function should return\n\
2432@code{error_mark_node}.",
2433 tree, (unsigned code, bool initialize_p), NULL)
2434
2435/* Expand a target-specific builtin. */
2436DEFHOOK
2437(expand_builtin,
2438 "\n\
2439Expand a call to a machine specific built-in function that was set up by\n\
2440@samp{TARGET_INIT_BUILTINS}. @var{exp} is the expression for the\n\
2441function call; the result should go to @var{target} if that is\n\
2442convenient, and have mode @var{mode} if that is convenient.\n\
2443@var{subtarget} may be used as the target for computing one of\n\
2444@var{exp}'s operands. @var{ignore} is nonzero if the value is to be\n\
2445ignored. This function should return the result of the call to the\n\
2446built-in function.",
2447 rtx,
2448 (tree exp, rtx target, rtx subtarget, machine_mode mode, int ignore),
2449 default_expand_builtin)
2450
2451/* Select a replacement for a target-specific builtin. This is done
2452 *before* regular type checking, and so allows the target to
2453 implement a crude form of function overloading. The result is a
2454 complete expression that implements the operation. PARAMS really
2455 has type VEC(tree,gc)*, but we don't want to include tree.h here. */
2456DEFHOOK
2457(resolve_overloaded_builtin,
2458 "Select a replacement for a machine specific built-in function that\n\
2459was set up by @samp{TARGET_INIT_BUILTINS}. This is done\n\
2460@emph{before} regular type checking, and so allows the target to\n\
2461implement a crude form of function overloading. @var{fndecl} is the\n\
2462declaration of the built-in function. @var{arglist} is the list of\n\
2463arguments passed to the built-in function. The result is a\n\
2464complete expression that implements the operation, usually\n\
2465another @code{CALL_EXPR}.\n\
2466@var{arglist} really has type @samp{VEC(tree,gc)*}",
2467 tree, (unsigned int /*location_t*/ loc, tree fndecl, void *arglist), NULL)
2468
2469DEFHOOK
2470(check_builtin_call,
2471 "Perform semantic checking on a call to a machine-specific built-in\n\
2472function after its arguments have been constrained to the function\n\
2473signature. Return true if the call is valid, otherwise report an error\n\
2474and return false.\n\
2475\n\
2476This hook is called after @code{TARGET_RESOLVE_OVERLOADED_BUILTIN}.\n\
2477The call was originally to built-in function @var{orig_fndecl},\n\
2478but after the optional @code{TARGET_RESOLVE_OVERLOADED_BUILTIN}\n\
2479step is now to built-in function @var{fndecl}. @var{loc} is the\n\
2480location of the call and @var{args} is an array of function arguments,\n\
2481of which there are @var{nargs}. @var{arg_loc} specifies the location\n\
2482of each argument.",
2483 bool, (location_t loc, vec<location_t> arg_loc, tree fndecl,
2484 tree orig_fndecl, unsigned int nargs, tree *args),
2485 NULL)
2486
2487/* Fold a target-specific builtin to a tree valid for both GIMPLE
2488 and GENERIC. */
2489DEFHOOK
2490(fold_builtin,
2491 "Fold a call to a machine specific built-in function that was set up by\n\
2492@samp{TARGET_INIT_BUILTINS}. @var{fndecl} is the declaration of the\n\
2493built-in function. @var{n_args} is the number of arguments passed to\n\
2494the function; the arguments themselves are pointed to by @var{argp}.\n\
2495The result is another tree, valid for both GIMPLE and GENERIC,\n\
2496containing a simplified expression for the call's result. If\n\
2497@var{ignore} is true the value will be ignored.",
2498 tree, (tree fndecl, int n_args, tree *argp, bool ignore),
2499 hook_tree_tree_int_treep_bool_null)
2500
2501/* Fold a target-specific builtin to a valid GIMPLE tree. */
2502DEFHOOK
2503(gimple_fold_builtin,
2504 "Fold a call to a machine specific built-in function that was set up\n\
2505by @samp{TARGET_INIT_BUILTINS}. @var{gsi} points to the gimple\n\
2506statement holding the function call. Returns true if any change\n\
2507was made to the GIMPLE stream.",
2508 bool, (gimple_stmt_iterator *gsi),
2509 hook_bool_gsiptr_false)
2510
2511/* Target hook is used to compare the target attributes in two functions to
2512 determine which function's features get higher priority. This is used
2513 during function multi-versioning to figure out the order in which two
2514 versions must be dispatched. A function version with a higher priority
2515 is checked for dispatching earlier. DECL1 and DECL2 are
2516 the two function decls that will be compared. It returns positive value
2517 if DECL1 is higher priority, negative value if DECL2 is higher priority
2518 and 0 if they are the same. */
2519DEFHOOK
2520(compare_version_priority,
2521 "This hook is used to compare the target attributes in two functions to\n\
2522determine which function's features get higher priority. This is used\n\
2523during function multi-versioning to figure out the order in which two\n\
2524versions must be dispatched. A function version with a higher priority\n\
2525is checked for dispatching earlier. @var{decl1} and @var{decl2} are\n\
2526 the two function decls that will be compared.",
2527 int, (tree decl1, tree decl2), NULL)
2528
2529/* Target hook is used to generate the dispatcher logic to invoke the right
2530 function version at run-time for a given set of function versions.
2531 ARG points to the callgraph node of the dispatcher function whose body
2532 must be generated. */
2533DEFHOOK
2534(generate_version_dispatcher_body,
2535 "This hook is used to generate the dispatcher logic to invoke the right\n\
2536function version at run-time for a given set of function versions.\n\
2537@var{arg} points to the callgraph node of the dispatcher function whose\n\
2538body must be generated.",
2539 tree, (void *arg), NULL)
2540
2541/* Target hook is used to get the dispatcher function for a set of function
2542 versions. The dispatcher function is called to invoke the right function
2543 version at run-time. DECL is one version from a set of semantically
2544 identical versions. */
2545DEFHOOK
2546(get_function_versions_dispatcher,
2547 "This hook is used to get the dispatcher function for a set of function\n\
2548versions. The dispatcher function is called to invoke the right function\n\
2549version at run-time. @var{decl} is one version from a set of semantically\n\
2550identical versions.",
2551 tree, (void *decl), NULL)
2552
2553/* Returns a code for a target-specific builtin that implements
2554 reciprocal of a target-specific function, or NULL_TREE if not available. */
2555DEFHOOK
2556(builtin_reciprocal,
2557 "This hook should return the DECL of a function that implements the\n\
2558reciprocal of the machine-specific builtin function @var{fndecl}, or\n\
2559@code{NULL_TREE} if such a function is not available.",
2560 tree, (tree fndecl),
2561 default_builtin_reciprocal)
2562
2563/* For a vendor-specific TYPE, return a pointer to a statically-allocated
2564 string containing the C++ mangling for TYPE. In all other cases, return
2565 NULL. */
2566DEFHOOK
2567(mangle_type,
2568 "If your target defines any fundamental types, or any types your target\n\
2569uses should be mangled differently from the default, define this hook\n\
2570to return the appropriate encoding for these types as part of a C++\n\
2571mangled name. The @var{type} argument is the tree structure representing\n\
2572the type to be mangled. The hook may be applied to trees which are\n\
2573not target-specific fundamental types; it should return @code{NULL}\n\
2574for all such types, as well as arguments it does not recognize. If the\n\
2575return value is not @code{NULL}, it must point to a statically-allocated\n\
2576string constant.\n\
2577\n\
2578Target-specific fundamental types might be new fundamental types or\n\
2579qualified versions of ordinary fundamental types. Encode new\n\
2580fundamental types as @samp{@w{u @var{n} @var{name}}}, where @var{name}\n\
2581is the name used for the type in source code, and @var{n} is the\n\
2582length of @var{name} in decimal. Encode qualified versions of\n\
2583ordinary types as @samp{@w{U @var{n} @var{name} @var{code}}}, where\n\
2584@var{name} is the name used for the type qualifier in source code,\n\
2585@var{n} is the length of @var{name} as above, and @var{code} is the\n\
2586code used to represent the unqualified version of this type. (See\n\
2587@code{write_builtin_type} in @file{cp/mangle.cc} for the list of\n\
2588codes.) In both cases the spaces are for clarity; do not include any\n\
2589spaces in your string.\n\
2590\n\
2591This hook is applied to types prior to typedef resolution. If the mangled\n\
2592name for a particular type depends only on that type's main variant, you\n\
2593can perform typedef resolution yourself using @code{TYPE_MAIN_VARIANT}\n\
2594before mangling.\n\
2595\n\
2596The default version of this hook always returns @code{NULL}, which is\n\
2597appropriate for a target that does not define any new fundamental\n\
2598types.",
2599 const char *, (const_tree type),
2600 hook_constcharptr_const_tree_null)
2601
2602/* Temporarily add conditional target specific types for the purpose of
2603 emitting C++ fundamental type tinfos. */
2604DEFHOOK
2605(emit_support_tinfos,
2606 "If your target defines any fundamental types which depend on ISA flags,\n\
2607they might need C++ tinfo symbols in libsupc++/libstdc++ regardless of\n\
2608ISA flags the library is compiled with.\n\
2609This hook allows creating tinfo symbols even for those cases, by temporarily\n\
2610creating each corresponding fundamental type trees, calling the\n\
2611@var{callback} function on it and setting the type back to @code{nullptr}.",
2612 void, (emit_support_tinfos_callback callback),
2613 default_emit_support_tinfos)
2614
2615/* Make any adjustments to libfunc names needed for this target. */
2616DEFHOOK
2617(init_libfuncs,
2618 "This hook should declare additional library routines or rename\n\
2619existing ones, using the functions @code{set_optab_libfunc} and\n\
2620@code{init_one_libfunc} defined in @file{optabs.cc}.\n\
2621@code{init_optabs} calls this macro after initializing all the normal\n\
2622library routines.\n\
2623\n\
2624The default is to do nothing. Most ports don't need to define this hook.",
2625 void, (void),
2626 hook_void_void)
2627
2628 /* Add a __gnu_ prefix to library functions rather than just __. */
2629DEFHOOKPOD
2630(libfunc_gnu_prefix,
2631 "If false (the default), internal library routines start with two\n\
2632underscores. If set to true, these routines start with @code{__gnu_}\n\
2633instead. E.g., @code{__muldi3} changes to @code{__gnu_muldi3}. This\n\
2634currently only affects functions defined in @file{libgcc2.c}. If this\n\
2635is set to true, the @file{tm.h} file must also\n\
2636@code{#define LIBGCC2_GNU_PREFIX}.",
2637 bool, false)
2638
2639/* Given a decl, a section name, and whether the decl initializer
2640 has relocs, choose attributes for the section. */
2641/* ??? Should be merged with SELECT_SECTION and UNIQUE_SECTION. */
2642DEFHOOK
2643(section_type_flags,
2644 "Choose a set of section attributes for use by @code{TARGET_ASM_NAMED_SECTION}\n\
2645based on a variable or function decl, a section name, and whether or not the\n\
2646declaration's initializer may contain runtime relocations. @var{decl} may be\n\
2647null, in which case read-write data should be assumed.\n\
2648\n\
2649The default version of this function handles choosing code vs data,\n\
2650read-only vs read-write data, and @code{flag_pic}. You should only\n\
2651need to override this if your target has special flags that might be\n\
2652set via @code{__attribute__}.",
2653 unsigned int, (tree decl, const char *name, int reloc),
2654 default_section_type_flags)
2655
2656DEFHOOK
2657(libc_has_function,
2658 "This hook determines whether a function from a class of functions\n\
2659@var{fn_class} is present in the target C library. If @var{type} is NULL,\n\
2660the caller asks for support for all standard (float, double, long double)\n\
2661types. If @var{type} is non-NULL, the caller asks for support for a\n\
2662specific type.",
2663 bool, (enum function_class fn_class, tree type),
2664 default_libc_has_function)
2665
2666DEFHOOK
2667(libc_has_fast_function,
2668 "This hook determines whether a function from a class of functions\n\
2669@code{(enum function_class)}@var{fcode} has a fast implementation.",
2670 bool, (int fcode),
2671 default_libc_has_fast_function)
2672
2673DEFHOOK
2674(libm_function_max_error,
2675 "This hook determines expected maximum errors for math functions measured\n\
2676in ulps (units of the last place). 0 means 0.5ulps precision (correctly\n\
2677rounded). ~0U means unknown errors. The @code{combined_fn} @var{cfn}\n\
2678argument should identify just which math built-in function it is rather than\n\
2679its variant, @var{mode} the variant in terms of floating-point machine mode.\n\
2680The hook should also take into account @code{flag_rounding_math} whether it\n\
2681is maximum error just in default rounding mode, or in all possible rounding\n\
2682modes. @var{boundary_p} is @code{true} for maximum errors on intrinsic math\n\
2683boundaries of functions rather than errors inside of the usual result ranges\n\
2684of the functions. E.g.@ the sin/cos function finite result is in between\n\
2685-1.0 and 1.0 inclusive, with @var{boundary_p} true the function returns how\n\
2686many ulps below or above those boundaries result could be.",
2687 unsigned, (unsigned cfn, machine_mode mode, bool boundary_p),
2688 default_libm_function_max_error)
2689
2690/* True if new jumps cannot be created, to replace existing ones or
2691 not, at the current point in the compilation. */
2692DEFHOOK
2693(cannot_modify_jumps_p,
2694 "This target hook returns @code{true} past the point in which new jump\n\
2695instructions could be created. On machines that require a register for\n\
2696every jump such as the SHmedia ISA of SH5, this point would typically be\n\
2697reload, so this target hook should be defined to a function such as:\n\
2698\n\
2699@smallexample\n\
2700static bool\n\
2701cannot_modify_jumps_past_reload_p ()\n\
2702@{\n\
2703 return (reload_completed || reload_in_progress);\n\
2704@}\n\
2705@end smallexample",
2706 bool, (void),
2707 hook_bool_void_false)
2708
2709/* True if FOLLOWER may be modified to follow FOLLOWEE. */
2710DEFHOOK
2711(can_follow_jump,
2712 "FOLLOWER and FOLLOWEE are JUMP_INSN instructions;\n\
2713return true if FOLLOWER may be modified to follow FOLLOWEE;\n\
2714false, if it can't.\n\
2715For example, on some targets, certain kinds of branches can't be made to\n\
2716follow through a hot/cold partitioning.",
2717 bool, (const rtx_insn *follower, const rtx_insn *followee),
2718 hook_bool_const_rtx_insn_const_rtx_insn_true)
2719
2720/* Return true if the target supports conditional execution. */
2721DEFHOOK
2722(have_conditional_execution,
2723 "This target hook returns true if the target supports conditional execution.\n\
2724This target hook is required only when the target has several different\n\
2725modes and they have different conditional execution capability, such as ARM.",
2726 bool, (void),
2727 default_have_conditional_execution)
2728
2729DEFHOOK
2730(gen_ccmp_first,
2731 "This function prepares to emit a comparison insn for the first compare in a\n\
2732 sequence of conditional comparisions. It returns an appropriate comparison\n\
2733 with @code{CC} for passing to @code{gen_ccmp_next} or @code{cbranch_optab}.\n\
2734 The insns to prepare the compare are saved in @var{prep_seq} and the compare\n\
2735 insns are saved in @var{gen_seq}. They will be emitted when all the\n\
2736 compares in the conditional comparision are generated without error.\n\
2737 @var{code} is the @code{rtx_code} of the compare for @var{op0} and @var{op1}.",
2738 rtx, (rtx_insn **prep_seq, rtx_insn **gen_seq, rtx_code code, tree op0, tree op1),
2739 NULL)
2740
2741DEFHOOK
2742(gen_ccmp_next,
2743 "This function prepares to emit a conditional comparison within a sequence\n\
2744 of conditional comparisons. It returns an appropriate comparison with\n\
2745 @code{CC} for passing to @code{gen_ccmp_next} or @code{cbranch_optab}.\n\
2746 The insns to prepare the compare are saved in @var{prep_seq} and the compare\n\
2747 insns are saved in @var{gen_seq}. They will be emitted when all the\n\
2748 compares in the conditional comparision are generated without error. The\n\
2749 @var{prev} expression is the result of a prior call to @code{gen_ccmp_first}\n\
2750 or @code{gen_ccmp_next}. It may return @code{NULL} if the combination of\n\
2751 @var{prev} and this comparison is not supported, otherwise the result must\n\
2752 be appropriate for passing to @code{gen_ccmp_next} or @code{cbranch_optab}.\n\
2753 @var{code} is the @code{rtx_code} of the compare for @var{op0} and @var{op1}.\n\
2754 @var{bit_code} is @code{AND} or @code{IOR}, which is the op on the compares.",
2755 rtx, (rtx_insn **prep_seq, rtx_insn **gen_seq, rtx prev, rtx_code cmp_code, tree op0, tree op1, rtx_code bit_code),
2756 NULL)
2757
2758/* Return a new value for loop unroll size. */
2759DEFHOOK
2760(loop_unroll_adjust,
2761 "This target hook returns a new value for the number of times @var{loop}\n\
2762should be unrolled. The parameter @var{nunroll} is the number of times\n\
2763the loop is to be unrolled. The parameter @var{loop} is a pointer to\n\
2764the loop, which is going to be checked for unrolling. This target hook\n\
2765is required only when the target has special constraints like maximum\n\
2766number of memory accesses.",
2767 unsigned, (unsigned nunroll, class loop *loop),
2768 NULL)
2769
2770/* True if X is a legitimate MODE-mode immediate operand. */
2771DEFHOOK
2772(legitimate_constant_p,
2773 "This hook returns true if @var{x} is a legitimate constant for a\n\
2774@var{mode}-mode immediate operand on the target machine. You can assume that\n\
2775@var{x} satisfies @code{CONSTANT_P}, so you need not check this.\n\
2776\n\
2777The default definition returns true.",
2778 bool, (machine_mode mode, rtx x),
2779 hook_bool_mode_rtx_true)
2780
2781/* True if X is a TLS operand whose value should be pre-computed. */
2782DEFHOOK
2783(precompute_tls_p,
2784 "This hook returns true if @var{x} is a TLS operand on the target\n\
2785machine that should be pre-computed when used as the argument in a call.\n\
2786You can assume that @var{x} satisfies @code{CONSTANT_P}, so you need not \n\
2787check this.\n\
2788\n\
2789The default definition returns false.",
2790 bool, (machine_mode mode, rtx x),
2791 hook_bool_mode_rtx_false)
2792
2793/* True if the constant X cannot be placed in the constant pool. */
2794DEFHOOK
2795(cannot_force_const_mem,
2796 "This hook should return true if @var{x} is of a form that cannot (or\n\
2797should not) be spilled to the constant pool. @var{mode} is the mode\n\
2798of @var{x}.\n\
2799\n\
2800The default version of this hook returns false.\n\
2801\n\
2802The primary reason to define this hook is to prevent reload from\n\
2803deciding that a non-legitimate constant would be better reloaded\n\
2804from the constant pool instead of spilling and reloading a register\n\
2805holding the constant. This restriction is often true of addresses\n\
2806of TLS symbols for various targets.",
2807 bool, (machine_mode mode, rtx x),
2808 hook_bool_mode_rtx_false)
2809
2810DEFHOOK_UNDOC
2811(cannot_copy_insn_p,
2812 "True if the insn @var{x} cannot be duplicated.",
2813 bool, (rtx_insn *), NULL)
2814
2815/* True if X is considered to be commutative. */
2816DEFHOOK
2817(commutative_p,
2818 "This target hook returns @code{true} if @var{x} is considered to be commutative.\n\
2819Usually, this is just COMMUTATIVE_P (@var{x}), but the HP PA doesn't consider\n\
2820PLUS to be commutative inside a MEM@. @var{outer_code} is the rtx code\n\
2821of the enclosing rtl, if known, otherwise it is UNKNOWN.",
2822 bool, (const_rtx x, int outer_code),
2823 hook_bool_const_rtx_commutative_p)
2824
2825/* True if ADDR is an address-expression whose effect depends
2826 on the mode of the memory reference it is used in. */
2827DEFHOOK
2828(mode_dependent_address_p,
2829 "This hook returns @code{true} if memory address @var{addr} in address\n\
2830space @var{addrspace} can have\n\
2831different meanings depending on the machine mode of the memory\n\
2832reference it is used for or if the address is valid for some modes\n\
2833but not others.\n\
2834\n\
2835Autoincrement and autodecrement addresses typically have mode-dependent\n\
2836effects because the amount of the increment or decrement is the size\n\
2837of the operand being addressed. Some machines have other mode-dependent\n\
2838addresses. Many RISC machines have no mode-dependent addresses.\n\
2839\n\
2840You may assume that @var{addr} is a valid address for the machine.\n\
2841\n\
2842The default version of this hook returns @code{false}.",
2843 bool, (const_rtx addr, addr_space_t addrspace),
2844 default_mode_dependent_address_p)
2845
2846/* Given an invalid address X for a given machine mode, try machine-specific
2847 ways to make it legitimate. Return X or an invalid address on failure. */
2848DEFHOOK
2849(legitimize_address,
2850 "This hook is given an invalid memory address @var{x} for an\n\
2851operand of mode @var{mode} and should try to return a valid memory\n\
2852address.\n\
2853\n\
2854@findex break_out_memory_refs\n\
2855@var{x} will always be the result of a call to @code{break_out_memory_refs},\n\
2856and @var{oldx} will be the operand that was given to that function to produce\n\
2857@var{x}.\n\
2858\n\
2859The code of the hook should not alter the substructure of\n\
2860@var{x}. If it transforms @var{x} into a more legitimate form, it\n\
2861should return the new @var{x}.\n\
2862\n\
2863It is not necessary for this hook to come up with a legitimate address,\n\
2864with the exception of native TLS addresses (@pxref{Emulated TLS}).\n\
2865The compiler has standard ways of doing so in all cases. In fact, if\n\
2866the target supports only emulated TLS, it\n\
2867is safe to omit this hook or make it return @var{x} if it cannot find\n\
2868a valid way to legitimize the address. But often a machine-dependent\n\
2869strategy can generate better code.",
2870 rtx, (rtx x, rtx oldx, machine_mode mode),
2871 default_legitimize_address)
2872
2873/* Given an address RTX, undo the effects of LEGITIMIZE_ADDRESS. */
2874DEFHOOK
2875(delegitimize_address,
2876 "This hook is used to undo the possibly obfuscating effects of the\n\
2877@code{LEGITIMIZE_ADDRESS} and @code{LEGITIMIZE_RELOAD_ADDRESS} target\n\
2878macros. Some backend implementations of these macros wrap symbol\n\
2879references inside an @code{UNSPEC} rtx to represent PIC or similar\n\
2880addressing modes. This target hook allows GCC's optimizers to understand\n\
2881the semantics of these opaque @code{UNSPEC}s by converting them back\n\
2882into their original form.",
2883 rtx, (rtx x),
2884 delegitimize_mem_from_attrs)
2885
2886/* Given an RTX, return true if it is not ok to emit it into debug info
2887 section. */
2888DEFHOOK
2889(const_not_ok_for_debug_p,
2890 "This hook should return true if @var{x} should not be emitted into\n\
2891debug sections.",
2892 bool, (rtx x),
2893 default_const_not_ok_for_debug_p)
2894
2895/* Given an address RTX, say whether it is valid. */
2896DEFHOOK
2897(legitimate_address_p,
2898 "A function that returns whether @var{x} (an RTX) is a legitimate memory\n\
2899address on the target machine for a memory operand of mode @var{mode}.\n\
2900If @var{ch} is not @code{ERROR_MARK}, it can be called from middle-end to\n\
2901determine if it is valid to use @var{x} as a memory operand for RTX insn\n\
2902which is generated for the given code_helper @var{ch}. For example,\n\
2903assuming the given @var{ch} is IFN_LEN_LOAD, on some target its underlying\n\
2904hardware instructions support fewer addressing modes than what are for the\n\
2905normal vector load and store, then with this @var{ch} target can know the\n\
2906actual use context and return more exact result.\n\
2907\n\
2908Legitimate addresses are defined in two variants: a strict variant and a\n\
2909non-strict one. The @var{strict} parameter chooses which variant is\n\
2910desired by the caller.\n\
2911\n\
2912The strict variant is used in the reload pass. It must be defined so\n\
2913that any pseudo-register that has not been allocated a hard register is\n\
2914considered a memory reference. This is because in contexts where some\n\
2915kind of register is required, a pseudo-register with no hard register\n\
2916must be rejected. For non-hard registers, the strict variant should look\n\
2917up the @code{reg_renumber} array; it should then proceed using the hard\n\
2918register number in the array, or treat the pseudo as a memory reference\n\
2919if the array holds @code{-1}.\n\
2920\n\
2921The non-strict variant is used in other passes. It must be defined to\n\
2922accept all pseudo-registers in every context where some kind of\n\
2923register is required.\n\
2924\n\
2925Normally, constant addresses which are the sum of a @code{symbol_ref}\n\
2926and an integer are stored inside a @code{const} RTX to mark them as\n\
2927constant. Therefore, there is no need to recognize such sums\n\
2928specifically as legitimate addresses. Normally you would simply\n\
2929recognize any @code{const} as legitimate.\n\
2930\n\
2931Usually @code{PRINT_OPERAND_ADDRESS} is not prepared to handle constant\n\
2932sums that are not marked with @code{const}. It assumes that a naked\n\
2933@code{plus} indicates indexing. If so, then you @emph{must} reject such\n\
2934naked constant sums as illegitimate addresses, so that none of them will\n\
2935be given to @code{PRINT_OPERAND_ADDRESS}.\n\
2936\n\
2937@cindex @code{TARGET_ENCODE_SECTION_INFO} and address validation\n\
2938On some machines, whether a symbolic address is legitimate depends on\n\
2939the section that the address refers to. On these machines, define the\n\
2940target hook @code{TARGET_ENCODE_SECTION_INFO} to store the information\n\
2941into the @code{symbol_ref}, and then check for it here. When you see a\n\
2942@code{const}, you will have to look inside it to find the\n\
2943@code{symbol_ref} in order to determine the section. @xref{Assembler\n\
2944Format}.\n\
2945\n\
2946@cindex @code{GO_IF_LEGITIMATE_ADDRESS}\n\
2947Some ports are still using a deprecated legacy substitute for\n\
2948this hook, the @code{GO_IF_LEGITIMATE_ADDRESS} macro. This macro\n\
2949has this syntax:\n\
2950\n\
2951@example\n\
2952#define GO_IF_LEGITIMATE_ADDRESS (@var{mode}, @var{x}, @var{label})\n\
2953@end example\n\
2954\n\
2955@noindent\n\
2956and should @code{goto @var{label}} if the address @var{x} is a valid\n\
2957address on the target machine for a memory operand of mode @var{mode}.\n\
2958\n\
2959@findex REG_OK_STRICT\n\
2960Compiler source files that want to use the strict variant of this\n\
2961macro define the macro @code{REG_OK_STRICT}. You should use an\n\
2962@code{#ifdef REG_OK_STRICT} conditional to define the strict variant in\n\
2963that case and the non-strict variant otherwise.\n\
2964\n\
2965Using the hook is usually simpler because it limits the number of\n\
2966files that are recompiled when changes are made.",
2967 bool, (machine_mode mode, rtx x, bool strict, code_helper ch),
2968 default_legitimate_address_p)
2969
2970/* True if the given constant can be put into an object_block. */
2971DEFHOOK
2972(use_blocks_for_constant_p,
2973 "This hook should return true if pool entries for constant @var{x} can\n\
2974be placed in an @code{object_block} structure. @var{mode} is the mode\n\
2975of @var{x}.\n\
2976\n\
2977The default version returns false for all constants.",
2978 bool, (machine_mode mode, const_rtx x),
2979 hook_bool_mode_const_rtx_false)
2980
2981/* True if the given decl can be put into an object_block. */
2982DEFHOOK
2983(use_blocks_for_decl_p,
2984 "This hook should return true if pool entries for @var{decl} should\n\
2985be placed in an @code{object_block} structure.\n\
2986\n\
2987The default version returns true for all decls.",
2988 bool, (const_tree decl),
2989 hook_bool_const_tree_true)
2990
2991/* The minimum and maximum byte offsets for anchored addresses. */
2992DEFHOOKPOD
2993(min_anchor_offset,
2994 "The minimum offset that should be applied to a section anchor.\n\
2995On most targets, it should be the smallest offset that can be\n\
2996applied to a base register while still giving a legitimate address\n\
2997for every mode. The default value is 0.",
2998 HOST_WIDE_INT, 0)
2999
3000DEFHOOKPOD
3001(max_anchor_offset,
3002 "Like @code{TARGET_MIN_ANCHOR_OFFSET}, but the maximum (inclusive)\n\
3003offset that should be applied to section anchors. The default\n\
3004value is 0.",
3005 HOST_WIDE_INT, 0)
3006
3007/* True if section anchors can be used to access the given symbol. */
3008DEFHOOK
3009(use_anchors_for_symbol_p,
3010 "Return true if GCC should attempt to use anchors to access @code{SYMBOL_REF}\n\
3011@var{x}. You can assume @samp{SYMBOL_REF_HAS_BLOCK_INFO_P (@var{x})} and\n\
3012@samp{!SYMBOL_REF_ANCHOR_P (@var{x})}.\n\
3013\n\
3014The default version is correct for most targets, but you might need to\n\
3015intercept this hook to handle things like target-specific attributes\n\
3016or target-specific sections.",
3017 bool, (const_rtx x),
3018 default_use_anchors_for_symbol_p)
3019
3020/* True if target supports indirect functions. */
3021DEFHOOK
3022(has_ifunc_p,
3023 "It returns true if the target supports GNU indirect functions.\n\
3024The support includes the assembler, linker and dynamic linker.\n\
3025The default value of this hook is based on target's libc.",
3026 bool, (void),
3027 default_has_ifunc_p)
3028
3029/* True if it is OK to reference indirect function resolvers locally. */
3030DEFHOOK
3031(ifunc_ref_local_ok,
3032 "Return true if it is OK to reference indirect function resolvers\n\
3033locally. The default is to return false.",
3034 bool, (void),
3035 hook_bool_void_false)
3036
3037/* True if it is OK to do sibling call optimization for the specified
3038 call expression EXP. DECL will be the called function, or NULL if
3039 this is an indirect call. */
3040DEFHOOK
3041(function_ok_for_sibcall,
3042 "True if it is OK to do sibling call optimization for the specified\n\
3043call expression @var{exp}. @var{decl} will be the called function,\n\
3044or @code{NULL} if this is an indirect call.\n\
3045\n\
3046It is not uncommon for limitations of calling conventions to prevent\n\
3047tail calls to functions outside the current unit of translation, or\n\
3048during PIC compilation. The hook is used to enforce these restrictions,\n\
3049as the @code{sibcall} md pattern cannot fail, or fall over to a\n\
3050``normal'' call. The criteria for successful sibling call optimization\n\
3051may vary greatly between different architectures.",
3052 bool, (tree decl, tree exp),
3053 hook_bool_tree_tree_false)
3054
3055/* Establish appropriate back-end context for processing the function
3056 FNDECL. The argument might be NULL to indicate processing at top
3057 level, outside of any function scope. */
3058DEFHOOK
3059(set_current_function,
3060 "The compiler invokes this hook whenever it changes its current function\n\
3061context (@code{cfun}). You can define this function if\n\
3062the back end needs to perform any initialization or reset actions on a\n\
3063per-function basis. For example, it may be used to implement function\n\
3064attributes that affect register usage or code generation patterns.\n\
3065The argument @var{decl} is the declaration for the new function context,\n\
3066and may be null to indicate that the compiler has left a function context\n\
3067and is returning to processing at the top level.\n\
3068The default hook function does nothing.\n\
3069\n\
3070GCC sets @code{cfun} to a dummy function context during initialization of\n\
3071some parts of the back end. The hook function is not invoked in this\n\
3072situation; you need not worry about the hook being invoked recursively,\n\
3073or when the back end is in a partially-initialized state.\n\
3074@code{cfun} might be @code{NULL} to indicate processing at top level,\n\
3075outside of any function scope.",
3076 void, (tree decl), hook_void_tree)
3077
3078/* True if EXP should be placed in a "small data" section. */
3079DEFHOOK
3080(in_small_data_p,
3081 "Returns true if @var{exp} should be placed into a ``small data'' section.\n\
3082The default version of this hook always returns false.",
3083 bool, (const_tree exp),
3084 hook_bool_const_tree_false)
3085
3086/* True if EXP names an object for which name resolution must resolve
3087 to the current executable or shared library. */
3088DEFHOOK
3089(binds_local_p,
3090 "Returns true if @var{exp} names an object for which name resolution\n\
3091rules must resolve to the current ``module'' (dynamic shared library\n\
3092or executable image).\n\
3093\n\
3094The default version of this hook implements the name resolution rules\n\
3095for ELF, which has a looser model of global name binding than other\n\
3096currently supported object file formats.",
3097 bool, (const_tree exp),
3098 default_binds_local_p)
3099
3100/* Check if profiling code is before or after prologue. */
3101DEFHOOK
3102(profile_before_prologue,
3103 "It returns true if target wants profile code emitted before prologue.\n\n\
3104The default version of this hook use the target macro\n\
3105@code{PROFILE_BEFORE_PROLOGUE}.",
3106 bool, (void),
3107 default_profile_before_prologue)
3108
3109/* Return true if a leaf function should stay leaf even with profiling
3110 enabled. */
3111DEFHOOK
3112(keep_leaf_when_profiled,
3113 "This target hook returns true if the target wants the leaf flag for\n\
3114the current function to stay true even if it calls mcount. This might\n\
3115make sense for targets using the leaf flag only to determine whether a\n\
3116stack frame needs to be generated or not and for which the call to\n\
3117mcount is generated before the function prologue.",
3118 bool, (void),
3119 default_keep_leaf_when_profiled)
3120
3121/* Modify and return the identifier of a DECL's external name,
3122 originally identified by ID, as required by the target,
3123 (eg, append @nn to windows32 stdcall function names).
3124 The default is to return ID without modification. */
3125DEFHOOK
3126(mangle_decl_assembler_name,
3127 "Define this hook if you need to postprocess the assembler name generated\n\
3128by target-independent code. The @var{id} provided to this hook will be\n\
3129the computed name (e.g., the macro @code{DECL_NAME} of the @var{decl} in C,\n\
3130or the mangled name of the @var{decl} in C++). The return value of the\n\
3131hook is an @code{IDENTIFIER_NODE} for the appropriate mangled name on\n\
3132your target system. The default implementation of this hook just\n\
3133returns the @var{id} provided.",
3134 tree, (tree decl, tree id),
3135 default_mangle_decl_assembler_name)
3136
3137/* Do something target-specific to record properties of the DECL into
3138 the associated SYMBOL_REF. */
3139DEFHOOK
3140(encode_section_info,
3141 "Define this hook if references to a symbol or a constant must be\n\
3142treated differently depending on something about the variable or\n\
3143function named by the symbol (such as what section it is in).\n\
3144\n\
3145The hook is executed immediately after rtl has been created for\n\
3146@var{decl}, which may be a variable or function declaration or\n\
3147an entry in the constant pool. In either case, @var{rtl} is the\n\
3148rtl in question. Do @emph{not} use @code{DECL_RTL (@var{decl})}\n\
3149in this hook; that field may not have been initialized yet.\n\
3150\n\
3151In the case of a constant, it is safe to assume that the rtl is\n\
3152a @code{mem} whose address is a @code{symbol_ref}. Most decls\n\
3153will also have this form, but that is not guaranteed. Global\n\
3154register variables, for instance, will have a @code{reg} for their\n\
3155rtl. (Normally the right thing to do with such unusual rtl is\n\
3156leave it alone.)\n\
3157\n\
3158The @var{new_decl_p} argument will be true if this is the first time\n\
3159that @code{TARGET_ENCODE_SECTION_INFO} has been invoked on this decl. It will\n\
3160be false for subsequent invocations, which will happen for duplicate\n\
3161declarations. Whether or not anything must be done for the duplicate\n\
3162declaration depends on whether the hook examines @code{DECL_ATTRIBUTES}.\n\
3163@var{new_decl_p} is always true when the hook is called for a constant.\n\
3164\n\
3165@cindex @code{SYMBOL_REF_FLAG}, in @code{TARGET_ENCODE_SECTION_INFO}\n\
3166The usual thing for this hook to do is to record flags in the\n\
3167@code{symbol_ref}, using @code{SYMBOL_REF_FLAG} or @code{SYMBOL_REF_FLAGS}.\n\
3168Historically, the name string was modified if it was necessary to\n\
3169encode more than one bit of information, but this practice is now\n\
3170discouraged; use @code{SYMBOL_REF_FLAGS}.\n\
3171\n\
3172The default definition of this hook, @code{default_encode_section_info}\n\
3173in @file{varasm.cc}, sets a number of commonly-useful bits in\n\
3174@code{SYMBOL_REF_FLAGS}. Check whether the default does what you need\n\
3175before overriding it.",
3176 void, (tree decl, rtx rtl, int new_decl_p),
3177 default_encode_section_info)
3178
3179/* Undo the effects of encode_section_info on the symbol string. */
3180DEFHOOK
3181(strip_name_encoding,
3182 "Decode @var{name} and return the real name part, sans\n\
3183the characters that @code{TARGET_ENCODE_SECTION_INFO}\n\
3184may have added.",
3185 const char *, (const char *name),
3186 default_strip_name_encoding)
3187
3188/* If shift optabs for MODE are known to always truncate the shift count,
3189 return the mask that they apply. Return 0 otherwise. */
3190DEFHOOK
3191(shift_truncation_mask,
3192 "This function describes how the standard shift patterns for @var{mode}\n\
3193deal with shifts by negative amounts or by more than the width of the mode.\n\
3194@xref{shift patterns}.\n\
3195\n\
3196On many machines, the shift patterns will apply a mask @var{m} to the\n\
3197shift count, meaning that a fixed-width shift of @var{x} by @var{y} is\n\
3198equivalent to an arbitrary-width shift of @var{x} by @var{y & m}. If\n\
3199this is true for mode @var{mode}, the function should return @var{m},\n\
3200otherwise it should return 0. A return value of 0 indicates that no\n\
3201particular behavior is guaranteed.\n\
3202\n\
3203Note that, unlike @code{SHIFT_COUNT_TRUNCATED}, this function does\n\
3204@emph{not} apply to general shift rtxes; it applies only to instructions\n\
3205that are generated by the named shift patterns.\n\
3206\n\
3207The default implementation of this function returns\n\
3208@code{GET_MODE_BITSIZE (@var{mode}) - 1} if @code{SHIFT_COUNT_TRUNCATED}\n\
3209and 0 otherwise. This definition is always safe, but if\n\
3210@code{SHIFT_COUNT_TRUNCATED} is false, and some shift patterns\n\
3211nevertheless truncate the shift count, you may get better code\n\
3212by overriding it.",
3213 unsigned HOST_WIDE_INT, (machine_mode mode),
3214 default_shift_truncation_mask)
3215
3216/* Return the number of divisions in the given MODE that should be present,
3217 so that it is profitable to turn the division into a multiplication by
3218 the reciprocal. */
3219DEFHOOK
3220(min_divisions_for_recip_mul,
3221 "When @option{-ffast-math} is in effect, GCC tries to optimize\n\
3222divisions by the same divisor, by turning them into multiplications by\n\
3223the reciprocal. This target hook specifies the minimum number of divisions\n\
3224that should be there for GCC to perform the optimization for a variable\n\
3225of mode @var{mode}. The default implementation returns 3 if the machine\n\
3226has an instruction for the division, and 2 if it does not.",
3227 unsigned int, (machine_mode mode),
3228 default_min_divisions_for_recip_mul)
3229
3230DEFHOOK
3231(truly_noop_truncation,
3232 "This hook returns true if it is safe to ``convert'' a value of\n\
3233@var{inprec} bits to one of @var{outprec} bits (where @var{outprec} is\n\
3234smaller than @var{inprec}) by merely operating on it as if it had only\n\
3235@var{outprec} bits. The default returns true unconditionally, which\n\
3236is correct for most machines. When @code{TARGET_TRULY_NOOP_TRUNCATION}\n\
3237returns false, the machine description should provide a @code{trunc}\n\
3238optab to specify the RTL that performs the required truncation.\n\
3239\n\
3240If @code{TARGET_MODES_TIEABLE_P} returns false for a pair of modes,\n\
3241suboptimal code can result if this hook returns true for the corresponding\n\
3242mode sizes. Making this hook return false in such cases may improve things.",
3243 bool, (poly_uint64 outprec, poly_uint64 inprec),
3244 hook_bool_puint64_puint64_true)
3245
3246/* If the representation of integral MODE is such that values are
3247 always sign-extended to a wider mode MODE_REP then return
3248 SIGN_EXTEND. Return UNKNOWN otherwise. */
3249/* Note that the return type ought to be RTX_CODE, but that's not
3250 necessarily defined at this point. */
3251DEFHOOK
3252(mode_rep_extended,
3253 "The representation of an integral mode can be such that the values\n\
3254are always extended to a wider integral mode. Return\n\
3255@code{SIGN_EXTEND} if values of @var{mode} are represented in\n\
3256sign-extended form to @var{rep_mode}. Return @code{UNKNOWN}\n\
3257otherwise. (Currently, none of the targets use zero-extended\n\
3258representation this way so unlike @code{LOAD_EXTEND_OP},\n\
3259@code{TARGET_MODE_REP_EXTENDED} is expected to return either\n\
3260@code{SIGN_EXTEND} or @code{UNKNOWN}. Also no target extends\n\
3261@var{mode} to @var{rep_mode} so that @var{rep_mode} is not the next\n\
3262widest integral mode and currently we take advantage of this fact.)\n\
3263\n\
3264Similarly to @code{LOAD_EXTEND_OP} you may return a non-@code{UNKNOWN}\n\
3265value even if the extension is not performed on certain hard registers\n\
3266as long as for the @code{REGNO_REG_CLASS} of these hard registers\n\
3267@code{TARGET_CAN_CHANGE_MODE_CLASS} returns false.\n\
3268\n\
3269Note that @code{TARGET_MODE_REP_EXTENDED} and @code{LOAD_EXTEND_OP}\n\
3270describe two related properties. If you define\n\
3271@code{TARGET_MODE_REP_EXTENDED (mode, word_mode)} you probably also want\n\
3272to define @code{LOAD_EXTEND_OP (mode)} to return the same type of\n\
3273extension.\n\
3274\n\
3275In order to enforce the representation of @code{mode},\n\
3276@code{TARGET_TRULY_NOOP_TRUNCATION} should return false when truncating to\n\
3277@code{mode}.",
3278 int, (scalar_int_mode mode, scalar_int_mode rep_mode),
3279 default_mode_rep_extended)
3280
3281DEFHOOK
3282(setjmp_preserves_nonvolatile_regs_p,
3283 "On some targets, it is assumed that the compiler will spill all pseudos\n\
3284 that are live across a call to @code{setjmp}, while other targets treat\n\
3285 @code{setjmp} calls as normal function calls.\n\
3286 \n\
3287 This hook returns false if @code{setjmp} calls do not preserve all\n\
3288 non-volatile registers so that gcc that must spill all pseudos that are\n\
3289 live across @code{setjmp} calls. Define this to return true if the\n\
3290 target does not need to spill all pseudos live across @code{setjmp} calls.\n\
3291 The default implementation conservatively assumes all pseudos must be\n\
3292 spilled across @code{setjmp} calls.",
3293 bool, (void),
3294 hook_bool_void_false)
3295
3296/* True if MODE is valid for a pointer in __attribute__((mode("MODE"))). */
3297DEFHOOK
3298(valid_pointer_mode,
3299 "Define this to return nonzero if the port can handle pointers\n\
3300with machine mode @var{mode}. The default version of this\n\
3301hook returns true for both @code{ptr_mode} and @code{Pmode}.",
3302 bool, (scalar_int_mode mode),
3303 default_valid_pointer_mode)
3304
3305/* Disambiguate with errno. */
3306DEFHOOK
3307(ref_may_alias_errno,
3308 "Define this to return nonzero if the memory reference @var{ref}\n\
3309may alias with the system C library errno location. The default\n\
3310version of this hook assumes the system C library errno location\n\
3311is either a declaration of type int or accessed by dereferencing\n\
3312a pointer to int.",
3313 bool, (ao_ref *ref),
3314 default_ref_may_alias_errno)
3315
3316/* Support for named address spaces. */
3317#undef HOOK_PREFIX
3318#define HOOK_PREFIX "TARGET_ADDR_SPACE_"
3319HOOK_VECTOR (TARGET_ADDR_SPACE_HOOKS, addr_space)
3320
3321/* MODE to use for a pointer into another address space. */
3322DEFHOOK
3323(pointer_mode,
3324 "Define this to return the machine mode to use for pointers to\n\
3325@var{address_space} if the target supports named address spaces.\n\
3326The default version of this hook returns @code{ptr_mode}.",
3327 scalar_int_mode, (addr_space_t address_space),
3328 default_addr_space_pointer_mode)
3329
3330/* MODE to use for an address in another address space. */
3331DEFHOOK
3332(address_mode,
3333 "Define this to return the machine mode to use for addresses in\n\
3334@var{address_space} if the target supports named address spaces.\n\
3335The default version of this hook returns @code{Pmode}.",
3336 scalar_int_mode, (addr_space_t address_space),
3337 default_addr_space_address_mode)
3338
3339/* True if MODE is valid for a pointer in __attribute__((mode("MODE")))
3340 in another address space. */
3341DEFHOOK
3342(valid_pointer_mode,
3343 "Define this to return nonzero if the port can handle pointers\n\
3344with machine mode @var{mode} to address space @var{as}. This target\n\
3345hook is the same as the @code{TARGET_VALID_POINTER_MODE} target hook,\n\
3346except that it includes explicit named address space support. The default\n\
3347version of this hook returns true for the modes returned by either the\n\
3348@code{TARGET_ADDR_SPACE_POINTER_MODE} or @code{TARGET_ADDR_SPACE_ADDRESS_MODE}\n\
3349target hooks for the given address space.",
3350 bool, (scalar_int_mode mode, addr_space_t as),
3351 default_addr_space_valid_pointer_mode)
3352
3353/* True if an address is a valid memory address to a given named address
3354 space for a given mode. */
3355DEFHOOK
3356(legitimate_address_p,
3357 "Define this to return true if @var{exp} is a valid address for mode\n\
3358@var{mode} in the named address space @var{as} with the use context\n\
3359@var{ch}. The @var{strict} parameter says whether strict addressing\n\
3360is in effect after reload has finished. The @var{ch} indicates what\n\
3361context @var{exp} will be used for. This target hook is the same as the\n\
3362@code{TARGET_LEGITIMATE_ADDRESS_P} target hook, except that it includes\n\
3363explicit named address space support.",
3364 bool, (machine_mode mode, rtx exp, bool strict, addr_space_t as, code_helper ch),
3365 default_addr_space_legitimate_address_p)
3366
3367/* Return an updated address to convert an invalid pointer to a named
3368 address space to a valid one. If NULL_RTX is returned use machine
3369 independent methods to make the address valid. */
3370DEFHOOK
3371(legitimize_address,
3372 "Define this to modify an invalid address @var{x} to be a valid address\n\
3373with mode @var{mode} in the named address space @var{as}. This target\n\
3374hook is the same as the @code{TARGET_LEGITIMIZE_ADDRESS} target hook,\n\
3375except that it includes explicit named address space support.",
3376 rtx, (rtx x, rtx oldx, machine_mode mode, addr_space_t as),
3377 default_addr_space_legitimize_address)
3378
3379/* True if one named address space is a subset of another named address. */
3380DEFHOOK
3381(subset_p,
3382 "Define this to return whether the @var{subset} named address space is\n\
3383contained within the @var{superset} named address space. Pointers to\n\
3384a named address space that is a subset of another named address space\n\
3385will be converted automatically without a cast if used together in\n\
3386arithmetic operations. Pointers to a superset address space can be\n\
3387converted to pointers to a subset address space via explicit casts.",
3388 bool, (addr_space_t subset, addr_space_t superset),
3389 default_addr_space_subset_p)
3390
3391/* True if 0 is a valid address in the address space, or false if
3392 0 is a NULL in the address space. */
3393DEFHOOK
3394(zero_address_valid,
3395 "Define this to modify the default handling of address 0 for the\n\
3396address space. Return true if 0 should be considered a valid address.",
3397 bool, (addr_space_t as),
3398 default_addr_space_zero_address_valid)
3399
3400/* Function to convert an rtl expression from one address space to another. */
3401DEFHOOK
3402(convert,
3403 "Define this to convert the pointer expression represented by the RTL\n\
3404@var{op} with type @var{from_type} that points to a named address\n\
3405space to a new pointer expression with type @var{to_type} that points\n\
3406to a different named address space. When this hook it called, it is\n\
3407guaranteed that one of the two address spaces is a subset of the other,\n\
3408as determined by the @code{TARGET_ADDR_SPACE_SUBSET_P} target hook.",
3409 rtx, (rtx op, tree from_type, tree to_type),
3410 default_addr_space_convert)
3411
3412/* Function to encode an address space into dwarf. */
3413DEFHOOK
3414(debug,
3415 "Define this to define how the address space is encoded in dwarf.\n\
3416The result is the value to be used with @code{DW_AT_address_class}.",
3417 int, (addr_space_t as),
3418 default_addr_space_debug)
3419
3420/* Function to emit custom diagnostic if an address space is used. */
3421DEFHOOK
3422(diagnose_usage,
3423 "Define this hook if the availability of an address space depends on\n\
3424command line options and some diagnostics should be printed when the\n\
3425address space is used. This hook is called during parsing and allows\n\
3426to emit a better diagnostic compared to the case where the address space\n\
3427was not registered with @code{c_register_addr_space}. @var{as} is\n\
3428the address space as registered with @code{c_register_addr_space}.\n\
3429@var{loc} is the location of the address space qualifier token.\n\
3430The default implementation does nothing.",
3431 void, (addr_space_t as, location_t loc),
3432 default_addr_space_diagnose_usage)
3433
3434HOOK_VECTOR_END (addr_space)
3435
3436#undef HOOK_PREFIX
3437#define HOOK_PREFIX "TARGET_"
3438
3439DEFHOOK
3440(lower_local_decl_alignment,
3441 "Define this hook to lower alignment of local, parm or result\n\
3442decl @samp{(@var{decl})}.",
3443 void, (tree decl),
3444 hook_void_tree)
3445
3446DEFHOOK
3447(static_rtx_alignment,
3448 "This hook returns the preferred alignment in bits for a\n\
3449statically-allocated rtx, such as a constant pool entry. @var{mode}\n\
3450is the mode of the rtx. The default implementation returns\n\
3451@samp{GET_MODE_ALIGNMENT (@var{mode})}.",
3452 HOST_WIDE_INT, (machine_mode mode),
3453 default_static_rtx_alignment)
3454
3455DEFHOOK
3456(constant_alignment,
3457 "This hook returns the alignment in bits of a constant that is being\n\
3458placed in memory. @var{constant} is the constant and @var{basic_align}\n\
3459is the alignment that the object would ordinarily have.\n\
3460\n\
3461The default definition just returns @var{basic_align}.\n\
3462\n\
3463The typical use of this hook is to increase alignment for string\n\
3464constants to be word aligned so that @code{strcpy} calls that copy\n\
3465constants can be done inline. The function\n\
3466@code{constant_alignment_word_strings} provides such a definition.",
3467 HOST_WIDE_INT, (const_tree constant, HOST_WIDE_INT basic_align),
3468 default_constant_alignment)
3469
3470DEFHOOK
3471(translate_mode_attribute,
3472 "Define this hook if during mode attribute processing, the port should\n\
3473translate machine_mode @var{mode} to another mode. For example, rs6000's\n\
3474@code{KFmode}, when it is the same as @code{TFmode}.\n\
3475\n\
3476The default version of the hook returns that mode that was passed in.",
3477 machine_mode, (machine_mode mode),
3478 default_translate_mode_attribute)
3479
3480/* True if MODE is valid for the target. By "valid", we mean able to
3481 be manipulated in non-trivial ways. In particular, this means all
3482 the arithmetic is supported. */
3483DEFHOOK
3484(scalar_mode_supported_p,
3485 "Define this to return nonzero if the port is prepared to handle\n\
3486insns involving scalar mode @var{mode}. For a scalar mode to be\n\
3487considered supported, all the basic arithmetic and comparisons\n\
3488must work.\n\
3489\n\
3490The default version of this hook returns true for any mode\n\
3491required to handle the basic C types (as defined by the port).\n\
3492Included here are the double-word arithmetic supported by the\n\
3493code in @file{optabs.cc}.",
3494 bool, (scalar_mode mode),
3495 default_scalar_mode_supported_p)
3496
3497/* Similarly for vector modes. "Supported" here is less strict. At
3498 least some operations are supported; need to check optabs or builtins
3499 for further details. */
3500DEFHOOK
3501(vector_mode_supported_p,
3502 "Define this to return nonzero if the current target is prepared to handle\n\
3503insns involving vector mode @var{mode}. At the very least, it\n\
3504must have move patterns for this mode.",
3505 bool, (machine_mode mode),
3506 hook_bool_mode_false)
3507
3508DEFHOOK
3509(vector_mode_supported_any_target_p,
3510 "Define this to return nonzero if the port is prepared to handle\n\
3511insns involving vector mode @var{mode} in any target configuration.\n\
3512Returning @var{true} means that the mode can be used as the @samp{TYPE_MODE}\n\
3513for vector types.\n\
3514\n\
3515The default version of this hook returns true. The final mode assigned to\n\
3516@samp{TYPE_MODE} will also be checked against\n\
3517@code{TARGET_VECTOR_MODE_SUPPORTED_P} to take target configuration into\n\
3518account.",
3519 bool, (machine_mode mode),
3520 hook_bool_mode_true)
3521
3522DEFHOOK
3523(compatible_vector_types_p,
3524 "Return true if there is no target-specific reason for treating\n\
3525vector types @var{type1} and @var{type2} as distinct types. The caller\n\
3526has already checked for target-independent reasons, meaning that the\n\
3527types are known to have the same mode, to have the same number of elements,\n\
3528and to have what the caller considers to be compatible element types.\n\
3529\n\
3530The main reason for defining this hook is to reject pairs of types\n\
3531that are handled differently by the target's calling convention.\n\
3532For example, when a new @var{N}-bit vector architecture is added\n\
3533to a target, the target may want to handle normal @var{N}-bit\n\
3534@code{VECTOR_TYPE} arguments and return values in the same way as\n\
3535before, to maintain backwards compatibility. However, it may also\n\
3536provide new, architecture-specific @code{VECTOR_TYPE}s that are passed\n\
3537and returned in a more efficient way. It is then important to maintain\n\
3538a distinction between the ``normal'' @code{VECTOR_TYPE}s and the new\n\
3539architecture-specific ones.\n\
3540\n\
3541The default implementation returns true, which is correct for most targets.",
3542 bool, (const_tree type1, const_tree type2),
3543 hook_bool_const_tree_const_tree_true)
3544
3545DEFHOOK
3546(vector_alignment,
3547 "This hook can be used to define the alignment for a vector of type\n\
3548@var{type}, in order to comply with a platform ABI. The default is to\n\
3549require natural alignment for vector types. The alignment returned by\n\
3550this hook must be a power-of-two multiple of the default alignment of\n\
3551the vector element type.",
3552 HOST_WIDE_INT, (const_tree type),
3553 default_vector_alignment)
3554
3555DEFHOOK
3556(array_mode,
3557 "Return the mode that GCC should use for an array that has\n\
3558@var{nelems} elements, with each element having mode @var{mode}.\n\
3559Return no mode if the target has no special requirements. In the\n\
3560latter case, GCC looks for an integer mode of the appropriate size\n\
3561if available and uses BLKmode otherwise. Usually the search for the\n\
3562integer mode is limited to @code{MAX_FIXED_MODE_SIZE}, but the\n\
3563@code{TARGET_ARRAY_MODE_SUPPORTED_P} hook allows a larger mode to be\n\
3564used in specific cases.\n\
3565\n\
3566The main use of this hook is to specify that an array of vectors should\n\
3567also have a vector mode. The default implementation returns no mode.",
3568 opt_machine_mode, (machine_mode mode, unsigned HOST_WIDE_INT nelems),
3569 hook_optmode_mode_uhwi_none)
3570
3571/* True if we should try to use a scalar mode to represent an array,
3572 overriding the usual MAX_FIXED_MODE limit. */
3573DEFHOOK
3574(array_mode_supported_p,
3575 "Return true if GCC should try to use a scalar mode to store an array\n\
3576of @var{nelems} elements, given that each element has mode @var{mode}.\n\
3577Returning true here overrides the usual @code{MAX_FIXED_MODE} limit\n\
3578and allows GCC to use any defined integer mode.\n\
3579\n\
3580One use of this hook is to support vector load and store operations\n\
3581that operate on several homogeneous vectors. For example, ARM NEON\n\
3582has operations like:\n\
3583\n\
3584@smallexample\n\
3585int8x8x3_t vld3_s8 (const int8_t *)\n\
3586@end smallexample\n\
3587\n\
3588where the return type is defined as:\n\
3589\n\
3590@smallexample\n\
3591typedef struct int8x8x3_t\n\
3592@{\n\
3593 int8x8_t val[3];\n\
3594@} int8x8x3_t;\n\
3595@end smallexample\n\
3596\n\
3597If this hook allows @code{val} to have a scalar mode, then\n\
3598@code{int8x8x3_t} can have the same mode. GCC can then store\n\
3599@code{int8x8x3_t}s in registers rather than forcing them onto the stack.",
3600 bool, (machine_mode mode, unsigned HOST_WIDE_INT nelems),
3601 hook_bool_mode_uhwi_false)
3602
3603DEFHOOK
3604(libgcc_floating_mode_supported_p,
3605 "Define this to return nonzero if libgcc provides support for the \n\
3606floating-point mode @var{mode}, which is known to pass \n\
3607@code{TARGET_SCALAR_MODE_SUPPORTED_P}. The default version of this \n\
3608hook returns true for all of @code{SFmode}, @code{DFmode}, \n\
3609@code{XFmode} and @code{TFmode}, if such modes exist.",
3610 bool, (scalar_float_mode mode),
3611 default_libgcc_floating_mode_supported_p)
3612
3613DEFHOOK
3614(floatn_mode,
3615 "Define this to return the machine mode to use for the type \n\
3616@code{_Float@var{n}}, if @var{extended} is false, or the type \n\
3617@code{_Float@var{n}x}, if @var{extended} is true. If such a type is not\n\
3618supported, return @code{opt_scalar_float_mode ()}. The default version of\n\
3619this hook returns @code{SFmode} for @code{_Float32}, @code{DFmode} for\n\
3620@code{_Float64} and @code{_Float32x} and @code{TFmode} for \n\
3621@code{_Float128}, if those modes exist and satisfy the requirements for \n\
3622those types and pass @code{TARGET_SCALAR_MODE_SUPPORTED_P} and \n\
3623@code{TARGET_LIBGCC_FLOATING_MODE_SUPPORTED_P}; for @code{_Float64x}, it \n\
3624returns the first of @code{XFmode} and @code{TFmode} that exists and \n\
3625satisfies the same requirements; for other types, it returns \n\
3626@code{opt_scalar_float_mode ()}. The hook is only called for values\n\
3627of @var{n} and @var{extended} that are valid according to\n\
3628ISO/IEC TS 18661-3:2015; that is, @var{n} is one of 32, 64, 128, or,\n\
3629if @var{extended} is false, 16 or greater than 128 and a multiple of 32.",
3630 opt_scalar_float_mode, (int n, bool extended),
3631 default_floatn_mode)
3632
3633DEFHOOK
3634(floatn_builtin_p,
3635 "Define this to return true if the @code{_Float@var{n}} and\n\
3636@code{_Float@var{n}x} built-in functions should implicitly enable the\n\
3637built-in function without the @code{__builtin_} prefix in addition to the\n\
3638normal built-in function with the @code{__builtin_} prefix. The default is\n\
3639to only enable built-in functions without the @code{__builtin_} prefix for\n\
3640the GNU C langauge. In strict ANSI/ISO mode, the built-in function without\n\
3641the @code{__builtin_} prefix is not enabled. The argument @code{FUNC} is the\n\
3642@code{enum built_in_function} id of the function to be enabled.",
3643 bool, (int func),
3644 default_floatn_builtin_p)
3645
3646/* Compute cost of moving data from a register of class FROM to one of
3647 TO, using MODE. */
3648DEFHOOK
3649(register_move_cost,
3650 "This target hook should return the cost of moving data of mode @var{mode}\n\
3651from a register in class @var{from} to one in class @var{to}. The classes\n\
3652are expressed using the enumeration values such as @code{GENERAL_REGS}.\n\
3653A value of 2 is the default; other values are interpreted relative to\n\
3654that.\n\
3655\n\
3656It is not required that the cost always equal 2 when @var{from} is the\n\
3657same as @var{to}; on some machines it is expensive to move between\n\
3658registers if they are not general registers.\n\
3659\n\
3660If reload sees an insn consisting of a single @code{set} between two\n\
3661hard registers, and if @code{TARGET_REGISTER_MOVE_COST} applied to their\n\
3662classes returns a value of 2, reload does not check to ensure that the\n\
3663constraints of the insn are met. Setting a cost of other than 2 will\n\
3664allow reload to verify that the constraints are met. You should do this\n\
3665if the @samp{mov@var{m}} pattern's constraints do not allow such copying.\n\
3666\n\
3667The default version of this function returns 2.",
3668 int, (machine_mode mode, reg_class_t from, reg_class_t to),
3669 default_register_move_cost)
3670
3671/* Compute cost of moving registers to/from memory. */
3672/* ??? Documenting the argument types for this hook requires a GFDL
3673 license grant. Also, the documentation uses a different name for RCLASS. */
3674DEFHOOK
3675(memory_move_cost,
3676 "This target hook should return the cost of moving data of mode @var{mode}\n\
3677between a register of class @var{rclass} and memory; @var{in} is @code{false}\n\
3678if the value is to be written to memory, @code{true} if it is to be read in.\n\
3679This cost is relative to those in @code{TARGET_REGISTER_MOVE_COST}.\n\
3680If moving between registers and memory is more expensive than between two\n\
3681registers, you should add this target hook to express the relative cost.\n\
3682\n\
3683If you do not add this target hook, GCC uses a default cost of 4 plus\n\
3684the cost of copying via a secondary reload register, if one is\n\
3685needed. If your machine requires a secondary reload register to copy\n\
3686between memory and a register of @var{rclass} but the reload mechanism is\n\
3687more complex than copying via an intermediate, use this target hook to\n\
3688reflect the actual cost of the move.\n\
3689\n\
3690GCC defines the function @code{memory_move_secondary_cost} if\n\
3691secondary reloads are needed. It computes the costs due to copying via\n\
3692a secondary register. If your machine copies from memory using a\n\
3693secondary register in the conventional way but the default base value of\n\
36944 is not correct for your machine, use this target hook to add some other\n\
3695value to the result of that function. The arguments to that function\n\
3696are the same as to this target hook.",
3697 int, (machine_mode mode, reg_class_t rclass, bool in),
3698 default_memory_move_cost)
3699
3700DEFHOOK
3701(use_by_pieces_infrastructure_p,
3702 "GCC will attempt several strategies when asked to copy between\n\
3703two areas of memory, or to set, clear or store to memory, for example\n\
3704when copying a @code{struct}. The @code{by_pieces} infrastructure\n\
3705implements such memory operations as a sequence of load, store or move\n\
3706insns. Alternate strategies are to expand the\n\
3707@code{cpymem} or @code{setmem} optabs, to emit a library call, or to emit\n\
3708unit-by-unit, loop-based operations.\n\
3709\n\
3710This target hook should return true if, for a memory operation with a\n\
3711given @var{size} and @var{alignment}, using the @code{by_pieces}\n\
3712infrastructure is expected to result in better code generation.\n\
3713Both @var{size} and @var{alignment} are measured in terms of storage\n\
3714units.\n\
3715\n\
3716The parameter @var{op} is one of: @code{CLEAR_BY_PIECES},\n\
3717@code{MOVE_BY_PIECES}, @code{SET_BY_PIECES}, @code{STORE_BY_PIECES} or\n\
3718@code{COMPARE_BY_PIECES}. These describe the type of memory operation\n\
3719under consideration.\n\
3720\n\
3721The parameter @var{speed_p} is true if the code is currently being\n\
3722optimized for speed rather than size.\n\
3723\n\
3724Returning true for higher values of @var{size} can improve code generation\n\
3725for speed if the target does not provide an implementation of the\n\
3726@code{cpymem} or @code{setmem} standard names, if the @code{cpymem} or\n\
3727@code{setmem} implementation would be more expensive than a sequence of\n\
3728insns, or if the overhead of a library call would dominate that of\n\
3729the body of the memory operation.\n\
3730\n\
3731Returning true for higher values of @code{size} may also cause an increase\n\
3732in code size, for example where the number of insns emitted to perform a\n\
3733move would be greater than that of a library call.",
3734 bool, (unsigned HOST_WIDE_INT size, unsigned int alignment,
3735 enum by_pieces_operation op, bool speed_p),
3736 default_use_by_pieces_infrastructure_p)
3737
3738DEFHOOK
3739(overlap_op_by_pieces_p,
3740 "This target hook should return true if when the @code{by_pieces}\n\
3741infrastructure is used, an offset adjusted unaligned memory operation\n\
3742in the smallest integer mode for the last piece operation of a memory\n\
3743region can be generated to avoid doing more than one smaller operations.",
3744 bool, (void),
3745 hook_bool_void_false)
3746
3747DEFHOOK
3748(compare_by_pieces_branch_ratio,
3749 "When expanding a block comparison in MODE, gcc can try to reduce the\n\
3750number of branches at the expense of more memory operations. This hook\n\
3751allows the target to override the default choice. It should return the\n\
3752factor by which branches should be reduced over the plain expansion with\n\
3753one comparison per @var{mode}-sized piece. A port can also prevent a\n\
3754particular mode from being used for block comparisons by returning a\n\
3755negative number from this hook.",
3756 int, (machine_mode mode),
3757 default_compare_by_pieces_branch_ratio)
3758
3759DEFHOOK
3760(slow_unaligned_access,
3761 "This hook returns true if memory accesses described by the\n\
3762@var{mode} and @var{alignment} parameters have a cost many times greater\n\
3763than aligned accesses, for example if they are emulated in a trap handler.\n\
3764This hook is invoked only for unaligned accesses, i.e.@: when\n\
3765@code{@var{alignment} < GET_MODE_ALIGNMENT (@var{mode})}.\n\
3766\n\
3767When this hook returns true, the compiler will act as if\n\
3768@code{STRICT_ALIGNMENT} were true when generating code for block\n\
3769moves. This can cause significantly more instructions to be produced.\n\
3770Therefore, do not make this hook return true if unaligned accesses only\n\
3771add a cycle or two to the time for a memory access.\n\
3772\n\
3773The hook must return true whenever @code{STRICT_ALIGNMENT} is true.\n\
3774The default implementation returns @code{STRICT_ALIGNMENT}.",
3775 bool, (machine_mode mode, unsigned int align),
3776 default_slow_unaligned_access)
3777
3778DEFHOOK
3779(optab_supported_p,
3780 "Return true if the optimizers should use optab @var{op} with\n\
3781modes @var{mode1} and @var{mode2} for optimization type @var{opt_type}.\n\
3782The optab is known to have an associated @file{.md} instruction\n\
3783whose C condition is true. @var{mode2} is only meaningful for conversion\n\
3784optabs; for direct optabs it is a copy of @var{mode1}.\n\
3785\n\
3786For example, when called with @var{op} equal to @code{rint_optab} and\n\
3787@var{mode1} equal to @code{DFmode}, the hook should say whether the\n\
3788optimizers should use optab @code{rintdf2}.\n\
3789\n\
3790The default hook returns true for all inputs.",
3791 bool, (int op, machine_mode mode1, machine_mode mode2,
3792 optimization_type opt_type),
3793 default_optab_supported_p)
3794
3795/* True for MODE if the target expects that registers in this mode will
3796 be allocated to registers in a small register class. The compiler is
3797 allowed to use registers explicitly used in the rtl as spill registers
3798 but it should prevent extending the lifetime of these registers. */
3799DEFHOOK
3800(small_register_classes_for_mode_p,
3801 "Define this to return nonzero for machine modes for which the port has\n\
3802small register classes. If this target hook returns nonzero for a given\n\
3803@var{mode}, the compiler will try to minimize the lifetime of registers\n\
3804in @var{mode}. The hook may be called with @code{VOIDmode} as argument.\n\
3805In this case, the hook is expected to return nonzero if it returns nonzero\n\
3806for any mode.\n\
3807\n\
3808On some machines, it is risky to let hard registers live across arbitrary\n\
3809insns. Typically, these machines have instructions that require values\n\
3810to be in specific registers (like an accumulator), and reload will fail\n\
3811if the required hard register is used for another purpose across such an\n\
3812insn.\n\
3813\n\
3814Passes before reload do not know which hard registers will be used\n\
3815in an instruction, but the machine modes of the registers set or used in\n\
3816the instruction are already known. And for some machines, register\n\
3817classes are small for, say, integer registers but not for floating point\n\
3818registers. For example, the AMD x86-64 architecture requires specific\n\
3819registers for the legacy x86 integer instructions, but there are many\n\
3820SSE registers for floating point operations. On such targets, a good\n\
3821strategy may be to return nonzero from this hook for @code{INTEGRAL_MODE_P}\n\
3822machine modes but zero for the SSE register classes.\n\
3823\n\
3824The default version of this hook returns false for any mode. It is always\n\
3825safe to redefine this hook to return with a nonzero value. But if you\n\
3826unnecessarily define it, you will reduce the amount of optimizations\n\
3827that can be performed in some cases. If you do not define this hook\n\
3828to return a nonzero value when it is required, the compiler will run out\n\
3829of spill registers and print a fatal error message.",
3830 bool, (machine_mode mode),
3831 hook_bool_mode_false)
3832
3833/* Register number for a flags register. Only needs to be defined if the
3834 target is constrainted to use post-reload comparison elimination. */
3835DEFHOOKPOD
3836(flags_regnum,
3837 "If the target has a dedicated flags register, and it needs to use the\n\
3838post-reload comparison elimination pass, or the delay slot filler pass,\n\
3839then this value should be set appropriately.",
3840unsigned int, INVALID_REGNUM)
3841
3842/* Compute a (partial) cost for rtx X. Return true if the complete
3843 cost has been computed, and false if subexpressions should be
3844 scanned. In either case, *TOTAL contains the cost result. */
3845/* Note that OUTER_CODE ought to be RTX_CODE, but that's
3846 not necessarily defined at this point. */
3847DEFHOOK
3848(rtx_costs,
3849 "This target hook describes the relative costs of RTL expressions.\n\
3850\n\
3851The cost may depend on the precise form of the expression, which is\n\
3852available for examination in @var{x}, and the fact that @var{x} appears\n\
3853as operand @var{opno} of an expression with rtx code @var{outer_code}.\n\
3854That is, the hook can assume that there is some rtx @var{y} such\n\
3855that @samp{GET_CODE (@var{y}) == @var{outer_code}} and such that\n\
3856either (a) @samp{XEXP (@var{y}, @var{opno}) == @var{x}} or\n\
3857(b) @samp{XVEC (@var{y}, @var{opno})} contains @var{x}.\n\
3858\n\
3859@var{mode} is @var{x}'s machine mode, or for cases like @code{const_int} that\n\
3860do not have a mode, the mode in which @var{x} is used.\n\
3861\n\
3862In implementing this hook, you can use the construct\n\
3863@code{COSTS_N_INSNS (@var{n})} to specify a cost equal to @var{n} fast\n\
3864instructions.\n\
3865\n\
3866On entry to the hook, @code{*@var{total}} contains a default estimate\n\
3867for the cost of the expression. The hook should modify this value as\n\
3868necessary. Traditionally, the default costs are @code{COSTS_N_INSNS (5)}\n\
3869for multiplications, @code{COSTS_N_INSNS (7)} for division and modulus\n\
3870operations, and @code{COSTS_N_INSNS (1)} for all other operations.\n\
3871\n\
3872When optimizing for code size, i.e.@: when @code{speed} is\n\
3873false, this target hook should be used to estimate the relative\n\
3874size cost of an expression, again relative to @code{COSTS_N_INSNS}.\n\
3875\n\
3876The hook returns true when all subexpressions of @var{x} have been\n\
3877processed, and false when @code{rtx_cost} should recurse.",
3878 bool, (rtx x, machine_mode mode, int outer_code, int opno, int *total, bool speed),
3879 hook_bool_rtx_mode_int_int_intp_bool_false)
3880
3881/* Compute the cost of X, used as an address. Never called with
3882 invalid addresses. */
3883DEFHOOK
3884(address_cost,
3885 "This hook computes the cost of an addressing mode that contains\n\
3886@var{address}. If not defined, the cost is computed from\n\
3887the @var{address} expression and the @code{TARGET_RTX_COST} hook.\n\
3888\n\
3889For most CISC machines, the default cost is a good approximation of the\n\
3890true cost of the addressing mode. However, on RISC machines, all\n\
3891instructions normally have the same length and execution time. Hence\n\
3892all addresses will have equal costs.\n\
3893\n\
3894In cases where more than one form of an address is known, the form with\n\
3895the lowest cost will be used. If multiple forms have the same, lowest,\n\
3896cost, the one that is the most complex will be used.\n\
3897\n\
3898For example, suppose an address that is equal to the sum of a register\n\
3899and a constant is used twice in the same basic block. When this macro\n\
3900is not defined, the address will be computed in a register and memory\n\
3901references will be indirect through that register. On machines where\n\
3902the cost of the addressing mode containing the sum is no higher than\n\
3903that of a simple indirect reference, this will produce an additional\n\
3904instruction and possibly require an additional register. Proper\n\
3905specification of this macro eliminates this overhead for such machines.\n\
3906\n\
3907This hook is never called with an invalid address.\n\
3908\n\
3909On machines where an address involving more than one register is as\n\
3910cheap as an address computation involving only one register, defining\n\
3911@code{TARGET_ADDRESS_COST} to reflect this can cause two registers to\n\
3912be live over a region of code where only one would have been if\n\
3913@code{TARGET_ADDRESS_COST} were not defined in that manner. This effect\n\
3914should be considered in the definition of this macro. Equivalent costs\n\
3915should probably only be given to addresses with different numbers of\n\
3916registers on machines with lots of registers.",
3917 int, (rtx address, machine_mode mode, addr_space_t as, bool speed),
3918 default_address_cost)
3919
3920/* Compute a cost for INSN. */
3921DEFHOOK
3922(insn_cost,
3923 "This target hook describes the relative costs of RTL instructions.\n\
3924\n\
3925In implementing this hook, you can use the construct\n\
3926@code{COSTS_N_INSNS (@var{n})} to specify a cost equal to @var{n} fast\n\
3927instructions.\n\
3928\n\
3929When optimizing for code size, i.e.@: when @code{speed} is\n\
3930false, this target hook should be used to estimate the relative\n\
3931size cost of an expression, again relative to @code{COSTS_N_INSNS}.",
3932 int, (rtx_insn *insn, bool speed), NULL)
3933
3934/* Give a cost, in RTX Costs units, for an edge. Like BRANCH_COST, but with
3935 well defined units. */
3936DEFHOOK
3937(max_noce_ifcvt_seq_cost,
3938 "This hook returns a value in the same units as @code{TARGET_RTX_COSTS},\n\
3939giving the maximum acceptable cost for a sequence generated by the RTL\n\
3940if-conversion pass when conditional execution is not available.\n\
3941The RTL if-conversion pass attempts to convert conditional operations\n\
3942that would require a branch to a series of unconditional operations and\n\
3943@code{mov@var{mode}cc} insns. This hook returns the maximum cost of the\n\
3944unconditional instructions and the @code{mov@var{mode}cc} insns.\n\
3945RTL if-conversion is cancelled if the cost of the converted sequence\n\
3946is greater than the value returned by this hook.\n\
3947\n\
3948@code{e} is the edge between the basic block containing the conditional\n\
3949branch to the basic block which would be executed if the condition\n\
3950were true.\n\
3951\n\
3952The default implementation of this hook uses the\n\
3953@code{max-rtl-if-conversion-[un]predictable} parameters if they are set,\n\
3954and uses a multiple of @code{BRANCH_COST} otherwise.",
3955unsigned int, (edge e),
3956default_max_noce_ifcvt_seq_cost)
3957
3958/* Return true if the given instruction sequence is a good candidate
3959 as a replacement for the if-convertible sequence. */
3960DEFHOOK
3961(noce_conversion_profitable_p,
3962 "This hook returns true if the instruction sequence @code{seq} is a good\n\
3963candidate as a replacement for the if-convertible sequence described in\n\
3964@code{if_info}.",
3965bool, (rtx_insn *seq, struct noce_if_info *if_info),
3966default_noce_conversion_profitable_p)
3967
3968/* Return true if new_addr should be preferred over the existing address used by
3969 memref in insn. */
3970DEFHOOK
3971(new_address_profitable_p,
3972 "Return @code{true} if it is profitable to replace the address in\n\
3973@var{memref} with @var{new_addr}. This allows targets to prevent the\n\
3974scheduler from undoing address optimizations. The instruction containing the\n\
3975memref is @var{insn}. The default implementation returns @code{true}.",
3976bool, (rtx memref, rtx_insn * insn, rtx new_addr),
3977default_new_address_profitable_p)
3978
3979DEFHOOK
3980(estimated_poly_value,
3981 "Return an estimate of the runtime value of @var{val}, for use in\n\
3982things like cost calculations or profiling frequencies. @var{kind} is used\n\
3983to ask for the minimum, maximum, and likely estimates of the value through\n\
3984the @code{POLY_VALUE_MIN}, @code{POLY_VALUE_MAX} and\n\
3985@code{POLY_VALUE_LIKELY} values. The default\n\
3986implementation returns the lowest possible value of @var{val}.",
3987 HOST_WIDE_INT, (poly_int64 val, poly_value_estimate_kind kind),
3988 default_estimated_poly_value)
3989
3990/* Permit speculative instructions in delay slots during delayed-branch
3991 scheduling. */
3992DEFHOOK
3993(no_speculation_in_delay_slots_p,
3994 "This predicate controls the use of the eager delay slot filler to disallow\n\
3995speculatively executed instructions being placed in delay slots. Targets\n\
3996such as certain MIPS architectures possess both branches with and without\n\
3997delay slots. As the eager delay slot filler can decrease performance,\n\
3998disabling it is beneficial when ordinary branches are available. Use of\n\
3999delay slot branches filled using the basic filler is often still desirable\n\
4000as the delay slot can hide a pipeline bubble.",
4001 bool, (void),
4002 hook_bool_void_false)
4003
4004/* Return where to allocate pseudo for a given hard register initial value. */
4005DEFHOOK
4006(allocate_initial_value,
4007 "\n\
4008When the initial value of a hard register has been copied in a pseudo\n\
4009register, it is often not necessary to actually allocate another register\n\
4010to this pseudo register, because the original hard register or a stack slot\n\
4011it has been saved into can be used. @code{TARGET_ALLOCATE_INITIAL_VALUE}\n\
4012is called at the start of register allocation once for each hard register\n\
4013that had its initial value copied by using\n\
4014@code{get_func_hard_reg_initial_val} or @code{get_hard_reg_initial_val}.\n\
4015Possible values are @code{NULL_RTX}, if you don't want\n\
4016to do any special allocation, a @code{REG} rtx---that would typically be\n\
4017the hard register itself, if it is known not to be clobbered---or a\n\
4018@code{MEM}.\n\
4019If you are returning a @code{MEM}, this is only a hint for the allocator;\n\
4020it might decide to use another register anyways.\n\
4021You may use @code{current_function_is_leaf} or \n\
4022@code{REG_N_SETS} in the hook to determine if the hard\n\
4023register in question will not be clobbered.\n\
4024The default value of this hook is @code{NULL}, which disables any special\n\
4025allocation.",
4026 rtx, (rtx hard_reg), NULL)
4027
4028/* Return nonzero if evaluating UNSPEC X might cause a trap.
4029 FLAGS has the same meaning as in rtlanal.cc: may_trap_p_1. */
4030DEFHOOK
4031(unspec_may_trap_p,
4032 "This target hook returns nonzero if @var{x}, an @code{unspec} or\n\
4033@code{unspec_volatile} operation, might cause a trap. Targets can use\n\
4034this hook to enhance precision of analysis for @code{unspec} and\n\
4035@code{unspec_volatile} operations. You may call @code{may_trap_p_1}\n\
4036to analyze inner elements of @var{x} in which case @var{flags} should be\n\
4037passed along.",
4038 int, (const_rtx x, unsigned flags),
4039 default_unspec_may_trap_p)
4040
4041/* Given a register, this hook should return a parallel of registers
4042 to represent where to find the register pieces. Define this hook
4043 if the register and its mode are represented in Dwarf in
4044 non-contiguous locations, or if the register should be
4045 represented in more than one register in Dwarf. Otherwise, this
4046 hook should return NULL_RTX. */
4047DEFHOOK
4048(dwarf_register_span,
4049 "Given a register, this hook should return a parallel of registers to\n\
4050represent where to find the register pieces. Define this hook if the\n\
4051register and its mode are represented in Dwarf in non-contiguous\n\
4052locations, or if the register should be represented in more than one\n\
4053register in Dwarf. Otherwise, this hook should return @code{NULL_RTX}.\n\
4054If not defined, the default is to return @code{NULL_RTX}.",
4055 rtx, (rtx reg),
4056 hook_rtx_rtx_null)
4057
4058/* Given a register return the mode of the corresponding DWARF frame
4059 register. */
4060DEFHOOK
4061(dwarf_frame_reg_mode,
4062 "Given a register, this hook should return the mode which the\n\
4063corresponding Dwarf frame register should have. This is normally\n\
4064used to return a smaller mode than the raw mode to prevent call\n\
4065clobbered parts of a register altering the frame register size",
4066 machine_mode, (int regno),
4067 default_dwarf_frame_reg_mode)
4068
4069/* If expand_builtin_init_dwarf_reg_sizes needs to fill in table
4070 entries not corresponding directly to registers below
4071 FIRST_PSEUDO_REGISTER, this hook should generate the necessary
4072 code, given the address of the table. */
4073DEFHOOK
4074(init_dwarf_reg_sizes_extra,
4075 "If some registers are represented in Dwarf-2 unwind information in\n\
4076multiple pieces, define this hook to fill in information about the\n\
4077sizes of those pieces in the table used by the unwinder at runtime.\n\
4078It will be called by @code{expand_builtin_init_dwarf_reg_sizes} after\n\
4079filling in a single size corresponding to each hard register;\n\
4080@var{address} is the address of the table.",
4081 void, (tree address),
4082 hook_void_tree)
4083
4084/* Fetch the fixed register(s) which hold condition codes, for
4085 targets where it makes sense to look for duplicate assignments to
4086 the condition codes. This should return true if there is such a
4087 register, false otherwise. The arguments should be set to the
4088 fixed register numbers. Up to two condition code registers are
4089 supported. If there is only one for this target, the int pointed
4090 at by the second argument should be set to -1. */
4091DEFHOOK
4092(fixed_condition_code_regs,
4093 "On targets which use a hard\n\
4094register rather than a pseudo-register to hold condition codes, the\n\
4095regular CSE passes are often not able to identify cases in which the\n\
4096hard register is set to a common value. Use this hook to enable a\n\
4097small pass which optimizes such cases. This hook should return true\n\
4098to enable this pass, and it should set the integers to which its\n\
4099arguments point to the hard register numbers used for condition codes.\n\
4100When there is only one such register, as is true on most systems, the\n\
4101integer pointed to by @var{p2} should be set to\n\
4102@code{INVALID_REGNUM}.\n\
4103\n\
4104The default version of this hook returns false.",
4105 bool, (unsigned int *p1, unsigned int *p2),
4106 hook_bool_uintp_uintp_false)
4107
4108/* If two condition code modes are compatible, return a condition
4109 code mode which is compatible with both, such that a comparison
4110 done in the returned mode will work for both of the original
4111 modes. If the condition code modes are not compatible, return
4112 VOIDmode. */
4113DEFHOOK
4114(cc_modes_compatible,
4115 "On targets which use multiple condition code modes in class\n\
4116@code{MODE_CC}, it is sometimes the case that a comparison can be\n\
4117validly done in more than one mode. On such a system, define this\n\
4118target hook to take two mode arguments and to return a mode in which\n\
4119both comparisons may be validly done. If there is no such mode,\n\
4120return @code{VOIDmode}.\n\
4121\n\
4122The default version of this hook checks whether the modes are the\n\
4123same. If they are, it returns that mode. If they are different, it\n\
4124returns @code{VOIDmode}.",
4125 machine_mode, (machine_mode m1, machine_mode m2),
4126 default_cc_modes_compatible)
4127
4128/* Do machine-dependent code transformations. Called just before
4129 delayed-branch scheduling. */
4130DEFHOOK
4131(machine_dependent_reorg,
4132 "If non-null, this hook performs a target-specific pass over the\n\
4133instruction stream. The compiler will run it at all optimization levels,\n\
4134just before the point at which it normally does delayed-branch scheduling.\n\
4135\n\
4136The exact purpose of the hook varies from target to target. Some use\n\
4137it to do transformations that are necessary for correctness, such as\n\
4138laying out in-function constant pools or avoiding hardware hazards.\n\
4139Others use it as an opportunity to do some machine-dependent optimizations.\n\
4140\n\
4141You need not implement the hook if it has nothing to do. The default\n\
4142definition is null.",
4143 void, (void), NULL)
4144
4145/* Create the __builtin_va_list type. */
4146DEFHOOK
4147(build_builtin_va_list,
4148 "This hook returns a type node for @code{va_list} for the target.\n\
4149The default version of the hook returns @code{void*}.",
4150 tree, (void),
4151 std_build_builtin_va_list)
4152
4153/* Enumerate the va list variants. */
4154DEFHOOK
4155(enum_va_list_p,
4156 "This target hook is used in function @code{c_common_nodes_and_builtins}\n\
4157to iterate through the target specific builtin types for va_list. The\n\
4158variable @var{idx} is used as iterator. @var{pname} has to be a pointer\n\
4159to a @code{const char *} and @var{ptree} a pointer to a @code{tree} typed\n\
4160variable.\n\
4161The arguments @var{pname} and @var{ptree} are used to store the result of\n\
4162this macro and are set to the name of the va_list builtin type and its\n\
4163internal type.\n\
4164If the return value of this macro is zero, then there is no more element.\n\
4165Otherwise the @var{IDX} should be increased for the next call of this\n\
4166macro to iterate through all types.",
4167 int, (int idx, const char **pname, tree *ptree),
4168 NULL)
4169
4170/* Get the cfun/fndecl calling abi __builtin_va_list type. */
4171DEFHOOK
4172(fn_abi_va_list,
4173 "This hook returns the va_list type of the calling convention specified by\n\
4174@var{fndecl}.\n\
4175The default version of this hook returns @code{va_list_type_node}.",
4176 tree, (tree fndecl),
4177 std_fn_abi_va_list)
4178
4179/* Get the __builtin_va_list type dependent on input type. */
4180DEFHOOK
4181(canonical_va_list_type,
4182 "This hook returns the va_list type of the calling convention specified by the\n\
4183type of @var{type}. If @var{type} is not a valid va_list type, it returns\n\
4184@code{NULL_TREE}.",
4185 tree, (tree type),
4186 std_canonical_va_list_type)
4187
4188/* ??? Documenting this hook requires a GFDL license grant. */
4189DEFHOOK_UNDOC
4190(expand_builtin_va_start,
4191"Expand the @code{__builtin_va_start} builtin.",
4192 void, (tree valist, rtx nextarg), NULL)
4193
4194/* Gimplifies a VA_ARG_EXPR. */
4195DEFHOOK
4196(gimplify_va_arg_expr,
4197 "This hook performs target-specific gimplification of\n\
4198@code{VA_ARG_EXPR}. The first two parameters correspond to the\n\
4199arguments to @code{va_arg}; the latter two are as in\n\
4200@code{gimplify.cc:gimplify_expr}.",
4201 tree, (tree valist, tree type, gimple_seq *pre_p, gimple_seq *post_p),
4202 std_gimplify_va_arg_expr)
4203
4204/* Validity-checking routines for PCH files, target-specific.
4205 get_pch_validity returns a pointer to the data to be stored,
4206 and stores the size in its argument. pch_valid_p gets the same
4207 information back and returns NULL if the PCH is valid,
4208 or an error message if not. */
4209DEFHOOK
4210(get_pch_validity,
4211 "This hook returns a pointer to the data needed by\n\
4212@code{TARGET_PCH_VALID_P} and sets\n\
4213@samp{*@var{sz}} to the size of the data in bytes.",
4214 void *, (size_t *sz),
4215 default_get_pch_validity)
4216
4217DEFHOOK
4218(pch_valid_p,
4219 "This hook checks whether the options used to create a PCH file are\n\
4220compatible with the current settings. It returns @code{NULL}\n\
4221if so and a suitable error message if not. Error messages will\n\
4222be presented to the user and must be localized using @samp{_(@var{msg})}.\n\
4223\n\
4224@var{data} is the data that was returned by @code{TARGET_GET_PCH_VALIDITY}\n\
4225when the PCH file was created and @var{sz} is the size of that data in bytes.\n\
4226It's safe to assume that the data was created by the same version of the\n\
4227compiler, so no format checking is needed.\n\
4228\n\
4229The default definition of @code{default_pch_valid_p} should be\n\
4230suitable for most targets.",
4231 const char *, (const void *data, size_t sz),
4232 default_pch_valid_p)
4233
4234DEFHOOK
4235(prepare_pch_save,
4236 "Called before writing out a PCH file. If the target has some\n\
4237garbage-collected data that needs to be in a particular state on PCH loads,\n\
4238it can use this hook to enforce that state. Very few targets need\n\
4239to do anything here.",
4240 void, (void),
4241 hook_void_void)
4242
4243/* If nonnull, this function checks whether a PCH file with the
4244 given set of target flags can be used. It returns NULL if so,
4245 otherwise it returns an error message. */
4246DEFHOOK
4247(check_pch_target_flags,
4248 "If this hook is nonnull, the default implementation of\n\
4249@code{TARGET_PCH_VALID_P} will use it to check for compatible values\n\
4250of @code{target_flags}. @var{pch_flags} specifies the value that\n\
4251@code{target_flags} had when the PCH file was created. The return\n\
4252value is the same as for @code{TARGET_PCH_VALID_P}.",
4253 const char *, (int pch_flags), NULL)
4254
4255/* True if the compiler should give an enum type only as many
4256 bytes as it takes to represent the range of possible values of
4257 that type. */
4258DEFHOOK
4259(default_short_enums,
4260 "This target hook should return true if the compiler should give an\n\
4261@code{enum} type only as many bytes as it takes to represent the range\n\
4262of possible values of that type. It should return false if all\n\
4263@code{enum} types should be allocated like @code{int}.\n\
4264\n\
4265The default is to return false.",
4266 bool, (void),
4267 hook_bool_void_false)
4268
4269/* This target hook returns an rtx that is used to store the address
4270 of the current frame into the built-in setjmp buffer. */
4271DEFHOOK
4272(builtin_setjmp_frame_value,
4273 "This target hook should return an rtx that is used to store\n\
4274the address of the current frame into the built in @code{setjmp} buffer.\n\
4275The default value, @code{virtual_stack_vars_rtx}, is correct for most\n\
4276machines. One reason you may need to define this target hook is if\n\
4277@code{hard_frame_pointer_rtx} is the appropriate value on your machine.",
4278 rtx, (void),
4279 default_builtin_setjmp_frame_value)
4280
4281/* This target hook should manipulate the outputs, inputs, constraints,
4282 and clobbers the port wishes for pre-processing the asm. */
4283DEFHOOK
4284(md_asm_adjust,
4285 "This target hook may add @dfn{clobbers} to @var{clobbers} and\n\
4286@var{clobbered_regs} for any hard regs the port wishes to automatically\n\
4287clobber for an asm. The @var{outputs} and @var{inputs} may be inspected\n\
4288to avoid clobbering a register that is already used by the asm. @var{loc}\n\
4289is the source location of the asm.\n\
4290\n\
4291It may modify the @var{outputs}, @var{inputs}, @var{input_modes}, and\n\
4292@var{constraints} as necessary for other pre-processing. In this case the\n\
4293return value is a sequence of insns to emit after the asm. Note that\n\
4294changes to @var{inputs} must be accompanied by the corresponding changes\n\
4295to @var{input_modes}.",
4296 rtx_insn *,
4297 (vec<rtx>& outputs, vec<rtx>& inputs, vec<machine_mode>& input_modes,
4298 vec<const char *>& constraints, vec<rtx>& clobbers,
4299 HARD_REG_SET& clobbered_regs, location_t loc),
4300 NULL)
4301
4302/* This target hook allows the backend to specify a calling convention
4303 in the debug information. This function actually returns an
4304 enum dwarf_calling_convention, but because of forward declarations
4305 and not wanting to include dwarf2.h everywhere target.h is included
4306 the function is being declared as an int. */
4307DEFHOOK
4308(dwarf_calling_convention,
4309 "Define this to enable the dwarf attribute @code{DW_AT_calling_convention} to\n\
4310be emitted for each function. Instead of an integer return the enum\n\
4311value for the @code{DW_CC_} tag.",
4312 int, (const_tree function),
4313 hook_int_const_tree_0)
4314
4315/* This target hook allows the backend to emit frame-related insns that
4316 contain UNSPECs or UNSPEC_VOLATILEs. The call frame debugging info
4317 engine will invoke it on insns of the form
4318 (set (reg) (unspec [...] UNSPEC_INDEX))
4319 and
4320 (set (reg) (unspec_volatile [...] UNSPECV_INDEX))
4321 to let the backend emit the call frame instructions. */
4322DEFHOOK
4323(dwarf_handle_frame_unspec,
4324 "This target hook allows the backend to emit frame-related insns that\n\
4325contain UNSPECs or UNSPEC_VOLATILEs. The DWARF 2 call frame debugging\n\
4326info engine will invoke it on insns of the form\n\
4327@smallexample\n\
4328(set (reg) (unspec [@dots{}] UNSPEC_INDEX))\n\
4329@end smallexample\n\
4330and\n\
4331@smallexample\n\
4332(set (reg) (unspec_volatile [@dots{}] UNSPECV_INDEX)).\n\
4333@end smallexample\n\
4334to let the backend emit the call frame instructions. @var{label} is\n\
4335the CFI label attached to the insn, @var{pattern} is the pattern of\n\
4336the insn and @var{index} is @code{UNSPEC_INDEX} or @code{UNSPECV_INDEX}.",
4337 void, (const char *label, rtx pattern, int index), NULL)
4338
4339DEFHOOK
4340(dwarf_poly_indeterminate_value,
4341 "Express the value of @code{poly_int} indeterminate @var{i} as a DWARF\n\
4342expression, with @var{i} counting from 1. Return the number of a DWARF\n\
4343register @var{R} and set @samp{*@var{factor}} and @samp{*@var{offset}} such\n\
4344that the value of the indeterminate is:\n\
4345@smallexample\n\
4346value_of(@var{R}) / @var{factor} - @var{offset}\n\
4347@end smallexample\n\
4348\n\
4349A target only needs to define this hook if it sets\n\
4350@samp{NUM_POLY_INT_COEFFS} to a value greater than 1.",
4351 unsigned int, (unsigned int i, unsigned int *factor, int *offset),
4352 default_dwarf_poly_indeterminate_value)
4353
4354/* ??? Documenting this hook requires a GFDL license grant. */
4355DEFHOOK_UNDOC
4356(stdarg_optimize_hook,
4357"Perform architecture specific checking of statements gimplified\
4358 from @code{VA_ARG_EXPR}. @var{stmt} is the statement. Returns true if\
4359 the statement doesn't need to be checked for @code{va_list} references.",
4360 bool, (struct stdarg_info *ai, const gimple *stmt), NULL)
4361
4362/* This target hook allows the operating system to override the DECL
4363 that represents the external variable that contains the stack
4364 protection guard variable. The type of this DECL is ptr_type_node. */
4365DEFHOOK
4366(stack_protect_guard,
4367 "This hook returns a @code{DECL} node for the external variable to use\n\
4368for the stack protection guard. This variable is initialized by the\n\
4369runtime to some random value and is used to initialize the guard value\n\
4370that is placed at the top of the local stack frame. The type of this\n\
4371variable must be @code{ptr_type_node}.\n\
4372\n\
4373The default version of this hook creates a variable called\n\
4374@samp{__stack_chk_guard}, which is normally defined in @file{libgcc2.c}.",
4375 tree, (void),
4376 default_stack_protect_guard)
4377
4378/* This target hook allows the operating system to override the CALL_EXPR
4379 that is invoked when a check vs the guard variable fails. */
4380DEFHOOK
4381(stack_protect_fail,
4382 "This hook returns a @code{CALL_EXPR} that alerts the runtime that the\n\
4383stack protect guard variable has been modified. This expression should\n\
4384involve a call to a @code{noreturn} function.\n\
4385\n\
4386The default version of this hook invokes a function called\n\
4387@samp{__stack_chk_fail}, taking no arguments. This function is\n\
4388normally defined in @file{libgcc2.c}.",
4389 tree, (void),
4390 default_external_stack_protect_fail)
4391
4392/* This target hook allows the operating system to disable the default stack
4393 protector runtime support. */
4394DEFHOOK
4395(stack_protect_runtime_enabled_p,
4396 "Returns true if the target wants GCC's default stack protect runtime support,\n\
4397otherwise return false. The default implementation always returns true.",
4398 bool, (void),
4399 hook_bool_void_true)
4400
4401DEFHOOK
4402(have_speculation_safe_value,
4403"This hook is used to determine the level of target support for\n\
4404 @code{__builtin_speculation_safe_value}. If called with an argument\n\
4405 of false, it returns true if the target has been modified to support\n\
4406 this builtin. If called with an argument of true, it returns true\n\
4407 if the target requires active mitigation execution might be speculative.\n\
4408 \n\
4409 The default implementation returns false if the target does not define\n\
4410 a pattern named @code{speculation_barrier}. Else it returns true\n\
4411 for the first case and whether the pattern is enabled for the current\n\
4412 compilation for the second case.\n\
4413 \n\
4414 For targets that have no processors that can execute instructions\n\
4415 speculatively an alternative implemenation of this hook is available:\n\
4416 simply redefine this hook to @code{speculation_safe_value_not_needed}\n\
4417 along with your other target hooks.",
4418bool, (bool active), default_have_speculation_safe_value)
4419
4420DEFHOOK
4421(speculation_safe_value,
4422"This target hook can be used to generate a target-specific code\n\
4423 sequence that implements the @code{__builtin_speculation_safe_value}\n\
4424 built-in function. The function must always return @var{val} in\n\
4425 @var{result} in mode @var{mode} when the cpu is not executing\n\
4426 speculatively, but must never return that when speculating until it\n\
4427 is known that the speculation will not be unwound. The hook supports\n\
4428 two primary mechanisms for implementing the requirements. The first\n\
4429 is to emit a speculation barrier which forces the processor to wait\n\
4430 until all prior speculative operations have been resolved; the second\n\
4431 is to use a target-specific mechanism that can track the speculation\n\
4432 state and to return @var{failval} if it can determine that\n\
4433 speculation must be unwound at a later time.\n\
4434 \n\
4435 The default implementation simply copies @var{val} to @var{result} and\n\
4436 emits a @code{speculation_barrier} instruction if that is defined.",
4437rtx, (machine_mode mode, rtx result, rtx val, rtx failval),
4438 default_speculation_safe_value)
4439
4440DEFHOOK
4441(predict_doloop_p,
4442 "Return true if we can predict it is possible to use a low-overhead loop\n\
4443for a particular loop. The parameter @var{loop} is a pointer to the loop.\n\
4444This target hook is required only when the target supports low-overhead\n\
4445loops, and will help ivopts to make some decisions.\n\
4446The default version of this hook returns false.",
4447 bool, (class loop *loop),
4448 default_predict_doloop_p)
4449
4450DEFHOOKPOD
4451(have_count_reg_decr_p,
4452 "Return true if the target supports hardware count register for decrement\n\
4453and branch.\n\
4454The default value is false.",
4455 bool, false)
4456
4457DEFHOOKPOD
4458(doloop_cost_for_generic,
4459 "One IV candidate dedicated for doloop is introduced in IVOPTs, we can\n\
4460calculate the computation cost of adopting it to any generic IV use by\n\
4461function get_computation_cost as before. But for targets which have\n\
4462hardware count register support for decrement and branch, it may have to\n\
4463move IV value from hardware count register to general purpose register\n\
4464while doloop IV candidate is used for generic IV uses. It probably takes\n\
4465expensive penalty. This hook allows target owners to define the cost for\n\
4466this especially for generic IV uses.\n\
4467The default value is zero.",
4468 int64_t, 0)
4469
4470DEFHOOKPOD
4471(doloop_cost_for_address,
4472 "One IV candidate dedicated for doloop is introduced in IVOPTs, we can\n\
4473calculate the computation cost of adopting it to any address IV use by\n\
4474function get_computation_cost as before. But for targets which have\n\
4475hardware count register support for decrement and branch, it may have to\n\
4476move IV value from hardware count register to general purpose register\n\
4477while doloop IV candidate is used for address IV uses. It probably takes\n\
4478expensive penalty. This hook allows target owners to define the cost for\n\
4479this escpecially for address IV uses.\n\
4480The default value is zero.",
4481 int64_t, 0)
4482
4483DEFHOOK
4484(can_use_doloop_p,
4485 "Return true if it is possible to use low-overhead loops (@code{doloop_end}\n\
4486and @code{doloop_begin}) for a particular loop. @var{iterations} gives the\n\
4487exact number of iterations, or 0 if not known. @var{iterations_max} gives\n\
4488the maximum number of iterations, or 0 if not known. @var{loop_depth} is\n\
4489the nesting depth of the loop, with 1 for innermost loops, 2 for loops that\n\
4490contain innermost loops, and so on. @var{entered_at_top} is true if the\n\
4491loop is only entered from the top.\n\
4492\n\
4493This hook is only used if @code{doloop_end} is available. The default\n\
4494implementation returns true. You can use @code{can_use_doloop_if_innermost}\n\
4495if the loop must be the innermost, and if there are no other restrictions.",
4496 bool, (const widest_int &iterations, const widest_int &iterations_max,
4497 unsigned int loop_depth, bool entered_at_top),
4498 hook_bool_wint_wint_uint_bool_true)
4499
4500/* Returns NULL if target supports the insn within a doloop block,
4501 otherwise it returns an error message. */
4502DEFHOOK
4503(invalid_within_doloop,
4504 "\n\
4505Take an instruction in @var{insn} and return NULL if it is valid within a\n\
4506low-overhead loop, otherwise return a string explaining why doloop\n\
4507could not be applied.\n\
4508\n\
4509Many targets use special registers for low-overhead looping. For any\n\
4510instruction that clobbers these this function should return a string indicating\n\
4511the reason why the doloop could not be applied.\n\
4512By default, the RTL loop optimizer does not use a present doloop pattern for\n\
4513loops containing function calls or branch on table instructions.",
4514 const char *, (const rtx_insn *insn),
4515 default_invalid_within_doloop)
4516
4517/* Returns the machine mode which the target prefers for doloop IV. */
4518DEFHOOK
4519(preferred_doloop_mode,
4520"This hook takes a @var{mode} for a doloop IV, where @code{mode} is the\n\
4521original mode for the operation. If the target prefers an alternate\n\
4522@code{mode} for the operation, then this hook should return that mode;\n\
4523otherwise the original @code{mode} should be returned. For example, on a\n\
452464-bit target, @code{DImode} might be preferred over @code{SImode}. Both the\n\
4525original and the returned modes should be @code{MODE_INT}.",
4526 machine_mode,
4527 (machine_mode mode),
4528 default_preferred_doloop_mode)
4529
4530/* Returns true for a legitimate combined insn. */
4531DEFHOOK
4532(legitimate_combined_insn,
4533"Take an instruction in @var{insn} and return @code{false} if the instruction\n\
4534is not appropriate as a combination of two or more instructions. The\n\
4535default is to accept all instructions.",
4536 bool, (rtx_insn *insn),
4537 hook_bool_rtx_insn_true)
4538
4539DEFHOOK
4540(valid_dllimport_attribute_p,
4541"@var{decl} is a variable or function with @code{__attribute__((dllimport))}\n\
4542specified. Use this hook if the target needs to add extra validation\n\
4543checks to @code{handle_dll_attribute}.",
4544 bool, (const_tree decl),
4545 hook_bool_const_tree_true)
4546
4547/* If non-zero, align constant anchors in CSE to a multiple of this
4548 value. */
4549DEFHOOKPOD
4550(const_anchor,
4551 "On some architectures it can take multiple instructions to synthesize\n\
4552a constant. If there is another constant already in a register that\n\
4553is close enough in value then it is preferable that the new constant\n\
4554is computed from this register using immediate addition or\n\
4555subtraction. We accomplish this through CSE. Besides the value of\n\
4556the constant we also add a lower and an upper constant anchor to the\n\
4557available expressions. These are then queried when encountering new\n\
4558constants. The anchors are computed by rounding the constant up and\n\
4559down to a multiple of the value of @code{TARGET_CONST_ANCHOR}.\n\
4560@code{TARGET_CONST_ANCHOR} should be the maximum positive value\n\
4561accepted by immediate-add plus one. We currently assume that the\n\
4562value of @code{TARGET_CONST_ANCHOR} is a power of 2. For example, on\n\
4563MIPS, where add-immediate takes a 16-bit signed value,\n\
4564@code{TARGET_CONST_ANCHOR} is set to @samp{0x8000}. The default value\n\
4565is zero, which disables this optimization.",
4566 unsigned HOST_WIDE_INT, 0)
4567
4568/* Defines, which target-dependent bits (upper 16) are used by port */
4569DEFHOOK
4570(memmodel_check,
4571 "Validate target specific memory model mask bits. When NULL no target specific\n\
4572memory model bits are allowed.",
4573 unsigned HOST_WIDE_INT, (unsigned HOST_WIDE_INT val), NULL)
4574
4575/* Defines an offset bitwise ored into shifted address to get corresponding
4576 Address Sanitizer shadow address, or -1 if Address Sanitizer is not
4577 supported by the target. */
4578DEFHOOK
4579(asan_shadow_offset,
4580 "Return the offset bitwise ored into shifted address to get corresponding\n\
4581Address Sanitizer shadow memory address. NULL if Address Sanitizer is not\n\
4582supported by the target. May return 0 if Address Sanitizer is not supported\n\
4583by a subtarget.",
4584 unsigned HOST_WIDE_INT, (void),
4585 NULL)
4586
4587/* Functions relating to calls - argument passing, returns, etc. */
4588/* Members of struct call have no special macro prefix. */
4589HOOK_VECTOR (TARGET_CALLS, calls)
4590
4591DEFHOOK
4592(promote_function_mode,
4593 "Like @code{PROMOTE_MODE}, but it is applied to outgoing function arguments or\n\
4594function return values. The target hook should return the new mode\n\
4595and possibly change @code{*@var{punsignedp}} if the promotion should\n\
4596change signedness. This function is called only for scalar @emph{or\n\
4597pointer} types.\n\
4598\n\
4599@var{for_return} allows to distinguish the promotion of arguments and\n\
4600return values. If it is @code{1}, a return value is being promoted and\n\
4601@code{TARGET_FUNCTION_VALUE} must perform the same promotions done here.\n\
4602If it is @code{2}, the returned mode should be that of the register in\n\
4603which an incoming parameter is copied, or the outgoing result is computed;\n\
4604then the hook should return the same mode as @code{promote_mode}, though\n\
4605the signedness may be different.\n\
4606\n\
4607@var{type} can be NULL when promoting function arguments of libcalls.\n\
4608\n\
4609The default is to not promote arguments and return values. You can\n\
4610also define the hook to @code{default_promote_function_mode_always_promote}\n\
4611if you would like to apply the same rules given by @code{PROMOTE_MODE}.",
4612 machine_mode, (const_tree type, machine_mode mode, int *punsignedp,
4613 const_tree funtype, int for_return),
4614 default_promote_function_mode)
4615
4616DEFHOOK
4617(promote_prototypes,
4618 "This target hook returns @code{true} if an argument declared in a\n\
4619prototype as an integral type smaller than @code{int} should actually be\n\
4620passed as an @code{int}. In addition to avoiding errors in certain\n\
4621cases of mismatch, it also makes for better code on certain machines.\n\
4622The default is to not promote prototypes.",
4623 bool, (const_tree fntype),
4624 hook_bool_const_tree_false)
4625
4626DEFHOOK
4627(struct_value_rtx,
4628 "This target hook should return the location of the structure value\n\
4629address (normally a @code{mem} or @code{reg}), or 0 if the address is\n\
4630passed as an ``invisible'' first argument. Note that @var{fndecl} may\n\
4631be @code{NULL}, for libcalls. You do not need to define this target\n\
4632hook if the address is always passed as an ``invisible'' first\n\
4633argument.\n\
4634\n\
4635On some architectures the place where the structure value address\n\
4636is found by the called function is not the same place that the\n\
4637caller put it. This can be due to register windows, or it could\n\
4638be because the function prologue moves it to a different place.\n\
4639@var{incoming} is @code{1} or @code{2} when the location is needed in\n\
4640the context of the called function, and @code{0} in the context of\n\
4641the caller.\n\
4642\n\
4643If @var{incoming} is nonzero and the address is to be found on the\n\
4644stack, return a @code{mem} which refers to the frame pointer. If\n\
4645@var{incoming} is @code{2}, the result is being used to fetch the\n\
4646structure value address at the beginning of a function. If you need\n\
4647to emit adjusting code, you should do it at this point.",
4648 rtx, (tree fndecl, int incoming),
4649 hook_rtx_tree_int_null)
4650
4651DEFHOOKPOD
4652(omit_struct_return_reg,
4653 "Normally, when a function returns a structure by memory, the address\n\
4654is passed as an invisible pointer argument, but the compiler also\n\
4655arranges to return the address from the function like it would a normal\n\
4656pointer return value. Define this to true if that behavior is\n\
4657undesirable on your target.",
4658 bool, false)
4659
4660DEFHOOK
4661(return_in_memory,
4662 "This target hook should return a nonzero value to say to return the\n\
4663function value in memory, just as large structures are always returned.\n\
4664Here @var{type} will be the data type of the value, and @var{fntype}\n\
4665will be the type of the function doing the returning, or @code{NULL} for\n\
4666libcalls.\n\
4667\n\
4668Note that values of mode @code{BLKmode} must be explicitly handled\n\
4669by this function. Also, the option @option{-fpcc-struct-return}\n\
4670takes effect regardless of this macro. On most systems, it is\n\
4671possible to leave the hook undefined; this causes a default\n\
4672definition to be used, whose value is the constant 1 for @code{BLKmode}\n\
4673values, and 0 otherwise.\n\
4674\n\
4675Do not use this hook to indicate that structures and unions should always\n\
4676be returned in memory. You should instead use @code{DEFAULT_PCC_STRUCT_RETURN}\n\
4677to indicate this.",
4678 bool, (const_tree type, const_tree fntype),
4679 default_return_in_memory)
4680
4681DEFHOOK
4682(return_in_msb,
4683 "This hook should return true if values of type @var{type} are returned\n\
4684at the most significant end of a register (in other words, if they are\n\
4685padded at the least significant end). You can assume that @var{type}\n\
4686is returned in a register; the caller is required to check this.\n\
4687\n\
4688Note that the register provided by @code{TARGET_FUNCTION_VALUE} must\n\
4689be able to hold the complete return value. For example, if a 1-, 2-\n\
4690or 3-byte structure is returned at the most significant end of a\n\
46914-byte register, @code{TARGET_FUNCTION_VALUE} should provide an\n\
4692@code{SImode} rtx.",
4693 bool, (const_tree type),
4694 hook_bool_const_tree_false)
4695
4696/* Return true if a parameter must be passed by reference. TYPE may
4697 be null if this is a libcall. CA may be null if this query is
4698 from __builtin_va_arg. */
4699DEFHOOK
4700(pass_by_reference,
4701 "This target hook should return @code{true} if argument @var{arg} at the\n\
4702position indicated by @var{cum} should be passed by reference. This\n\
4703predicate is queried after target independent reasons for being\n\
4704passed by reference, such as @code{TREE_ADDRESSABLE (@var{arg}.type)}.\n\
4705\n\
4706If the hook returns true, a copy of that argument is made in memory and a\n\
4707pointer to the argument is passed instead of the argument itself.\n\
4708The pointer is passed in whatever way is appropriate for passing a pointer\n\
4709to that type.",
4710 bool,
4711 (cumulative_args_t cum, const function_arg_info &arg),
4712 hook_bool_CUMULATIVE_ARGS_arg_info_false)
4713
4714DEFHOOK
4715(expand_builtin_saveregs,
4716 "If defined, this hook produces the machine-specific code for a call to\n\
4717@code{__builtin_saveregs}. This code will be moved to the very\n\
4718beginning of the function, before any parameter access are made. The\n\
4719return value of this function should be an RTX that contains the value\n\
4720to use as the return of @code{__builtin_saveregs}.",
4721 rtx, (void),
4722 default_expand_builtin_saveregs)
4723
4724/* Returns pretend_argument_size. */
4725DEFHOOK
4726(setup_incoming_varargs,
4727 "This target hook offers an alternative to using\n\
4728@code{__builtin_saveregs} and defining the hook\n\
4729@code{TARGET_EXPAND_BUILTIN_SAVEREGS}. Use it to store the anonymous\n\
4730register arguments into the stack so that all the arguments appear to\n\
4731have been passed consecutively on the stack. Once this is done, you can\n\
4732use the standard implementation of varargs that works for machines that\n\
4733pass all their arguments on the stack.\n\
4734\n\
4735The argument @var{args_so_far} points to the @code{CUMULATIVE_ARGS} data\n\
4736structure, containing the values that are obtained after processing the\n\
4737named arguments. The argument @var{arg} describes the last of these named\n\
4738arguments. The argument @var{arg} should not be used if the function type\n\
4739satisfies @code{TYPE_NO_NAMED_ARGS_STDARG_P}, since in that case there are\n\
4740no named arguments and all arguments are accessed with @code{va_arg}.\n\
4741\n\
4742The target hook should do two things: first, push onto the stack all the\n\
4743argument registers @emph{not} used for the named arguments, and second,\n\
4744store the size of the data thus pushed into the @code{int}-valued\n\
4745variable pointed to by @var{pretend_args_size}. The value that you\n\
4746store here will serve as additional offset for setting up the stack\n\
4747frame.\n\
4748\n\
4749Because you must generate code to push the anonymous arguments at\n\
4750compile time without knowing their data types,\n\
4751@code{TARGET_SETUP_INCOMING_VARARGS} is only useful on machines that\n\
4752have just a single category of argument register and use it uniformly\n\
4753for all data types.\n\
4754\n\
4755If the argument @var{second_time} is nonzero, it means that the\n\
4756arguments of the function are being analyzed for the second time. This\n\
4757happens for an inline function, which is not actually compiled until the\n\
4758end of the source file. The hook @code{TARGET_SETUP_INCOMING_VARARGS} should\n\
4759not generate any instructions in this case.",
4760 void, (cumulative_args_t args_so_far, const function_arg_info &arg,
4761 int *pretend_args_size, int second_time),
4762 default_setup_incoming_varargs)
4763
4764DEFHOOK
4765(call_args,
4766 "While generating RTL for a function call, this target hook is invoked once\n\
4767for each argument passed to the function, either a register returned by\n\
4768@code{TARGET_FUNCTION_ARG} or a memory location. It is called just\n\
4769before the point where argument registers are stored. The type of the\n\
4770function to be called is also passed as the second argument; it is\n\
4771@code{NULL_TREE} for libcalls. The @code{TARGET_END_CALL_ARGS} hook is\n\
4772invoked just after the code to copy the return reg has been emitted.\n\
4773This functionality can be used to perform special setup of call argument\n\
4774registers if a target needs it.\n\
4775For functions without arguments, the hook is called once with @code{pc_rtx}\n\
4776passed instead of an argument register.\n\
4777Most ports do not need to implement anything for this hook.",
4778 void, (rtx, tree),
4779 hook_void_rtx_tree)
4780
4781DEFHOOK
4782(end_call_args,
4783 "This target hook is invoked while generating RTL for a function call,\n\
4784just after the point where the return reg is copied into a pseudo. It\n\
4785signals that all the call argument and return registers for the just\n\
4786emitted call are now no longer in use.\n\
4787Most ports do not need to implement anything for this hook.",
4788 void, (void),
4789 hook_void_void)
4790
4791DEFHOOK
4792(push_argument,
4793 "This target hook returns @code{true} if push instructions will be\n\
4794used to pass outgoing arguments. When the push instruction usage is\n\
4795optional, @var{npush} is nonzero to indicate the number of bytes to\n\
4796push. Otherwise, @var{npush} is zero. If the target machine does not\n\
4797have a push instruction or push instruction should be avoided,\n\
4798@code{false} should be returned. That directs GCC to use an alternate\n\
4799strategy: to allocate the entire argument block and then store the\n\
4800arguments into it. If this target hook may return @code{true},\n\
4801@code{PUSH_ROUNDING} must be defined.",
4802 bool, (unsigned int npush),
4803 default_push_argument)
4804
4805DEFHOOK
4806(strict_argument_naming,
4807 "Define this hook to return @code{true} if the location where a function\n\
4808argument is passed depends on whether or not it is a named argument.\n\
4809\n\
4810This hook controls how the @var{named} argument to @code{TARGET_FUNCTION_ARG}\n\
4811is set for varargs and stdarg functions. If this hook returns\n\
4812@code{true}, the @var{named} argument is always true for named\n\
4813arguments, and false for unnamed arguments. If it returns @code{false},\n\
4814but @code{TARGET_PRETEND_OUTGOING_VARARGS_NAMED} returns @code{true},\n\
4815then all arguments are treated as named. Otherwise, all named arguments\n\
4816except the last are treated as named.\n\
4817\n\
4818You need not define this hook if it always returns @code{false}.",
4819 bool, (cumulative_args_t ca),
4820 hook_bool_CUMULATIVE_ARGS_false)
4821
4822/* Returns true if we should use
4823 targetm.calls.setup_incoming_varargs() and/or
4824 targetm.calls.strict_argument_naming(). */
4825DEFHOOK
4826(pretend_outgoing_varargs_named,
4827 "If you need to conditionally change ABIs so that one works with\n\
4828@code{TARGET_SETUP_INCOMING_VARARGS}, but the other works like neither\n\
4829@code{TARGET_SETUP_INCOMING_VARARGS} nor @code{TARGET_STRICT_ARGUMENT_NAMING} was\n\
4830defined, then define this hook to return @code{true} if\n\
4831@code{TARGET_SETUP_INCOMING_VARARGS} is used, @code{false} otherwise.\n\
4832Otherwise, you should not define this hook.",
4833 bool, (cumulative_args_t ca),
4834 default_pretend_outgoing_varargs_named)
4835
4836/* Given a complex type T, return true if a parameter of type T
4837 should be passed as two scalars. */
4838DEFHOOK
4839(split_complex_arg,
4840 "This hook should return true if parameter of type @var{type} are passed\n\
4841as two scalar parameters. By default, GCC will attempt to pack complex\n\
4842arguments into the target's word size. Some ABIs require complex arguments\n\
4843to be split and treated as their individual components. For example, on\n\
4844AIX64, complex floats should be passed in a pair of floating point\n\
4845registers, even though a complex float would fit in one 64-bit floating\n\
4846point register.\n\
4847\n\
4848The default value of this hook is @code{NULL}, which is treated as always\n\
4849false.",
4850 bool, (const_tree type), NULL)
4851
4852/* Return true if type T, mode MODE, may not be passed in registers,
4853 but must be passed on the stack. */
4854/* ??? This predicate should be applied strictly after pass-by-reference.
4855 Need audit to verify that this is the case. */
4856DEFHOOK
4857(must_pass_in_stack,
4858 "This target hook should return @code{true} if we should not pass @var{arg}\n\
4859solely in registers. The file @file{expr.h} defines a\n\
4860definition that is usually appropriate, refer to @file{expr.h} for additional\n\
4861documentation.",
4862 bool, (const function_arg_info &arg),
4863 must_pass_in_stack_var_size_or_pad)
4864
4865/* Return true if type TYPE, mode MODE, which is passed by reference,
4866 should have the object copy generated by the callee rather than
4867 the caller. It is never called for TYPE requiring constructors. */
4868DEFHOOK
4869(callee_copies,
4870 "The function argument described by the parameters to this hook is\n\
4871known to be passed by reference. The hook should return true if the\n\
4872function argument should be copied by the callee instead of copied\n\
4873by the caller.\n\
4874\n\
4875For any argument for which the hook returns true, if it can be\n\
4876determined that the argument is not modified, then a copy need\n\
4877not be generated.\n\
4878\n\
4879The default version of this hook always returns false.",
4880 bool,
4881 (cumulative_args_t cum, const function_arg_info &arg),
4882 hook_bool_CUMULATIVE_ARGS_arg_info_false)
4883
4884/* Return zero for arguments passed entirely on the stack or entirely
4885 in registers. If passed in both, return the number of bytes passed
4886 in registers; the balance is therefore passed on the stack. */
4887DEFHOOK
4888(arg_partial_bytes,
4889 "This target hook returns the number of bytes at the beginning of an\n\
4890argument that must be put in registers. The value must be zero for\n\
4891arguments that are passed entirely in registers or that are entirely\n\
4892pushed on the stack.\n\
4893\n\
4894On some machines, certain arguments must be passed partially in\n\
4895registers and partially in memory. On these machines, typically the\n\
4896first few words of arguments are passed in registers, and the rest\n\
4897on the stack. If a multi-word argument (a @code{double} or a\n\
4898structure) crosses that boundary, its first few words must be passed\n\
4899in registers and the rest must be pushed. This macro tells the\n\
4900compiler when this occurs, and how many bytes should go in registers.\n\
4901\n\
4902@code{TARGET_FUNCTION_ARG} for these arguments should return the first\n\
4903register to be used by the caller for this argument; likewise\n\
4904@code{TARGET_FUNCTION_INCOMING_ARG}, for the called function.",
4905 int, (cumulative_args_t cum, const function_arg_info &arg),
4906 hook_int_CUMULATIVE_ARGS_arg_info_0)
4907
4908/* Update the state in CA to advance past an argument in the
4909 argument list. The values MODE, TYPE, and NAMED describe that
4910 argument. */
4911DEFHOOK
4912(function_arg_advance,
4913 "This hook updates the summarizer variable pointed to by @var{ca} to\n\
4914advance past argument @var{arg} in the argument list. Once this is done,\n\
4915the variable @var{cum} is suitable for analyzing the @emph{following}\n\
4916argument with @code{TARGET_FUNCTION_ARG}, etc.\n\
4917\n\
4918This hook need not do anything if the argument in question was passed\n\
4919on the stack. The compiler knows how to track the amount of stack space\n\
4920used for arguments without any special help.",
4921 void,
4922 (cumulative_args_t ca, const function_arg_info &arg),
4923 default_function_arg_advance)
4924
4925DEFHOOK
4926(function_arg_offset,
4927 "This hook returns the number of bytes to add to the offset of an\n\
4928argument of type @var{type} and mode @var{mode} when passed in memory.\n\
4929This is needed for the SPU, which passes @code{char} and @code{short}\n\
4930arguments in the preferred slot that is in the middle of the quad word\n\
4931instead of starting at the top. The default implementation returns 0.",
4932 HOST_WIDE_INT, (machine_mode mode, const_tree type),
4933 default_function_arg_offset)
4934
4935DEFHOOK
4936(function_arg_padding,
4937 "This hook determines whether, and in which direction, to pad out\n\
4938an argument of mode @var{mode} and type @var{type}. It returns\n\
4939@code{PAD_UPWARD} to insert padding above the argument, @code{PAD_DOWNWARD}\n\
4940to insert padding below the argument, or @code{PAD_NONE} to inhibit padding.\n\
4941\n\
4942The @emph{amount} of padding is not controlled by this hook, but by\n\
4943@code{TARGET_FUNCTION_ARG_ROUND_BOUNDARY}. It is always just enough\n\
4944to reach the next multiple of that boundary.\n\
4945\n\
4946This hook has a default definition that is right for most systems.\n\
4947For little-endian machines, the default is to pad upward. For\n\
4948big-endian machines, the default is to pad downward for an argument of\n\
4949constant size shorter than an @code{int}, and upward otherwise.",
4950 pad_direction, (machine_mode mode, const_tree type),
4951 default_function_arg_padding)
4952
4953/* Return zero if the argument described by the state of CA should
4954 be placed on a stack, or a hard register in which to store the
4955 argument. The values MODE, TYPE, and NAMED describe that
4956 argument. */
4957DEFHOOK
4958(function_arg,
4959 "Return an RTX indicating whether function argument @var{arg} is passed\n\
4960in a register and if so, which register. Argument @var{ca} summarizes all\n\
4961the previous arguments.\n\
4962\n\
4963The return value is usually either a @code{reg} RTX for the hard\n\
4964register in which to pass the argument, or zero to pass the argument\n\
4965on the stack.\n\
4966\n\
4967The value of the expression can also be a @code{parallel} RTX@. This is\n\
4968used when an argument is passed in multiple locations. The mode of the\n\
4969@code{parallel} should be the mode of the entire argument. The\n\
4970@code{parallel} holds any number of @code{expr_list} pairs; each one\n\
4971describes where part of the argument is passed. In each\n\
4972@code{expr_list} the first operand must be a @code{reg} RTX for the hard\n\
4973register in which to pass this part of the argument, and the mode of the\n\
4974register RTX indicates how large this part of the argument is. The\n\
4975second operand of the @code{expr_list} is a @code{const_int} which gives\n\
4976the offset in bytes into the entire argument of where this part starts.\n\
4977As a special exception the first @code{expr_list} in the @code{parallel}\n\
4978RTX may have a first operand of zero. This indicates that the entire\n\
4979argument is also stored on the stack.\n\
4980\n\
4981The last time this hook is called, it is called with @code{MODE ==\n\
4982VOIDmode}, and its result is passed to the @code{call} or @code{call_value}\n\
4983pattern as operands 2 and 3 respectively.\n\
4984\n\
4985@cindex @file{stdarg.h} and register arguments\n\
4986The usual way to make the ISO library @file{stdarg.h} work on a\n\
4987machine where some arguments are usually passed in registers, is to\n\
4988cause nameless arguments to be passed on the stack instead. This is\n\
4989done by making @code{TARGET_FUNCTION_ARG} return 0 whenever\n\
4990@var{named} is @code{false}.\n\
4991\n\
4992@cindex @code{TARGET_MUST_PASS_IN_STACK}, and @code{TARGET_FUNCTION_ARG}\n\
4993@cindex @code{REG_PARM_STACK_SPACE}, and @code{TARGET_FUNCTION_ARG}\n\
4994You may use the hook @code{targetm.calls.must_pass_in_stack}\n\
4995in the definition of this macro to determine if this argument is of a\n\
4996type that must be passed in the stack. If @code{REG_PARM_STACK_SPACE}\n\
4997is not defined and @code{TARGET_FUNCTION_ARG} returns nonzero for such an\n\
4998argument, the compiler will abort. If @code{REG_PARM_STACK_SPACE} is\n\
4999defined, the argument will be computed in the stack and then loaded into\n\
5000a register.",
5001 rtx, (cumulative_args_t ca, const function_arg_info &arg),
5002 default_function_arg)
5003
5004DEFHOOK
5005(function_incoming_arg,
5006 "Define this hook if the caller and callee on the target have different\n\
5007views of where arguments are passed. Also define this hook if there are\n\
5008functions that are never directly called, but are invoked by the hardware\n\
5009and which have nonstandard calling conventions.\n\
5010\n\
5011In this case @code{TARGET_FUNCTION_ARG} computes the register in\n\
5012which the caller passes the value, and\n\
5013@code{TARGET_FUNCTION_INCOMING_ARG} should be defined in a similar\n\
5014fashion to tell the function being called where the arguments will\n\
5015arrive.\n\
5016\n\
5017@code{TARGET_FUNCTION_INCOMING_ARG} can also return arbitrary address\n\
5018computation using hard register, which can be forced into a register,\n\
5019so that it can be used to pass special arguments.\n\
5020\n\
5021If @code{TARGET_FUNCTION_INCOMING_ARG} is not defined,\n\
5022@code{TARGET_FUNCTION_ARG} serves both purposes.",
5023 rtx, (cumulative_args_t ca, const function_arg_info &arg),
5024 default_function_incoming_arg)
5025
5026DEFHOOK
5027(function_arg_boundary,
5028 "This hook returns the alignment boundary, in bits, of an argument\n\
5029with the specified mode and type. The default hook returns\n\
5030@code{PARM_BOUNDARY} for all arguments.",
5031 unsigned int, (machine_mode mode, const_tree type),
5032 default_function_arg_boundary)
5033
5034DEFHOOK
5035(function_arg_round_boundary,
5036 "Normally, the size of an argument is rounded up to @code{PARM_BOUNDARY},\n\
5037which is the default value for this hook. You can define this hook to\n\
5038return a different value if an argument size must be rounded to a larger\n\
5039value.",
5040 unsigned int, (machine_mode mode, const_tree type),
5041 default_function_arg_round_boundary)
5042
5043/* Return the diagnostic message string if function without a prototype
5044 is not allowed for this 'val' argument; NULL otherwise. */
5045DEFHOOK
5046(invalid_arg_for_unprototyped_fn,
5047 "If defined, this macro returns the diagnostic message when it is\n\
5048illegal to pass argument @var{val} to function @var{funcdecl}\n\
5049with prototype @var{typelist}.",
5050 const char *, (const_tree typelist, const_tree funcdecl, const_tree val),
5051 hook_invalid_arg_for_unprototyped_fn)
5052
5053/* Return an rtx for the return value location of the function
5054 specified by FN_DECL_OR_TYPE with a return type of RET_TYPE. */
5055DEFHOOK
5056(function_value,
5057 "\n\
5058Define this to return an RTX representing the place where a function\n\
5059returns or receives a value of data type @var{ret_type}, a tree node\n\
5060representing a data type. @var{fn_decl_or_type} is a tree node\n\
5061representing @code{FUNCTION_DECL} or @code{FUNCTION_TYPE} of a\n\
5062function being called. If @var{outgoing} is false, the hook should\n\
5063compute the register in which the caller will see the return value.\n\
5064Otherwise, the hook should return an RTX representing the place where\n\
5065a function returns a value.\n\
5066\n\
5067On many machines, only @code{TYPE_MODE (@var{ret_type})} is relevant.\n\
5068(Actually, on most machines, scalar values are returned in the same\n\
5069place regardless of mode.) The value of the expression is usually a\n\
5070@code{reg} RTX for the hard register where the return value is stored.\n\
5071The value can also be a @code{parallel} RTX, if the return value is in\n\
5072multiple places. See @code{TARGET_FUNCTION_ARG} for an explanation of the\n\
5073@code{parallel} form. Note that the callee will populate every\n\
5074location specified in the @code{parallel}, but if the first element of\n\
5075the @code{parallel} contains the whole return value, callers will use\n\
5076that element as the canonical location and ignore the others. The m68k\n\
5077port uses this type of @code{parallel} to return pointers in both\n\
5078@samp{%a0} (the canonical location) and @samp{%d0}.\n\
5079\n\
5080If @code{TARGET_PROMOTE_FUNCTION_RETURN} returns true, you must apply\n\
5081the same promotion rules specified in @code{PROMOTE_MODE} if\n\
5082@var{valtype} is a scalar type.\n\
5083\n\
5084If the precise function being called is known, @var{func} is a tree\n\
5085node (@code{FUNCTION_DECL}) for it; otherwise, @var{func} is a null\n\
5086pointer. This makes it possible to use a different value-returning\n\
5087convention for specific functions when all their calls are\n\
5088known.\n\
5089\n\
5090Some target machines have ``register windows'' so that the register in\n\
5091which a function returns its value is not the same as the one in which\n\
5092the caller sees the value. For such machines, you should return\n\
5093different RTX depending on @var{outgoing}.\n\
5094\n\
5095@code{TARGET_FUNCTION_VALUE} is not used for return values with\n\
5096aggregate data types, because these are returned in another way. See\n\
5097@code{TARGET_STRUCT_VALUE_RTX} and related macros, below.",
5098 rtx, (const_tree ret_type, const_tree fn_decl_or_type, bool outgoing),
5099 default_function_value)
5100
5101/* Return the rtx for the result of a libcall of mode MODE,
5102 calling the function FN_NAME. */
5103DEFHOOK
5104(libcall_value,
5105 "Define this hook if the back-end needs to know the name of the libcall\n\
5106function in order to determine where the result should be returned.\n\
5107\n\
5108The mode of the result is given by @var{mode} and the name of the called\n\
5109library function is given by @var{fun}. The hook should return an RTX\n\
5110representing the place where the library function result will be returned.\n\
5111\n\
5112If this hook is not defined, then LIBCALL_VALUE will be used.",
5113 rtx, (machine_mode mode, const_rtx fun),
5114 default_libcall_value)
5115
5116/* Return true if REGNO is a possible register number for
5117 a function value as seen by the caller. */
5118DEFHOOK
5119(function_value_regno_p,
5120 "A target hook that return @code{true} if @var{regno} is the number of a hard\n\
5121register in which the values of called function may come back.\n\
5122\n\
5123A register whose use for returning values is limited to serving as the\n\
5124second of a pair (for a value of type @code{double}, say) need not be\n\
5125recognized by this target hook.\n\
5126\n\
5127If the machine has register windows, so that the caller and the called\n\
5128function use different registers for the return value, this target hook\n\
5129should recognize only the caller's register numbers.\n\
5130\n\
5131If this hook is not defined, then FUNCTION_VALUE_REGNO_P will be used.",
5132 bool, (const unsigned int regno),
5133 default_function_value_regno_p)
5134
5135DEFHOOK
5136(fntype_abi,
5137 "Return the ABI used by a function with type @var{type}; see the\n\
5138definition of @code{predefined_function_abi} for details of the ABI\n\
5139descriptor. Targets only need to define this hook if they support\n\
5140interoperability between several ABIs in the same translation unit.",
5141 const predefined_function_abi &, (const_tree type),
5142 NULL)
5143
5144DEFHOOK
5145(insn_callee_abi,
5146 "This hook returns a description of the ABI used by the target of\n\
5147call instruction @var{insn}; see the definition of\n\
5148@code{predefined_function_abi} for details of the ABI descriptor.\n\
5149Only the global function @code{insn_callee_abi} should call this hook\n\
5150directly.\n\
5151\n\
5152Targets only need to define this hook if they support\n\
5153interoperability between several ABIs in the same translation unit.",
5154 const predefined_function_abi &, (const rtx_insn *insn),
5155 NULL)
5156
5157/* ??? Documenting this hook requires a GFDL license grant. */
5158DEFHOOK_UNDOC
5159(internal_arg_pointer,
5160"Return an rtx for the argument pointer incoming to the\
5161 current function.",
5162 rtx, (void),
5163 default_internal_arg_pointer)
5164
5165/* Update the current function stack boundary if needed. */
5166DEFHOOK
5167(update_stack_boundary,
5168 "Define this macro to update the current function stack boundary if\n\
5169necessary.",
5170 void, (void), NULL)
5171
5172/* Handle stack alignment and return an rtx for Dynamic Realign
5173 Argument Pointer if necessary. */
5174DEFHOOK
5175(get_drap_rtx,
5176 "This hook should return an rtx for Dynamic Realign Argument Pointer (DRAP) if a\n\
5177different argument pointer register is needed to access the function's\n\
5178argument list due to stack realignment. Return @code{NULL} if no DRAP\n\
5179is needed.",
5180 rtx, (void), NULL)
5181
5182/* Generate instruction sequence to zero call used registers. */
5183DEFHOOK
5184(zero_call_used_regs,
5185 "This target hook emits instructions to zero the subset of @var{selected_regs}\n\
5186that could conceivably contain values that are useful to an attacker.\n\
5187Return the set of registers that were actually cleared.\n\
5188\n\
5189For most targets, the returned set of registers is a subset of\n\
5190@var{selected_regs}, however, for some of the targets (for example MIPS),\n\
5191clearing some registers that are in the @var{selected_regs} requires\n\
5192clearing other call used registers that are not in the @var{selected_regs},\n\
5193under such situation, the returned set of registers must be a subset of all\n\
5194call used registers.\n\
5195\n\
5196The default implementation uses normal move instructions to zero\n\
5197all the registers in @var{selected_regs}. Define this hook if the\n\
5198target has more efficient ways of zeroing certain registers,\n\
5199or if you believe that certain registers would never contain\n\
5200values that are useful to an attacker.",
5201 HARD_REG_SET, (HARD_REG_SET selected_regs),
5202default_zero_call_used_regs)
5203
5204/* Return true if all function parameters should be spilled to the
5205 stack. */
5206DEFHOOK
5207(allocate_stack_slots_for_args,
5208 "When optimization is disabled, this hook indicates whether or not\n\
5209arguments should be allocated to stack slots. Normally, GCC allocates\n\
5210stacks slots for arguments when not optimizing in order to make\n\
5211debugging easier. However, when a function is declared with\n\
5212@code{__attribute__((naked))}, there is no stack frame, and the compiler\n\
5213cannot safely move arguments from the registers in which they are passed\n\
5214to the stack. Therefore, this hook should return true in general, but\n\
5215false for naked functions. The default implementation always returns true.",
5216 bool, (void),
5217 hook_bool_void_true)
5218
5219/* Return an rtx for the static chain for FNDECL_OR_TYPE. If INCOMING_P
5220 is true, then it should be for the callee; otherwise for the caller. */
5221DEFHOOK
5222(static_chain,
5223 "This hook replaces the use of @code{STATIC_CHAIN_REGNUM} et al for\n\
5224targets that may use different static chain locations for different\n\
5225nested functions. This may be required if the target has function\n\
5226attributes that affect the calling conventions of the function and\n\
5227those calling conventions use different static chain locations.\n\
5228\n\
5229The default version of this hook uses @code{STATIC_CHAIN_REGNUM} et al.\n\
5230\n\
5231If the static chain is passed in memory, this hook should be used to\n\
5232provide rtx giving @code{mem} expressions that denote where they are stored.\n\
5233Often the @code{mem} expression as seen by the caller will be at an offset\n\
5234from the stack pointer and the @code{mem} expression as seen by the callee\n\
5235will be at an offset from the frame pointer.\n\
5236@findex stack_pointer_rtx\n\
5237@findex frame_pointer_rtx\n\
5238@findex arg_pointer_rtx\n\
5239The variables @code{stack_pointer_rtx}, @code{frame_pointer_rtx}, and\n\
5240@code{arg_pointer_rtx} will have been initialized and should be used\n\
5241to refer to those items.",
5242 rtx, (const_tree fndecl_or_type, bool incoming_p),
5243 default_static_chain)
5244
5245/* Fill in the trampoline at MEM with a call to FNDECL and a
5246 static chain value of CHAIN. */
5247DEFHOOK
5248(trampoline_init,
5249 "This hook is called to initialize a trampoline.\n\
5250@var{m_tramp} is an RTX for the memory block for the trampoline; @var{fndecl}\n\
5251is the @code{FUNCTION_DECL} for the nested function; @var{static_chain} is an\n\
5252RTX for the static chain value that should be passed to the function\n\
5253when it is called.\n\
5254\n\
5255If the target defines @code{TARGET_ASM_TRAMPOLINE_TEMPLATE}, then the\n\
5256first thing this hook should do is emit a block move into @var{m_tramp}\n\
5257from the memory block returned by @code{assemble_trampoline_template}.\n\
5258Note that the block move need only cover the constant parts of the\n\
5259trampoline. If the target isolates the variable parts of the trampoline\n\
5260to the end, not all @code{TRAMPOLINE_SIZE} bytes need be copied.\n\
5261\n\
5262If the target requires any other actions, such as flushing caches\n\
5263(possibly calling function maybe_emit_call_builtin___clear_cache) or\n\
5264enabling stack execution, these actions should be performed after\n\
5265initializing the trampoline proper.",
5266 void, (rtx m_tramp, tree fndecl, rtx static_chain),
5267 default_trampoline_init)
5268
5269/* Emit a call to a function to clear the instruction cache. */
5270DEFHOOK
5271(emit_call_builtin___clear_cache,
5272 "On targets that do not define a @code{clear_cache} insn expander,\n\
5273but that define the @code{CLEAR_CACHE_INSN} macro,\n\
5274maybe_emit_call_builtin___clear_cache relies on this target hook\n\
5275to clear an address range in the instruction cache.\n\
5276\n\
5277The default implementation calls the @code{__clear_cache} builtin,\n\
5278taking the assembler name from the builtin declaration. Overriding\n\
5279definitions may call alternate functions, with alternate calling\n\
5280conventions, or emit alternate RTX to perform the job.",
5281 void, (rtx begin, rtx end),
5282 default_emit_call_builtin___clear_cache)
5283
5284/* Adjust the address of the trampoline in a target-specific way. */
5285DEFHOOK
5286(trampoline_adjust_address,
5287 "This hook should perform any machine-specific adjustment in\n\
5288the address of the trampoline. Its argument contains the address of the\n\
5289memory block that was passed to @code{TARGET_TRAMPOLINE_INIT}. In case\n\
5290the address to be used for a function call should be different from the\n\
5291address at which the template was stored, the different address should\n\
5292be returned; otherwise @var{addr} should be returned unchanged.\n\
5293If this hook is not defined, @var{addr} will be used for function calls.",
5294 rtx, (rtx addr), NULL)
5295
5296DEFHOOKPOD
5297(custom_function_descriptors,
5298 "If the target can use GCC's generic descriptor mechanism for nested\n\
5299functions, define this hook to a power of 2 representing an unused bit\n\
5300in function pointers which can be used to differentiate descriptors at\n\
5301run time. This value gives the number of bytes by which descriptor\n\
5302pointers are misaligned compared to function pointers. For example, on\n\
5303targets that require functions to be aligned to a 4-byte boundary, a\n\
5304value of either 1 or 2 is appropriate unless the architecture already\n\
5305reserves the bit for another purpose, such as on ARM.\n\
5306\n\
5307Define this hook to 0 if the target implements ABI support for\n\
5308function descriptors in its standard calling sequence, like for example\n\
5309HPPA or IA-64.\n\
5310\n\
5311Using descriptors for nested functions\n\
5312eliminates the need for trampolines that reside on the stack and require\n\
5313it to be made executable.",
5314 int, -1)
5315
5316/* Return the number of bytes of its own arguments that a function
5317 pops on returning, or 0 if the function pops no arguments and the
5318 caller must therefore pop them all after the function returns. */
5319/* ??? tm.texi has no types for the parameters. */
5320DEFHOOK
5321(return_pops_args,
5322 "This target hook returns the number of bytes of its own arguments that\n\
5323a function pops on returning, or 0 if the function pops no arguments\n\
5324and the caller must therefore pop them all after the function returns.\n\
5325\n\
5326@var{fundecl} is a C variable whose value is a tree node that describes\n\
5327the function in question. Normally it is a node of type\n\
5328@code{FUNCTION_DECL} that describes the declaration of the function.\n\
5329From this you can obtain the @code{DECL_ATTRIBUTES} of the function.\n\
5330\n\
5331@var{funtype} is a C variable whose value is a tree node that\n\
5332describes the function in question. Normally it is a node of type\n\
5333@code{FUNCTION_TYPE} that describes the data type of the function.\n\
5334From this it is possible to obtain the data types of the value and\n\
5335arguments (if known).\n\
5336\n\
5337When a call to a library function is being considered, @var{fundecl}\n\
5338will contain an identifier node for the library function. Thus, if\n\
5339you need to distinguish among various library functions, you can do so\n\
5340by their names. Note that ``library function'' in this context means\n\
5341a function used to perform arithmetic, whose name is known specially\n\
5342in the compiler and was not mentioned in the C code being compiled.\n\
5343\n\
5344@var{size} is the number of bytes of arguments passed on the\n\
5345stack. If a variable number of bytes is passed, it is zero, and\n\
5346argument popping will always be the responsibility of the calling function.\n\
5347\n\
5348On the VAX, all functions always pop their arguments, so the definition\n\
5349of this macro is @var{size}. On the 68000, using the standard\n\
5350calling convention, no functions pop their arguments, so the value of\n\
5351the macro is always 0 in this case. But an alternative calling\n\
5352convention is available in which functions that take a fixed number of\n\
5353arguments pop them but other functions (such as @code{printf}) pop\n\
5354nothing (the caller pops all). When this convention is in use,\n\
5355@var{funtype} is examined to determine whether a function takes a fixed\n\
5356number of arguments.",
5357 poly_int64, (tree fundecl, tree funtype, poly_int64 size),
5358 default_return_pops_args)
5359
5360/* Return a mode wide enough to copy any function value that might be
5361 returned. */
5362DEFHOOK
5363(get_raw_result_mode,
5364 "This target hook returns the mode to be used when accessing raw return\n\
5365registers in @code{__builtin_return}. Define this macro if the value\n\
5366in @var{reg_raw_mode} is not correct. Use @code{VOIDmode} if a register\n\
5367should be ignored for @code{__builtin_return} purposes.",
5368 fixed_size_mode, (int regno),
5369 default_get_reg_raw_mode)
5370
5371/* Return a mode wide enough to copy any argument value that might be
5372 passed. */
5373DEFHOOK
5374(get_raw_arg_mode,
5375 "This target hook returns the mode to be used when accessing raw argument\n\
5376registers in @code{__builtin_apply_args}. Define this macro if the value\n\
5377in @var{reg_raw_mode} is not correct. Use @code{VOIDmode} if a register\n\
5378should be ignored for @code{__builtin_apply_args} purposes.",
5379 fixed_size_mode, (int regno),
5380 default_get_reg_raw_mode)
5381
5382/* Return true if a type is an empty record. */
5383DEFHOOK
5384(empty_record_p,
5385 "This target hook returns true if the type is an empty record. The default\n\
5386is to return @code{false}.",
5387 bool, (const_tree type),
5388 hook_bool_const_tree_false)
5389
5390/* Warn about the change in empty class parameter passing ABI. */
5391DEFHOOK
5392(warn_parameter_passing_abi,
5393 "This target hook warns about the change in empty class parameter passing\n\
5394ABI.",
5395 void, (cumulative_args_t ca, tree type),
5396 hook_void_CUMULATIVE_ARGS_tree)
5397
5398HOOK_VECTOR_END (calls)
5399
5400DEFHOOK
5401(use_pseudo_pic_reg,
5402 "This hook should return 1 in case pseudo register should be created\n\
5403for pic_offset_table_rtx during function expand.",
5404 bool, (void),
5405 hook_bool_void_false)
5406
5407DEFHOOK
5408(init_pic_reg,
5409 "Perform a target dependent initialization of pic_offset_table_rtx.\n\
5410This hook is called at the start of register allocation.",
5411 void, (void),
5412 hook_void_void)
5413
5414/* Return the diagnostic message string if conversion from FROMTYPE
5415 to TOTYPE is not allowed, NULL otherwise. */
5416DEFHOOK
5417(invalid_conversion,
5418 "If defined, this macro returns the diagnostic message when it is\n\
5419invalid to convert from @var{fromtype} to @var{totype}, or @code{NULL}\n\
5420if validity should be determined by the front end.",
5421 const char *, (const_tree fromtype, const_tree totype),
5422 hook_constcharptr_const_tree_const_tree_null)
5423
5424/* Return the diagnostic message string if the unary operation OP is
5425 not permitted on TYPE, NULL otherwise. */
5426DEFHOOK
5427(invalid_unary_op,
5428 "If defined, this macro returns the diagnostic message when it is\n\
5429invalid to apply operation @var{op} (where unary plus is denoted by\n\
5430@code{CONVERT_EXPR}) to an operand of type @var{type}, or @code{NULL}\n\
5431if validity should be determined by the front end.",
5432 const char *, (int op, const_tree type),
5433 hook_constcharptr_int_const_tree_null)
5434
5435/* Return the diagnostic message string if the binary operation OP
5436 is not permitted on TYPE1 and TYPE2, NULL otherwise. */
5437DEFHOOK
5438(invalid_binary_op,
5439 "If defined, this macro returns the diagnostic message when it is\n\
5440invalid to apply operation @var{op} to operands of types @var{type1}\n\
5441and @var{type2}, or @code{NULL} if validity should be determined by\n\
5442the front end.",
5443 const char *, (int op, const_tree type1, const_tree type2),
5444 hook_constcharptr_int_const_tree_const_tree_null)
5445
5446/* If values of TYPE are promoted to some other type when used in
5447 expressions (analogous to the integer promotions), return that type,
5448 or NULL_TREE otherwise. */
5449DEFHOOK
5450(promoted_type,
5451 "If defined, this target hook returns the type to which values of\n\
5452@var{type} should be promoted when they appear in expressions,\n\
5453analogous to the integer promotions, or @code{NULL_TREE} to use the\n\
5454front end's normal promotion rules. This hook is useful when there are\n\
5455target-specific types with special promotion rules.\n\
5456This is currently used only by the C and C++ front ends.",
5457 tree, (const_tree type),
5458 hook_tree_const_tree_null)
5459
5460/* Convert EXPR to TYPE, if target-specific types with special conversion
5461 rules are involved. Return the converted expression, or NULL to apply
5462 the standard conversion rules. */
5463DEFHOOK
5464(convert_to_type,
5465 "If defined, this hook returns the result of converting @var{expr} to\n\
5466@var{type}. It should return the converted expression,\n\
5467or @code{NULL_TREE} to apply the front end's normal conversion rules.\n\
5468This hook is useful when there are target-specific types with special\n\
5469conversion rules.\n\
5470This is currently used only by the C and C++ front ends.",
5471 tree, (tree type, tree expr),
5472 hook_tree_tree_tree_null)
5473
5474DEFHOOK
5475(verify_type_context,
5476 "If defined, this hook returns false if there is a target-specific reason\n\
5477why type @var{type} cannot be used in the source language context described\n\
5478by @var{context}. When @var{silent_p} is false, the hook also reports an\n\
5479error against @var{loc} for invalid uses of @var{type}.\n\
5480\n\
5481Calls to this hook should be made through the global function\n\
5482@code{verify_type_context}, which makes the @var{silent_p} parameter\n\
5483default to false and also handles @code{error_mark_node}.\n\
5484\n\
5485The default implementation always returns true.",
5486 bool, (location_t loc, type_context_kind context, const_tree type,
5487 bool silent_p),
5488 NULL)
5489
5490DEFHOOK
5491(can_change_mode_class,
5492 "This hook returns true if it is possible to bitcast values held in\n\
5493registers of class @var{rclass} from mode @var{from} to mode @var{to}\n\
5494and if doing so preserves the low-order bits that are common to both modes.\n\
5495The result is only meaningful if @var{rclass} has registers that can hold\n\
5496both @code{from} and @code{to}. The default implementation returns true.\n\
5497\n\
5498As an example of when such bitcasting is invalid, loading 32-bit integer or\n\
5499floating-point objects into floating-point registers on Alpha extends them\n\
5500to 64 bits. Therefore loading a 64-bit object and then storing it as a\n\
550132-bit object does not store the low-order 32 bits, as would be the case\n\
5502for a normal register. Therefore, @file{alpha.h} defines\n\
5503@code{TARGET_CAN_CHANGE_MODE_CLASS} to return:\n\
5504\n\
5505@smallexample\n\
5506(GET_MODE_SIZE (from) == GET_MODE_SIZE (to)\n\
5507 || !reg_classes_intersect_p (FLOAT_REGS, rclass))\n\
5508@end smallexample\n\
5509\n\
5510Even if storing from a register in mode @var{to} would be valid,\n\
5511if both @var{from} and @code{raw_reg_mode} for @var{rclass} are wider\n\
5512than @code{word_mode}, then we must prevent @var{to} narrowing the\n\
5513mode. This happens when the middle-end assumes that it can load\n\
5514or store pieces of an @var{N}-word pseudo, and that the pseudo will\n\
5515eventually be allocated to @var{N} @code{word_mode} hard registers.\n\
5516Failure to prevent this kind of mode change will result in the\n\
5517entire @code{raw_reg_mode} being modified instead of the partial\n\
5518value that the middle-end intended.",
5519 bool, (machine_mode from, machine_mode to, reg_class_t rclass),
5520 hook_bool_mode_mode_reg_class_t_true)
5521
5522/* Change pseudo allocno class calculated by IRA. */
5523DEFHOOK
5524(ira_change_pseudo_allocno_class,
5525 "A target hook which can change allocno class for given pseudo from\n\
5526 allocno and best class calculated by IRA.\n\
5527 \n\
5528 The default version of this target hook always returns given class.",
5529 reg_class_t, (int, reg_class_t, reg_class_t),
5530 default_ira_change_pseudo_allocno_class)
5531
5532/* Return true if we use LRA instead of reload. */
5533DEFHOOK
5534(lra_p,
5535 "A target hook which returns true if we use LRA instead of reload pass.\n\
5536\n\
5537The default version of this target hook returns true. New ports\n\
5538should use LRA, and existing ports are encouraged to convert.",
5539 bool, (void),
5540 default_lra_p)
5541
5542/* Return register priority of given hard regno for the current target. */
5543DEFHOOK
5544(register_priority,
5545 "A target hook which returns the register priority number to which the\n\
5546register @var{hard_regno} belongs to. The bigger the number, the\n\
5547more preferable the hard register usage (when all other conditions are\n\
5548the same). This hook can be used to prefer some hard register over\n\
5549others in LRA. For example, some x86-64 register usage needs\n\
5550additional prefix which makes instructions longer. The hook can\n\
5551return lower priority number for such registers make them less favorable\n\
5552and as result making the generated code smaller.\n\
5553\n\
5554The default version of this target hook returns always zero.",
5555 int, (int),
5556 default_register_priority)
5557
5558/* Return true if we need register usage leveling. */
5559DEFHOOK
5560(register_usage_leveling_p,
5561 "A target hook which returns true if we need register usage leveling.\n\
5562That means if a few hard registers are equally good for the\n\
5563assignment, we choose the least used hard register. The register\n\
5564usage leveling may be profitable for some targets. Don't use the\n\
5565usage leveling for targets with conditional execution or targets\n\
5566with big register files as it hurts if-conversion and cross-jumping\n\
5567optimizations.\n\
5568\n\
5569The default version of this target hook returns always false.",
5570 bool, (void),
5571 default_register_usage_leveling_p)
5572
5573/* Return true if maximal address displacement can be different. */
5574DEFHOOK
5575(different_addr_displacement_p,
5576 "A target hook which returns true if an address with the same structure\n\
5577can have different maximal legitimate displacement. For example, the\n\
5578displacement can depend on memory mode or on operand combinations in\n\
5579the insn.\n\
5580\n\
5581The default version of this target hook returns always false.",
5582 bool, (void),
5583 default_different_addr_displacement_p)
5584
5585/* Determine class for spilling pseudos of given mode into registers
5586 instead of memory. */
5587DEFHOOK
5588(spill_class,
5589 "This hook defines a class of registers which could be used for spilling\n\
5590pseudos of the given mode and class, or @code{NO_REGS} if only memory\n\
5591should be used. Not defining this hook is equivalent to returning\n\
5592@code{NO_REGS} for all inputs.",
5593 reg_class_t, (reg_class_t, machine_mode),
5594 NULL)
5595
5596/* Determine an additional allocno class. */
5597DEFHOOK
5598(additional_allocno_class_p,
5599 "This hook should return @code{true} if given class of registers should\n\
5600be an allocno class in any way. Usually RA uses only one register\n\
5601class from all classes containing the same register set. In some\n\
5602complicated cases, you need to have two or more such classes as\n\
5603allocno ones for RA correct work. Not defining this hook is\n\
5604equivalent to returning @code{false} for all inputs.",
5605 bool, (reg_class_t),
5606 hook_bool_reg_class_t_false)
5607
5608DEFHOOK
5609(cstore_mode,
5610 "This hook defines the machine mode to use for the boolean result of\n\
5611conditional store patterns. The ICODE argument is the instruction code\n\
5612for the cstore being performed. Not definiting this hook is the same\n\
5613as accepting the mode encoded into operand 0 of the cstore expander\n\
5614patterns.",
5615 scalar_int_mode, (enum insn_code icode),
5616 default_cstore_mode)
5617
5618/* This target hook allows the backend to compute the register pressure
5619 classes to use. */
5620DEFHOOK
5621(compute_pressure_classes,
5622 "A target hook which lets a backend compute the set of pressure classes to\n\
5623be used by those optimization passes which take register pressure into\n\
5624account, as opposed to letting IRA compute them. It returns the number of\n\
5625register classes stored in the array @var{pressure_classes}.",
5626 int, (enum reg_class *pressure_classes), NULL)
5627
5628/* True if a structure, union or array with MODE containing FIELD should
5629 be accessed using BLKmode. */
5630DEFHOOK
5631(member_type_forces_blk,
5632 "Return true if a structure, union or array containing @var{field} should\n\
5633be accessed using @code{BLKMODE}.\n\
5634\n\
5635If @var{field} is the only field in the structure, @var{mode} is its\n\
5636mode, otherwise @var{mode} is VOIDmode. @var{mode} is provided in the\n\
5637case where structures of one field would require the structure's mode to\n\
5638retain the field's mode.\n\
5639\n\
5640Normally, this is not needed.",
5641 bool, (const_tree field, machine_mode mode),
5642 default_member_type_forces_blk)
5643
5644/* See tree-ssa-math-opts.cc:divmod_candidate_p for conditions
5645 that gate the divod transform. */
5646DEFHOOK
5647(expand_divmod_libfunc,
5648 "Define this hook for enabling divmod transform if the port does not have\n\
5649hardware divmod insn but defines target-specific divmod libfuncs.",
5650 void, (rtx libfunc, machine_mode mode, rtx op0, rtx op1, rtx *quot, rtx *rem),
5651 NULL)
5652
5653/* Return the class for a secondary reload, and fill in extra information. */
5654DEFHOOK
5655(secondary_reload,
5656 "Many machines have some registers that cannot be copied directly to or\n\
5657from memory or even from other types of registers. An example is the\n\
5658@samp{MQ} register, which on most machines, can only be copied to or\n\
5659from general registers, but not memory. Below, we shall be using the\n\
5660term 'intermediate register' when a move operation cannot be performed\n\
5661directly, but has to be done by copying the source into the intermediate\n\
5662register first, and then copying the intermediate register to the\n\
5663destination. An intermediate register always has the same mode as\n\
5664source and destination. Since it holds the actual value being copied,\n\
5665reload might apply optimizations to re-use an intermediate register\n\
5666and eliding the copy from the source when it can determine that the\n\
5667intermediate register still holds the required value.\n\
5668\n\
5669Another kind of secondary reload is required on some machines which\n\
5670allow copying all registers to and from memory, but require a scratch\n\
5671register for stores to some memory locations (e.g., those with symbolic\n\
5672address on the RT, and those with certain symbolic address on the SPARC\n\
5673when compiling PIC)@. Scratch registers need not have the same mode\n\
5674as the value being copied, and usually hold a different value than\n\
5675that being copied. Special patterns in the md file are needed to\n\
5676describe how the copy is performed with the help of the scratch register;\n\
5677these patterns also describe the number, register class(es) and mode(s)\n\
5678of the scratch register(s).\n\
5679\n\
5680In some cases, both an intermediate and a scratch register are required.\n\
5681\n\
5682For input reloads, this target hook is called with nonzero @var{in_p},\n\
5683and @var{x} is an rtx that needs to be copied to a register of class\n\
5684@var{reload_class} in @var{reload_mode}. For output reloads, this target\n\
5685hook is called with zero @var{in_p}, and a register of class @var{reload_class}\n\
5686needs to be copied to rtx @var{x} in @var{reload_mode}.\n\
5687\n\
5688If copying a register of @var{reload_class} from/to @var{x} requires\n\
5689an intermediate register, the hook @code{secondary_reload} should\n\
5690return the register class required for this intermediate register.\n\
5691If no intermediate register is required, it should return NO_REGS.\n\
5692If more than one intermediate register is required, describe the one\n\
5693that is closest in the copy chain to the reload register.\n\
5694\n\
5695If scratch registers are needed, you also have to describe how to\n\
5696perform the copy from/to the reload register to/from this\n\
5697closest intermediate register. Or if no intermediate register is\n\
5698required, but still a scratch register is needed, describe the\n\
5699copy from/to the reload register to/from the reload operand @var{x}.\n\
5700\n\
5701You do this by setting @code{sri->icode} to the instruction code of a pattern\n\
5702in the md file which performs the move. Operands 0 and 1 are the output\n\
5703and input of this copy, respectively. Operands from operand 2 onward are\n\
5704for scratch operands. These scratch operands must have a mode, and a\n\
5705single-register-class\n\
5706@c [later: or memory]\n\
5707output constraint.\n\
5708\n\
5709When an intermediate register is used, the @code{secondary_reload}\n\
5710hook will be called again to determine how to copy the intermediate\n\
5711register to/from the reload operand @var{x}, so your hook must also\n\
5712have code to handle the register class of the intermediate operand.\n\
5713\n\
5714@c [For later: maybe we'll allow multi-alternative reload patterns -\n\
5715@c the port maintainer could name a mov<mode> pattern that has clobbers -\n\
5716@c and match the constraints of input and output to determine the required\n\
5717@c alternative. A restriction would be that constraints used to match\n\
5718@c against reloads registers would have to be written as register class\n\
5719@c constraints, or we need a new target macro / hook that tells us if an\n\
5720@c arbitrary constraint can match an unknown register of a given class.\n\
5721@c Such a macro / hook would also be useful in other places.]\n\
5722\n\
5723\n\
5724@var{x} might be a pseudo-register or a @code{subreg} of a\n\
5725pseudo-register, which could either be in a hard register or in memory.\n\
5726Use @code{true_regnum} to find out; it will return @minus{}1 if the pseudo is\n\
5727in memory and the hard register number if it is in a register.\n\
5728\n\
5729Scratch operands in memory (constraint @code{\"=m\"} / @code{\"=&m\"}) are\n\
5730currently not supported. For the time being, you will have to continue\n\
5731to use @code{TARGET_SECONDARY_MEMORY_NEEDED} for that purpose.\n\
5732\n\
5733@code{copy_cost} also uses this target hook to find out how values are\n\
5734copied. If you want it to include some extra cost for the need to allocate\n\
5735(a) scratch register(s), set @code{sri->extra_cost} to the additional cost.\n\
5736Or if two dependent moves are supposed to have a lower cost than the sum\n\
5737of the individual moves due to expected fortuitous scheduling and/or special\n\
5738forwarding logic, you can set @code{sri->extra_cost} to a negative amount.",
5739 reg_class_t,
5740 (bool in_p, rtx x, reg_class_t reload_class, machine_mode reload_mode,
5741 secondary_reload_info *sri),
5742 default_secondary_reload)
5743
5744DEFHOOK
5745(secondary_memory_needed,
5746 "Certain machines have the property that some registers cannot be copied\n\
5747to some other registers without using memory. Define this hook on\n\
5748those machines to return true if objects of mode @var{m} in registers\n\
5749of @var{class1} can only be copied to registers of class @var{class2} by\n\
5750 storing a register of @var{class1} into memory and loading that memory\n\
5751location into a register of @var{class2}. The default definition returns\n\
5752false for all inputs.",
5753 bool, (machine_mode mode, reg_class_t class1, reg_class_t class2),
5754 hook_bool_mode_reg_class_t_reg_class_t_false)
5755
5756DEFHOOK
5757(secondary_memory_needed_mode,
5758 "If @code{TARGET_SECONDARY_MEMORY_NEEDED} tells the compiler to use memory\n\
5759when moving between two particular registers of mode @var{mode},\n\
5760this hook specifies the mode that the memory should have.\n\
5761\n\
5762The default depends on @code{TARGET_LRA_P}. Without LRA, the default\n\
5763is to use a word-sized mode for integral modes that are smaller than a\n\
5764a word. This is right thing to do on most machines because it ensures\n\
5765that all bits of the register are copied and prevents accesses to the\n\
5766registers in a narrower mode, which some machines prohibit for\n\
5767floating-point registers.\n\
5768\n\
5769However, this default behavior is not correct on some machines, such as\n\
5770the DEC Alpha, that store short integers in floating-point registers\n\
5771differently than in integer registers. On those machines, the default\n\
5772widening will not work correctly and you must define this hook to\n\
5773suppress that widening in some cases. See the file @file{alpha.cc} for\n\
5774details.\n\
5775\n\
5776With LRA, the default is to use @var{mode} unmodified.",
5777 machine_mode, (machine_mode mode),
5778 default_secondary_memory_needed_mode)
5779
5780/* Given an rtx X being reloaded into a reg required to be in class CLASS,
5781 return the class of reg to actually use. */
5782DEFHOOK
5783(preferred_reload_class,
5784 "A target hook that places additional restrictions on the register class\n\
5785to use when it is necessary to copy value @var{x} into a register in class\n\
5786@var{rclass}. The value is a register class; perhaps @var{rclass}, or perhaps\n\
5787another, smaller class.\n\
5788\n\
5789The default version of this hook always returns value of @code{rclass} argument.\n\
5790\n\
5791Sometimes returning a more restrictive class makes better code. For\n\
5792example, on the 68000, when @var{x} is an integer constant that is in range\n\
5793for a @samp{moveq} instruction, the value of this macro is always\n\
5794@code{DATA_REGS} as long as @var{rclass} includes the data registers.\n\
5795Requiring a data register guarantees that a @samp{moveq} will be used.\n\
5796\n\
5797One case where @code{TARGET_PREFERRED_RELOAD_CLASS} must not return\n\
5798@var{rclass} is if @var{x} is a legitimate constant which cannot be\n\
5799loaded into some register class. By returning @code{NO_REGS} you can\n\
5800force @var{x} into a memory location. For example, rs6000 can load\n\
5801immediate values into general-purpose registers, but does not have an\n\
5802instruction for loading an immediate value into a floating-point\n\
5803register, so @code{TARGET_PREFERRED_RELOAD_CLASS} returns @code{NO_REGS} when\n\
5804@var{x} is a floating-point constant. If the constant can't be loaded\n\
5805into any kind of register, code generation will be better if\n\
5806@code{TARGET_LEGITIMATE_CONSTANT_P} makes the constant illegitimate instead\n\
5807of using @code{TARGET_PREFERRED_RELOAD_CLASS}.\n\
5808\n\
5809If an insn has pseudos in it after register allocation, reload will go\n\
5810through the alternatives and call repeatedly @code{TARGET_PREFERRED_RELOAD_CLASS}\n\
5811to find the best one. Returning @code{NO_REGS}, in this case, makes\n\
5812reload add a @code{!} in front of the constraint: the x86 back-end uses\n\
5813this feature to discourage usage of 387 registers when math is done in\n\
5814the SSE registers (and vice versa).",
5815 reg_class_t,
5816 (rtx x, reg_class_t rclass),
5817 default_preferred_reload_class)
5818
5819/* Like TARGET_PREFERRED_RELOAD_CLASS, but for output reloads instead of
5820 input reloads. */
5821DEFHOOK
5822(preferred_output_reload_class,
5823 "Like @code{TARGET_PREFERRED_RELOAD_CLASS}, but for output reloads instead of\n\
5824input reloads.\n\
5825\n\
5826The default version of this hook always returns value of @code{rclass}\n\
5827argument.\n\
5828\n\
5829You can also use @code{TARGET_PREFERRED_OUTPUT_RELOAD_CLASS} to discourage\n\
5830reload from using some alternatives, like @code{TARGET_PREFERRED_RELOAD_CLASS}.",
5831 reg_class_t,
5832 (rtx x, reg_class_t rclass),
5833 default_preferred_output_reload_class)
5834
5835DEFHOOK
5836(select_early_remat_modes,
5837 "On some targets, certain modes cannot be held in registers around a\n\
5838standard ABI call and are relatively expensive to spill to the stack.\n\
5839The early rematerialization pass can help in such cases by aggressively\n\
5840recomputing values after calls, so that they don't need to be spilled.\n\
5841\n\
5842This hook returns the set of such modes by setting the associated bits\n\
5843in @var{modes}. The default implementation selects no modes, which has\n\
5844the effect of disabling the early rematerialization pass.",
5845 void, (sbitmap modes),
5846 default_select_early_remat_modes)
5847
5848DEFHOOK
5849(class_likely_spilled_p,
5850 "A target hook which returns @code{true} if pseudos that have been assigned\n\
5851to registers of class @var{rclass} would likely be spilled because\n\
5852registers of @var{rclass} are needed for spill registers.\n\
5853\n\
5854The default version of this target hook returns @code{true} if @var{rclass}\n\
5855has exactly one register and @code{false} otherwise. On most machines, this\n\
5856default should be used. For generally register-starved machines, such as\n\
5857i386, or machines with right register constraints, such as SH, this hook\n\
5858can be used to avoid excessive spilling.\n\
5859\n\
5860This hook is also used by some of the global intra-procedural code\n\
5861transformations to throtle code motion, to avoid increasing register\n\
5862pressure.",
5863 bool, (reg_class_t rclass),
5864 default_class_likely_spilled_p)
5865
5866/* Return the maximum number of consecutive registers
5867 needed to represent mode MODE in a register of class RCLASS. */
5868DEFHOOK
5869(class_max_nregs,
5870 "A target hook returns the maximum number of consecutive registers\n\
5871of class @var{rclass} needed to hold a value of mode @var{mode}.\n\
5872\n\
5873This is closely related to the macro @code{TARGET_HARD_REGNO_NREGS}.\n\
5874In fact, the value returned by @code{TARGET_CLASS_MAX_NREGS (@var{rclass},\n\
5875@var{mode})} target hook should be the maximum value of\n\
5876@code{TARGET_HARD_REGNO_NREGS (@var{regno}, @var{mode})} for all @var{regno}\n\
5877values in the class @var{rclass}.\n\
5878\n\
5879This target hook helps control the handling of multiple-word values\n\
5880in the reload pass.\n\
5881\n\
5882The default version of this target hook returns the size of @var{mode}\n\
5883in words.",
5884 unsigned char, (reg_class_t rclass, machine_mode mode),
5885 default_class_max_nregs)
5886
5887DEFHOOK
5888(preferred_rename_class,
5889 "A target hook that places additional preference on the register\n\
5890class to use when it is necessary to rename a register in class\n\
5891@var{rclass} to another class, or perhaps @var{NO_REGS}, if no\n\
5892preferred register class is found or hook @code{preferred_rename_class}\n\
5893is not implemented.\n\
5894Sometimes returning a more restrictive class makes better code. For\n\
5895example, on ARM, thumb-2 instructions using @code{LO_REGS} may be\n\
5896smaller than instructions using @code{GENERIC_REGS}. By returning\n\
5897@code{LO_REGS} from @code{preferred_rename_class}, code size can\n\
5898be reduced.",
5899 reg_class_t, (reg_class_t rclass),
5900 default_preferred_rename_class)
5901
5902/* This target hook allows the backend to avoid unsafe substitution
5903 during register allocation. */
5904DEFHOOK
5905(cannot_substitute_mem_equiv_p,
5906 "A target hook which returns @code{true} if @var{subst} can't\n\
5907substitute safely pseudos with equivalent memory values during\n\
5908register allocation.\n\
5909The default version of this target hook returns @code{false}.\n\
5910On most machines, this default should be used. For generally\n\
5911machines with non orthogonal register usage for addressing, such\n\
5912as SH, this hook can be used to avoid excessive spilling.",
5913 bool, (rtx subst),
5914 hook_bool_rtx_false)
5915
5916/* This target hook allows the backend to legitimize base plus
5917 displacement addressing. */
5918DEFHOOK
5919(legitimize_address_displacement,
5920 "This hook tries to split address offset @var{orig_offset} into\n\
5921two parts: one that should be added to the base address to create\n\
5922a local anchor point, and an additional offset that can be applied\n\
5923to the anchor to address a value of mode @var{mode}. The idea is that\n\
5924the local anchor could be shared by other accesses to nearby locations.\n\
5925\n\
5926The hook returns true if it succeeds, storing the offset of the\n\
5927anchor from the base in @var{offset1} and the offset of the final address\n\
5928from the anchor in @var{offset2}. The default implementation returns false.",
5929 bool, (rtx *offset1, rtx *offset2, poly_int64 orig_offset, machine_mode mode),
5930 default_legitimize_address_displacement)
5931
5932/* This target hook allows the backend to perform additional
5933 processing while initializing for variable expansion. */
5934DEFHOOK
5935(expand_to_rtl_hook,
5936 "This hook is called just before expansion into rtl, allowing the target\n\
5937to perform additional initializations or analysis before the expansion.\n\
5938For example, the rs6000 port uses it to allocate a scratch stack slot\n\
5939for use in copying SDmode values between memory and floating point\n\
5940registers whenever the function being expanded has any SDmode\n\
5941usage.",
5942 void, (void),
5943 hook_void_void)
5944
5945/* This target hook allows the backend to perform additional
5946 instantiations on rtx that are not actually in insns yet,
5947 but will be later. */
5948DEFHOOK
5949(instantiate_decls,
5950 "This hook allows the backend to perform additional instantiations on rtl\n\
5951that are not actually in any insns yet, but will be later.",
5952 void, (void),
5953 hook_void_void)
5954
5955DEFHOOK
5956(hard_regno_nregs,
5957 "This hook returns the number of consecutive hard registers, starting\n\
5958at register number @var{regno}, required to hold a value of mode\n\
5959@var{mode}. This hook must never return zero, even if a register\n\
5960cannot hold the requested mode - indicate that with\n\
5961@code{TARGET_HARD_REGNO_MODE_OK} and/or\n\
5962@code{TARGET_CAN_CHANGE_MODE_CLASS} instead.\n\
5963\n\
5964The default definition returns the number of words in @var{mode}.",
5965 unsigned int, (unsigned int regno, machine_mode mode),
5966 default_hard_regno_nregs)
5967
5968DEFHOOK
5969(hard_regno_mode_ok,
5970 "This hook returns true if it is permissible to store a value\n\
5971of mode @var{mode} in hard register number @var{regno} (or in several\n\
5972registers starting with that one). The default definition returns true\n\
5973unconditionally.\n\
5974\n\
5975You need not include code to check for the numbers of fixed registers,\n\
5976because the allocation mechanism considers them to be always occupied.\n\
5977\n\
5978@cindex register pairs\n\
5979On some machines, double-precision values must be kept in even/odd\n\
5980register pairs. You can implement that by defining this hook to reject\n\
5981odd register numbers for such modes.\n\
5982\n\
5983The minimum requirement for a mode to be OK in a register is that the\n\
5984@samp{mov@var{mode}} instruction pattern support moves between the\n\
5985register and other hard register in the same class and that moving a\n\
5986value into the register and back out not alter it.\n\
5987\n\
5988Since the same instruction used to move @code{word_mode} will work for\n\
5989all narrower integer modes, it is not necessary on any machine for\n\
5990this hook to distinguish between these modes, provided you define\n\
5991patterns @samp{movhi}, etc., to take advantage of this. This is\n\
5992useful because of the interaction between @code{TARGET_HARD_REGNO_MODE_OK}\n\
5993and @code{TARGET_MODES_TIEABLE_P}; it is very desirable for all integer\n\
5994modes to be tieable.\n\
5995\n\
5996Many machines have special registers for floating point arithmetic.\n\
5997Often people assume that floating point machine modes are allowed only\n\
5998in floating point registers. This is not true. Any registers that\n\
5999can hold integers can safely @emph{hold} a floating point machine\n\
6000mode, whether or not floating arithmetic can be done on it in those\n\
6001registers. Integer move instructions can be used to move the values.\n\
6002\n\
6003On some machines, though, the converse is true: fixed-point machine\n\
6004modes may not go in floating registers. This is true if the floating\n\
6005registers normalize any value stored in them, because storing a\n\
6006non-floating value there would garble it. In this case,\n\
6007@code{TARGET_HARD_REGNO_MODE_OK} should reject fixed-point machine modes in\n\
6008floating registers. But if the floating registers do not automatically\n\
6009normalize, if you can store any bit pattern in one and retrieve it\n\
6010unchanged without a trap, then any machine mode may go in a floating\n\
6011register, so you can define this hook to say so.\n\
6012\n\
6013The primary significance of special floating registers is rather that\n\
6014they are the registers acceptable in floating point arithmetic\n\
6015instructions. However, this is of no concern to\n\
6016@code{TARGET_HARD_REGNO_MODE_OK}. You handle it by writing the proper\n\
6017constraints for those instructions.\n\
6018\n\
6019On some machines, the floating registers are especially slow to access,\n\
6020so that it is better to store a value in a stack frame than in such a\n\
6021register if floating point arithmetic is not being done. As long as the\n\
6022floating registers are not in class @code{GENERAL_REGS}, they will not\n\
6023be used unless some pattern's constraint asks for one.",
6024 bool, (unsigned int regno, machine_mode mode),
6025 hook_bool_uint_mode_true)
6026
6027DEFHOOK
6028(modes_tieable_p,
6029 "This hook returns true if a value of mode @var{mode1} is accessible\n\
6030in mode @var{mode2} without copying.\n\
6031\n\
6032If @code{TARGET_HARD_REGNO_MODE_OK (@var{r}, @var{mode1})} and\n\
6033@code{TARGET_HARD_REGNO_MODE_OK (@var{r}, @var{mode2})} are always\n\
6034the same for any @var{r}, then\n\
6035@code{TARGET_MODES_TIEABLE_P (@var{mode1}, @var{mode2})}\n\
6036should be true. If they differ for any @var{r}, you should define\n\
6037this hook to return false unless some other mechanism ensures the\n\
6038accessibility of the value in a narrower mode.\n\
6039\n\
6040You should define this hook to return true in as many cases as\n\
6041possible since doing so will allow GCC to perform better register\n\
6042allocation. The default definition returns true unconditionally.",
6043 bool, (machine_mode mode1, machine_mode mode2),
6044 hook_bool_mode_mode_true)
6045
6046/* Return true if is OK to use a hard register REGNO as scratch register
6047 in peephole2. */
6048DEFHOOK
6049(hard_regno_scratch_ok,
6050 "This target hook should return @code{true} if it is OK to use a hard register\n\
6051@var{regno} as scratch reg in peephole2.\n\
6052\n\
6053One common use of this macro is to prevent using of a register that\n\
6054is not saved by a prologue in an interrupt handler.\n\
6055\n\
6056The default version of this hook always returns @code{true}.",
6057 bool, (unsigned int regno),
6058 default_hard_regno_scratch_ok)
6059
6060DEFHOOK
6061(hard_regno_call_part_clobbered,
6062 "ABIs usually specify that calls must preserve the full contents\n\
6063of a particular register, or that calls can alter any part of a\n\
6064particular register. This information is captured by the target macro\n\
6065@code{CALL_REALLY_USED_REGISTERS}. However, some ABIs specify that calls\n\
6066must preserve certain bits of a particular register but can alter others.\n\
6067This hook should return true if this applies to at least one of the\n\
6068registers in @samp{(reg:@var{mode} @var{regno})}, and if as a result the\n\
6069call would alter part of the @var{mode} value. For example, if a call\n\
6070preserves the low 32 bits of a 64-bit hard register @var{regno} but can\n\
6071clobber the upper 32 bits, this hook should return true for a 64-bit mode\n\
6072but false for a 32-bit mode.\n\
6073\n\
6074The value of @var{abi_id} comes from the @code{predefined_function_abi}\n\
6075structure that describes the ABI of the call; see the definition of the\n\
6076structure for more details. If (as is usual) the target uses the same ABI\n\
6077for all functions in a translation unit, @var{abi_id} is always 0.\n\
6078\n\
6079The default implementation returns false, which is correct\n\
6080for targets that don't have partly call-clobbered registers.",
6081 bool, (unsigned int abi_id, unsigned int regno, machine_mode mode),
6082 hook_bool_uint_uint_mode_false)
6083
6084DEFHOOK
6085(get_multilib_abi_name,
6086 "This hook returns name of multilib ABI name.",
6087 const char *, (void),
6088 hook_constcharptr_void_null)
6089
6090/* Return the smallest number of different values for which it is best to
6091 use a jump-table instead of a tree of conditional branches. */
6092DEFHOOK
6093(case_values_threshold,
6094 "This function return the smallest number of different values for which it\n\
6095is best to use a jump-table instead of a tree of conditional branches.\n\
6096The default is four for machines with a @code{casesi} instruction and\n\
6097five otherwise. This is best for most machines.",
6098 unsigned int, (void),
6099 default_case_values_threshold)
6100
6101DEFHOOK
6102(starting_frame_offset,
6103 "This hook returns the offset from the frame pointer to the first local\n\
6104variable slot to be allocated. If @code{FRAME_GROWS_DOWNWARD}, it is the\n\
6105offset to @emph{end} of the first slot allocated, otherwise it is the\n\
6106offset to @emph{beginning} of the first slot allocated. The default\n\
6107implementation returns 0.",
6108 HOST_WIDE_INT, (void),
6109 hook_hwi_void_0)
6110
6111/* Optional callback to advise the target to compute the frame layout. */
6112DEFHOOK
6113(compute_frame_layout,
6114 "This target hook is called once each time the frame layout needs to be\n\
6115recalculated. The calculations can be cached by the target and can then\n\
6116be used by @code{INITIAL_ELIMINATION_OFFSET} instead of re-computing the\n\
6117layout on every invocation of that hook. This is particularly useful\n\
6118for targets that have an expensive frame layout function. Implementing\n\
6119this callback is optional.",
6120 void, (void),
6121 hook_void_void)
6122
6123/* Return true if a function must have and use a frame pointer. */
6124DEFHOOK
6125(frame_pointer_required,
6126 "This target hook should return @code{true} if a function must have and use\n\
6127a frame pointer. This target hook is called in the reload pass. If its return\n\
6128value is @code{true} the function will have a frame pointer.\n\
6129\n\
6130This target hook can in principle examine the current function and decide\n\
6131according to the facts, but on most machines the constant @code{false} or the\n\
6132constant @code{true} suffices. Use @code{false} when the machine allows code\n\
6133to be generated with no frame pointer, and doing so saves some time or space.\n\
6134Use @code{true} when there is no possible advantage to avoiding a frame\n\
6135pointer.\n\
6136\n\
6137In certain cases, the compiler does not know how to produce valid code\n\
6138without a frame pointer. The compiler recognizes those cases and\n\
6139automatically gives the function a frame pointer regardless of what\n\
6140@code{targetm.frame_pointer_required} returns. You don't need to worry about\n\
6141them.\n\
6142\n\
6143In a function that does not require a frame pointer, the frame pointer\n\
6144register can be allocated for ordinary usage, unless you mark it as a\n\
6145fixed register. See @code{FIXED_REGISTERS} for more information.\n\
6146\n\
6147Default return value is @code{false}.",
6148 bool, (void),
6149 hook_bool_void_false)
6150
6151/* Returns true if the compiler is allowed to try to replace register number
6152 from-reg with register number to-reg. */
6153DEFHOOK
6154(can_eliminate,
6155 "This target hook should return @code{true} if the compiler is allowed to\n\
6156try to replace register number @var{from_reg} with register number\n\
6157@var{to_reg}. This target hook will usually be @code{true}, since most of the\n\
6158cases preventing register elimination are things that the compiler already\n\
6159knows about.\n\
6160\n\
6161Default return value is @code{true}.",
6162 bool, (const int from_reg, const int to_reg),
6163 hook_bool_const_int_const_int_true)
6164
6165/* Modify any or all of fixed_regs, call_used_regs, global_regs,
6166 reg_names, and reg_class_contents to account of the vagaries of the
6167 target. */
6168DEFHOOK
6169(conditional_register_usage,
6170 "This hook may conditionally modify five variables\n\
6171@code{fixed_regs}, @code{call_used_regs}, @code{global_regs},\n\
6172@code{reg_names}, and @code{reg_class_contents}, to take into account\n\
6173any dependence of these register sets on target flags. The first three\n\
6174of these are of type @code{char []} (interpreted as boolean vectors).\n\
6175@code{global_regs} is a @code{const char *[]}, and\n\
6176@code{reg_class_contents} is a @code{HARD_REG_SET}. Before the macro is\n\
6177called, @code{fixed_regs}, @code{call_used_regs},\n\
6178@code{reg_class_contents}, and @code{reg_names} have been initialized\n\
6179from @code{FIXED_REGISTERS}, @code{CALL_USED_REGISTERS},\n\
6180@code{REG_CLASS_CONTENTS}, and @code{REGISTER_NAMES}, respectively.\n\
6181@code{global_regs} has been cleared, and any @option{-ffixed-@var{reg}},\n\
6182@option{-fcall-used-@var{reg}} and @option{-fcall-saved-@var{reg}}\n\
6183command options have been applied.\n\
6184\n\
6185@cindex disabling certain registers\n\
6186@cindex controlling register usage\n\
6187If the usage of an entire class of registers depends on the target\n\
6188flags, you may indicate this to GCC by using this macro to modify\n\
6189@code{fixed_regs} and @code{call_used_regs} to 1 for each of the\n\
6190registers in the classes which should not be used by GCC@. Also make\n\
6191@code{define_register_constraint}s return @code{NO_REGS} for constraints\n\
6192that shouldn't be used.\n\
6193\n\
6194(However, if this class is not included in @code{GENERAL_REGS} and all\n\
6195of the insn patterns whose constraints permit this class are\n\
6196controlled by target switches, then GCC will automatically avoid using\n\
6197these registers when the target switches are opposed to them.)",
6198 void, (void),
6199 hook_void_void)
6200
6201DEFHOOK
6202(stack_clash_protection_alloca_probe_range,
6203 "Some targets have an ABI defined interval for which no probing needs to be done.\n\
6204When a probe does need to be done this same interval is used as the probe distance\n\
6205up when doing stack clash protection for alloca.\n\
6206On such targets this value can be set to override the default probing up interval.\n\
6207Define this variable to return nonzero if such a probe range is required or zero otherwise.\n\
6208Defining this hook also requires your functions which make use of alloca to have at least 8 byes\n\
6209of outgoing arguments. If this is not the case the stack will be corrupted.\n\
6210You need not define this macro if it would always have the value zero.",
6211 HOST_WIDE_INT, (void),
6212 default_stack_clash_protection_alloca_probe_range)
6213
6214
6215/* Functions specific to the C family of frontends. */
6216#undef HOOK_PREFIX
6217#define HOOK_PREFIX "TARGET_C_"
6218HOOK_VECTOR (TARGET_C, c)
6219
6220/* ??? Documenting this hook requires a GFDL license grant. */
6221DEFHOOK_UNDOC
6222(mode_for_suffix,
6223"Return machine mode for non-standard constant literal suffix @var{c},\
6224 or VOIDmode if non-standard suffixes are unsupported.",
6225 machine_mode, (char c),
6226 default_mode_for_suffix)
6227
6228DEFHOOK
6229(excess_precision,
6230 "Return a value, with the same meaning as the C99 macro\n\
6231@code{FLT_EVAL_METHOD} that describes which excess precision should be\n\
6232applied. @var{type} is either @code{EXCESS_PRECISION_TYPE_IMPLICIT},\n\
6233@code{EXCESS_PRECISION_TYPE_FAST},\n\
6234@code{EXCESS_PRECISION_TYPE_STANDARD}, or\n\
6235@code{EXCESS_PRECISION_TYPE_FLOAT16}. For\n\
6236@code{EXCESS_PRECISION_TYPE_IMPLICIT}, the target should return which\n\
6237precision and range operations will be implictly evaluated in regardless\n\
6238of the excess precision explicitly added. For\n\
6239@code{EXCESS_PRECISION_TYPE_STANDARD}, \n\
6240@code{EXCESS_PRECISION_TYPE_FLOAT16}, and\n\
6241@code{EXCESS_PRECISION_TYPE_FAST}, the target should return the\n\
6242explicit excess precision that should be added depending on the\n\
6243value set for @option{-fexcess-precision=@r{[}standard@r{|}fast@r{|}16@r{]}}.\n\
6244Note that unpredictable explicit excess precision does not make sense,\n\
6245so a target should never return @code{FLT_EVAL_METHOD_UNPREDICTABLE}\n\
6246when @var{type} is @code{EXCESS_PRECISION_TYPE_STANDARD},\n\
6247@code{EXCESS_PRECISION_TYPE_FLOAT16} or\n\
6248@code{EXCESS_PRECISION_TYPE_FAST}.",
6249 enum flt_eval_method, (enum excess_precision_type type),
6250 default_excess_precision)
6251
6252/* Return true if _BitInt(N) is supported and fill details about it into
6253 *INFO. */
6254DEFHOOK
6255(bitint_type_info,
6256 "This target hook returns true if @code{_BitInt(@var{N})} is supported and\n\
6257provides details on it. @code{_BitInt(@var{N})} is to be represented as\n\
6258series of @code{info->limb_mode}\n\
6259@code{CEIL (@var{N}, GET_MODE_PRECISION (info->limb_mode))} limbs,\n\
6260ordered from least significant to most significant if\n\
6261@code{!info->big_endian}, otherwise from most significant to least\n\
6262significant. If @code{info->extended} is false, the bits above or equal to\n\
6263@var{N} are undefined when stored in a register or memory, otherwise they\n\
6264are zero or sign extended depending on if it is\n\
6265@code{unsigned _BitInt(@var{N})} or one of @code{_BitInt(@var{N})} or\n\
6266@code{signed _BitInt(@var{N})}. Alignment of the type is\n\
6267@code{GET_MODE_ALIGNMENT (info->limb_mode)}.",
6268 bool, (int n, struct bitint_info *info),
6269 default_bitint_type_info)
6270
6271HOOK_VECTOR_END (c)
6272
6273/* Functions specific to the C++ frontend. */
6274#undef HOOK_PREFIX
6275#define HOOK_PREFIX "TARGET_CXX_"
6276HOOK_VECTOR (TARGET_CXX, cxx)
6277
6278/* Return the integer type used for guard variables. */
6279DEFHOOK
6280(guard_type,
6281 "Define this hook to override the integer type used for guard variables.\n\
6282These are used to implement one-time construction of static objects. The\n\
6283default is long_long_integer_type_node.",
6284 tree, (void),
6285 default_cxx_guard_type)
6286
6287/* Return true if only the low bit of the guard should be tested. */
6288DEFHOOK
6289(guard_mask_bit,
6290 "This hook determines how guard variables are used. It should return\n\
6291@code{false} (the default) if the first byte should be used. A return value of\n\
6292@code{true} indicates that only the least significant bit should be used.",
6293 bool, (void),
6294 hook_bool_void_false)
6295
6296/* Returns the size of the array cookie for an array of type. */
6297DEFHOOK
6298(get_cookie_size,
6299 "This hook returns the size of the cookie to use when allocating an array\n\
6300whose elements have the indicated @var{type}. Assumes that it is already\n\
6301known that a cookie is needed. The default is\n\
6302@code{max(sizeof (size_t), alignof(type))}, as defined in section 2.7 of the\n\
6303IA64/Generic C++ ABI@.",
6304 tree, (tree type),
6305 default_cxx_get_cookie_size)
6306
6307/* Returns true if the element size should be stored in the array cookie. */
6308DEFHOOK
6309(cookie_has_size,
6310 "This hook should return @code{true} if the element size should be stored in\n\
6311array cookies. The default is to return @code{false}.",
6312 bool, (void),
6313 hook_bool_void_false)
6314
6315/* Allows backends to perform additional processing when
6316 deciding if a class should be exported or imported. */
6317DEFHOOK
6318(import_export_class,
6319 "If defined by a backend this hook allows the decision made to export\n\
6320class @var{type} to be overruled. Upon entry @var{import_export}\n\
6321will contain 1 if the class is going to be exported, @minus{}1 if it is going\n\
6322to be imported and 0 otherwise. This function should return the\n\
6323modified value and perform any other actions necessary to support the\n\
6324backend's targeted operating system.",
6325 int, (tree type, int import_export), NULL)
6326
6327/* Returns true if constructors and destructors return "this". */
6328DEFHOOK
6329(cdtor_returns_this,
6330 "This hook should return @code{true} if constructors and destructors return\n\
6331the address of the object created/destroyed. The default is to return\n\
6332@code{false}.",
6333 bool, (void),
6334 hook_bool_void_false)
6335
6336/* Returns true if the key method for a class can be an inline
6337 function, so long as it is not declared inline in the class
6338 itself. Returning true is the behavior required by the Itanium C++ ABI. */
6339DEFHOOK
6340(key_method_may_be_inline,
6341 "This hook returns true if the key method for a class (i.e., the method\n\
6342which, if defined in the current translation unit, causes the virtual\n\
6343table to be emitted) may be an inline function. Under the standard\n\
6344Itanium C++ ABI the key method may be an inline function so long as\n\
6345the function is not declared inline in the class definition. Under\n\
6346some variants of the ABI, an inline function can never be the key\n\
6347method. The default is to return @code{true}.",
6348 bool, (void),
6349 hook_bool_void_true)
6350
6351DEFHOOK
6352(determine_class_data_visibility,
6353"@var{decl} is a virtual table, virtual table table, typeinfo object,\n\
6354or other similar implicit class data object that will be emitted with\n\
6355external linkage in this translation unit. No ELF visibility has been\n\
6356explicitly specified. If the target needs to specify a visibility\n\
6357other than that of the containing class, use this hook to set\n\
6358@code{DECL_VISIBILITY} and @code{DECL_VISIBILITY_SPECIFIED}.",
6359 void, (tree decl),
6360 hook_void_tree)
6361
6362/* Returns true (the default) if virtual tables and other
6363 similar implicit class data objects are always COMDAT if they
6364 have external linkage. If this hook returns false, then
6365 class data for classes whose virtual table will be emitted in
6366 only one translation unit will not be COMDAT. */
6367DEFHOOK
6368(class_data_always_comdat,
6369 "This hook returns true (the default) if virtual tables and other\n\
6370similar implicit class data objects are always COMDAT if they have\n\
6371external linkage. If this hook returns false, then class data for\n\
6372classes whose virtual table will be emitted in only one translation\n\
6373unit will not be COMDAT.",
6374 bool, (void),
6375 hook_bool_void_true)
6376
6377/* Returns true (the default) if the RTTI for the basic types,
6378 which is always defined in the C++ runtime, should be COMDAT;
6379 false if it should not be COMDAT. */
6380DEFHOOK
6381(library_rtti_comdat,
6382 "This hook returns true (the default) if the RTTI information for\n\
6383the basic types which is defined in the C++ runtime should always\n\
6384be COMDAT, false if it should not be COMDAT.",
6385 bool, (void),
6386 hook_bool_void_true)
6387
6388/* Returns true if __aeabi_atexit should be used to register static
6389 destructors. */
6390DEFHOOK
6391(use_aeabi_atexit,
6392 "This hook returns true if @code{__aeabi_atexit} (as defined by the ARM EABI)\n\
6393should be used to register static destructors when @option{-fuse-cxa-atexit}\n\
6394is in effect. The default is to return false to use @code{__cxa_atexit}.",
6395 bool, (void),
6396 hook_bool_void_false)
6397
6398/* Returns true if target may use atexit in the same manner as
6399 __cxa_atexit to register static destructors. */
6400DEFHOOK
6401(use_atexit_for_cxa_atexit,
6402 "This hook returns true if the target @code{atexit} function can be used\n\
6403in the same manner as @code{__cxa_atexit} to register C++ static\n\
6404destructors. This requires that @code{atexit}-registered functions in\n\
6405shared libraries are run in the correct order when the libraries are\n\
6406unloaded. The default is to return false.",
6407 bool, (void),
6408 hook_bool_void_false)
6409
6410DEFHOOK
6411(adjust_class_at_definition,
6412"@var{type} is a C++ class (i.e., RECORD_TYPE or UNION_TYPE) that has just\n\
6413been defined. Use this hook to make adjustments to the class (eg, tweak\n\
6414visibility or perform any other required target modifications).",
6415 void, (tree type),
6416 hook_void_tree)
6417
6418DEFHOOK
6419(decl_mangling_context,
6420 "Return target-specific mangling context of @var{decl} or @code{NULL_TREE}.",
6421 tree, (const_tree decl),
6422 hook_tree_const_tree_null)
6423
6424HOOK_VECTOR_END (cxx)
6425
6426/* Functions and data for emulated TLS support. */
6427#undef HOOK_PREFIX
6428#define HOOK_PREFIX "TARGET_EMUTLS_"
6429HOOK_VECTOR (TARGET_EMUTLS, emutls)
6430
6431/* Name of the address and common functions. */
6432DEFHOOKPOD
6433(get_address,
6434 "Contains the name of the helper function that uses a TLS control\n\
6435object to locate a TLS instance. The default causes libgcc's\n\
6436emulated TLS helper function to be used.",
6437 const char *, "__builtin___emutls_get_address")
6438
6439DEFHOOKPOD
6440(register_common,
6441 "Contains the name of the helper function that should be used at\n\
6442program startup to register TLS objects that are implicitly\n\
6443initialized to zero. If this is @code{NULL}, all TLS objects will\n\
6444have explicit initializers. The default causes libgcc's emulated TLS\n\
6445registration function to be used.",
6446 const char *, "__builtin___emutls_register_common")
6447
6448/* Prefixes for proxy variable and template. */
6449DEFHOOKPOD
6450(var_section,
6451 "Contains the name of the section in which TLS control variables should\n\
6452be placed. The default of @code{NULL} allows these to be placed in\n\
6453any section.",
6454 const char *, NULL)
6455
6456DEFHOOKPOD
6457(tmpl_section,
6458 "Contains the name of the section in which TLS initializers should be\n\
6459placed. The default of @code{NULL} allows these to be placed in any\n\
6460section.",
6461 const char *, NULL)
6462
6463/* Prefixes for proxy variable and template. */
6464DEFHOOKPOD
6465(var_prefix,
6466 "Contains the prefix to be prepended to TLS control variable names.\n\
6467The default of @code{NULL} uses a target-specific prefix.",
6468 const char *, NULL)
6469
6470DEFHOOKPOD
6471(tmpl_prefix,
6472 "Contains the prefix to be prepended to TLS initializer objects. The\n\
6473default of @code{NULL} uses a target-specific prefix.",
6474 const char *, NULL)
6475
6476/* Function to generate field definitions of the proxy variable. */
6477DEFHOOK
6478(var_fields,
6479 "Specifies a function that generates the FIELD_DECLs for a TLS control\n\
6480object type. @var{type} is the RECORD_TYPE the fields are for and\n\
6481@var{name} should be filled with the structure tag, if the default of\n\
6482@code{__emutls_object} is unsuitable. The default creates a type suitable\n\
6483for libgcc's emulated TLS function.",
6484 tree, (tree type, tree *name),
6485 default_emutls_var_fields)
6486
6487/* Function to initialize a proxy variable. */
6488DEFHOOK
6489(var_init,
6490 "Specifies a function that generates the CONSTRUCTOR to initialize a\n\
6491TLS control object. @var{var} is the TLS control object, @var{decl}\n\
6492is the TLS object and @var{tmpl_addr} is the address of the\n\
6493initializer. The default initializes libgcc's emulated TLS control object.",
6494 tree, (tree var, tree decl, tree tmpl_addr),
6495 default_emutls_var_init)
6496
6497/* Whether we are allowed to alter the usual alignment of the
6498 proxy variable. */
6499DEFHOOKPOD
6500(var_align_fixed,
6501 "Specifies whether the alignment of TLS control variable objects is\n\
6502fixed and should not be increased as some backends may do to optimize\n\
6503single objects. The default is false.",
6504 bool, false)
6505
6506/* Whether we can emit debug information for TLS vars. */
6507DEFHOOKPOD
6508(debug_form_tls_address,
6509 "Specifies whether a DWARF @code{DW_OP_form_tls_address} location descriptor\n\
6510may be used to describe emulated TLS control objects.",
6511 bool, false)
6512
6513HOOK_VECTOR_END (emutls)
6514
6515#undef HOOK_PREFIX
6516#define HOOK_PREFIX "TARGET_OPTION_"
6517HOOK_VECTOR (TARGET_OPTION_HOOKS, target_option_hooks)
6518
6519/* Function to validate the attribute((target(...))) strings. If
6520 the option is validated, the hook should also fill in
6521 DECL_FUNCTION_SPECIFIC_TARGET in the function decl node. */
6522DEFHOOK
6523(valid_attribute_p,
6524 "This hook is called to parse @code{attribute(target(\"...\"))}, which\n\
6525allows setting target-specific options on individual functions.\n\
6526These function-specific options may differ\n\
6527from the options specified on the command line. The hook should return\n\
6528@code{true} if the options are valid.\n\
6529\n\
6530The hook should set the @code{DECL_FUNCTION_SPECIFIC_TARGET} field in\n\
6531the function declaration to hold a pointer to a target-specific\n\
6532@code{struct cl_target_option} structure.",
6533 bool, (tree fndecl, tree name, tree args, int flags),
6534 default_target_option_valid_attribute_p)
6535
6536/* Function to save any extra target state in the target options structure. */
6537DEFHOOK
6538(save,
6539 "This hook is called to save any additional target-specific information\n\
6540in the @code{struct cl_target_option} structure for function-specific\n\
6541options from the @code{struct gcc_options} structure.\n\
6542@xref{Option file format}.",
6543 void, (struct cl_target_option *ptr, struct gcc_options *opts,
6544 struct gcc_options *opts_set), NULL)
6545
6546/* Function to restore any extra target state from the target options
6547 structure. */
6548DEFHOOK
6549(restore,
6550 "This hook is called to restore any additional target-specific\n\
6551information in the @code{struct cl_target_option} structure for\n\
6552function-specific options to the @code{struct gcc_options} structure.",
6553 void, (struct gcc_options *opts, struct gcc_options *opts_set,
6554 struct cl_target_option *ptr), NULL)
6555
6556/* Function to update target-specific option information after being
6557 streamed in. */
6558DEFHOOK
6559(post_stream_in,
6560 "This hook is called to update target-specific information in the\n\
6561@code{struct cl_target_option} structure after it is streamed in from\n\
6562LTO bytecode.",
6563 void, (struct cl_target_option *ptr), NULL)
6564
6565/* Function to print any extra target state from the target options
6566 structure. */
6567DEFHOOK
6568(print,
6569 "This hook is called to print any additional target-specific\n\
6570information in the @code{struct cl_target_option} structure for\n\
6571function-specific options.",
6572 void, (FILE *file, int indent, struct cl_target_option *ptr), NULL)
6573
6574/* Function to parse arguments to be validated for #pragma target, and to
6575 change the state if the options are valid. If the first argument is
6576 NULL, the second argument specifies the default options to use. Return
6577 true if the options are valid, and set the current state. */
6578DEFHOOK
6579(pragma_parse,
6580 "This target hook parses the options for @code{#pragma GCC target}, which\n\
6581sets the target-specific options for functions that occur later in the\n\
6582input stream. The options accepted should be the same as those handled by the\n\
6583@code{TARGET_OPTION_VALID_ATTRIBUTE_P} hook.",
6584 bool, (tree args, tree pop_target),
6585 default_target_option_pragma_parse)
6586
6587/* Do option overrides for the target. */
6588DEFHOOK
6589(override,
6590 "Sometimes certain combinations of command options do not make sense on\n\
6591a particular target machine. You can override the hook\n\
6592@code{TARGET_OPTION_OVERRIDE} to take account of this. This hooks is called\n\
6593once just after all the command options have been parsed.\n\
6594\n\
6595Don't use this hook to turn on various extra optimizations for\n\
6596@option{-O}. That is what @code{TARGET_OPTION_OPTIMIZATION} is for.\n\
6597\n\
6598If you need to do something whenever the optimization level is\n\
6599changed via the optimize attribute or pragma, see\n\
6600@code{TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE}",
6601 void, (void),
6602 hook_void_void)
6603
6604/* This function returns true if DECL1 and DECL2 are versions of the same
6605 function. DECL1 and DECL2 are function versions if and only if they
6606 have the same function signature and different target specific attributes,
6607 that is, they are compiled for different target machines. */
6608DEFHOOK
6609(function_versions,
6610 "This target hook returns @code{true} if @var{DECL1} and @var{DECL2} are\n\
6611versions of the same function. @var{DECL1} and @var{DECL2} are function\n\
6612versions if and only if they have the same function signature and\n\
6613different target specific attributes, that is, they are compiled for\n\
6614different target machines.",
6615 bool, (tree decl1, tree decl2),
6616 hook_bool_tree_tree_false)
6617
6618/* Function to determine if one function can inline another function. */
6619#undef HOOK_PREFIX
6620#define HOOK_PREFIX "TARGET_"
6621DEFHOOK
6622(can_inline_p,
6623 "This target hook returns @code{false} if the @var{caller} function\n\
6624cannot inline @var{callee}, based on target specific information. By\n\
6625default, inlining is not allowed if the callee function has function\n\
6626specific target options and the caller does not use the same options.",
6627 bool, (tree caller, tree callee),
6628 default_target_can_inline_p)
6629
6630DEFHOOK
6631(update_ipa_fn_target_info,
6632 "Allow target to analyze all gimple statements for the given function to\n\
6633record and update some target specific information for inlining. A typical\n\
6634example is that a caller with one isa feature disabled is normally not\n\
6635allowed to inline a callee with that same isa feature enabled even which is\n\
6636attributed by always_inline, but with the conservative analysis on all\n\
6637statements of the callee if we are able to guarantee the callee does not\n\
6638exploit any instructions from the mismatch isa feature, it would be safe to\n\
6639allow the caller to inline the callee.\n\
6640@var{info} is one @code{unsigned int} value to record information in which\n\
6641one set bit indicates one corresponding feature is detected in the analysis,\n\
6642@var{stmt} is the statement being analyzed. Return true if target still\n\
6643need to analyze the subsequent statements, otherwise return false to stop\n\
6644subsequent analysis.\n\
6645The default version of this hook returns false.",
6646 bool, (unsigned int& info, const gimple* stmt),
6647 default_update_ipa_fn_target_info)
6648
6649DEFHOOK
6650(need_ipa_fn_target_info,
6651 "Allow target to check early whether it is necessary to analyze all gimple\n\
6652statements in the given function to update target specific information for\n\
6653inlining. See hook @code{update_ipa_fn_target_info} for usage example of\n\
6654target specific information. This hook is expected to be invoked ahead of\n\
6655the iterating with hook @code{update_ipa_fn_target_info}.\n\
6656@var{decl} is the function being analyzed, @var{info} is the same as what\n\
6657in hook @code{update_ipa_fn_target_info}, target can do one time update\n\
6658into @var{info} without iterating for some case. Return true if target\n\
6659decides to analyze all gimple statements to collect information, otherwise\n\
6660return false.\n\
6661The default version of this hook returns false.",
6662 bool, (const_tree decl, unsigned int& info),
6663 default_need_ipa_fn_target_info)
6664
6665DEFHOOK
6666(relayout_function,
6667"This target hook fixes function @var{fndecl} after attributes are processed.\n\
6668Default does nothing. On ARM, the default function's alignment is updated\n\
6669with the attribute target.",
6670 void, (tree fndecl),
6671 hook_void_tree)
6672
6673HOOK_VECTOR_END (target_option)
6674
6675/* For targets that need to mark extra registers as live on entry to
6676 the function, they should define this target hook and set their
6677 bits in the bitmap passed in. */
6678DEFHOOK
6679(extra_live_on_entry,
6680 "Add any hard registers to @var{regs} that are live on entry to the\n\
6681function. This hook only needs to be defined to provide registers that\n\
6682cannot be found by examination of FUNCTION_ARG_REGNO_P, the callee saved\n\
6683registers, STATIC_CHAIN_INCOMING_REGNUM, STATIC_CHAIN_REGNUM,\n\
6684TARGET_STRUCT_VALUE_RTX, FRAME_POINTER_REGNUM, EH_USES,\n\
6685FRAME_POINTER_REGNUM, ARG_POINTER_REGNUM, and the PIC_OFFSET_TABLE_REGNUM.",
6686 void, (bitmap regs),
6687 hook_void_bitmap)
6688
6689/* Targets should define this target hook to mark that non-callee clobbers are
6690 present in CALL_INSN_FUNCTION_USAGE for all the calls that bind to a local
6691 definition. */
6692DEFHOOKPOD
6693(call_fusage_contains_non_callee_clobbers,
6694 "Set to true if each call that binds to a local definition explicitly\n\
6695clobbers or sets all non-fixed registers modified by performing the call.\n\
6696That is, by the call pattern itself, or by code that might be inserted by the\n\
6697linker (e.g.@: stubs, veneers, branch islands), but not including those\n\
6698modifiable by the callee. The affected registers may be mentioned explicitly\n\
6699in the call pattern, or included as clobbers in CALL_INSN_FUNCTION_USAGE.\n\
6700The default version of this hook is set to false. The purpose of this hook\n\
6701is to enable the fipa-ra optimization.",
6702 bool,
6703 false)
6704
6705/* Fill in additional registers set up by prologue into a regset. */
6706DEFHOOK
6707(set_up_by_prologue,
6708 "This hook should add additional registers that are computed by the prologue\n\
6709to the hard regset for shrink-wrapping optimization purposes.",
6710 void, (struct hard_reg_set_container *),
6711 NULL)
6712
6713/* For targets that have attributes that can affect whether a
6714 function's return statements need checking. For instance a 'naked'
6715 function attribute. */
6716DEFHOOK
6717(warn_func_return,
6718 "True if a function's return statements should be checked for matching\n\
6719the function's return type. This includes checking for falling off the end\n\
6720of a non-void function. Return false if no such check should be made.",
6721 bool, (tree),
6722 hook_bool_tree_true)
6723
6724#undef HOOK_PREFIX
6725#define HOOK_PREFIX "TARGET_SHRINK_WRAP_"
6726HOOK_VECTOR (TARGET_SHRINK_WRAP_HOOKS, shrink_wrap)
6727
6728DEFHOOK
6729(get_separate_components,
6730 "This hook should return an @code{sbitmap} with the bits set for those\n\
6731components that can be separately shrink-wrapped in the current function.\n\
6732Return @code{NULL} if the current function should not get any separate\n\
6733shrink-wrapping.\n\
6734Don't define this hook if it would always return @code{NULL}.\n\
6735If it is defined, the other hooks in this group have to be defined as well.",
6736 sbitmap, (void),
6737 NULL)
6738
6739DEFHOOK
6740(components_for_bb,
6741 "This hook should return an @code{sbitmap} with the bits set for those\n\
6742components where either the prologue component has to be executed before\n\
6743the @code{basic_block}, or the epilogue component after it, or both.",
6744 sbitmap, (basic_block),
6745 NULL)
6746
6747DEFHOOK
6748(disqualify_components,
6749 "This hook should clear the bits in the @var{components} bitmap for those\n\
6750components in @var{edge_components} that the target cannot handle on edge\n\
6751@var{e}, where @var{is_prologue} says if this is for a prologue or an\n\
6752epilogue instead.",
6753 void, (sbitmap components, edge e, sbitmap edge_components, bool is_prologue),
6754 NULL)
6755
6756DEFHOOK
6757(emit_prologue_components,
6758 "Emit prologue insns for the components indicated by the parameter.",
6759 void, (sbitmap),
6760 NULL)
6761
6762DEFHOOK
6763(emit_epilogue_components,
6764 "Emit epilogue insns for the components indicated by the parameter.",
6765 void, (sbitmap),
6766 NULL)
6767
6768DEFHOOK
6769(set_handled_components,
6770 "Mark the components in the parameter as handled, so that the\n\
6771@code{prologue} and @code{epilogue} named patterns know to ignore those\n\
6772components. The target code should not hang on to the @code{sbitmap}, it\n\
6773will be deleted after this call.",
6774 void, (sbitmap),
6775 NULL)
6776
6777HOOK_VECTOR_END (shrink_wrap)
6778#undef HOOK_PREFIX
6779#define HOOK_PREFIX "TARGET_"
6780
6781/* Determine the type of unwind info to emit for debugging. */
6782DEFHOOK
6783(debug_unwind_info,
6784 "This hook defines the mechanism that will be used for describing frame\n\
6785unwind information to the debugger. Normally the hook will return\n\
6786@code{UI_DWARF2} if DWARF 2 debug information is enabled, and\n\
6787return @code{UI_NONE} otherwise.\n\
6788\n\
6789A target may return @code{UI_DWARF2} even when DWARF 2 debug information\n\
6790is disabled in order to always output DWARF 2 frame information.\n\
6791\n\
6792A target may return @code{UI_TARGET} if it has ABI specified unwind tables.\n\
6793This will suppress generation of the normal debug frame unwind information.",
6794 enum unwind_info_type, (void),
6795 default_debug_unwind_info)
6796
6797DEFHOOK
6798(reset_location_view,
6799 "This hook, if defined, enables -ginternal-reset-location-views, and\n\
6800uses its result to override cases in which the estimated min insn\n\
6801length might be nonzero even when a PC advance (i.e., a view reset)\n\
6802cannot be taken for granted.\n\
6803\n\
6804If the hook is defined, it must return a positive value to indicate\n\
6805the insn definitely advances the PC, and so the view number can be\n\
6806safely assumed to be reset; a negative value to mean the insn\n\
6807definitely does not advance the PC, and os the view number must not\n\
6808be reset; or zero to decide based on the estimated insn length.\n\
6809\n\
6810If insn length is to be regarded as reliable, set the hook to\n\
6811@code{hook_int_rtx_insn_0}.",
6812 int, (rtx_insn *), NULL)
6813
6814/* The code parameter should be of type enum rtx_code but this is not
6815 defined at this time. */
6816DEFHOOK
6817(canonicalize_comparison,
6818 "On some machines not all possible comparisons are defined, but you can\n\
6819convert an invalid comparison into a valid one. For example, the Alpha\n\
6820does not have a @code{GT} comparison, but you can use an @code{LT}\n\
6821comparison instead and swap the order of the operands.\n\
6822\n\
6823On such machines, implement this hook to do any required conversions.\n\
6824@var{code} is the initial comparison code and @var{op0} and @var{op1}\n\
6825are the left and right operands of the comparison, respectively. If\n\
6826@var{op0_preserve_value} is @code{true} the implementation is not\n\
6827allowed to change the value of @var{op0} since the value might be used\n\
6828in RTXs which aren't comparisons. E.g. the implementation is not\n\
6829allowed to swap operands in that case.\n\
6830\n\
6831GCC will not assume that the comparison resulting from this macro is\n\
6832valid but will see if the resulting insn matches a pattern in the\n\
6833@file{md} file.\n\
6834\n\
6835You need not to implement this hook if it would never change the\n\
6836comparison code or operands.",
6837 void, (int *code, rtx *op0, rtx *op1, bool op0_preserve_value),
6838 default_canonicalize_comparison)
6839
6840DEFHOOK
6841(min_arithmetic_precision,
6842 "On some RISC architectures with 64-bit registers, the processor also\n\
6843maintains 32-bit condition codes that make it possible to do real 32-bit\n\
6844arithmetic, although the operations are performed on the full registers.\n\
6845\n\
6846On such architectures, defining this hook to 32 tells the compiler to try\n\
6847using 32-bit arithmetical operations setting the condition codes instead\n\
6848of doing full 64-bit arithmetic.\n\
6849\n\
6850More generally, define this hook on RISC architectures if you want the\n\
6851compiler to try using arithmetical operations setting the condition codes\n\
6852with a precision lower than the word precision.\n\
6853\n\
6854You need not define this hook if @code{WORD_REGISTER_OPERATIONS} is not\n\
6855defined to 1.",
6856 unsigned int, (void), default_min_arithmetic_precision)
6857
6858DEFHOOKPOD
6859(atomic_test_and_set_trueval,
6860 "This value should be set if the result written by\n\
6861@code{atomic_test_and_set} is not exactly 1, i.e.@: the\n\
6862@code{bool} @code{true}.",
6863 unsigned char, 1)
6864
6865/* Return an unsigned int representing the alignment (in bits) of the atomic
6866 type which maps to machine MODE. This allows alignment to be overridden
6867 as needed. */
6868DEFHOOK
6869(atomic_align_for_mode,
6870"If defined, this function returns an appropriate alignment in bits for an\n\
6871atomic object of machine_mode @var{mode}. If 0 is returned then the\n\
6872default alignment for the specified mode is used.",
6873 unsigned int, (machine_mode mode),
6874 hook_uint_mode_0)
6875
6876DEFHOOK
6877(atomic_assign_expand_fenv,
6878"ISO C11 requires atomic compound assignments that may raise floating-point\n\
6879exceptions to raise exceptions corresponding to the arithmetic operation\n\
6880whose result was successfully stored in a compare-and-exchange sequence.\n\
6881This requires code equivalent to calls to @code{feholdexcept},\n\
6882@code{feclearexcept} and @code{feupdateenv} to be generated at\n\
6883appropriate points in the compare-and-exchange sequence. This hook should\n\
6884set @code{*@var{hold}} to an expression equivalent to the call to\n\
6885@code{feholdexcept}, @code{*@var{clear}} to an expression equivalent to\n\
6886the call to @code{feclearexcept} and @code{*@var{update}} to an expression\n\
6887equivalent to the call to @code{feupdateenv}. The three expressions are\n\
6888@code{NULL_TREE} on entry to the hook and may be left as @code{NULL_TREE}\n\
6889if no code is required in a particular place. The default implementation\n\
6890leaves all three expressions as @code{NULL_TREE}. The\n\
6891@code{__atomic_feraiseexcept} function from @code{libatomic} may be of use\n\
6892as part of the code generated in @code{*@var{update}}.",
6893 void, (tree *hold, tree *clear, tree *update),
6894 default_atomic_assign_expand_fenv)
6895
6896/* Leave the boolean fields at the end. */
6897
6898/* True if we can create zeroed data by switching to a BSS section
6899 and then using ASM_OUTPUT_SKIP to allocate the space. */
6900DEFHOOKPOD
6901(have_switchable_bss_sections,
6902 "This flag is true if we can create zeroed data by switching to a BSS\n\
6903section and then using @code{ASM_OUTPUT_SKIP} to allocate the space.\n\
6904This is true on most ELF targets.",
6905 bool, false)
6906
6907/* True if "native" constructors and destructors are supported,
6908 false if we're using collect2 for the job. */
6909DEFHOOKPOD
6910(have_ctors_dtors,
6911 "This value is true if the target supports some ``native'' method of\n\
6912collecting constructors and destructors to be run at startup and exit.\n\
6913It is false if we must use @command{collect2}.",
6914 bool, false)
6915
6916/* True if the target wants DTORs to be run from cxa_atexit. */
6917DEFHOOKPOD
6918(dtors_from_cxa_atexit,
6919 "This value is true if the target wants destructors to be queued to be\n\
6920run from __cxa_atexit. If this is the case then, for each priority level,\n\
6921a new constructor will be entered that registers the destructors for that\n\
6922level with __cxa_atexit (and there will be no destructors emitted).\n\
6923It is false the method implied by @code{have_ctors_dtors} is used.",
6924 bool, false)
6925
6926/* True if thread-local storage is supported. */
6927DEFHOOKPOD
6928(have_tls,
6929 "Contains the value true if the target supports thread-local storage.\n\
6930The default value is false.",
6931 bool, false)
6932
6933/* True if a small readonly data section is supported. */
6934DEFHOOKPOD
6935(have_srodata_section,
6936 "Contains the value true if the target places read-only\n\
6937``small data'' into a separate section. The default value is false.",
6938 bool, false)
6939
6940/* True if EH frame info sections should be zero-terminated. */
6941DEFHOOKPOD
6942(terminate_dw2_eh_frame_info,
6943 "Contains the value true if the target should add a zero word onto the\n\
6944end of a Dwarf-2 frame info section when used for exception handling.\n\
6945Default value is false if @code{EH_FRAME_SECTION_NAME} is defined, and\n\
6946true otherwise.",
6947 bool, true)
6948
6949/* True if #NO_APP should be emitted at the beginning of assembly output. */
6950DEFHOOKPOD
6951(asm_file_start_app_off,
6952 "If this flag is true, the text of the macro @code{ASM_APP_OFF} will be\n\
6953printed as the very first line in the assembly file, unless\n\
6954@option{-fverbose-asm} is in effect. (If that macro has been defined\n\
6955to the empty string, this variable has no effect.) With the normal\n\
6956definition of @code{ASM_APP_OFF}, the effect is to notify the GNU\n\
6957assembler that it need not bother stripping comments or extra\n\
6958whitespace from its input. This allows it to work a bit faster.\n\
6959\n\
6960The default is false. You should not set it to true unless you have\n\
6961verified that your port does not generate any extra whitespace or\n\
6962comments that will cause GAS to issue errors in NO_APP mode.",
6963 bool, false)
6964
6965/* True if output_file_directive should be called for main_input_filename
6966 at the beginning of assembly output. */
6967DEFHOOKPOD
6968(asm_file_start_file_directive,
6969 "If this flag is true, @code{output_file_directive} will be called\n\
6970for the primary source file, immediately after printing\n\
6971@code{ASM_APP_OFF} (if that is enabled). Most ELF assemblers expect\n\
6972this to be done. The default is false.",
6973 bool, false)
6974
6975/* Returns true if we should generate exception tables for use with the
6976 ARM EABI. The effects the encoding of function exception specifications. */
6977DEFHOOKPOD
6978(arm_eabi_unwinder,
6979 "This flag should be set to @code{true} on targets that use an ARM EABI\n\
6980based unwinding library, and @code{false} on other targets. This effects\n\
6981the format of unwinding tables, and how the unwinder in entered after\n\
6982running a cleanup. The default is @code{false}.",
6983 bool, false)
6984
6985DEFHOOKPOD
6986(want_debug_pub_sections,
6987 "True if the @code{.debug_pubtypes} and @code{.debug_pubnames} sections\n\
6988should be emitted. These sections are not used on most platforms, and\n\
6989in particular GDB does not use them.",
6990 bool, false)
6991
6992DEFHOOKPOD
6993(delay_sched2,
6994 "True if sched2 is not to be run at its normal place.\n\
6995This usually means it will be run as part of machine-specific reorg.",
6996bool, false)
6997
6998DEFHOOKPOD
6999(delay_vartrack,
7000 "True if vartrack is not to be run at its normal place.\n\
7001This usually means it will be run as part of machine-specific reorg.",
7002bool, false)
7003
7004DEFHOOKPOD
7005(no_register_allocation,
7006 "True if register allocation and the passes\n\
7007following it should not be run. Usually true only for virtual assembler\n\
7008targets.",
7009bool, false)
7010
7011/* Leave the boolean fields at the end. */
7012
7013/* Functions related to mode switching. */
7014#undef HOOK_PREFIX
7015#define HOOK_PREFIX "TARGET_MODE_"
7016HOOK_VECTOR (TARGET_TOGGLE_, mode_switching)
7017
7018DEFHOOK
7019(emit,
7020 "Generate one or more insns to set @var{entity} to @var{mode}.\n\
7021@var{hard_reg_live} is the set of hard registers live at the point where\n\
7022the insn(s) are to be inserted. @var{prev_moxde} indicates the mode\n\
7023to switch from. Sets of a lower numbered entity will be emitted before\n\
7024sets of a higher numbered entity to a mode of the same or lower priority.",
7025 void, (int entity, int mode, int prev_mode, HARD_REG_SET regs_live), NULL)
7026
7027DEFHOOK
7028(needed,
7029 "@var{entity} is an integer specifying a mode-switched entity.\n\
7030If @code{OPTIMIZE_MODE_SWITCHING} is defined, you must define this macro\n\
7031to return an integer value not larger than the corresponding element\n\
7032in @code{NUM_MODES_FOR_MODE_SWITCHING}, to denote the mode that @var{entity}\n\
7033must be switched into prior to the execution of @var{insn}.",
7034 int, (int entity, rtx_insn *insn), NULL)
7035
7036DEFHOOK
7037(after,
7038 "@var{entity} is an integer specifying a mode-switched entity.\n\
7039If this macro is defined, it is evaluated for every @var{insn} during mode\n\
7040switching. It determines the mode that an insn results\n\
7041in (if different from the incoming mode).",
7042 int, (int entity, int mode, rtx_insn *insn), NULL)
7043
7044DEFHOOK
7045(entry,
7046 "If this macro is defined, it is evaluated for every @var{entity} that\n\
7047needs mode switching. It should evaluate to an integer, which is a mode\n\
7048that @var{entity} is assumed to be switched to at function entry.\n\
7049If @code{TARGET_MODE_ENTRY} is defined then @code{TARGET_MODE_EXIT}\n\
7050must be defined.",
7051 int, (int entity), NULL)
7052
7053DEFHOOK
7054(exit,
7055 "If this macro is defined, it is evaluated for every @var{entity} that\n\
7056needs mode switching. It should evaluate to an integer, which is a mode\n\
7057that @var{entity} is assumed to be switched to at function exit.\n\
7058If @code{TARGET_MODE_EXIT} is defined then @code{TARGET_MODE_ENTRY}\n\
7059must be defined.",
7060 int, (int entity), NULL)
7061
7062DEFHOOK
7063(priority,
7064 "This macro specifies the order in which modes for @var{entity}\n\
7065are processed. 0 is the highest priority,\n\
7066@code{NUM_MODES_FOR_MODE_SWITCHING[@var{entity}] - 1} the lowest.\n\
7067The value of the macro should be an integer designating a mode\n\
7068for @var{entity}. For any fixed @var{entity}, @code{mode_priority}\n\
7069(@var{entity}, @var{n}) shall be a bijection in 0 @dots{}\n\
7070@code{num_modes_for_mode_switching[@var{entity}] - 1}.",
7071 int, (int entity, int n), NULL)
7072
7073HOOK_VECTOR_END (mode_switching)
7074
7075#undef HOOK_PREFIX
7076#define HOOK_PREFIX "TARGET_MEMTAG_"
7077HOOK_VECTOR (TARGET_MEMTAG_, memtag)
7078
7079DEFHOOK
7080(can_tag_addresses,
7081 "True if the backend architecture naturally supports ignoring some region\n\
7082of pointers. This feature means that @option{-fsanitize=hwaddress} can\n\
7083work.\n\
7084\n\
7085At preset, this feature does not support address spaces. It also requires\n\
7086@code{Pmode} to be the same as @code{ptr_mode}.",
7087 bool, (), default_memtag_can_tag_addresses)
7088
7089DEFHOOK
7090(tag_size,
7091 "Return the size of a tag (in bits) for this platform.\n\
7092\n\
7093The default returns 8.",
7094 uint8_t, (), default_memtag_tag_size)
7095
7096DEFHOOK
7097(granule_size,
7098 "Return the size in real memory that each byte in shadow memory refers to.\n\
7099I.e. if a variable is @var{X} bytes long in memory, then this hook should\n\
7100return the value @var{Y} such that the tag in shadow memory spans\n\
7101@var{X}/@var{Y} bytes.\n\
7102\n\
7103Most variables will need to be aligned to this amount since two variables\n\
7104that are neighbors in memory and share a tag granule would need to share\n\
7105the same tag.\n\
7106\n\
7107The default returns 16.",
7108 uint8_t, (), default_memtag_granule_size)
7109
7110DEFHOOK
7111(insert_random_tag,
7112 "Return an RTX representing the value of @var{untagged} but with a\n\
7113(possibly) random tag in it.\n\
7114Put that value into @var{target} if it is convenient to do so.\n\
7115This function is used to generate a tagged base for the current stack frame.",
7116 rtx, (rtx untagged, rtx target), default_memtag_insert_random_tag)
7117
7118DEFHOOK
7119(add_tag,
7120 "Return an RTX that represents the result of adding @var{addr_offset} to\n\
7121the address in pointer @var{base} and @var{tag_offset} to the tag in pointer\n\
7122@var{base}.\n\
7123The resulting RTX must either be a valid memory address or be able to get\n\
7124put into an operand with @code{force_operand}.\n\
7125\n\
7126Unlike other memtag hooks, this must return an expression and not emit any\n\
7127RTL.",
7128 rtx, (rtx base, poly_int64 addr_offset, uint8_t tag_offset),
7129 default_memtag_add_tag)
7130
7131DEFHOOK
7132(set_tag,
7133 "Return an RTX representing @var{untagged_base} but with the tag @var{tag}.\n\
7134Try and store this in @var{target} if convenient.\n\
7135@var{untagged_base} is required to have a zero tag when this hook is called.\n\
7136The default of this hook is to set the top byte of @var{untagged_base} to\n\
7137@var{tag}.",
7138 rtx, (rtx untagged_base, rtx tag, rtx target), default_memtag_set_tag)
7139
7140DEFHOOK
7141(extract_tag,
7142 "Return an RTX representing the tag stored in @var{tagged_pointer}.\n\
7143Store the result in @var{target} if it is convenient.\n\
7144The default represents the top byte of the original pointer.",
7145 rtx, (rtx tagged_pointer, rtx target), default_memtag_extract_tag)
7146
7147DEFHOOK
7148(untagged_pointer,
7149 "Return an RTX representing @var{tagged_pointer} with its tag set to zero.\n\
7150Store the result in @var{target} if convenient.\n\
7151The default clears the top byte of the original pointer.",
7152 rtx, (rtx tagged_pointer, rtx target), default_memtag_untagged_pointer)
7153
7154HOOK_VECTOR_END (memtag)
7155#undef HOOK_PREFIX
7156#define HOOK_PREFIX "TARGET_"
7157
7158#define DEF_TARGET_INSN(NAME, PROTO) \
7159 DEFHOOK_UNDOC (have_##NAME, "", bool, (void), false)
7160#include "target-insns.def"
7161#undef DEF_TARGET_INSN
7162
7163#define DEF_TARGET_INSN(NAME, PROTO) \
7164 DEFHOOK_UNDOC (gen_##NAME, "", rtx_insn *, PROTO, NULL)
7165#include "target-insns.def"
7166#undef DEF_TARGET_INSN
7167
7168#define DEF_TARGET_INSN(NAME, PROTO) \
7169 DEFHOOKPOD (code_for_##NAME, "*", enum insn_code, CODE_FOR_nothing)
7170#include "target-insns.def"
7171#undef DEF_TARGET_INSN
7172
7173DEFHOOK
7174(run_target_selftests,
7175 "If selftests are enabled, run any selftests for this target.",
7176 void, (void),
7177 NULL)
7178
7179DEFHOOK
7180(gcov_type_size,
7181 "Returns the gcov type size in bits. This type is used for example for\n\
7182counters incremented by profiling and code-coverage events. The default\n\
7183value is 64, if the type size of long long is greater than 32, otherwise the\n\
7184default value is 32. A 64-bit type is recommended to avoid overflows of the\n\
7185counters. If the @option{-fprofile-update=atomic} is used, then the\n\
7186counters are incremented using atomic operations. Targets not supporting\n\
718764-bit atomic operations may override the default value and request a 32-bit\n\
7188type.",
7189 HOST_WIDE_INT, (void), default_gcov_type_size)
7190
7191/* This value represents whether the shadow call stack is implemented on
7192 the target platform. */
7193DEFHOOKPOD
7194(have_shadow_call_stack,
7195 "This value is true if the target platform supports\n\
7196@option{-fsanitize=shadow-call-stack}. The default value is false.",
7197 bool, false)
7198
7199/* Close the 'struct gcc_target' definition. */
7200HOOK_VECTOR_END (C90_EMPTY_HACK)
7201
7202

source code of gcc/target.def