]>
Commit | Line | Data |
---|---|---|
38f8b050 | 1 | /* Target hook definitions. |
96e45421 | 2 | Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, |
ee3d2ecd | 3 | 2011, 2012 |
38f8b050 JR |
4 | Free Software Foundation, Inc. |
5 | ||
6 | This program is free software; you can redistribute it and/or modify it | |
7 | under the terms of the GNU General Public License as published by the | |
8 | Free Software Foundation; either version 3, or (at your option) any | |
9 | later version. | |
10 | ||
11 | This program is distributed in the hope that it will be useful, | |
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | GNU General Public License for more details. | |
15 | ||
16 | You should have received a copy of the GNU General Public License | |
17 | along with this program; see the file COPYING3. If not see | |
18 | <http://www.gnu.org/licenses/>. | |
19 | ||
20 | In other words, you are welcome to use, share and improve this program. | |
21 | You are forbidden to forbid anyone else to use, share and improve | |
22 | what you give them. Help stamp out software-hoarding! */ | |
23 | ||
acce4e77 JM |
24 | /* See target-hooks-macros.h for details of macros that should be |
25 | provided by the including file, and how to use them here. */ | |
26 | #include "target-hooks-macros.h" | |
38f8b050 | 27 | |
acce4e77 JM |
28 | #undef HOOK_TYPE |
29 | #define HOOK_TYPE "Target Hook" | |
38f8b050 | 30 | |
acce4e77 | 31 | HOOK_VECTOR (TARGET_INITIALIZER, gcc_target) |
38f8b050 JR |
32 | |
33 | /* Functions that output assembler for the target. */ | |
34 | #define HOOK_PREFIX "TARGET_ASM_" | |
35 | HOOK_VECTOR (TARGET_ASM_OUT, asm_out) | |
36 | ||
37 | /* Opening and closing parentheses for asm expression grouping. */ | |
38 | DEFHOOKPOD | |
39 | (open_paren, | |
40 | "", | |
41 | const char *, "(") | |
42 | DEFHOOKPODX (close_paren, const char *, ")") | |
43 | ||
44 | /* Assembler instructions for creating various kinds of integer object. */ | |
45 | DEFHOOKPOD | |
46 | (byte_op, | |
47 | "", | |
48 | const char *, "\t.byte\t") | |
49 | DEFHOOKPOD (aligned_op, "*", struct asm_int_op, TARGET_ASM_ALIGNED_INT_OP) | |
50 | DEFHOOKPOD (unaligned_op, "*", struct asm_int_op, TARGET_ASM_UNALIGNED_INT_OP) | |
51 | ||
ad0c4c36 DD |
52 | /* The maximum number of bytes to skip when applying |
53 | LABEL_ALIGN_AFTER_BARRIER. */ | |
54 | DEFHOOK | |
55 | (label_align_after_barrier_max_skip, | |
56 | "", | |
57 | int, (rtx label), | |
58 | default_label_align_after_barrier_max_skip) | |
59 | ||
60 | /* The maximum number of bytes to skip when applying | |
61 | LOOP_ALIGN. */ | |
62 | DEFHOOK | |
63 | (loop_align_max_skip, | |
64 | "", | |
65 | int, (rtx label), | |
66 | default_loop_align_max_skip) | |
67 | ||
68 | /* The maximum number of bytes to skip when applying | |
69 | LABEL_ALIGN. */ | |
70 | DEFHOOK | |
71 | (label_align_max_skip, | |
72 | "", | |
73 | int, (rtx label), | |
74 | default_label_align_max_skip) | |
75 | ||
76 | /* The maximum number of bytes to skip when applying | |
77 | JUMP_ALIGN. */ | |
78 | DEFHOOK | |
79 | (jump_align_max_skip, | |
80 | "", | |
81 | int, (rtx label), | |
82 | default_jump_align_max_skip) | |
83 | ||
38f8b050 JR |
84 | /* Try to output the assembler code for an integer object whose |
85 | value is given by X. SIZE is the size of the object in bytes and | |
86 | ALIGNED_P indicates whether it is aligned. Return true if | |
87 | successful. Only handles cases for which BYTE_OP, ALIGNED_OP | |
88 | and UNALIGNED_OP are NULL. */ | |
89 | DEFHOOK | |
90 | (integer, | |
91 | "", | |
92 | /* Only handles cases for which BYTE_OP, ALIGNED_OP and UNALIGNED_OP are | |
93 | NULL. */ | |
94 | bool, (rtx x, unsigned int size, int aligned_p), | |
95 | default_assemble_integer) | |
96 | ||
97 | /* Output code that will globalize a label. */ | |
98 | DEFHOOK | |
99 | (globalize_label, | |
100 | "", | |
101 | void, (FILE *stream, const char *name), | |
102 | default_globalize_label) | |
103 | ||
104 | /* Output code that will globalize a declaration. */ | |
105 | DEFHOOK | |
106 | (globalize_decl_name, | |
107 | "", | |
108 | void, (FILE *stream, tree decl), default_globalize_decl_name) | |
109 | ||
110 | /* Output code that will emit a label for unwind info, if this | |
111 | target requires such labels. Second argument is the decl the | |
112 | unwind info is associated with, third is a boolean: true if | |
113 | this is for exception handling, fourth is a boolean: true if | |
114 | this is only a placeholder for an omitted FDE. */ | |
115 | DEFHOOK | |
116 | (emit_unwind_label, | |
117 | "", | |
118 | void, (FILE *stream, tree decl, int for_eh, int empty), | |
119 | default_emit_unwind_label) | |
120 | ||
121 | /* Output code that will emit a label to divide up the exception table. */ | |
122 | DEFHOOK | |
123 | (emit_except_table_label, | |
124 | "", | |
125 | void, (FILE *stream), | |
126 | default_emit_except_table_label) | |
127 | ||
a68b5e52 RH |
128 | /* Emit a directive for setting the personality for the function. */ |
129 | DEFHOOK | |
130 | (emit_except_personality, | |
131 | "If the target implements @code{TARGET_ASM_UNWIND_EMIT}, this hook may be\ | |
132 | used to emit a directive to install a personality hook into the unwind\ | |
133 | info. This hook should not be used if dwarf2 unwind info is used.", | |
134 | void, (rtx personality), | |
135 | NULL) | |
136 | ||
38f8b050 JR |
137 | /* Emit any directives required to unwind this instruction. */ |
138 | DEFHOOK | |
139 | (unwind_emit, | |
140 | "", | |
141 | void, (FILE *stream, rtx insn), | |
2784ed9c | 142 | NULL) |
38f8b050 | 143 | |
3bc6b3e6 RH |
144 | DEFHOOKPOD |
145 | (unwind_emit_before_insn, | |
146 | "True if the @code{TARGET_ASM_UNWIND_EMIT} hook should be called before\ | |
147 | the assembly for @var{insn} has been emitted, false if the hook should\ | |
148 | be called afterward.", | |
149 | bool, true) | |
150 | ||
4ee3b013 JR |
151 | /* Generate an internal label. |
152 | For now this is just a wrapper for ASM_GENERATE_INTERNAL_LABEL. */ | |
153 | DEFHOOK_UNDOC | |
154 | (generate_internal_label, | |
155 | "", | |
156 | void, (char *buf, const char *prefix, unsigned long labelno), | |
157 | default_generate_internal_label) | |
158 | ||
38f8b050 JR |
159 | /* Output an internal label. */ |
160 | DEFHOOK | |
161 | (internal_label, | |
162 | "", | |
163 | void, (FILE *stream, const char *prefix, unsigned long labelno), | |
164 | default_internal_label) | |
165 | ||
166 | /* Output label for the constant. */ | |
ad78130c | 167 | DEFHOOK |
38f8b050 JR |
168 | (declare_constant_name, |
169 | "", | |
ad78130c | 170 | void, (FILE *file, const char *name, const_tree expr, HOST_WIDE_INT size), |
38f8b050 JR |
171 | default_asm_declare_constant_name) |
172 | ||
173 | /* Emit a ttype table reference to a typeinfo object. */ | |
174 | DEFHOOK | |
175 | (ttype, | |
176 | "", | |
177 | bool, (rtx sym), | |
178 | hook_bool_rtx_false) | |
179 | ||
180 | /* Emit an assembler directive to set visibility for the symbol | |
181 | associated with the tree decl. */ | |
182 | DEFHOOK | |
183 | (assemble_visibility, | |
184 | "", | |
185 | void, (tree decl, int visibility), | |
186 | default_assemble_visibility) | |
187 | ||
188 | /* Output the assembler code for entry to a function. */ | |
189 | DEFHOOK | |
190 | (function_prologue, | |
191 | "", | |
192 | void, (FILE *file, HOST_WIDE_INT size), | |
193 | default_function_pro_epilogue) | |
194 | ||
195 | /* Output the assembler code for end of prologue. */ | |
196 | DEFHOOK | |
197 | (function_end_prologue, | |
198 | "", | |
199 | void, (FILE *file), | |
200 | no_asm_to_stream) | |
201 | ||
202 | /* Output the assembler code for start of epilogue. */ | |
203 | DEFHOOK | |
204 | (function_begin_epilogue, | |
205 | "", | |
206 | void, (FILE *file), | |
207 | no_asm_to_stream) | |
208 | ||
209 | /* Output the assembler code for function exit. */ | |
210 | DEFHOOK | |
211 | (function_epilogue, | |
212 | "", | |
213 | void, (FILE *file, HOST_WIDE_INT size), | |
214 | default_function_pro_epilogue) | |
215 | ||
216 | /* Initialize target-specific sections. */ | |
217 | DEFHOOK | |
218 | (init_sections, | |
219 | "", | |
220 | void, (void), | |
221 | hook_void_void) | |
222 | ||
223 | /* Tell assembler to change to section NAME with attributes FLAGS. | |
224 | If DECL is non-NULL, it is the VAR_DECL or FUNCTION_DECL with | |
225 | which this section is associated. */ | |
226 | DEFHOOK | |
227 | (named_section, | |
228 | "", | |
229 | void, (const char *name, unsigned int flags, tree decl), | |
230 | default_no_named_section) | |
231 | ||
f16d3f39 JH |
232 | /* Return preferred text (sub)section for function DECL. |
233 | Main purpose of this function is to separate cold, normal and hot | |
234 | functions. STARTUP is true when function is known to be used only | |
235 | at startup (from static constructors or it is main()). | |
236 | EXIT is true when function is known to be used only at exit | |
237 | (from static destructors). | |
238 | Return NULL if function should go to default text section. */ | |
239 | DEFHOOK | |
240 | (function_section, | |
241 | "", | |
242 | section *, (tree decl, enum node_frequency freq, bool startup, bool exit), | |
243 | default_function_section) | |
244 | ||
14d11d40 IS |
245 | /* Output the assembler code for function exit. */ |
246 | DEFHOOK | |
247 | (function_switched_text_sections, | |
248 | "Used by the target to emit any assembler directives or additional\ | |
249 | labels needed when a function is partitioned between different\ | |
250 | sections. Output should be written to @var{file}. The function\ | |
251 | decl is available as @var{decl} and the new section is `cold' if\ | |
252 | @var{new_is_cold} is @code{true}.", | |
253 | void, (FILE *file, tree decl, bool new_is_cold), | |
254 | default_function_switched_text_sections) | |
255 | ||
38f8b050 JR |
256 | /* Return a mask describing how relocations should be treated when |
257 | selecting sections. Bit 1 should be set if global relocations | |
258 | should be placed in a read-write section; bit 0 should be set if | |
259 | local relocations should be placed in a read-write section. */ | |
260 | DEFHOOK | |
261 | (reloc_rw_mask, | |
262 | "", | |
263 | int, (void), | |
264 | default_reloc_rw_mask) | |
265 | ||
266 | /* Return a section for EXP. It may be a DECL or a constant. RELOC | |
267 | is nonzero if runtime relocations must be applied; bit 1 will be | |
268 | set if the runtime relocations require non-local name resolution. | |
269 | ALIGN is the required alignment of the data. */ | |
270 | DEFHOOK | |
271 | (select_section, | |
272 | "", | |
273 | section *, (tree exp, int reloc, unsigned HOST_WIDE_INT align), | |
274 | default_select_section) | |
275 | ||
276 | /* Return a section for X. MODE is X's mode and ALIGN is its | |
277 | alignment in bits. */ | |
278 | DEFHOOK | |
279 | (select_rtx_section, | |
280 | "", | |
281 | section *, (enum machine_mode mode, rtx x, unsigned HOST_WIDE_INT align), | |
282 | default_select_rtx_section) | |
283 | ||
284 | /* Select a unique section name for DECL. RELOC is the same as | |
285 | for SELECT_SECTION. */ | |
286 | DEFHOOK | |
287 | (unique_section, | |
288 | "", | |
289 | void, (tree decl, int reloc), | |
290 | default_unique_section) | |
291 | ||
292 | /* Return the readonly data section associated with function DECL. */ | |
293 | DEFHOOK | |
294 | (function_rodata_section, | |
295 | "", | |
296 | section *, (tree decl), | |
297 | default_function_rodata_section) | |
298 | ||
727a65e6 BS |
299 | /* Nonnull if the target wants to override the default ".rodata" prefix |
300 | for mergeable data sections. */ | |
301 | DEFHOOKPOD | |
302 | (mergeable_rodata_prefix, | |
303 | "Usually, the compiler uses the prefix @code{\".rodata\"} to construct\n\ | |
304 | section names for mergeable constant data. Define this macro to override\n\ | |
305 | the string if a different section name should be used.", | |
306 | const char *, ".rodata") | |
307 | ||
50b0b78a IS |
308 | /* Return the section to be used for transactional memory clone tables. */ |
309 | DEFHOOK | |
310 | (tm_clone_table_section, | |
311 | "Return the section that should be used for transactional memory clone\ | |
312 | tables.", | |
313 | section *, (void), default_clone_table_section) | |
314 | ||
38f8b050 JR |
315 | /* Output a constructor for a symbol with a given priority. */ |
316 | DEFHOOK | |
317 | (constructor, | |
318 | "", | |
319 | void, (rtx symbol, int priority), NULL) | |
320 | ||
321 | /* Output a destructor for a symbol with a given priority. */ | |
322 | DEFHOOK | |
323 | (destructor, | |
324 | "", | |
325 | void, (rtx symbol, int priority), NULL) | |
326 | ||
327 | /* Output the assembler code for a thunk function. THUNK_DECL is the | |
328 | declaration for the thunk function itself, FUNCTION is the decl for | |
329 | the target function. DELTA is an immediate constant offset to be | |
330 | added to THIS. If VCALL_OFFSET is nonzero, the word at | |
331 | *(*this + vcall_offset) should be added to THIS. */ | |
332 | DEFHOOK | |
333 | (output_mi_thunk, | |
334 | "", | |
335 | void, (FILE *file, tree thunk_fndecl, HOST_WIDE_INT delta, | |
336 | HOST_WIDE_INT vcall_offset, tree function), | |
337 | NULL) | |
338 | ||
339 | /* Determine whether output_mi_thunk would succeed. */ | |
340 | /* ??? Ideally, this hook would not exist, and success or failure | |
341 | would be returned from output_mi_thunk directly. But there's | |
342 | too much undo-able setup involved in invoking output_mi_thunk. | |
343 | Could be fixed by making output_mi_thunk emit rtl instead of | |
344 | text to the output file. */ | |
345 | DEFHOOK | |
346 | (can_output_mi_thunk, | |
347 | "", | |
348 | bool, (const_tree thunk_fndecl, HOST_WIDE_INT delta, | |
349 | HOST_WIDE_INT vcall_offset, const_tree function), | |
350 | hook_bool_const_tree_hwi_hwi_const_tree_false) | |
351 | ||
352 | /* Output any boilerplate text needed at the beginning of a | |
353 | translation unit. */ | |
354 | DEFHOOK | |
355 | (file_start, | |
356 | "", | |
357 | void, (void), | |
358 | default_file_start) | |
359 | ||
360 | /* Output any boilerplate text needed at the end of a translation unit. */ | |
361 | DEFHOOK | |
362 | (file_end, | |
363 | "", | |
364 | void, (void), | |
365 | hook_void_void) | |
366 | ||
367 | /* Output any boilerplate text needed at the beginning of an | |
368 | LTO output stream. */ | |
369 | DEFHOOK | |
370 | (lto_start, | |
371 | "", | |
372 | void, (void), | |
373 | hook_void_void) | |
374 | ||
375 | /* Output any boilerplate text needed at the end of an | |
376 | LTO output stream. */ | |
377 | DEFHOOK | |
378 | (lto_end, | |
379 | "", | |
380 | void, (void), | |
381 | hook_void_void) | |
382 | ||
383 | /* Output any boilerplace text needed at the end of a | |
384 | translation unit before debug and unwind info is emitted. */ | |
385 | DEFHOOK | |
386 | (code_end, | |
387 | "", | |
388 | void, (void), | |
389 | hook_void_void) | |
390 | ||
391 | /* Output an assembler pseudo-op to declare a library function name | |
392 | external. */ | |
393 | DEFHOOK | |
394 | (external_libcall, | |
395 | "", | |
396 | void, (rtx symref), | |
397 | default_external_libcall) | |
398 | ||
399 | /* Output an assembler directive to mark decl live. This instructs | |
400 | linker to not dead code strip this symbol. */ | |
401 | DEFHOOK | |
402 | (mark_decl_preserved, | |
403 | "", | |
404 | void, (const char *symbol), | |
405 | hook_void_constcharptr) | |
406 | ||
407 | /* Output a record of the command line switches that have been passed. */ | |
408 | DEFHOOK | |
409 | (record_gcc_switches, | |
410 | "", | |
411 | int, (print_switch_type type, const char *text), | |
412 | NULL) | |
413 | ||
414 | /* The name of the section that the example ELF implementation of | |
415 | record_gcc_switches will use to store the information. Target | |
416 | specific versions of record_gcc_switches may or may not use | |
417 | this information. */ | |
418 | DEFHOOKPOD | |
419 | (record_gcc_switches_section, | |
420 | "", | |
421 | const char *, ".GCC.command.line") | |
422 | ||
423 | /* Output the definition of a section anchor. */ | |
424 | DEFHOOK | |
425 | (output_anchor, | |
426 | "", | |
427 | void, (rtx x), | |
428 | default_asm_output_anchor) | |
429 | ||
a8781821 SB |
430 | DEFHOOK |
431 | (output_ident, | |
432 | "Output a string based on @var{name}, suitable for the @samp{#ident} \ | |
433 | directive, or the equivalent directive or pragma in non-C-family languages. \ | |
434 | If this hook is not defined, nothing is output for the @samp{#ident} \ | |
435 | directive.", | |
436 | void, (const char *name), | |
437 | hook_void_constcharptr) | |
438 | ||
38f8b050 JR |
439 | /* Output a DTP-relative reference to a TLS symbol. */ |
440 | DEFHOOK | |
441 | (output_dwarf_dtprel, | |
442 | "", | |
443 | void, (FILE *file, int size, rtx x), | |
444 | NULL) | |
445 | ||
446 | /* Some target machines need to postscan each insn after it is output. */ | |
447 | DEFHOOK | |
448 | (final_postscan_insn, | |
449 | "", | |
450 | void, (FILE *file, rtx insn, rtx *opvec, int noperands), | |
451 | NULL) | |
452 | ||
453 | /* Emit the trampoline template. This hook may be NULL. */ | |
454 | DEFHOOK | |
455 | (trampoline_template, | |
456 | "", | |
457 | void, (FILE *f), | |
458 | NULL) | |
459 | ||
b5f5d41d AS |
460 | DEFHOOK |
461 | (output_source_filename, | |
462 | "Output COFF information or DWARF debugging information which indicates\ | |
463 | that filename @var{name} is the current source file to the stdio\ | |
464 | stream @var{file}.\n\ | |
465 | \n\ | |
466 | This target hook need not be defined if the standard form of output\ | |
467 | for the file format in use is appropriate.", | |
468 | void ,(FILE *file, const char *name), | |
469 | default_asm_output_source_filename) | |
470 | ||
6cbd8875 AS |
471 | DEFHOOK |
472 | (output_addr_const_extra, | |
473 | "", | |
474 | bool, (FILE *file, rtx x), | |
e1267133 | 475 | hook_bool_FILEptr_rtx_false) |
6cbd8875 | 476 | |
38f8b050 JR |
477 | /* ??? The TARGET_PRINT_OPERAND* hooks are part of the asm_out struct, |
478 | even though that is not reflected in the macro name to override their | |
479 | initializers. */ | |
480 | #undef HOOK_PREFIX | |
481 | #define HOOK_PREFIX "TARGET_" | |
482 | ||
483 | /* Emit a machine-specific insn operand. */ | |
4d00d5dd JR |
484 | /* ??? tm.texi only documents the old macro PRINT_OPERAND, |
485 | not this hook, and uses a different name for the argument FILE. */ | |
38f8b050 JR |
486 | DEFHOOK_UNDOC |
487 | (print_operand, | |
488 | "", | |
489 | void, (FILE *file, rtx x, int code), | |
490 | default_print_operand) | |
491 | ||
492 | /* Emit a machine-specific memory address. */ | |
4d00d5dd JR |
493 | /* ??? tm.texi only documents the old macro PRINT_OPERAND_ADDRESS, |
494 | not this hook, and uses different argument names. */ | |
38f8b050 JR |
495 | DEFHOOK_UNDOC |
496 | (print_operand_address, | |
497 | "", | |
498 | void, (FILE *file, rtx addr), | |
499 | default_print_operand_address) | |
500 | ||
501 | /* Determine whether CODE is a valid punctuation character for the | |
502 | `print_operand' hook. */ | |
4d00d5dd JR |
503 | /* ??? tm.texi only documents the old macro PRINT_OPERAND_PUNCT_VALID_P, |
504 | not this hook. */ | |
38f8b050 JR |
505 | DEFHOOK_UNDOC |
506 | (print_operand_punct_valid_p, | |
507 | "", | |
508 | bool ,(unsigned char code), | |
509 | default_print_operand_punct_valid_p) | |
510 | ||
77754180 DK |
511 | /* Given a symbol name, perform same mangling as assemble_name and |
512 | ASM_OUTPUT_LABELREF, returning result as an IDENTIFIER_NODE. */ | |
513 | DEFHOOK | |
514 | (mangle_assembler_name, | |
515 | "Given a symbol @var{name}, perform same mangling as @code{varasm.c}'s\ | |
516 | @code{assemble_name}, but in memory rather than to a file stream, returning\ | |
517 | result as an @code{IDENTIFIER_NODE}. Required for correct LTO symtabs. The\ | |
518 | default implementation calls the @code{TARGET_STRIP_NAME_ENCODING} hook and\ | |
519 | then prepends the @code{USER_LABEL_PREFIX}, if any.", | |
520 | tree, (const char *name), | |
521 | default_mangle_assembler_name) | |
522 | ||
38f8b050 JR |
523 | HOOK_VECTOR_END (asm_out) |
524 | ||
525 | /* Functions relating to instruction scheduling. All of these | |
526 | default to null pointers, which haifa-sched.c looks for and handles. */ | |
527 | #undef HOOK_PREFIX | |
528 | #define HOOK_PREFIX "TARGET_SCHED_" | |
529 | HOOK_VECTOR (TARGET_SCHED, sched) | |
530 | ||
531 | /* Given the current cost, COST, of an insn, INSN, calculate and | |
532 | return a new cost based on its relationship to DEP_INSN through | |
533 | the dependence LINK. The default is to make no adjustment. */ | |
534 | DEFHOOK | |
535 | (adjust_cost, | |
536 | "", | |
537 | int, (rtx insn, rtx link, rtx dep_insn, int cost), NULL) | |
538 | ||
539 | /* Adjust the priority of an insn as you see fit. Returns the new priority. */ | |
540 | DEFHOOK | |
541 | (adjust_priority, | |
542 | "", | |
543 | int, (rtx insn, int priority), NULL) | |
544 | ||
545 | /* Function which returns the maximum number of insns that can be | |
546 | scheduled in the same machine cycle. This must be constant | |
547 | over an entire compilation. The default is 1. */ | |
548 | DEFHOOK | |
549 | (issue_rate, | |
550 | "", | |
551 | int, (void), NULL) | |
552 | ||
553 | /* Calculate how much this insn affects how many more insns we | |
554 | can emit this cycle. Default is they all cost the same. */ | |
555 | DEFHOOK | |
556 | (variable_issue, | |
557 | "", | |
558 | int, (FILE *file, int verbose, rtx insn, int more), NULL) | |
559 | ||
560 | /* Initialize machine-dependent scheduling code. */ | |
561 | DEFHOOK | |
562 | (init, | |
563 | "", | |
564 | void, (FILE *file, int verbose, int max_ready), NULL) | |
565 | ||
566 | /* Finalize machine-dependent scheduling code. */ | |
567 | DEFHOOK | |
568 | (finish, | |
569 | "", | |
570 | void, (FILE *file, int verbose), NULL) | |
571 | ||
572 | /* Initialize machine-dependent function wide scheduling code. */ | |
573 | DEFHOOK | |
574 | (init_global, | |
575 | "", | |
576 | void, (FILE *file, int verbose, int old_max_uid), NULL) | |
577 | ||
578 | /* Finalize machine-dependent function wide scheduling code. */ | |
579 | DEFHOOK | |
580 | (finish_global, | |
581 | "", | |
582 | void, (FILE *file, int verbose), NULL) | |
583 | ||
584 | /* Reorder insns in a machine-dependent fashion, in two different | |
585 | places. Default does nothing. */ | |
586 | DEFHOOK | |
587 | (reorder, | |
588 | "", | |
589 | int, (FILE *file, int verbose, rtx *ready, int *n_readyp, int clock), NULL) | |
590 | ||
591 | DEFHOOK | |
592 | (reorder2, | |
593 | "", | |
594 | int, (FILE *file, int verbose, rtx *ready, int *n_readyp, int clock), NULL) | |
595 | ||
596 | /* The following member value is a pointer to a function called | |
597 | after evaluation forward dependencies of insns in chain given | |
598 | by two parameter values (head and tail correspondingly). */ | |
599 | DEFHOOK | |
600 | (dependencies_evaluation_hook, | |
601 | "", | |
602 | void, (rtx head, rtx tail), NULL) | |
603 | ||
604 | /* The values of the following four members are pointers to functions | |
605 | used to simplify the automaton descriptions. dfa_pre_cycle_insn and | |
606 | dfa_post_cycle_insn give functions returning insns which are used to | |
607 | change the pipeline hazard recognizer state when the new simulated | |
608 | processor cycle correspondingly starts and finishes. The function | |
609 | defined by init_dfa_pre_cycle_insn and init_dfa_post_cycle_insn are | |
610 | used to initialize the corresponding insns. The default values of | |
611 | the members result in not changing the automaton state when the | |
612 | new simulated processor cycle correspondingly starts and finishes. */ | |
613 | ||
614 | DEFHOOK | |
615 | (init_dfa_pre_cycle_insn, | |
616 | "", | |
617 | void, (void), NULL) | |
618 | ||
619 | DEFHOOK | |
620 | (dfa_pre_cycle_insn, | |
621 | "", | |
622 | rtx, (void), NULL) | |
623 | ||
624 | DEFHOOK | |
625 | (init_dfa_post_cycle_insn, | |
626 | "", | |
627 | void, (void), NULL) | |
628 | ||
629 | DEFHOOK | |
630 | (dfa_post_cycle_insn, | |
631 | "", | |
632 | rtx, (void), NULL) | |
633 | ||
634 | /* The values of the following two members are pointers to | |
635 | functions used to simplify the automaton descriptions. | |
636 | dfa_pre_advance_cycle and dfa_post_advance_cycle are getting called | |
637 | immediately before and after cycle is advanced. */ | |
638 | ||
639 | DEFHOOK | |
640 | (dfa_pre_advance_cycle, | |
641 | "", | |
642 | void, (void), NULL) | |
643 | ||
644 | DEFHOOK | |
645 | (dfa_post_advance_cycle, | |
646 | "", | |
647 | void, (void), NULL) | |
648 | ||
649 | /* The following member value is a pointer to a function returning value | |
650 | which defines how many insns in queue `ready' will we try for | |
651 | multi-pass scheduling. If the member value is nonzero and the | |
652 | function returns positive value, the DFA based scheduler will make | |
653 | multi-pass scheduling for the first cycle. In other words, we will | |
654 | try to choose ready insn which permits to start maximum number of | |
655 | insns on the same cycle. */ | |
656 | DEFHOOK | |
657 | (first_cycle_multipass_dfa_lookahead, | |
658 | "", | |
659 | int, (void), NULL) | |
660 | ||
661 | /* The following member value is pointer to a function controlling | |
662 | what insns from the ready insn queue will be considered for the | |
663 | multipass insn scheduling. If the hook returns zero for insn | |
664 | passed as the parameter, the insn will be not chosen to be issued. */ | |
665 | DEFHOOK | |
666 | (first_cycle_multipass_dfa_lookahead_guard, | |
667 | "", | |
668 | int, (rtx insn), NULL) | |
669 | ||
894fd6f2 MK |
670 | /* This hook prepares the target for a new round of multipass |
671 | scheduling. | |
672 | DATA is a pointer to target-specific data used for multipass scheduling. | |
673 | READY_TRY and N_READY represent the current state of search in the | |
674 | optimization space. The target can filter out instructions that | |
675 | should not be tried during current round by setting corresponding | |
676 | elements in READY_TRY to non-zero. | |
677 | FIRST_CYCLE_INSN_P is true if this is the first round of multipass | |
678 | scheduling on current cycle. */ | |
679 | DEFHOOK | |
680 | (first_cycle_multipass_begin, | |
681 | "", | |
682 | void, (void *data, char *ready_try, int n_ready, bool first_cycle_insn_p), | |
683 | NULL) | |
684 | ||
685 | /* This hook is called when multipass scheduling evaluates instruction INSN. | |
686 | DATA is a pointer to target-specific data that can be used to record effects | |
687 | of INSN on CPU that are not described in DFA. | |
688 | READY_TRY and N_READY represent the current state of search in the | |
689 | optimization space. The target can filter out instructions that | |
073a8998 | 690 | should not be tried after issuing INSN by setting corresponding |
894fd6f2 MK |
691 | elements in READY_TRY to non-zero. |
692 | INSN is the instruction being evaluated. | |
693 | PREV_DATA is a pointer to target-specific data corresponding | |
073a8998 | 694 | to a state before issuing INSN. */ |
894fd6f2 MK |
695 | DEFHOOK |
696 | (first_cycle_multipass_issue, | |
697 | "", | |
698 | void, (void *data, char *ready_try, int n_ready, rtx insn, | |
699 | const void *prev_data), NULL) | |
700 | ||
701 | /* This hook is called when multipass scheduling backtracks from evaluation of | |
702 | instruction corresponding to DATA. | |
703 | DATA is a pointer to target-specific data that stores the effects | |
704 | of instruction from which the algorithm backtracks on CPU that are not | |
705 | described in DFA. | |
706 | READY_TRY and N_READY represent the current state of search in the | |
707 | optimization space. The target can filter out instructions that | |
073a8998 | 708 | should not be tried after issuing INSN by setting corresponding |
894fd6f2 MK |
709 | elements in READY_TRY to non-zero. */ |
710 | DEFHOOK | |
711 | (first_cycle_multipass_backtrack, | |
712 | "", | |
713 | void, (const void *data, char *ready_try, int n_ready), NULL) | |
714 | ||
715 | /* This hook notifies the target about the result of the concluded current | |
716 | round of multipass scheduling. | |
717 | DATA is a pointer. | |
718 | If DATA is non-NULL it points to target-specific data used for multipass | |
719 | scheduling which corresponds to instruction at the start of the chain of | |
720 | the winning solution. DATA is NULL when multipass scheduling cannot find | |
721 | a good enough solution on current cycle and decides to retry later, | |
722 | usually after advancing the cycle count. */ | |
723 | DEFHOOK | |
724 | (first_cycle_multipass_end, | |
725 | "", | |
726 | void, (const void *data), NULL) | |
727 | ||
728 | /* This hook is called to initialize target-specific data for multipass | |
729 | scheduling after it has been allocated. | |
730 | DATA is a pointer to target-specific data that stores the effects | |
731 | of instruction from which the algorithm backtracks on CPU that are not | |
732 | described in DFA. */ | |
733 | DEFHOOK | |
734 | (first_cycle_multipass_init, | |
735 | "", | |
736 | void, (void *data), NULL) | |
737 | ||
738 | /* This hook is called to finalize target-specific data for multipass | |
739 | scheduling before it is deallocated. | |
740 | DATA is a pointer to target-specific data that stores the effects | |
741 | of instruction from which the algorithm backtracks on CPU that are not | |
742 | described in DFA. */ | |
743 | DEFHOOK | |
744 | (first_cycle_multipass_fini, | |
745 | "", | |
746 | void, (void *data), NULL) | |
747 | ||
38f8b050 JR |
748 | /* The following member value is pointer to a function called by |
749 | the insn scheduler before issuing insn passed as the third | |
750 | parameter on given cycle. If the hook returns nonzero, the | |
751 | insn is not issued on given processors cycle. Instead of that, | |
752 | the processor cycle is advanced. If the value passed through | |
753 | the last parameter is zero, the insn ready queue is not sorted | |
754 | on the new cycle start as usually. The first parameter passes | |
755 | file for debugging output. The second one passes the scheduler | |
756 | verbose level of the debugging output. The forth and the fifth | |
757 | parameter values are correspondingly processor cycle on which | |
758 | the previous insn has been issued and the current processor cycle. */ | |
c06bbdf7 | 759 | DEFHOOK |
38f8b050 JR |
760 | (dfa_new_cycle, |
761 | "", | |
c06bbdf7 JR |
762 | int, (FILE *dump, int verbose, rtx insn, int last_clock, |
763 | int clock, int *sort_p), | |
38f8b050 JR |
764 | NULL) |
765 | ||
766 | /* The following member value is a pointer to a function called by the | |
767 | insn scheduler. It should return true if there exists a dependence | |
768 | which is considered costly by the target, between the insn | |
769 | DEP_PRO (&_DEP), and the insn DEP_CON (&_DEP). The first parameter is | |
770 | the dep that represents the dependence between the two insns. The | |
771 | second argument is the cost of the dependence as estimated by | |
772 | the scheduler. The last argument is the distance in cycles | |
773 | between the already scheduled insn (first parameter) and the | |
774 | second insn (second parameter). */ | |
775 | DEFHOOK | |
776 | (is_costly_dependence, | |
777 | "", | |
778 | bool, (struct _dep *_dep, int cost, int distance), NULL) | |
779 | ||
780 | DEFHOOK_UNDOC | |
781 | (adjust_cost_2, | |
782 | "Given the current cost, @var{cost}, of an insn, @var{insn}, calculate and\ | |
783 | return a new cost based on its relationship to @var{dep_insn} through the\ | |
784 | dependence of weakness @var{dw}. The default is to make no adjustment.", | |
785 | int, (rtx insn, int dep_type1, rtx dep_insn, int cost, int dw), NULL) | |
786 | ||
787 | /* The following member value is a pointer to a function called | |
788 | by the insn scheduler. This hook is called to notify the backend | |
789 | that new instructions were emitted. */ | |
790 | DEFHOOK | |
791 | (h_i_d_extended, | |
792 | "", | |
793 | void, (void), NULL) | |
794 | ||
795 | /* Next 5 functions are for multi-point scheduling. */ | |
796 | ||
797 | /* Allocate memory for scheduler context. */ | |
798 | DEFHOOK | |
799 | (alloc_sched_context, | |
800 | "", | |
801 | void *, (void), NULL) | |
802 | ||
803 | /* Fills the context from the local machine scheduler context. */ | |
804 | DEFHOOK | |
805 | (init_sched_context, | |
806 | "", | |
807 | void, (void *tc, bool clean_p), NULL) | |
808 | ||
809 | /* Sets local machine scheduler context to a saved value. */ | |
810 | DEFHOOK | |
811 | (set_sched_context, | |
812 | "", | |
813 | void, (void *tc), NULL) | |
814 | ||
815 | /* Clears a scheduler context so it becomes like after init. */ | |
816 | DEFHOOK | |
817 | (clear_sched_context, | |
818 | "", | |
819 | void, (void *tc), NULL) | |
820 | ||
821 | /* Frees the scheduler context. */ | |
822 | DEFHOOK | |
823 | (free_sched_context, | |
824 | "", | |
825 | void, (void *tc), NULL) | |
826 | ||
827 | /* The following member value is a pointer to a function called | |
828 | by the insn scheduler. | |
829 | The first parameter is an instruction, the second parameter is the type | |
830 | of the requested speculation, and the third parameter is a pointer to the | |
831 | speculative pattern of the corresponding type (set if return value == 1). | |
832 | It should return | |
833 | -1, if there is no pattern, that will satisfy the requested speculation type, | |
834 | 0, if current pattern satisfies the requested speculation type, | |
835 | 1, if pattern of the instruction should be changed to the newly | |
836 | generated one. */ | |
837 | DEFHOOK | |
838 | (speculate_insn, | |
839 | "", | |
840 | int, (rtx insn, int request, rtx *new_pat), NULL) | |
841 | ||
842 | /* The following member value is a pointer to a function called | |
843 | by the insn scheduler. It should return true if the check instruction | |
844 | passed as the parameter needs a recovery block. */ | |
845 | DEFHOOK | |
846 | (needs_block_p, | |
847 | "", | |
848 | bool, (int dep_status), NULL) | |
849 | ||
850 | /* The following member value is a pointer to a function called | |
851 | by the insn scheduler. It should return a pattern for the check | |
852 | instruction. | |
853 | The first parameter is a speculative instruction, the second parameter | |
854 | is the label of the corresponding recovery block (or null, if it is a | |
855 | simple check). If the mutation of the check is requested (e.g. from | |
856 | ld.c to chk.a), the third parameter is true - in this case the first | |
857 | parameter is the previous check. */ | |
858 | DEFHOOK | |
859 | (gen_spec_check, | |
860 | "", | |
861 | rtx, (rtx insn, rtx label, int mutate_p), NULL) | |
862 | ||
863 | /* The following member value is a pointer to a function controlling | |
864 | what insns from the ready insn queue will be considered for the | |
865 | multipass insn scheduling. If the hook returns zero for the insn | |
866 | passed as the parameter, the insn will not be chosen to be | |
867 | issued. This hook is used to discard speculative instructions, | |
868 | that stand at the first position of the ready list. */ | |
869 | DEFHOOK | |
870 | (first_cycle_multipass_dfa_lookahead_guard_spec, | |
871 | "", | |
872 | bool, (const_rtx insn), NULL) | |
873 | ||
874 | /* The following member value is a pointer to a function that provides | |
875 | information about the speculation capabilities of the target. | |
876 | The parameter is a pointer to spec_info variable. */ | |
877 | DEFHOOK | |
878 | (set_sched_flags, | |
879 | "", | |
880 | void, (struct spec_info_def *spec_info), NULL) | |
881 | ||
882 | DEFHOOK_UNDOC | |
883 | (get_insn_spec_ds, | |
884 | "Return speculation types of instruction @var{insn}.", | |
885 | int, (rtx insn), NULL) | |
886 | ||
887 | DEFHOOK_UNDOC | |
888 | (get_insn_checked_ds, | |
889 | "Return speculation types that are checked for instruction @var{insn}", | |
890 | int, (rtx insn), NULL) | |
891 | ||
892 | DEFHOOK_UNDOC | |
893 | (skip_rtx_p, | |
894 | "Return bool if rtx scanning should just skip current layer and\ | |
895 | advance to the inner rtxes.", | |
896 | bool, (const_rtx x), NULL) | |
897 | ||
898 | /* The following member value is a pointer to a function that provides | |
899 | information about the target resource-based lower bound which is | |
900 | used by the swing modulo scheduler. The parameter is a pointer | |
901 | to ddg variable. */ | |
902 | DEFHOOK | |
903 | (sms_res_mii, | |
904 | "", | |
905 | int, (struct ddg *g), NULL) | |
906 | ||
7942e47e RY |
907 | /* The following member value is a function that initializes dispatch |
908 | schedling and adds instructions to dispatch window according to its | |
909 | parameters. */ | |
910 | DEFHOOK | |
911 | (dispatch_do, | |
912 | "", | |
913 | void, (rtx insn, int x), | |
914 | hook_void_rtx_int) | |
915 | ||
916 | /* The following member value is a a function that returns true is | |
917 | dispatch schedling is supported in hardware and condition passed | |
918 | as the second parameter is true. */ | |
919 | DEFHOOK | |
920 | (dispatch, | |
921 | "", | |
922 | bool, (rtx insn, int x), | |
923 | hook_bool_rtx_int_false) | |
924 | ||
b0bd15f7 BS |
925 | DEFHOOKPOD |
926 | (exposed_pipeline, | |
927 | "True if the processor has an exposed pipeline, which means that not just\n\ | |
928 | the order of instructions is important for correctness when scheduling, but\n\ | |
929 | also the latencies of operations.", | |
930 | bool, false) | |
931 | ||
df7b0cc4 EI |
932 | /* The following member value is a function that returns number |
933 | of operations reassociator should try to put in parallel for | |
934 | statements of the given type. By default 1 is used. */ | |
935 | DEFHOOK | |
936 | (reassociation_width, | |
937 | "This hook is called by tree reassociator to determine a level of\n\ | |
938 | parallelism required in output calculations chain.", | |
939 | int, (unsigned int opc, enum machine_mode mode), | |
940 | hook_int_uint_mode_1) | |
941 | ||
38f8b050 JR |
942 | HOOK_VECTOR_END (sched) |
943 | ||
944 | /* Functions relating to vectorization. */ | |
945 | #undef HOOK_PREFIX | |
946 | #define HOOK_PREFIX "TARGET_VECTORIZE_" | |
947 | HOOK_VECTOR (TARGET_VECTORIZE, vectorize) | |
948 | ||
949 | /* The following member value is a pointer to a function called | |
950 | by the vectorizer, and return the decl of the target builtin | |
951 | function. */ | |
952 | DEFHOOK | |
953 | (builtin_mask_for_load, | |
954 | "", | |
955 | tree, (void), NULL) | |
956 | ||
957 | /* Returns a code for builtin that realizes vectorized version of | |
958 | function, or NULL_TREE if not available. */ | |
959 | DEFHOOK | |
960 | (builtin_vectorized_function, | |
961 | "", | |
962 | tree, (tree fndecl, tree vec_type_out, tree vec_type_in), | |
963 | default_builtin_vectorized_function) | |
964 | ||
965 | /* Returns a function declaration for a builtin that realizes the | |
966 | vector conversion, or NULL_TREE if not available. */ | |
967 | DEFHOOK | |
968 | (builtin_conversion, | |
969 | "", | |
970 | tree, (unsigned code, tree dest_type, tree src_type), | |
971 | default_builtin_vectorized_conversion) | |
972 | ||
720f5239 IR |
973 | /* Cost of different vector/scalar statements in vectorization cost |
974 | model. In case of misaligned vector loads and stores the cost depends | |
975 | on the data type and misalignment value. */ | |
38f8b050 JR |
976 | DEFHOOK |
977 | (builtin_vectorization_cost, | |
978 | "", | |
720f5239 | 979 | int, (enum vect_cost_for_stmt type_of_cost, tree vectype, int misalign), |
38f8b050 JR |
980 | default_builtin_vectorization_cost) |
981 | ||
982 | /* Return true if vector alignment is reachable (by peeling N | |
983 | iterations) for the given type. */ | |
984 | DEFHOOK | |
985 | (vector_alignment_reachable, | |
986 | "", | |
987 | bool, (const_tree type, bool is_packed), | |
988 | default_builtin_vector_alignment_reachable) | |
989 | ||
22e4dee7 RH |
990 | /* Return true if a vector created for vec_perm_const is valid. |
991 | A NULL indicates that all constants are valid permutations. */ | |
38f8b050 | 992 | DEFHOOK |
5a3c0068 | 993 | (vec_perm_const_ok, |
38f8b050 | 994 | "", |
22e4dee7 RH |
995 | bool, (enum machine_mode, const unsigned char *sel), |
996 | NULL) | |
38f8b050 JR |
997 | |
998 | /* Return true if the target supports misaligned store/load of a | |
999 | specific factor denoted in the third parameter. The last parameter | |
1000 | is true if the access is defined in a packed struct. */ | |
1001 | DEFHOOK | |
1002 | (support_vector_misalignment, | |
1003 | "", | |
1004 | bool, | |
1005 | (enum machine_mode mode, const_tree type, int misalignment, bool is_packed), | |
1006 | default_builtin_support_vector_misalignment) | |
1007 | ||
0a35513e AH |
1008 | /* Return the builtin decl needed to load a vector of TYPE. */ |
1009 | DEFHOOK | |
1010 | (builtin_tm_load, | |
1011 | "This hook should return the built-in decl needed to load a vector of the " | |
1012 | "given type within a transaction.", | |
1013 | tree, | |
1014 | (tree), | |
1015 | default_builtin_tm_load_store) | |
1016 | ||
1017 | /* Return the builtin decl needed to store a vector of TYPE. */ | |
1018 | DEFHOOK | |
1019 | (builtin_tm_store, | |
1020 | "This hook should return the built-in decl needed to store a vector of the " | |
1021 | "given type within a transaction.", | |
1022 | tree, | |
1023 | (tree), | |
1024 | default_builtin_tm_load_store) | |
1025 | ||
cc4b5170 RG |
1026 | /* Returns the preferred mode for SIMD operations for the specified |
1027 | scalar mode. */ | |
26983c22 | 1028 | DEFHOOK |
cc4b5170 | 1029 | (preferred_simd_mode, |
26983c22 | 1030 | "", |
cc4b5170 | 1031 | enum machine_mode, |
26983c22 | 1032 | (enum machine_mode mode), |
cc4b5170 | 1033 | default_preferred_simd_mode) |
26983c22 | 1034 | |
767f865f RG |
1035 | /* Returns a mask of vector sizes to iterate over when auto-vectorizing |
1036 | after processing the preferred one derived from preferred_simd_mode. */ | |
1037 | DEFHOOK | |
1038 | (autovectorize_vector_sizes, | |
1039 | "", | |
1040 | unsigned int, | |
1041 | (void), | |
1042 | default_autovectorize_vector_sizes) | |
1043 | ||
aec7ae7d JJ |
1044 | /* Target builtin that implements vector gather operation. */ |
1045 | DEFHOOK | |
1046 | (builtin_gather, | |
1047 | "", | |
1048 | tree, | |
1049 | (const_tree mem_vectype, const_tree index_type, int scale), | |
1050 | NULL) | |
1051 | ||
c3e7ee41 BS |
1052 | /* Target function to initialize the cost model for a loop or block. */ |
1053 | DEFHOOK | |
1054 | (init_cost, | |
1055 | "This hook should initialize target-specific data structures in preparation " | |
1056 | "for modeling the costs of vectorizing a loop or basic block. The default " | |
92345349 BS |
1057 | "allocates three unsigned integers for accumulating costs for the prologue, " |
1058 | "body, and epilogue of the loop or basic block. If @var{loop_info} is " | |
1059 | "non-NULL, it identifies the loop being vectorized; otherwise a single block " | |
1060 | "is being vectorized.", | |
c3e7ee41 BS |
1061 | void *, |
1062 | (struct loop *loop_info), | |
1063 | default_init_cost) | |
1064 | ||
1065 | /* Target function to record N statements of the given kind using the | |
92345349 BS |
1066 | given vector type within the cost model data for the current loop or |
1067 | block. */ | |
c3e7ee41 BS |
1068 | DEFHOOK |
1069 | (add_stmt_cost, | |
1070 | "This hook should update the target-specific @var{data} in response to " | |
92345349 BS |
1071 | "adding @var{count} copies of the given @var{kind} of statement to a " |
1072 | "loop or basic block. The default adds the builtin vectorizer cost for " | |
1073 | "the copies of the statement to the accumulator specified by @var{where}, " | |
1074 | "(the prologue, body, or epilogue) and returns the amount added. The " | |
1075 | "return value should be viewed as a tentative cost that may later be " | |
1076 | "revised.", | |
c3e7ee41 BS |
1077 | unsigned, |
1078 | (void *data, int count, enum vect_cost_for_stmt kind, | |
92345349 BS |
1079 | struct _stmt_vec_info *stmt_info, int misalign, |
1080 | enum vect_cost_model_location where), | |
c3e7ee41 BS |
1081 | default_add_stmt_cost) |
1082 | ||
1083 | /* Target function to calculate the total cost of the current vectorized | |
1084 | loop or block. */ | |
1085 | DEFHOOK | |
1086 | (finish_cost, | |
1087 | "This hook should complete calculations of the cost of vectorizing a loop " | |
92345349 BS |
1088 | "or basic block based on @var{data}, and return the prologue, body, and " |
1089 | "epilogue costs as unsigned integers. The default returns the value of " | |
1090 | "the three accumulators.", | |
1091 | void, | |
1092 | (void *data, unsigned *prologue_cost, unsigned *body_cost, | |
1093 | unsigned *epilogue_cost), | |
c3e7ee41 BS |
1094 | default_finish_cost) |
1095 | ||
1096 | /* Function to delete target-specific cost modeling data. */ | |
1097 | DEFHOOK | |
1098 | (destroy_cost_data, | |
1099 | "This hook should release @var{data} and any related data structures " | |
1100 | "allocated by TARGET_VECTORIZE_INIT_COST. The default releases the " | |
1101 | "accumulator.", | |
1102 | void, | |
1103 | (void *data), | |
1104 | default_destroy_cost_data) | |
1105 | ||
38f8b050 JR |
1106 | HOOK_VECTOR_END (vectorize) |
1107 | ||
1108 | #undef HOOK_PREFIX | |
1109 | #define HOOK_PREFIX "TARGET_" | |
1110 | ||
38f8b050 JR |
1111 | /* Allow target specific overriding of option settings after options have |
1112 | been changed by an attribute or pragma or when it is reset at the | |
1113 | end of the code affected by an attribute or pragma. */ | |
1114 | DEFHOOK | |
1115 | (override_options_after_change, | |
1116 | "", | |
1117 | void, (void), | |
1118 | hook_void_void) | |
1119 | ||
38f8b050 JR |
1120 | DEFHOOK_UNDOC |
1121 | (eh_return_filter_mode, | |
1122 | "Return machine mode for filter value.", | |
1123 | enum machine_mode, (void), | |
1124 | default_eh_return_filter_mode) | |
1125 | ||
1126 | /* Return machine mode for libgcc expanded cmp instructions. */ | |
1127 | DEFHOOK | |
1128 | (libgcc_cmp_return_mode, | |
1129 | "", | |
1130 | enum machine_mode, (void), | |
1131 | default_libgcc_cmp_return_mode) | |
1132 | ||
1133 | /* Return machine mode for libgcc expanded shift instructions. */ | |
1134 | DEFHOOK | |
1135 | (libgcc_shift_count_mode, | |
1136 | "", | |
1137 | enum machine_mode, (void), | |
1138 | default_libgcc_shift_count_mode) | |
1139 | ||
1140 | /* Return machine mode to be used for _Unwind_Word type. */ | |
1141 | DEFHOOK | |
1142 | (unwind_word_mode, | |
1143 | "", | |
1144 | enum machine_mode, (void), | |
1145 | default_unwind_word_mode) | |
1146 | ||
1147 | /* Given two decls, merge their attributes and return the result. */ | |
1148 | DEFHOOK | |
1149 | (merge_decl_attributes, | |
1150 | "", | |
1151 | tree, (tree olddecl, tree newdecl), | |
1152 | merge_decl_attributes) | |
1153 | ||
1154 | /* Given two types, merge their attributes and return the result. */ | |
1155 | DEFHOOK | |
1156 | (merge_type_attributes, | |
1157 | "", | |
1158 | tree, (tree type1, tree type2), | |
1159 | merge_type_attributes) | |
1160 | ||
1161 | /* Table of machine attributes and functions to handle them. | |
1162 | Ignored if NULL. */ | |
1163 | DEFHOOKPOD | |
1164 | (attribute_table, | |
1165 | "", | |
1166 | const struct attribute_spec *, NULL) | |
1167 | ||
1168 | /* Return true iff attribute NAME expects a plain identifier as its first | |
1169 | argument. */ | |
1170 | DEFHOOK | |
1171 | (attribute_takes_identifier_p, | |
1172 | "", | |
1173 | bool, (const_tree name), | |
1174 | hook_bool_const_tree_false) | |
1175 | ||
1176 | /* Return zero if the attributes on TYPE1 and TYPE2 are incompatible, | |
1177 | one if they are compatible and two if they are nearly compatible | |
1178 | (which causes a warning to be generated). */ | |
1179 | DEFHOOK | |
1180 | (comp_type_attributes, | |
1181 | "", | |
1182 | int, (const_tree type1, const_tree type2), | |
1183 | hook_int_const_tree_const_tree_1) | |
1184 | ||
1185 | /* Assign default attributes to the newly defined TYPE. */ | |
1186 | DEFHOOK | |
1187 | (set_default_type_attributes, | |
1188 | "", | |
1189 | void, (tree type), | |
1190 | hook_void_tree) | |
1191 | ||
1192 | /* Insert attributes on the newly created DECL. */ | |
1193 | DEFHOOK | |
1194 | (insert_attributes, | |
1195 | "", | |
1196 | void, (tree node, tree *attr_ptr), | |
1197 | hook_void_tree_treeptr) | |
1198 | ||
1199 | /* Return true if FNDECL (which has at least one machine attribute) | |
1200 | can be inlined despite its machine attributes, false otherwise. */ | |
1201 | DEFHOOK | |
1202 | (function_attribute_inlinable_p, | |
1203 | "", | |
1204 | bool, (const_tree fndecl), | |
1205 | hook_bool_const_tree_false) | |
1206 | ||
1207 | /* Return true if bitfields in RECORD_TYPE should follow the | |
1208 | Microsoft Visual C++ bitfield layout rules. */ | |
1209 | DEFHOOK | |
1210 | (ms_bitfield_layout_p, | |
1211 | "", | |
1212 | bool, (const_tree record_type), | |
1213 | hook_bool_const_tree_false) | |
1214 | ||
2e681adf JR |
1215 | /* For now this is only an interface to WORDS_BIG_ENDIAN for |
1216 | target-independent code like the front ends, need performance testing | |
1217 | before switching completely to the target hook. */ | |
1218 | DEFHOOK_UNDOC | |
1219 | (words_big_endian, | |
1220 | "", | |
1221 | bool, (void), | |
1222 | targhook_words_big_endian) | |
1223 | ||
1224 | /* Likewise for FLOAT_WORDS_BIG_ENDIAN. */ | |
1225 | DEFHOOK_UNDOC | |
1226 | (float_words_big_endian, | |
1227 | "", | |
1228 | bool, (void), | |
1229 | targhook_float_words_big_endian) | |
1230 | ||
38f8b050 JR |
1231 | /* True if the target supports decimal floating point. */ |
1232 | DEFHOOK | |
1233 | (decimal_float_supported_p, | |
1234 | "", | |
1235 | bool, (void), | |
1236 | default_decimal_float_supported_p) | |
1237 | ||
1238 | /* True if the target supports fixed-point. */ | |
1239 | DEFHOOK | |
1240 | (fixed_point_supported_p, | |
1241 | "", | |
1242 | bool, (void), | |
1243 | default_fixed_point_supported_p) | |
1244 | ||
1245 | /* Return true if anonymous bitfields affect structure alignment. */ | |
1246 | DEFHOOK | |
1247 | (align_anon_bitfield, | |
1248 | "", | |
1249 | bool, (void), | |
1250 | hook_bool_void_false) | |
1251 | ||
1252 | /* Return true if volatile bitfields should use the narrowest type possible. | |
1253 | Return false if they should use the container type. */ | |
1254 | DEFHOOK | |
1255 | (narrow_volatile_bitfield, | |
1256 | "", | |
1257 | bool, (void), | |
1258 | hook_bool_void_false) | |
1259 | ||
1260 | /* Set up target-specific built-in functions. */ | |
1261 | DEFHOOK | |
1262 | (init_builtins, | |
1263 | "", | |
1264 | void, (void), | |
1265 | hook_void_void) | |
1266 | ||
1267 | /* Initialize (if INITIALIZE_P is true) and return the target-specific | |
1268 | built-in function decl for CODE. | |
1269 | Return NULL if that is not possible. Return error_mark_node if CODE | |
1270 | is outside of the range of valid target builtin function codes. */ | |
1271 | DEFHOOK | |
1272 | (builtin_decl, | |
1273 | "", | |
1274 | tree, (unsigned code, bool initialize_p), NULL) | |
1275 | ||
1276 | /* Expand a target-specific builtin. */ | |
1277 | DEFHOOK | |
1278 | (expand_builtin, | |
1279 | "", | |
1280 | rtx, | |
1281 | (tree exp, rtx target, rtx subtarget, enum machine_mode mode, int ignore), | |
1282 | default_expand_builtin) | |
1283 | ||
1284 | /* Select a replacement for a target-specific builtin. This is done | |
1285 | *before* regular type checking, and so allows the target to | |
1286 | implement a crude form of function overloading. The result is a | |
1287 | complete expression that implements the operation. PARAMS really | |
1288 | has type VEC(tree,gc)*, but we don't want to include tree.h here. */ | |
d66f5459 | 1289 | DEFHOOK |
38f8b050 JR |
1290 | (resolve_overloaded_builtin, |
1291 | "", | |
d66f5459 | 1292 | tree, (unsigned int /*location_t*/ loc, tree fndecl, void *arglist), NULL) |
38f8b050 JR |
1293 | |
1294 | /* Fold a target-specific builtin. */ | |
08914aaa | 1295 | DEFHOOK |
38f8b050 JR |
1296 | (fold_builtin, |
1297 | "", | |
08914aaa | 1298 | tree, (tree fndecl, int n_args, tree *argp, bool ignore), |
38f8b050 JR |
1299 | hook_tree_tree_int_treep_bool_null) |
1300 | ||
1301 | /* Returns a code for a target-specific builtin that implements | |
1302 | reciprocal of the function, or NULL_TREE if not available. */ | |
89356d17 | 1303 | DEFHOOK |
38f8b050 JR |
1304 | (builtin_reciprocal, |
1305 | "", | |
89356d17 | 1306 | tree, (unsigned fn, bool md_fn, bool sqrt), |
38f8b050 JR |
1307 | default_builtin_reciprocal) |
1308 | ||
1309 | /* For a vendor-specific TYPE, return a pointer to a statically-allocated | |
1310 | string containing the C++ mangling for TYPE. In all other cases, return | |
1311 | NULL. */ | |
1312 | DEFHOOK | |
1313 | (mangle_type, | |
1314 | "", | |
1315 | const char *, (const_tree type), | |
1316 | hook_constcharptr_const_tree_null) | |
1317 | ||
1318 | /* Make any adjustments to libfunc names needed for this target. */ | |
1319 | DEFHOOK | |
1320 | (init_libfuncs, | |
1321 | "", | |
1322 | void, (void), | |
1323 | hook_void_void) | |
1324 | ||
cdbf4541 BS |
1325 | /* Add a __gnu_ prefix to library functions rather than just __. */ |
1326 | DEFHOOKPOD | |
1327 | (libfunc_gnu_prefix, | |
1328 | "If false (the default), internal library routines start with two\n\ | |
1329 | underscores. If set to true, these routines start with @code{__gnu_}\n\ | |
1330 | instead. E.g., @code{__muldi3} changes to @code{__gnu_muldi3}. This\n\ | |
1331 | currently only affects functions defined in @file{libgcc2.c}. If this\n\ | |
1332 | is set to true, the @file{tm.h} file must also\n\ | |
1333 | @code{#define LIBGCC2_GNU_PREFIX}.", | |
1334 | bool, false) | |
1335 | ||
38f8b050 JR |
1336 | /* Given a decl, a section name, and whether the decl initializer |
1337 | has relocs, choose attributes for the section. */ | |
1338 | /* ??? Should be merged with SELECT_SECTION and UNIQUE_SECTION. */ | |
1339 | DEFHOOK | |
1340 | (section_type_flags, | |
1341 | "", | |
1342 | unsigned int, (tree decl, const char *name, int reloc), | |
1343 | default_section_type_flags) | |
1344 | ||
1345 | /* True if new jumps cannot be created, to replace existing ones or | |
1346 | not, at the current point in the compilation. */ | |
1347 | DEFHOOK | |
1348 | (cannot_modify_jumps_p, | |
1349 | "", | |
1350 | bool, (void), | |
1351 | hook_bool_void_false) | |
1352 | ||
1353 | /* Return a register class for which branch target register | |
1354 | optimizations should be applied. */ | |
1355 | DEFHOOK | |
1356 | (branch_target_register_class, | |
1357 | "", | |
a87cf97e | 1358 | reg_class_t, (void), |
38f8b050 JR |
1359 | default_branch_target_register_class) |
1360 | ||
1361 | /* Return true if branch target register optimizations should include | |
1362 | callee-saved registers that are not already live during the current | |
1363 | function. AFTER_PE_GEN is true if prologues and epilogues have | |
1364 | already been generated. */ | |
1365 | DEFHOOK | |
1366 | (branch_target_register_callee_saved, | |
1367 | "", | |
1368 | bool, (bool after_prologue_epilogue_gen), | |
1369 | hook_bool_bool_false) | |
1370 | ||
1371 | /* Return true if the target supports conditional execution. */ | |
1372 | DEFHOOK | |
1373 | (have_conditional_execution, | |
1374 | "", | |
1375 | bool, (void), | |
1376 | default_have_conditional_execution) | |
1377 | ||
1378 | /* Return a new value for loop unroll size. */ | |
1379 | DEFHOOK | |
1380 | (loop_unroll_adjust, | |
1381 | "", | |
1382 | unsigned, (unsigned nunroll, struct loop *loop), | |
1383 | NULL) | |
1384 | ||
1a627b35 RS |
1385 | /* True if X is a legitimate MODE-mode immediate operand. */ |
1386 | DEFHOOK | |
1387 | (legitimate_constant_p, | |
1388 | "", | |
1389 | bool, (enum machine_mode mode, rtx x), | |
1390 | hook_bool_mode_rtx_true) | |
1391 | ||
38f8b050 JR |
1392 | /* True if the constant X cannot be placed in the constant pool. */ |
1393 | DEFHOOK | |
1394 | (cannot_force_const_mem, | |
1395 | "", | |
fbbf66e7 RS |
1396 | bool, (enum machine_mode mode, rtx x), |
1397 | hook_bool_mode_rtx_false) | |
38f8b050 JR |
1398 | |
1399 | DEFHOOK_UNDOC | |
1400 | (cannot_copy_insn_p, | |
1401 | "True if the insn @var{x} cannot be duplicated.", | |
1402 | bool, (rtx), NULL) | |
1403 | ||
1404 | /* True if X is considered to be commutative. */ | |
1405 | DEFHOOK | |
1406 | (commutative_p, | |
1407 | "", | |
1408 | bool, (const_rtx x, int outer_code), | |
1409 | hook_bool_const_rtx_commutative_p) | |
1410 | ||
1411 | /* True if ADDR is an address-expression whose effect depends | |
1412 | on the mode of the memory reference it is used in. */ | |
1413 | DEFHOOK | |
1414 | (mode_dependent_address_p, | |
1415 | "", | |
1416 | bool, (const_rtx addr), | |
1417 | default_mode_dependent_address_p) | |
1418 | ||
1419 | /* Given an invalid address X for a given machine mode, try machine-specific | |
1420 | ways to make it legitimate. Return X or an invalid address on failure. */ | |
1421 | DEFHOOK | |
1422 | (legitimize_address, | |
1423 | "", | |
1424 | rtx, (rtx x, rtx oldx, enum machine_mode mode), | |
1425 | default_legitimize_address) | |
1426 | ||
1427 | /* Given an address RTX, undo the effects of LEGITIMIZE_ADDRESS. */ | |
1428 | DEFHOOK | |
1429 | (delegitimize_address, | |
1430 | "", | |
1431 | rtx, (rtx x), | |
1432 | delegitimize_mem_from_attrs) | |
1433 | ||
93bcc8c9 JJ |
1434 | /* Given an RTX, return true if it is not ok to emit it into debug info |
1435 | section. */ | |
1436 | DEFHOOK | |
1437 | (const_not_ok_for_debug_p, | |
1438 | "", | |
1439 | bool, (rtx x), | |
1440 | hook_bool_rtx_false) | |
1441 | ||
38f8b050 JR |
1442 | /* Given an address RTX, say whether it is valid. */ |
1443 | DEFHOOK | |
1444 | (legitimate_address_p, | |
1445 | "", | |
1446 | bool, (enum machine_mode mode, rtx x, bool strict), | |
1447 | default_legitimate_address_p) | |
1448 | ||
1449 | /* True if the given constant can be put into an object_block. */ | |
1450 | DEFHOOK | |
1451 | (use_blocks_for_constant_p, | |
1452 | "", | |
1453 | bool, (enum machine_mode mode, const_rtx x), | |
1454 | hook_bool_mode_const_rtx_false) | |
1455 | ||
1456 | /* The minimum and maximum byte offsets for anchored addresses. */ | |
1457 | DEFHOOKPOD | |
1458 | (min_anchor_offset, | |
1459 | "", | |
1460 | HOST_WIDE_INT, 0) | |
1461 | ||
1462 | DEFHOOKPOD | |
1463 | (max_anchor_offset, | |
1464 | "", | |
1465 | HOST_WIDE_INT, 0) | |
1466 | ||
1467 | /* True if section anchors can be used to access the given symbol. */ | |
1468 | DEFHOOK | |
1469 | (use_anchors_for_symbol_p, | |
1470 | "", | |
1471 | bool, (const_rtx x), | |
1472 | default_use_anchors_for_symbol_p) | |
1473 | ||
1474 | /* True if it is OK to do sibling call optimization for the specified | |
1475 | call expression EXP. DECL will be the called function, or NULL if | |
1476 | this is an indirect call. */ | |
1477 | DEFHOOK | |
1478 | (function_ok_for_sibcall, | |
1479 | "", | |
1480 | bool, (tree decl, tree exp), | |
1481 | hook_bool_tree_tree_false) | |
1482 | ||
1483 | /* Establish appropriate back-end context for processing the function | |
1484 | FNDECL. The argument might be NULL to indicate processing at top | |
1485 | level, outside of any function scope. */ | |
1486 | DEFHOOK | |
1487 | (set_current_function, | |
1488 | "", | |
1489 | void, (tree decl), hook_void_tree) | |
1490 | ||
1491 | /* True if EXP should be placed in a "small data" section. */ | |
1492 | DEFHOOK | |
1493 | (in_small_data_p, | |
1494 | "", | |
1495 | bool, (const_tree exp), | |
1496 | hook_bool_const_tree_false) | |
1497 | ||
1498 | /* True if EXP names an object for which name resolution must resolve | |
1499 | to the current executable or shared library. */ | |
1500 | DEFHOOK | |
1501 | (binds_local_p, | |
1502 | "", | |
1503 | bool, (const_tree exp), | |
1504 | default_binds_local_p) | |
1505 | ||
3c5273a9 KT |
1506 | /* Check if profiling code is before or after prologue. */ |
1507 | DEFHOOK | |
1508 | (profile_before_prologue, | |
1509 | "It returns true if target wants profile code emitted before prologue.\n\n\ | |
1510 | The default version of this hook use the target macro\n\ | |
1511 | @code{PROFILE_BEFORE_PROLOGUE}.", | |
1512 | bool, (void), | |
1513 | default_profile_before_prologue) | |
1514 | ||
38f8b050 JR |
1515 | /* Modify and return the identifier of a DECL's external name, |
1516 | originally identified by ID, as required by the target, | |
1517 | (eg, append @nn to windows32 stdcall function names). | |
1518 | The default is to return ID without modification. */ | |
1519 | DEFHOOK | |
1520 | (mangle_decl_assembler_name, | |
1521 | "", | |
1522 | tree, (tree decl, tree id), | |
1523 | default_mangle_decl_assembler_name) | |
1524 | ||
1525 | /* Do something target-specific to record properties of the DECL into | |
1526 | the associated SYMBOL_REF. */ | |
1527 | DEFHOOK | |
1528 | (encode_section_info, | |
1529 | "", | |
1530 | void, (tree decl, rtx rtl, int new_decl_p), | |
1531 | default_encode_section_info) | |
1532 | ||
1533 | /* Undo the effects of encode_section_info on the symbol string. */ | |
1534 | DEFHOOK | |
1535 | (strip_name_encoding, | |
1536 | "", | |
1537 | const char *, (const char *name), | |
1538 | default_strip_name_encoding) | |
1539 | ||
1540 | /* If shift optabs for MODE are known to always truncate the shift count, | |
1541 | return the mask that they apply. Return 0 otherwise. */ | |
1542 | DEFHOOK | |
1543 | (shift_truncation_mask, | |
1544 | "", | |
1545 | unsigned HOST_WIDE_INT, (enum machine_mode mode), | |
1546 | default_shift_truncation_mask) | |
1547 | ||
1548 | /* Return the number of divisions in the given MODE that should be present, | |
1549 | so that it is profitable to turn the division into a multiplication by | |
1550 | the reciprocal. */ | |
1551 | DEFHOOK | |
1552 | (min_divisions_for_recip_mul, | |
1553 | "", | |
1554 | unsigned int, (enum machine_mode mode), | |
1555 | default_min_divisions_for_recip_mul) | |
1556 | ||
1557 | /* If the representation of integral MODE is such that values are | |
1558 | always sign-extended to a wider mode MODE_REP then return | |
1559 | SIGN_EXTEND. Return UNKNOWN otherwise. */ | |
1560 | /* Note that the return type ought to be RTX_CODE, but that's not | |
1561 | necessarily defined at this point. */ | |
1562 | DEFHOOK | |
1563 | (mode_rep_extended, | |
1564 | "", | |
1565 | int, (enum machine_mode mode, enum machine_mode rep_mode), | |
1566 | default_mode_rep_extended) | |
1567 | ||
1568 | /* True if MODE is valid for a pointer in __attribute__((mode("MODE"))). */ | |
1569 | DEFHOOK | |
1570 | (valid_pointer_mode, | |
1571 | "", | |
1572 | bool, (enum machine_mode mode), | |
1573 | default_valid_pointer_mode) | |
1574 | ||
7352c013 RG |
1575 | /* Disambiguate with errno. */ |
1576 | DEFHOOK | |
1577 | (ref_may_alias_errno, | |
1578 | "Define this to return nonzero if the memory reference @var{ref}\ | |
1579 | may alias with the system C library errno location. The default\ | |
1580 | version of this hook assumes the system C library errno location\ | |
1581 | is either a declaration of type int or accessed by dereferencing\ | |
1582 | a pointer to int.", | |
1583 | bool, (struct ao_ref_s *ref), | |
1584 | default_ref_may_alias_errno) | |
1585 | ||
38f8b050 JR |
1586 | /* Support for named address spaces. */ |
1587 | #undef HOOK_PREFIX | |
1588 | #define HOOK_PREFIX "TARGET_ADDR_SPACE_" | |
1589 | HOOK_VECTOR (TARGET_ADDR_SPACE_HOOKS, addr_space) | |
1590 | ||
1591 | /* MODE to use for a pointer into another address space. */ | |
1592 | DEFHOOK | |
1593 | (pointer_mode, | |
1594 | "", | |
1595 | enum machine_mode, (addr_space_t address_space), | |
1596 | default_addr_space_pointer_mode) | |
1597 | ||
1598 | /* MODE to use for an address in another address space. */ | |
1599 | DEFHOOK | |
1600 | (address_mode, | |
1601 | "", | |
1602 | enum machine_mode, (addr_space_t address_space), | |
1603 | default_addr_space_address_mode) | |
1604 | ||
1605 | /* True if MODE is valid for a pointer in __attribute__((mode("MODE"))) | |
1606 | in another address space. */ | |
1607 | DEFHOOK | |
1608 | (valid_pointer_mode, | |
1609 | "", | |
1610 | bool, (enum machine_mode mode, addr_space_t as), | |
1611 | default_addr_space_valid_pointer_mode) | |
1612 | ||
1613 | /* True if an address is a valid memory address to a given named address | |
1614 | space for a given mode. */ | |
1615 | DEFHOOK | |
1616 | (legitimate_address_p, | |
1617 | "", | |
1618 | bool, (enum machine_mode mode, rtx exp, bool strict, addr_space_t as), | |
1619 | default_addr_space_legitimate_address_p) | |
1620 | ||
1621 | /* Return an updated address to convert an invalid pointer to a named | |
1622 | address space to a valid one. If NULL_RTX is returned use machine | |
1623 | independent methods to make the address valid. */ | |
1624 | DEFHOOK | |
1625 | (legitimize_address, | |
1626 | "", | |
1627 | rtx, (rtx x, rtx oldx, enum machine_mode mode, addr_space_t as), | |
1628 | default_addr_space_legitimize_address) | |
1629 | ||
1630 | /* True if one named address space is a subset of another named address. */ | |
1631 | DEFHOOK | |
1632 | (subset_p, | |
1633 | "", | |
b5bcaa4a | 1634 | bool, (addr_space_t subset, addr_space_t superset), |
38f8b050 JR |
1635 | default_addr_space_subset_p) |
1636 | ||
1637 | /* Function to convert an rtl expression from one address space to another. */ | |
1638 | DEFHOOK | |
1639 | (convert, | |
1640 | "", | |
1641 | rtx, (rtx op, tree from_type, tree to_type), | |
1642 | default_addr_space_convert) | |
1643 | ||
1644 | HOOK_VECTOR_END (addr_space) | |
1645 | ||
1646 | #undef HOOK_PREFIX | |
1647 | #define HOOK_PREFIX "TARGET_" | |
1648 | ||
1649 | /* True if MODE is valid for the target. By "valid", we mean able to | |
1650 | be manipulated in non-trivial ways. In particular, this means all | |
1651 | the arithmetic is supported. */ | |
1652 | DEFHOOK | |
1653 | (scalar_mode_supported_p, | |
1654 | "", | |
1655 | bool, (enum machine_mode mode), | |
1656 | default_scalar_mode_supported_p) | |
1657 | ||
1658 | /* Similarly for vector modes. "Supported" here is less strict. At | |
1659 | least some operations are supported; need to check optabs or builtins | |
1660 | for further details. */ | |
1661 | DEFHOOK | |
1662 | (vector_mode_supported_p, | |
1663 | "", | |
1664 | bool, (enum machine_mode mode), | |
1665 | hook_bool_mode_false) | |
1666 | ||
5aea1e76 UW |
1667 | DEFHOOK |
1668 | (vector_alignment, | |
1669 | "This hook can be used to define the alignment for a vector of type\n\ | |
1670 | @var{type}, in order to comply with a platform ABI. The default is to\n\ | |
1671 | require natural alignment for vector types. The alignment returned by\n\ | |
1672 | this hook must be a power-of-two multiple of the default alignment of\n\ | |
1673 | the vector element type.", | |
1674 | HOST_WIDE_INT, (const_tree type), | |
1675 | default_vector_alignment) | |
1676 | ||
0f6d54f7 RS |
1677 | /* True if we should try to use a scalar mode to represent an array, |
1678 | overriding the usual MAX_FIXED_MODE limit. */ | |
1679 | DEFHOOK | |
1680 | (array_mode_supported_p, | |
1681 | "Return true if GCC should try to use a scalar mode to store an array\n\ | |
1682 | of @var{nelems} elements, given that each element has mode @var{mode}.\n\ | |
1683 | Returning true here overrides the usual @code{MAX_FIXED_MODE} limit\n\ | |
1684 | and allows GCC to use any defined integer mode.\n\ | |
1685 | \n\ | |
1686 | One use of this hook is to support vector load and store operations\n\ | |
1687 | that operate on several homogeneous vectors. For example, ARM NEON\n\ | |
1688 | has operations like:\n\ | |
1689 | \n\ | |
1690 | @smallexample\n\ | |
1691 | int8x8x3_t vld3_s8 (const int8_t *)\n\ | |
1692 | @end smallexample\n\ | |
1693 | \n\ | |
1694 | where the return type is defined as:\n\ | |
1695 | \n\ | |
1696 | @smallexample\n\ | |
1697 | typedef struct int8x8x3_t\n\ | |
1698 | @{\n\ | |
1699 | int8x8_t val[3];\n\ | |
1700 | @} int8x8x3_t;\n\ | |
1701 | @end smallexample\n\ | |
1702 | \n\ | |
1703 | If this hook allows @code{val} to have a scalar mode, then\n\ | |
1704 | @code{int8x8x3_t} can have the same mode. GCC can then store\n\ | |
1705 | @code{int8x8x3_t}s in registers rather than forcing them onto the stack.", | |
1706 | bool, (enum machine_mode mode, unsigned HOST_WIDE_INT nelems), | |
1707 | hook_bool_mode_uhwi_false) | |
1708 | ||
38f8b050 JR |
1709 | /* Compute cost of moving data from a register of class FROM to one of |
1710 | TO, using MODE. */ | |
1711 | DEFHOOK | |
1712 | (register_move_cost, | |
1713 | "", | |
a87cf97e | 1714 | int, (enum machine_mode mode, reg_class_t from, reg_class_t to), |
38f8b050 JR |
1715 | default_register_move_cost) |
1716 | ||
1717 | /* Compute cost of moving registers to/from memory. */ | |
1718 | /* ??? Documenting the argument types for this hook requires a GFDL | |
1719 | license grant. Also, the documentation uses a different name for RCLASS. */ | |
911852ff | 1720 | DEFHOOK |
38f8b050 JR |
1721 | (memory_move_cost, |
1722 | "", | |
a87cf97e | 1723 | int, (enum machine_mode mode, reg_class_t rclass, bool in), |
38f8b050 JR |
1724 | default_memory_move_cost) |
1725 | ||
1726 | /* True for MODE if the target expects that registers in this mode will | |
1727 | be allocated to registers in a small register class. The compiler is | |
1728 | allowed to use registers explicitly used in the rtl as spill registers | |
1729 | but it should prevent extending the lifetime of these registers. */ | |
1730 | DEFHOOK | |
1731 | (small_register_classes_for_mode_p, | |
1732 | "", | |
1733 | bool, (enum machine_mode mode), | |
1734 | hook_bool_mode_false) | |
1735 | ||
e692f276 RH |
1736 | /* Register number for a flags register. Only needs to be defined if the |
1737 | target is constrainted to use post-reload comparison elimination. */ | |
1738 | DEFHOOKPOD | |
1739 | (flags_regnum, | |
1740 | "If the target has a dedicated flags register, and it needs to use the\ | |
1741 | post-reload comparison elimination pass, then this value should be set\ | |
1742 | appropriately.", | |
1743 | unsigned int, INVALID_REGNUM) | |
1744 | ||
38f8b050 JR |
1745 | /* Compute a (partial) cost for rtx X. Return true if the complete |
1746 | cost has been computed, and false if subexpressions should be | |
1747 | scanned. In either case, *TOTAL contains the cost result. */ | |
1748 | /* Note that CODE and OUTER_CODE ought to be RTX_CODE, but that's | |
1749 | not necessarily defined at this point. */ | |
1750 | DEFHOOK | |
1751 | (rtx_costs, | |
1752 | "", | |
68f932c4 RS |
1753 | bool, (rtx x, int code, int outer_code, int opno, int *total, bool speed), |
1754 | hook_bool_rtx_int_int_int_intp_bool_false) | |
38f8b050 JR |
1755 | |
1756 | /* Compute the cost of X, used as an address. Never called with | |
1757 | invalid addresses. */ | |
1758 | DEFHOOK | |
1759 | (address_cost, | |
1760 | "", | |
b413068c | 1761 | int, (rtx address, enum machine_mode mode, addr_space_t as, bool speed), |
38f8b050 JR |
1762 | default_address_cost) |
1763 | ||
1764 | /* Return where to allocate pseudo for a given hard register initial value. */ | |
1765 | DEFHOOK | |
1766 | (allocate_initial_value, | |
1767 | "", | |
1768 | rtx, (rtx hard_reg), NULL) | |
1769 | ||
1770 | /* Return nonzero if evaluating UNSPEC[_VOLATILE] X might cause a trap. | |
1771 | FLAGS has the same meaning as in rtlanal.c: may_trap_p_1. */ | |
1772 | DEFHOOK | |
1773 | (unspec_may_trap_p, | |
1774 | "", | |
1775 | int, (const_rtx x, unsigned flags), | |
1776 | default_unspec_may_trap_p) | |
1777 | ||
1778 | /* Given a register, this hook should return a parallel of registers | |
1779 | to represent where to find the register pieces. Define this hook | |
1780 | if the register and its mode are represented in Dwarf in | |
1781 | non-contiguous locations, or if the register should be | |
1782 | represented in more than one register in Dwarf. Otherwise, this | |
1783 | hook should return NULL_RTX. */ | |
1784 | DEFHOOK | |
1785 | (dwarf_register_span, | |
1786 | "", | |
1787 | rtx, (rtx reg), | |
1788 | hook_rtx_rtx_null) | |
1789 | ||
1790 | /* If expand_builtin_init_dwarf_reg_sizes needs to fill in table | |
1791 | entries not corresponding directly to registers below | |
1792 | FIRST_PSEUDO_REGISTER, this hook should generate the necessary | |
1793 | code, given the address of the table. */ | |
1794 | DEFHOOK | |
1795 | (init_dwarf_reg_sizes_extra, | |
1796 | "", | |
1797 | void, (tree address), | |
1798 | hook_void_tree) | |
1799 | ||
1800 | /* Fetch the fixed register(s) which hold condition codes, for | |
1801 | targets where it makes sense to look for duplicate assignments to | |
1802 | the condition codes. This should return true if there is such a | |
1803 | register, false otherwise. The arguments should be set to the | |
1804 | fixed register numbers. Up to two condition code registers are | |
1805 | supported. If there is only one for this target, the int pointed | |
1806 | at by the second argument should be set to -1. */ | |
1807 | DEFHOOK | |
1808 | (fixed_condition_code_regs, | |
1809 | "", | |
1810 | bool, (unsigned int *p1, unsigned int *p2), | |
1811 | hook_bool_uintp_uintp_false) | |
1812 | ||
1813 | /* If two condition code modes are compatible, return a condition | |
1814 | code mode which is compatible with both, such that a comparison | |
1815 | done in the returned mode will work for both of the original | |
1816 | modes. If the condition code modes are not compatible, return | |
1817 | VOIDmode. */ | |
1818 | DEFHOOK | |
1819 | (cc_modes_compatible, | |
1820 | "", | |
1821 | enum machine_mode, (enum machine_mode m1, enum machine_mode m2), | |
1822 | default_cc_modes_compatible) | |
1823 | ||
1824 | /* Do machine-dependent code transformations. Called just before | |
1825 | delayed-branch scheduling. */ | |
1826 | DEFHOOK | |
1827 | (machine_dependent_reorg, | |
1828 | "", | |
1829 | void, (void), NULL) | |
1830 | ||
1831 | /* Create the __builtin_va_list type. */ | |
1832 | DEFHOOK | |
1833 | (build_builtin_va_list, | |
1834 | "", | |
1835 | tree, (void), | |
1836 | std_build_builtin_va_list) | |
1837 | ||
1838 | /* Enumerate the va list variants. */ | |
07a5b2bc | 1839 | DEFHOOK |
38f8b050 JR |
1840 | (enum_va_list_p, |
1841 | "", | |
1842 | int, (int idx, const char **pname, tree *ptree), | |
1843 | NULL) | |
1844 | ||
1845 | /* Get the cfun/fndecl calling abi __builtin_va_list type. */ | |
1846 | DEFHOOK | |
1847 | (fn_abi_va_list, | |
1848 | "", | |
1849 | tree, (tree fndecl), | |
1850 | std_fn_abi_va_list) | |
1851 | ||
1852 | /* Get the __builtin_va_list type dependent on input type. */ | |
1853 | DEFHOOK | |
1854 | (canonical_va_list_type, | |
1855 | "", | |
1856 | tree, (tree type), | |
1857 | std_canonical_va_list_type) | |
1858 | ||
1859 | /* ??? Documenting this hook requires a GFDL license grant. */ | |
1860 | DEFHOOK_UNDOC | |
1861 | (expand_builtin_va_start, | |
1862 | "Expand the @code{__builtin_va_start} builtin.", | |
1863 | void, (tree valist, rtx nextarg), NULL) | |
1864 | ||
1865 | /* Gimplifies a VA_ARG_EXPR. */ | |
1866 | DEFHOOK | |
1867 | (gimplify_va_arg_expr, | |
1868 | "", | |
1869 | tree, (tree valist, tree type, gimple_seq *pre_p, gimple_seq *post_p), | |
1870 | std_gimplify_va_arg_expr) | |
1871 | ||
1872 | /* Validity-checking routines for PCH files, target-specific. | |
1873 | get_pch_validity returns a pointer to the data to be stored, | |
1874 | and stores the size in its argument. pch_valid_p gets the same | |
1875 | information back and returns NULL if the PCH is valid, | |
1876 | or an error message if not. */ | |
1877 | DEFHOOK | |
1878 | (get_pch_validity, | |
1879 | "", | |
1880 | void *, (size_t *sz), | |
1881 | default_get_pch_validity) | |
1882 | ||
1883 | DEFHOOK | |
1884 | (pch_valid_p, | |
1885 | "", | |
1886 | const char *, (const void *data, size_t sz), | |
1887 | default_pch_valid_p) | |
1888 | ||
e32ea2d1 RS |
1889 | DEFHOOK |
1890 | (prepare_pch_save, | |
1891 | "Called before writing out a PCH file. If the target has some\n\ | |
1892 | garbage-collected data that needs to be in a particular state on PCH loads,\n\ | |
1893 | it can use this hook to enforce that state. Very few targets need\n\ | |
1894 | to do anything here.", | |
1895 | void, (void), | |
1896 | hook_void_void) | |
1897 | ||
38f8b050 JR |
1898 | /* If nonnull, this function checks whether a PCH file with the |
1899 | given set of target flags can be used. It returns NULL if so, | |
1900 | otherwise it returns an error message. */ | |
1901 | DEFHOOK | |
1902 | (check_pch_target_flags, | |
1903 | "", | |
1904 | const char *, (int pch_flags), NULL) | |
1905 | ||
1906 | /* True if the compiler should give an enum type only as many | |
1907 | bytes as it takes to represent the range of possible values of | |
1908 | that type. */ | |
1909 | DEFHOOK | |
1910 | (default_short_enums, | |
1911 | "", | |
1912 | bool, (void), | |
1913 | hook_bool_void_false) | |
1914 | ||
1915 | /* This target hook returns an rtx that is used to store the address | |
1916 | of the current frame into the built-in setjmp buffer. */ | |
1917 | DEFHOOK | |
1918 | (builtin_setjmp_frame_value, | |
1919 | "", | |
1920 | rtx, (void), | |
1921 | default_builtin_setjmp_frame_value) | |
1922 | ||
1923 | /* This target hook should add STRING_CST trees for any hard regs | |
1924 | the port wishes to automatically clobber for an asm. */ | |
1925 | DEFHOOK | |
1926 | (md_asm_clobbers, | |
1927 | "", | |
1928 | tree, (tree outputs, tree inputs, tree clobbers), | |
1929 | hook_tree_tree_tree_tree_3rd_identity) | |
1930 | ||
1931 | /* This target hook allows the backend to specify a calling convention | |
1932 | in the debug information. This function actually returns an | |
1933 | enum dwarf_calling_convention, but because of forward declarations | |
1934 | and not wanting to include dwarf2.h everywhere target.h is included | |
1935 | the function is being declared as an int. */ | |
1936 | DEFHOOK | |
1937 | (dwarf_calling_convention, | |
1938 | "", | |
1939 | int, (const_tree function), | |
1940 | hook_int_const_tree_0) | |
1941 | ||
1942 | /* This target hook allows the backend to emit frame-related insns that | |
1943 | contain UNSPECs or UNSPEC_VOLATILEs. The call frame debugging info | |
1944 | engine will invoke it on insns of the form | |
1945 | (set (reg) (unspec [...] UNSPEC_INDEX)) | |
1946 | and | |
1947 | (set (reg) (unspec_volatile [...] UNSPECV_INDEX)) | |
1948 | to let the backend emit the call frame instructions. */ | |
1949 | DEFHOOK | |
1950 | (dwarf_handle_frame_unspec, | |
1951 | "", | |
1952 | void, (const char *label, rtx pattern, int index), NULL) | |
1953 | ||
1954 | /* ??? Documenting this hook requires a GFDL license grant. */ | |
1955 | DEFHOOK_UNDOC | |
1956 | (stdarg_optimize_hook, | |
1957 | "Perform architecture specific checking of statements gimplified\ | |
1958 | from @code{VA_ARG_EXPR}. @var{stmt} is the statement. Returns true if\ | |
1959 | the statement doesn't need to be checked for @code{va_list} references.", | |
1960 | bool, (struct stdarg_info *ai, const_gimple stmt), NULL) | |
1961 | ||
1962 | /* This target hook allows the operating system to override the DECL | |
1963 | that represents the external variable that contains the stack | |
1964 | protection guard variable. The type of this DECL is ptr_type_node. */ | |
1965 | DEFHOOK | |
1966 | (stack_protect_guard, | |
1967 | "", | |
1968 | tree, (void), | |
1969 | default_stack_protect_guard) | |
1970 | ||
1971 | /* This target hook allows the operating system to override the CALL_EXPR | |
1972 | that is invoked when a check vs the guard variable fails. */ | |
1973 | DEFHOOK | |
1974 | (stack_protect_fail, | |
1975 | "", | |
1976 | tree, (void), | |
1977 | default_external_stack_protect_fail) | |
1978 | ||
1979 | /* Returns NULL if target supports the insn within a doloop block, | |
1980 | otherwise it returns an error message. */ | |
1981 | DEFHOOK | |
1982 | (invalid_within_doloop, | |
1983 | "", | |
1984 | const char *, (const_rtx insn), | |
1985 | default_invalid_within_doloop) | |
1986 | ||
78e4f1ad UB |
1987 | /* Returns true for a legitimate combined insn. */ |
1988 | DEFHOOK | |
1989 | (legitimate_combined_insn, | |
1990 | "Take an instruction in @var{insn} and return @code{false} if the instruction\ | |
1991 | is not appropriate as a combination of two or more instructions. The\ | |
1992 | default is to accept all instructions.", | |
1993 | bool, (rtx insn), | |
1994 | hook_bool_rtx_true) | |
1995 | ||
38f8b050 JR |
1996 | DEFHOOK |
1997 | (valid_dllimport_attribute_p, | |
1998 | "@var{decl} is a variable or function with @code{__attribute__((dllimport))}\ | |
1999 | specified. Use this hook if the target needs to add extra validation\ | |
2000 | checks to @code{handle_dll_attribute}.", | |
2001 | bool, (const_tree decl), | |
2002 | hook_bool_const_tree_true) | |
2003 | ||
2004 | /* If non-zero, align constant anchors in CSE to a multiple of this | |
2005 | value. */ | |
2006 | DEFHOOKPOD | |
2007 | (const_anchor, | |
2008 | "", | |
2009 | unsigned HOST_WIDE_INT, 0) | |
2010 | ||
5dcfdccd KY |
2011 | /* Defines, which target-dependent bits (upper 16) are used by port */ |
2012 | DEFHOOK | |
2013 | (memmodel_check, | |
2014 | "", | |
2015 | unsigned HOST_WIDE_INT, (unsigned HOST_WIDE_INT val), NULL) | |
2016 | ||
38f8b050 JR |
2017 | /* Functions relating to calls - argument passing, returns, etc. */ |
2018 | /* Members of struct call have no special macro prefix. */ | |
2019 | HOOK_VECTOR (TARGET_CALLS, calls) | |
2020 | ||
2021 | DEFHOOK | |
2022 | (promote_function_mode, | |
2023 | "", | |
2024 | enum machine_mode, (const_tree type, enum machine_mode mode, int *punsignedp, | |
2025 | const_tree funtype, int for_return), | |
2026 | default_promote_function_mode) | |
2027 | ||
2028 | DEFHOOK | |
2029 | (promote_prototypes, | |
2030 | "", | |
2031 | bool, (const_tree fntype), | |
2032 | hook_bool_const_tree_false) | |
2033 | ||
2034 | DEFHOOK | |
2035 | (struct_value_rtx, | |
2036 | "", | |
2037 | rtx, (tree fndecl, int incoming), | |
2038 | hook_rtx_tree_int_null) | |
2039 | DEFHOOK | |
2040 | (return_in_memory, | |
2041 | "", | |
2042 | bool, (const_tree type, const_tree fntype), | |
2043 | default_return_in_memory) | |
2044 | ||
2045 | DEFHOOK | |
2046 | (return_in_msb, | |
2047 | "", | |
2048 | bool, (const_tree type), | |
2049 | hook_bool_const_tree_false) | |
2050 | ||
2051 | /* Return true if a parameter must be passed by reference. TYPE may | |
2052 | be null if this is a libcall. CA may be null if this query is | |
2053 | from __builtin_va_arg. */ | |
ec9f85e5 | 2054 | DEFHOOK |
38f8b050 JR |
2055 | (pass_by_reference, |
2056 | "", | |
2057 | bool, | |
d5cc9181 | 2058 | (cumulative_args_t cum, enum machine_mode mode, const_tree type, bool named), |
38f8b050 JR |
2059 | hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false) |
2060 | ||
2061 | DEFHOOK | |
2062 | (expand_builtin_saveregs, | |
2063 | "", | |
2064 | rtx, (void), | |
2065 | default_expand_builtin_saveregs) | |
2066 | ||
2067 | /* Returns pretend_argument_size. */ | |
2068 | DEFHOOK | |
2069 | (setup_incoming_varargs, | |
2070 | "", | |
d5cc9181 | 2071 | void, (cumulative_args_t args_so_far, enum machine_mode mode, tree type, |
38f8b050 JR |
2072 | int *pretend_args_size, int second_time), |
2073 | default_setup_incoming_varargs) | |
2074 | ||
2075 | DEFHOOK | |
2076 | (strict_argument_naming, | |
2077 | "", | |
d5cc9181 | 2078 | bool, (cumulative_args_t ca), |
38f8b050 JR |
2079 | hook_bool_CUMULATIVE_ARGS_false) |
2080 | ||
2081 | /* Returns true if we should use | |
2082 | targetm.calls.setup_incoming_varargs() and/or | |
2083 | targetm.calls.strict_argument_naming(). */ | |
2084 | DEFHOOK | |
2085 | (pretend_outgoing_varargs_named, | |
2086 | "", | |
d5cc9181 | 2087 | bool, (cumulative_args_t ca), |
38f8b050 JR |
2088 | default_pretend_outgoing_varargs_named) |
2089 | ||
2090 | /* Given a complex type T, return true if a parameter of type T | |
2091 | should be passed as two scalars. */ | |
2092 | DEFHOOK | |
2093 | (split_complex_arg, | |
2094 | "", | |
2095 | bool, (const_tree type), NULL) | |
2096 | ||
2097 | /* Return true if type T, mode MODE, may not be passed in registers, | |
2098 | but must be passed on the stack. */ | |
2099 | /* ??? This predicate should be applied strictly after pass-by-reference. | |
2100 | Need audit to verify that this is the case. */ | |
2101 | DEFHOOK | |
2102 | (must_pass_in_stack, | |
2103 | "", | |
2104 | bool, (enum machine_mode mode, const_tree type), | |
2105 | must_pass_in_stack_var_size_or_pad) | |
2106 | ||
2107 | /* Return true if type TYPE, mode MODE, which is passed by reference, | |
2108 | should have the object copy generated by the callee rather than | |
2109 | the caller. It is never called for TYPE requiring constructors. */ | |
2110 | DEFHOOK | |
2111 | (callee_copies, | |
2112 | "", | |
2113 | bool, | |
d5cc9181 | 2114 | (cumulative_args_t cum, enum machine_mode mode, const_tree type, bool named), |
38f8b050 JR |
2115 | hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false) |
2116 | ||
2117 | /* Return zero for arguments passed entirely on the stack or entirely | |
2118 | in registers. If passed in both, return the number of bytes passed | |
2119 | in registers; the balance is therefore passed on the stack. */ | |
2120 | DEFHOOK | |
2121 | (arg_partial_bytes, | |
2122 | "", | |
d5cc9181 | 2123 | int, (cumulative_args_t cum, enum machine_mode mode, tree type, bool named), |
38f8b050 JR |
2124 | hook_int_CUMULATIVE_ARGS_mode_tree_bool_0) |
2125 | ||
2126 | /* Update the state in CA to advance past an argument in the | |
2127 | argument list. The values MODE, TYPE, and NAMED describe that | |
2128 | argument. */ | |
b25b9e8f | 2129 | DEFHOOK |
38f8b050 JR |
2130 | (function_arg_advance, |
2131 | "", | |
2132 | void, | |
d5cc9181 | 2133 | (cumulative_args_t ca, enum machine_mode mode, const_tree type, bool named), |
38f8b050 JR |
2134 | default_function_arg_advance) |
2135 | ||
2136 | /* Return zero if the argument described by the state of CA should | |
2137 | be placed on a stack, or a hard register in which to store the | |
2138 | argument. The values MODE, TYPE, and NAMED describe that | |
2139 | argument. */ | |
b25b9e8f | 2140 | DEFHOOK |
38f8b050 JR |
2141 | (function_arg, |
2142 | "", | |
d5cc9181 | 2143 | rtx, (cumulative_args_t ca, enum machine_mode mode, const_tree type, |
38f8b050 JR |
2144 | bool named), |
2145 | default_function_arg) | |
2146 | ||
2147 | /* Likewise, but for machines with register windows. Return the | |
2148 | location where the argument will appear to the callee. */ | |
b25b9e8f | 2149 | DEFHOOK |
38f8b050 JR |
2150 | (function_incoming_arg, |
2151 | "", | |
d5cc9181 | 2152 | rtx, (cumulative_args_t ca, enum machine_mode mode, const_tree type, |
38f8b050 JR |
2153 | bool named), |
2154 | default_function_incoming_arg) | |
2155 | ||
c2ed6cf8 NF |
2156 | DEFHOOK |
2157 | (function_arg_boundary, | |
2158 | "", | |
2159 | unsigned int, (enum machine_mode mode, const_tree type), | |
2160 | default_function_arg_boundary) | |
2161 | ||
123148b5 BS |
2162 | DEFHOOK |
2163 | (function_arg_round_boundary, | |
2164 | "Normally, the size of an argument is rounded up to @code{PARM_BOUNDARY},\n\ | |
2165 | which is the default value for this hook. You can define this hook to\n\ | |
2166 | return a different value if an argument size must be rounded to a larger\n\ | |
2167 | value.", | |
2168 | unsigned int, (enum machine_mode mode, const_tree type), | |
2169 | default_function_arg_round_boundary) | |
2170 | ||
38f8b050 JR |
2171 | /* Return the diagnostic message string if function without a prototype |
2172 | is not allowed for this 'val' argument; NULL otherwise. */ | |
2173 | DEFHOOK | |
2174 | (invalid_arg_for_unprototyped_fn, | |
2175 | "", | |
2176 | const char *, (const_tree typelist, const_tree funcdecl, const_tree val), | |
2177 | hook_invalid_arg_for_unprototyped_fn) | |
2178 | ||
2179 | /* Return an rtx for the return value location of the function | |
2180 | specified by FN_DECL_OR_TYPE with a return type of RET_TYPE. */ | |
2181 | DEFHOOK | |
2182 | (function_value, | |
2183 | "", | |
2184 | rtx, (const_tree ret_type, const_tree fn_decl_or_type, bool outgoing), | |
2185 | default_function_value) | |
2186 | ||
2187 | /* Return the rtx for the result of a libcall of mode MODE, | |
2188 | calling the function FN_NAME. */ | |
2189 | DEFHOOK | |
2190 | (libcall_value, | |
2191 | "", | |
2192 | rtx, (enum machine_mode mode, const_rtx fun), | |
2193 | default_libcall_value) | |
2194 | ||
2195 | /* Return true if REGNO is a possible register number for | |
2196 | a function value as seen by the caller. */ | |
2197 | DEFHOOK | |
2198 | (function_value_regno_p, | |
2199 | "", | |
2200 | bool, (const unsigned int regno), | |
2201 | default_function_value_regno_p) | |
2202 | ||
2203 | /* ??? Documenting this hook requires a GFDL license grant. */ | |
2204 | DEFHOOK_UNDOC | |
2205 | (internal_arg_pointer, | |
2206 | "Return an rtx for the argument pointer incoming to the\ | |
2207 | current function.", | |
2208 | rtx, (void), | |
2209 | default_internal_arg_pointer) | |
2210 | ||
2211 | /* Update the current function stack boundary if needed. */ | |
2212 | DEFHOOK | |
2213 | (update_stack_boundary, | |
2214 | "", | |
2215 | void, (void), NULL) | |
2216 | ||
2217 | /* Handle stack alignment and return an rtx for Dynamic Realign | |
2218 | Argument Pointer if necessary. */ | |
2219 | DEFHOOK | |
2220 | (get_drap_rtx, | |
2221 | "", | |
2222 | rtx, (void), NULL) | |
2223 | ||
2224 | /* Return true if all function parameters should be spilled to the | |
2225 | stack. */ | |
2226 | DEFHOOK | |
2227 | (allocate_stack_slots_for_args, | |
2228 | "", | |
2229 | bool, (void), | |
2230 | hook_bool_void_true) | |
2231 | ||
2232 | /* Return an rtx for the static chain for FNDECL. If INCOMING_P is true, | |
2233 | then it should be for the callee; otherwise for the caller. */ | |
2234 | DEFHOOK | |
2235 | (static_chain, | |
2236 | "", | |
2237 | rtx, (const_tree fndecl, bool incoming_p), | |
2238 | default_static_chain) | |
2239 | ||
2240 | /* Fill in the trampoline at MEM with a call to FNDECL and a | |
2241 | static chain value of CHAIN. */ | |
2242 | DEFHOOK | |
2243 | (trampoline_init, | |
2244 | "", | |
2245 | void, (rtx m_tramp, tree fndecl, rtx static_chain), | |
2246 | default_trampoline_init) | |
2247 | ||
2248 | /* Adjust the address of the trampoline in a target-specific way. */ | |
2249 | DEFHOOK | |
2250 | (trampoline_adjust_address, | |
2251 | "", | |
2252 | rtx, (rtx addr), NULL) | |
2253 | ||
2254 | /* Return the number of bytes of its own arguments that a function | |
2255 | pops on returning, or 0 if the function pops no arguments and the | |
2256 | caller must therefore pop them all after the function returns. */ | |
2257 | /* ??? tm.texi has no types for the parameters. */ | |
893d13d5 | 2258 | DEFHOOK |
38f8b050 JR |
2259 | (return_pops_args, |
2260 | "", | |
2261 | int, (tree fundecl, tree funtype, int size), | |
2262 | default_return_pops_args) | |
2263 | ||
ffa88471 SE |
2264 | /* Return a mode wide enough to copy any function value that might be |
2265 | returned. */ | |
2266 | DEFHOOK | |
2267 | (get_raw_result_mode, | |
2268 | "This target hook returns the mode to be used when accessing raw return\ | |
2269 | registers in @code{__builtin_return}. Define this macro if the value\ | |
2270 | in @var{reg_raw_mode} is not correct.", | |
2271 | enum machine_mode, (int regno), | |
2272 | default_get_reg_raw_mode) | |
2273 | ||
2274 | /* Return a mode wide enough to copy any argument value that might be | |
2275 | passed. */ | |
2276 | DEFHOOK | |
2277 | (get_raw_arg_mode, | |
2278 | "This target hook returns the mode to be used when accessing raw argument\ | |
2279 | registers in @code{__builtin_apply_args}. Define this macro if the value\ | |
2280 | in @var{reg_raw_mode} is not correct.", | |
2281 | enum machine_mode, (int regno), | |
2282 | default_get_reg_raw_mode) | |
2283 | ||
38f8b050 JR |
2284 | HOOK_VECTOR_END (calls) |
2285 | ||
2286 | /* Return the diagnostic message string if conversion from FROMTYPE | |
2287 | to TOTYPE is not allowed, NULL otherwise. */ | |
2288 | DEFHOOK | |
2289 | (invalid_conversion, | |
2290 | "", | |
2291 | const char *, (const_tree fromtype, const_tree totype), | |
2292 | hook_constcharptr_const_tree_const_tree_null) | |
2293 | ||
2294 | /* Return the diagnostic message string if the unary operation OP is | |
2295 | not permitted on TYPE, NULL otherwise. */ | |
2296 | DEFHOOK | |
2297 | (invalid_unary_op, | |
2298 | "", | |
2299 | const char *, (int op, const_tree type), | |
2300 | hook_constcharptr_int_const_tree_null) | |
2301 | ||
2302 | /* Return the diagnostic message string if the binary operation OP | |
2303 | is not permitted on TYPE1 and TYPE2, NULL otherwise. */ | |
2304 | DEFHOOK | |
2305 | (invalid_binary_op, | |
2306 | "", | |
2307 | const char *, (int op, const_tree type1, const_tree type2), | |
2308 | hook_constcharptr_int_const_tree_const_tree_null) | |
2309 | ||
2310 | /* Return the diagnostic message string if TYPE is not valid as a | |
2311 | function parameter type, NULL otherwise. */ | |
2312 | DEFHOOK | |
2313 | (invalid_parameter_type, | |
2314 | "", | |
2315 | const char *, (const_tree type), | |
2316 | hook_constcharptr_const_tree_null) | |
2317 | ||
2318 | /* Return the diagnostic message string if TYPE is not valid as a | |
2319 | function return type, NULL otherwise. */ | |
2320 | DEFHOOK | |
2321 | (invalid_return_type, | |
2322 | "", | |
2323 | const char *, (const_tree type), | |
2324 | hook_constcharptr_const_tree_null) | |
2325 | ||
2326 | /* If values of TYPE are promoted to some other type when used in | |
2327 | expressions (analogous to the integer promotions), return that type, | |
2328 | or NULL_TREE otherwise. */ | |
2329 | DEFHOOK | |
2330 | (promoted_type, | |
2331 | "", | |
2332 | tree, (const_tree type), | |
2333 | hook_tree_const_tree_null) | |
2334 | ||
2335 | /* Convert EXPR to TYPE, if target-specific types with special conversion | |
2336 | rules are involved. Return the converted expression, or NULL to apply | |
2337 | the standard conversion rules. */ | |
2338 | DEFHOOK | |
2339 | (convert_to_type, | |
2340 | "", | |
2341 | tree, (tree type, tree expr), | |
2342 | hook_tree_tree_tree_null) | |
2343 | ||
d9886a9e L |
2344 | /* True if a structure, union or array with MODE containing FIELD should |
2345 | be accessed using BLKmode. */ | |
2346 | DEFHOOK | |
2347 | (member_type_forces_blk, | |
2348 | "", | |
2349 | bool, (const_tree field, enum machine_mode mode), | |
2350 | default_member_type_forces_blk) | |
2351 | ||
38f8b050 JR |
2352 | /* Return the class for a secondary reload, and fill in extra information. */ |
2353 | DEFHOOK | |
2354 | (secondary_reload, | |
2355 | "", | |
a87cf97e JR |
2356 | reg_class_t, |
2357 | (bool in_p, rtx x, reg_class_t reload_class, enum machine_mode reload_mode, | |
38f8b050 JR |
2358 | secondary_reload_info *sri), |
2359 | default_secondary_reload) | |
2360 | ||
fba42e24 AS |
2361 | /* Given an rtx X being reloaded into a reg required to be in class CLASS, |
2362 | return the class of reg to actually use. */ | |
2363 | DEFHOOK | |
2364 | (preferred_reload_class, | |
2365 | "", | |
2366 | reg_class_t, | |
2367 | (rtx x, reg_class_t rclass), | |
2368 | default_preferred_reload_class) | |
2369 | ||
abd26bfb AS |
2370 | /* Like TARGET_PREFERRED_RELOAD_CLASS, but for output reloads instead of |
2371 | input reloads. */ | |
2372 | DEFHOOK | |
2373 | (preferred_output_reload_class, | |
2374 | "", | |
2375 | reg_class_t, | |
2376 | (rtx x, reg_class_t rclass), | |
2377 | default_preferred_output_reload_class) | |
2378 | ||
07b8f0a8 AS |
2379 | DEFHOOK |
2380 | (class_likely_spilled_p, | |
2381 | "", | |
2382 | bool, (reg_class_t rclass), | |
2383 | default_class_likely_spilled_p) | |
2384 | ||
a8c44c52 AS |
2385 | /* Return the maximum number of consecutive registers |
2386 | needed to represent mode MODE in a register of class RCLASS. */ | |
2387 | DEFHOOK | |
2388 | (class_max_nregs, | |
2389 | "", | |
2390 | unsigned char, (reg_class_t rclass, enum machine_mode mode), | |
2391 | default_class_max_nregs) | |
2392 | ||
5f286f4a YQ |
2393 | DEFHOOK |
2394 | (preferred_rename_class, | |
2395 | "A target hook that places additional preference on the register\ | |
2396 | class to use when it is necessary to rename a register in class\ | |
6d3fbe2f JR |
2397 | @var{rclass} to another class, or perhaps @var{NO_REGS}, if no\ |
2398 | preferred register class is found or hook @code{preferred_rename_class}\ | |
5f286f4a YQ |
2399 | is not implemented.\ |
2400 | Sometimes returning a more restrictive class makes better code. For\ | |
2401 | example, on ARM, thumb-2 instructions using @code{LO_REGS} may be\ | |
2402 | smaller than instructions using @code{GENERIC_REGS}. By returning\ | |
2403 | @code{LO_REGS} from @code{preferred_rename_class}, code size can\ | |
2404 | be reduced.", | |
2405 | reg_class_t, (reg_class_t rclass), | |
2406 | default_preferred_rename_class) | |
2407 | ||
38f8b050 JR |
2408 | /* This target hook allows the backend to perform additional |
2409 | processing while initializing for variable expansion. */ | |
2410 | DEFHOOK | |
2411 | (expand_to_rtl_hook, | |
2412 | "", | |
2413 | void, (void), | |
2414 | hook_void_void) | |
2415 | ||
2416 | /* This target hook allows the backend to perform additional | |
2417 | instantiations on rtx that are not actually in insns yet, | |
2418 | but will be later. */ | |
2419 | DEFHOOK | |
2420 | (instantiate_decls, | |
2421 | "", | |
2422 | void, (void), | |
2423 | hook_void_void) | |
2424 | ||
2425 | /* Return true if is OK to use a hard register REGNO as scratch register | |
2426 | in peephole2. */ | |
2427 | DEFHOOK | |
2428 | (hard_regno_scratch_ok, | |
2429 | "", | |
2430 | bool, (unsigned int regno), | |
2431 | default_hard_regno_scratch_ok) | |
2432 | ||
2433 | /* Return the smallest number of different values for which it is best to | |
2434 | use a jump-table instead of a tree of conditional branches. */ | |
2435 | DEFHOOK | |
2436 | (case_values_threshold, | |
2437 | "", | |
2438 | unsigned int, (void), | |
2439 | default_case_values_threshold) | |
2440 | ||
2441 | /* Retutn true if a function must have and use a frame pointer. */ | |
2442 | DEFHOOK | |
2443 | (frame_pointer_required, | |
2444 | "", | |
2445 | bool, (void), | |
2446 | hook_bool_void_false) | |
2447 | ||
2448 | /* Returns true if the compiler is allowed to try to replace register number | |
2449 | from-reg with register number to-reg. */ | |
2450 | DEFHOOK | |
2451 | (can_eliminate, | |
2452 | "", | |
2453 | bool, (const int from_reg, const int to_reg), | |
2454 | hook_bool_const_int_const_int_true) | |
2455 | ||
5efd84c5 NF |
2456 | /* Modify any or all of fixed_regs, call_used_regs, global_regs, |
2457 | reg_names, and reg_class_contents to account of the vagaries of the | |
2458 | target. */ | |
2459 | DEFHOOK | |
2460 | (conditional_register_usage, | |
2461 | "", | |
2462 | void, (void), | |
2463 | hook_void_void) | |
2464 | ||
38f8b050 JR |
2465 | /* Functions specific to the C family of frontends. */ |
2466 | #undef HOOK_PREFIX | |
2467 | #define HOOK_PREFIX "TARGET_C_" | |
2468 | HOOK_VECTOR (TARGET_C, c) | |
2469 | ||
2470 | /* ??? Documenting this hook requires a GFDL license grant. */ | |
2471 | DEFHOOK_UNDOC | |
2472 | (mode_for_suffix, | |
2473 | "Return machine mode for non-standard constant literal suffix @var{c},\ | |
2474 | or VOIDmode if non-standard suffixes are unsupported.", | |
2475 | enum machine_mode, (char c), | |
2476 | default_mode_for_suffix) | |
2477 | ||
2478 | HOOK_VECTOR_END (c) | |
2479 | ||
2480 | /* Functions specific to the C++ frontend. */ | |
2481 | #undef HOOK_PREFIX | |
2482 | #define HOOK_PREFIX "TARGET_CXX_" | |
2483 | HOOK_VECTOR (TARGET_CXX, cxx) | |
2484 | ||
2485 | /* Return the integer type used for guard variables. */ | |
2486 | DEFHOOK | |
2487 | (guard_type, | |
2488 | "", | |
2489 | tree, (void), | |
2490 | default_cxx_guard_type) | |
2491 | ||
2492 | /* Return true if only the low bit of the guard should be tested. */ | |
2493 | DEFHOOK | |
2494 | (guard_mask_bit, | |
2495 | "", | |
2496 | bool, (void), | |
2497 | hook_bool_void_false) | |
2498 | ||
2499 | /* Returns the size of the array cookie for an array of type. */ | |
2500 | DEFHOOK | |
2501 | (get_cookie_size, | |
2502 | "", | |
2503 | tree, (tree type), | |
2504 | default_cxx_get_cookie_size) | |
2505 | ||
2506 | /* Returns true if the element size should be stored in the array cookie. */ | |
2507 | DEFHOOK | |
2508 | (cookie_has_size, | |
2509 | "", | |
2510 | bool, (void), | |
2511 | hook_bool_void_false) | |
2512 | ||
2513 | /* Allows backends to perform additional processing when | |
2514 | deciding if a class should be exported or imported. */ | |
2515 | DEFHOOK | |
2516 | (import_export_class, | |
2517 | "", | |
2518 | int, (tree type, int import_export), NULL) | |
2519 | ||
2520 | /* Returns true if constructors and destructors return "this". */ | |
2521 | DEFHOOK | |
2522 | (cdtor_returns_this, | |
2523 | "", | |
2524 | bool, (void), | |
2525 | hook_bool_void_false) | |
2526 | ||
2527 | /* Returns true if the key method for a class can be an inline | |
2528 | function, so long as it is not declared inline in the class | |
2529 | itself. Returning true is the behavior required by the Itanium C++ ABI. */ | |
2530 | DEFHOOK | |
2531 | (key_method_may_be_inline, | |
2532 | "", | |
2533 | bool, (void), | |
2534 | hook_bool_void_true) | |
2535 | ||
2536 | DEFHOOK | |
2537 | (determine_class_data_visibility, | |
2538 | "@var{decl} is a virtual table, virtual table table, typeinfo object,\ | |
2539 | or other similar implicit class data object that will be emitted with\ | |
2540 | external linkage in this translation unit. No ELF visibility has been\ | |
2541 | explicitly specified. If the target needs to specify a visibility\ | |
2542 | other than that of the containing class, use this hook to set\ | |
2543 | @code{DECL_VISIBILITY} and @code{DECL_VISIBILITY_SPECIFIED}.", | |
2544 | void, (tree decl), | |
2545 | hook_void_tree) | |
2546 | ||
2547 | /* Returns true (the default) if virtual tables and other | |
2548 | similar implicit class data objects are always COMDAT if they | |
2549 | have external linkage. If this hook returns false, then | |
2550 | class data for classes whose virtual table will be emitted in | |
2551 | only one translation unit will not be COMDAT. */ | |
2552 | DEFHOOK | |
2553 | (class_data_always_comdat, | |
2554 | "", | |
2555 | bool, (void), | |
2556 | hook_bool_void_true) | |
2557 | ||
2558 | /* Returns true (the default) if the RTTI for the basic types, | |
2559 | which is always defined in the C++ runtime, should be COMDAT; | |
2560 | false if it should not be COMDAT. */ | |
2561 | DEFHOOK | |
2562 | (library_rtti_comdat, | |
2563 | "", | |
2564 | bool, (void), | |
2565 | hook_bool_void_true) | |
2566 | ||
2567 | /* Returns true if __aeabi_atexit should be used to register static | |
2568 | destructors. */ | |
2569 | DEFHOOK | |
2570 | (use_aeabi_atexit, | |
2571 | "", | |
2572 | bool, (void), | |
2573 | hook_bool_void_false) | |
2574 | ||
2575 | /* Returns true if target may use atexit in the same manner as | |
2576 | __cxa_atexit to register static destructors. */ | |
2577 | DEFHOOK | |
2578 | (use_atexit_for_cxa_atexit, | |
2579 | "", | |
2580 | bool, (void), | |
2581 | hook_bool_void_false) | |
2582 | ||
2583 | DEFHOOK | |
2584 | (adjust_class_at_definition, | |
2585 | "@var{type} is a C++ class (i.e., RECORD_TYPE or UNION_TYPE) that has just\ | |
2586 | been defined. Use this hook to make adjustments to the class (eg, tweak\ | |
2587 | visibility or perform any other required target modifications).", | |
2588 | void, (tree type), | |
2589 | hook_void_tree) | |
2590 | ||
5b880ea6 RO |
2591 | DEFHOOK |
2592 | (decl_mangling_context, | |
2593 | "Return target-specific mangling context of @var{decl} or @code{NULL_TREE}.", | |
2594 | tree, (const_tree decl), | |
2595 | hook_tree_const_tree_null) | |
2596 | ||
38f8b050 JR |
2597 | HOOK_VECTOR_END (cxx) |
2598 | ||
2599 | /* Functions and data for emulated TLS support. */ | |
2600 | #undef HOOK_PREFIX | |
2601 | #define HOOK_PREFIX "TARGET_EMUTLS_" | |
2602 | HOOK_VECTOR (TARGET_EMUTLS, emutls) | |
2603 | ||
2604 | /* Name of the address and common functions. */ | |
2605 | DEFHOOKPOD | |
2606 | (get_address, | |
2607 | "", | |
2608 | const char *, "__builtin___emutls_get_address") | |
2609 | ||
2610 | DEFHOOKPOD | |
2611 | (register_common, | |
2612 | "", | |
2613 | const char *, "__builtin___emutls_register_common") | |
2614 | ||
2615 | /* Prefixes for proxy variable and template. */ | |
2616 | DEFHOOKPOD | |
2617 | (var_section, | |
2618 | "", | |
2619 | const char *, NULL) | |
2620 | ||
2621 | DEFHOOKPOD | |
2622 | (tmpl_section, | |
2623 | "", | |
2624 | const char *, NULL) | |
2625 | ||
2626 | /* Prefixes for proxy variable and template. */ | |
2627 | DEFHOOKPOD | |
2628 | (var_prefix, | |
2629 | "", | |
2630 | const char *, NULL) | |
2631 | ||
2632 | DEFHOOKPOD | |
2633 | (tmpl_prefix, | |
2634 | "", | |
2635 | const char *, NULL) | |
2636 | ||
2637 | /* Function to generate field definitions of the proxy variable. */ | |
2638 | DEFHOOK | |
2639 | (var_fields, | |
2640 | "", | |
2641 | tree, (tree type, tree *name), | |
2642 | default_emutls_var_fields) | |
2643 | ||
2644 | /* Function to initialize a proxy variable. */ | |
2645 | DEFHOOK | |
2646 | (var_init, | |
2647 | "", | |
2648 | tree, (tree var, tree decl, tree tmpl_addr), | |
2649 | default_emutls_var_init) | |
2650 | ||
2651 | /* Whether we are allowed to alter the usual alignment of the | |
2652 | proxy variable. */ | |
2653 | DEFHOOKPOD | |
2654 | (var_align_fixed, | |
2655 | "", | |
2656 | bool, false) | |
2657 | ||
2658 | /* Whether we can emit debug information for TLS vars. */ | |
2659 | DEFHOOKPOD | |
2660 | (debug_form_tls_address, | |
2661 | "", | |
2662 | bool, false) | |
2663 | ||
2664 | HOOK_VECTOR_END (emutls) | |
2665 | ||
2666 | #undef HOOK_PREFIX | |
2667 | #define HOOK_PREFIX "TARGET_OPTION_" | |
2668 | HOOK_VECTOR (TARGET_OPTION_HOOKS, target_option_hooks) | |
2669 | ||
2670 | /* Function to validate the attribute((option(...))) strings or NULL. If | |
2671 | the option is validated, it is assumed that DECL_FUNCTION_SPECIFIC will | |
2672 | be filled in in the function decl node. */ | |
2673 | DEFHOOK | |
2674 | (valid_attribute_p, | |
2675 | "", | |
2676 | bool, (tree fndecl, tree name, tree args, int flags), | |
2677 | default_target_option_valid_attribute_p) | |
2678 | ||
2679 | /* Function to save any extra target state in the target options structure. */ | |
2680 | DEFHOOK | |
2681 | (save, | |
2682 | "", | |
2683 | void, (struct cl_target_option *ptr), NULL) | |
2684 | ||
2685 | /* Function to restore any extra target state from the target options | |
2686 | structure. */ | |
2687 | DEFHOOK | |
2688 | (restore, | |
2689 | "", | |
2690 | void, (struct cl_target_option *ptr), NULL) | |
2691 | ||
2692 | /* Function to print any extra target state from the target options | |
2693 | structure. */ | |
2694 | DEFHOOK | |
2695 | (print, | |
2696 | "", | |
2697 | void, (FILE *file, int indent, struct cl_target_option *ptr), NULL) | |
2698 | ||
2699 | /* Function to parse arguments to be validated for #pragma option, and to | |
2700 | change the state if the options are valid. If the first argument is | |
2701 | NULL, the second argument specifies the default options to use. Return | |
2702 | true if the options are valid, and set the current state. */ | |
56cb42ea JR |
2703 | /* ??? The documentation in tm.texi is incomplete. */ |
2704 | DEFHOOK | |
38f8b050 JR |
2705 | (pragma_parse, |
2706 | "", | |
2707 | bool, (tree args, tree pop_target), | |
2708 | default_target_option_pragma_parse) | |
2709 | ||
2710 | /* Do option overrides for the target. */ | |
2711 | DEFHOOK | |
2712 | (override, | |
2713 | "", | |
2714 | void, (void), | |
c5387660 | 2715 | hook_void_void) |
38f8b050 JR |
2716 | |
2717 | /* Function to determine if one function can inline another function. */ | |
2718 | #undef HOOK_PREFIX | |
2719 | #define HOOK_PREFIX "TARGET_" | |
2720 | DEFHOOK | |
2721 | (can_inline_p, | |
2722 | "", | |
2723 | bool, (tree caller, tree callee), | |
2724 | default_target_can_inline_p) | |
2725 | ||
2726 | HOOK_VECTOR_END (target_option) | |
2727 | ||
2728 | /* For targets that need to mark extra registers as live on entry to | |
2729 | the function, they should define this target hook and set their | |
2730 | bits in the bitmap passed in. */ | |
2731 | DEFHOOK | |
2732 | (extra_live_on_entry, | |
2733 | "", | |
2734 | void, (bitmap regs), | |
2735 | hook_void_bitmap) | |
2736 | ||
ee3d2ecd JJ |
2737 | /* Fill in additional registers set up by prologue into a regset. */ |
2738 | DEFHOOK | |
2739 | (set_up_by_prologue, | |
2740 | "This hook should add additional registers that are computed by the prologue\ | |
2741 | to the hard regset for shrink-wrapping optimization purposes.", | |
2742 | void, (struct hard_reg_set_container *), | |
2743 | NULL) | |
2744 | ||
d45eae79 SL |
2745 | /* For targets that have attributes that can affect whether a |
2746 | function's return statements need checking. For instance a 'naked' | |
2747 | function attribute. */ | |
2748 | DEFHOOK | |
2749 | (warn_func_return, | |
2750 | "True if a function's return statements should be checked for matching the function's return type. This includes checking for falling off the end of a non-void function. Return false if no such check should be made.", | |
2751 | bool, (tree), | |
2752 | hook_bool_tree_true) | |
2753 | ||
f0a0390e RH |
2754 | /* Determine the type of unwind info to emit for debugging. */ |
2755 | DEFHOOK | |
2756 | (debug_unwind_info, | |
2757 | "", | |
2758 | enum unwind_info_type, (void), | |
2759 | default_debug_unwind_info) | |
2760 | ||
57c5ab1b RH |
2761 | DEFHOOKPOD |
2762 | (atomic_test_and_set_trueval, | |
2763 | "This value should be set if the result written by\ | |
2764 | @code{atomic_test_and_set} is not exactly 1, i.e. the\ | |
2765 | @code{bool} @code{true}.", | |
2766 | unsigned char, 1) | |
2767 | ||
38f8b050 JR |
2768 | /* Leave the boolean fields at the end. */ |
2769 | ||
38f8b050 JR |
2770 | /* True if we can create zeroed data by switching to a BSS section |
2771 | and then using ASM_OUTPUT_SKIP to allocate the space. */ | |
2772 | DEFHOOKPOD | |
2773 | (have_switchable_bss_sections, | |
2774 | "", | |
2775 | bool, false) | |
2776 | ||
2777 | /* True if "native" constructors and destructors are supported, | |
2778 | false if we're using collect2 for the job. */ | |
2779 | DEFHOOKPOD | |
2780 | (have_ctors_dtors, | |
2781 | "", | |
2782 | bool, false) | |
2783 | ||
2784 | /* True if thread-local storage is supported. */ | |
2785 | DEFHOOKPOD | |
2786 | (have_tls, | |
2787 | "", | |
2788 | bool, false) | |
2789 | ||
2790 | /* True if a small readonly data section is supported. */ | |
2791 | DEFHOOKPOD | |
2792 | (have_srodata_section, | |
2793 | "", | |
2794 | bool, false) | |
2795 | ||
2796 | /* True if EH frame info sections should be zero-terminated. */ | |
2797 | DEFHOOKPOD | |
2798 | (terminate_dw2_eh_frame_info, | |
2799 | "", | |
2800 | bool, true) | |
2801 | ||
2802 | /* True if #NO_APP should be emitted at the beginning of assembly output. */ | |
2803 | DEFHOOKPOD | |
2804 | (asm_file_start_app_off, | |
2805 | "", | |
2806 | bool, false) | |
2807 | ||
2808 | /* True if output_file_directive should be called for main_input_filename | |
2809 | at the beginning of assembly output. */ | |
2810 | DEFHOOKPOD | |
2811 | (asm_file_start_file_directive, | |
2812 | "", | |
2813 | bool, false) | |
2814 | ||
38f8b050 JR |
2815 | /* True if the target is allowed to reorder memory accesses unless |
2816 | synchronization is explicitly requested. */ | |
2817 | DEFHOOKPOD | |
2818 | (relaxed_ordering, | |
2819 | "", | |
2820 | bool, false) | |
2821 | ||
2822 | /* Returns true if we should generate exception tables for use with the | |
2823 | ARM EABI. The effects the encoding of function exception specifications. */ | |
2824 | DEFHOOKPOD | |
2825 | (arm_eabi_unwinder, | |
2826 | "", | |
2827 | bool, false) | |
2828 | ||
9730bc27 TT |
2829 | DEFHOOKPOD |
2830 | (want_debug_pub_sections, | |
2831 | "True if the @code{.debug_pubtypes} and @code{.debug_pubnames} sections\ | |
2832 | should be emitted. These sections are not used on most platforms, and\ | |
2833 | in particular GDB does not use them.", | |
2834 | bool, false) | |
2835 | ||
638c962f JH |
2836 | DEFHOOKPOD |
2837 | (force_at_comp_dir, | |
2838 | "True if the @code{DW_AT_comp_dir} attribute should be emitted for each \ | |
2839 | compilation unit. This attribute is required for the darwin linker \ | |
2840 | to emit debug information.", | |
2841 | bool, false) | |
2842 | ||
2ba42841 AO |
2843 | DEFHOOKPOD |
2844 | (delay_sched2, "True if sched2 is not to be run at its normal place. \ | |
2845 | This usually means it will be run as part of machine-specific reorg.", | |
2846 | bool, false) | |
2847 | ||
2848 | DEFHOOKPOD | |
2849 | (delay_vartrack, "True if vartrack is not to be run at its normal place. \ | |
2850 | This usually means it will be run as part of machine-specific reorg.", | |
2851 | bool, false) | |
2852 | ||
38f8b050 JR |
2853 | /* Leave the boolean fields at the end. */ |
2854 | ||
38f8b050 JR |
2855 | /* Close the 'struct gcc_target' definition. */ |
2856 | HOOK_VECTOR_END (C90_EMPTY_HACK) |