|
0
|
1 /* Data structure definitions for a generic GCC target.
|
|
|
2 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
|
|
|
3 Free Software Foundation, Inc.
|
|
|
4
|
|
|
5 This program is free software; you can redistribute it and/or modify it
|
|
|
6 under the terms of the GNU General Public License as published by the
|
|
|
7 Free Software Foundation; either version 3, or (at your option) any
|
|
|
8 later version.
|
|
|
9
|
|
|
10 This program is distributed in the hope that it will be useful,
|
|
|
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
13 GNU General Public License for more details.
|
|
|
14
|
|
|
15 You should have received a copy of the GNU General Public License
|
|
|
16 along with this program; see the file COPYING3. If not see
|
|
|
17 <http://www.gnu.org/licenses/>.
|
|
|
18
|
|
|
19 In other words, you are welcome to use, share and improve this program.
|
|
|
20 You are forbidden to forbid anyone else to use, share and improve
|
|
|
21 what you give them. Help stamp out software-hoarding! */
|
|
|
22
|
|
|
23
|
|
|
24 /* This file contains a data structure that describes a GCC target.
|
|
|
25 At present it is incomplete, but in future it should grow to
|
|
|
26 contain most or all target machine and target O/S specific
|
|
|
27 information.
|
|
|
28
|
|
|
29 This structure has its initializer declared in target-def.h in the
|
|
|
30 form of large macro TARGET_INITIALIZER that expands to many smaller
|
|
|
31 macros.
|
|
|
32
|
|
|
33 The smaller macros each initialize one component of the structure,
|
|
|
34 and each has a default. Each target should have a file that
|
|
|
35 includes target.h and target-def.h, and overrides any inappropriate
|
|
|
36 defaults by undefining the relevant macro and defining a suitable
|
|
|
37 replacement. That file should then contain the definition of
|
|
|
38 "targetm" like so:
|
|
|
39
|
|
|
40 struct gcc_target targetm = TARGET_INITIALIZER;
|
|
|
41
|
|
|
42 Doing things this way allows us to bring together everything that
|
|
|
43 defines a GCC target. By supplying a default that is appropriate
|
|
|
44 to most targets, we can easily add new items without needing to
|
|
|
45 edit dozens of target configuration files. It should also allow us
|
|
|
46 to gradually reduce the amount of conditional compilation that is
|
|
|
47 scattered throughout GCC. */
|
|
|
48
|
|
|
49 #ifndef GCC_TARGET_H
|
|
|
50 #define GCC_TARGET_H
|
|
|
51
|
|
|
52 #include "tm.h"
|
|
|
53 #include "insn-modes.h"
|
|
|
54
|
|
|
55 /* Types used by the record_gcc_switches() target function. */
|
|
|
56 typedef enum
|
|
|
57 {
|
|
|
58 SWITCH_TYPE_PASSED, /* A switch passed on the command line. */
|
|
|
59 SWITCH_TYPE_ENABLED, /* An option that is currently enabled. */
|
|
|
60 SWITCH_TYPE_DESCRIPTIVE, /* Descriptive text, not a switch or option. */
|
|
|
61 SWITCH_TYPE_LINE_START, /* Please emit any necessary text at the start of a line. */
|
|
|
62 SWITCH_TYPE_LINE_END /* Please emit a line terminator. */
|
|
|
63 }
|
|
|
64 print_switch_type;
|
|
|
65
|
|
|
66 typedef int (* print_switch_fn_type) (print_switch_type, const char *);
|
|
|
67
|
|
|
68 /* An example implementation for ELF targets. Defined in varasm.c */
|
|
|
69 extern int elf_record_gcc_switches (print_switch_type type, const char *);
|
|
|
70
|
|
|
71 struct stdarg_info;
|
|
|
72 struct spec_info_def;
|
|
|
73
|
|
|
74 /* The struct used by the secondary_reload target hook. */
|
|
|
75 typedef struct secondary_reload_info
|
|
|
76 {
|
|
|
77 /* icode is actually an enum insn_code, but we don't want to force every
|
|
|
78 file that includes target.h to include optabs.h . */
|
|
|
79 int icode;
|
|
|
80 int extra_cost; /* Cost for using (a) scratch register(s) to be taken
|
|
|
81 into account by copy_cost. */
|
|
|
82 /* The next two members are for the use of the backward
|
|
|
83 compatibility hook. */
|
|
|
84 struct secondary_reload_info *prev_sri;
|
|
|
85 int t_icode; /* Actually an enum insn_code - see above. */
|
|
|
86 } secondary_reload_info;
|
|
|
87
|
|
|
88 /* This is defined in sched-int.h . */
|
|
|
89 struct _dep;
|
|
|
90
|
|
|
91 /* This is defined in ddg.h . */
|
|
|
92 struct ddg;
|
|
|
93
|
|
|
94 struct gcc_target
|
|
|
95 {
|
|
|
96 /* Functions that output assembler for the target. */
|
|
|
97 struct asm_out
|
|
|
98 {
|
|
|
99 /* Opening and closing parentheses for asm expression grouping. */
|
|
|
100 const char *open_paren, *close_paren;
|
|
|
101
|
|
|
102 /* Assembler instructions for creating various kinds of integer object. */
|
|
|
103 const char *byte_op;
|
|
|
104 struct asm_int_op
|
|
|
105 {
|
|
|
106 const char *hi;
|
|
|
107 const char *si;
|
|
|
108 const char *di;
|
|
|
109 const char *ti;
|
|
|
110 } aligned_op, unaligned_op;
|
|
|
111
|
|
|
112 /* Try to output the assembler code for an integer object whose
|
|
|
113 value is given by X. SIZE is the size of the object in bytes and
|
|
|
114 ALIGNED_P indicates whether it is aligned. Return true if
|
|
|
115 successful. Only handles cases for which BYTE_OP, ALIGNED_OP
|
|
|
116 and UNALIGNED_OP are NULL. */
|
|
|
117 bool (* integer) (rtx x, unsigned int size, int aligned_p);
|
|
|
118
|
|
|
119 /* Output code that will globalize a label. */
|
|
|
120 void (* globalize_label) (FILE *, const char *);
|
|
|
121
|
|
|
122 /* Output code that will globalize a declaration. */
|
|
|
123 void (* globalize_decl_name) (FILE *, tree);
|
|
|
124
|
|
|
125 /* Output code that will emit a label for unwind info, if this
|
|
|
126 target requires such labels. Second argument is the decl the
|
|
|
127 unwind info is associated with, third is a boolean: true if
|
|
|
128 this is for exception handling, fourth is a boolean: true if
|
|
|
129 this is only a placeholder for an omitted FDE. */
|
|
|
130 void (* unwind_label) (FILE *, tree, int, int);
|
|
|
131
|
|
|
132 /* Output code that will emit a label to divide up the exception
|
|
|
133 table. */
|
|
|
134 void (* except_table_label) (FILE *);
|
|
|
135
|
|
|
136 /* Emit any directives required to unwind this instruction. */
|
|
|
137 void (* unwind_emit) (FILE *, rtx);
|
|
|
138
|
|
|
139 /* Output an internal label. */
|
|
|
140 void (* internal_label) (FILE *, const char *, unsigned long);
|
|
|
141
|
|
|
142 /* Emit a ttype table reference to a typeinfo object. */
|
|
|
143 bool (* ttype) (rtx);
|
|
|
144
|
|
|
145 /* Emit an assembler directive to set visibility for the symbol
|
|
|
146 associated with the tree decl. */
|
|
|
147 void (* visibility) (tree, int);
|
|
|
148
|
|
|
149 /* Output the assembler code for entry to a function. */
|
|
|
150 void (* function_prologue) (FILE *, HOST_WIDE_INT);
|
|
|
151
|
|
|
152 /* Output the assembler code for end of prologue. */
|
|
|
153 void (* function_end_prologue) (FILE *);
|
|
|
154
|
|
|
155 /* Output the assembler code for start of epilogue. */
|
|
|
156 void (* function_begin_epilogue) (FILE *);
|
|
|
157
|
|
|
158 /* Output the assembler code for function exit. */
|
|
|
159 void (* function_epilogue) (FILE *, HOST_WIDE_INT);
|
|
|
160
|
|
|
161 /* Initialize target-specific sections. */
|
|
|
162 void (* init_sections) (void);
|
|
|
163
|
|
|
164 /* Tell assembler to change to section NAME with attributes FLAGS.
|
|
|
165 If DECL is non-NULL, it is the VAR_DECL or FUNCTION_DECL with
|
|
|
166 which this section is associated. */
|
|
|
167 void (* named_section) (const char *name, unsigned int flags, tree decl);
|
|
|
168
|
|
|
169 /* Return a mask describing how relocations should be treated when
|
|
|
170 selecting sections. Bit 1 should be set if global relocations
|
|
|
171 should be placed in a read-write section; bit 0 should be set if
|
|
|
172 local relocations should be placed in a read-write section. */
|
|
|
173 int (*reloc_rw_mask) (void);
|
|
|
174
|
|
|
175 /* Return a section for EXP. It may be a DECL or a constant. RELOC
|
|
|
176 is nonzero if runtime relocations must be applied; bit 1 will be
|
|
|
177 set if the runtime relocations require non-local name resolution.
|
|
|
178 ALIGN is the required alignment of the data. */
|
|
|
179 section *(* select_section) (tree, int, unsigned HOST_WIDE_INT);
|
|
|
180
|
|
|
181 /* Return a section for X. MODE is X's mode and ALIGN is its
|
|
|
182 alignment in bits. */
|
|
|
183 section *(* select_rtx_section) (enum machine_mode, rtx,
|
|
|
184 unsigned HOST_WIDE_INT);
|
|
|
185
|
|
|
186 /* Select a unique section name for DECL. RELOC is the same as
|
|
|
187 for SELECT_SECTION. */
|
|
|
188 void (* unique_section) (tree, int);
|
|
|
189
|
|
|
190 /* Return the readonly data section associated with function DECL. */
|
|
|
191 section *(* function_rodata_section) (tree);
|
|
|
192
|
|
|
193 /* Output a constructor for a symbol with a given priority. */
|
|
|
194 void (* constructor) (rtx, int);
|
|
|
195
|
|
|
196 /* Output a destructor for a symbol with a given priority. */
|
|
|
197 void (* destructor) (rtx, int);
|
|
|
198
|
|
|
199 /* Output the assembler code for a thunk function. THUNK_DECL is the
|
|
|
200 declaration for the thunk function itself, FUNCTION is the decl for
|
|
|
201 the target function. DELTA is an immediate constant offset to be
|
|
|
202 added to THIS. If VCALL_OFFSET is nonzero, the word at
|
|
|
203 *(*this + vcall_offset) should be added to THIS. */
|
|
|
204 void (* output_mi_thunk) (FILE *file, tree thunk_decl,
|
|
|
205 HOST_WIDE_INT delta, HOST_WIDE_INT vcall_offset,
|
|
|
206 tree function_decl);
|
|
|
207
|
|
|
208 /* Determine whether output_mi_thunk would succeed. */
|
|
|
209 /* ??? Ideally, this hook would not exist, and success or failure
|
|
|
210 would be returned from output_mi_thunk directly. But there's
|
|
|
211 too much undo-able setup involved in invoking output_mi_thunk.
|
|
|
212 Could be fixed by making output_mi_thunk emit rtl instead of
|
|
|
213 text to the output file. */
|
|
|
214 bool (* can_output_mi_thunk) (const_tree thunk_decl, HOST_WIDE_INT delta,
|
|
|
215 HOST_WIDE_INT vcall_offset,
|
|
|
216 const_tree function_decl);
|
|
|
217
|
|
|
218 /* Output any boilerplate text needed at the beginning of a
|
|
|
219 translation unit. */
|
|
|
220 void (*file_start) (void);
|
|
|
221
|
|
|
222 /* Output any boilerplate text needed at the end of a
|
|
|
223 translation unit. */
|
|
|
224 void (*file_end) (void);
|
|
|
225
|
|
|
226 /* Output an assembler pseudo-op to declare a library function name
|
|
|
227 external. */
|
|
|
228 void (*external_libcall) (rtx);
|
|
|
229
|
|
|
230 /* Output an assembler directive to mark decl live. This instructs
|
|
|
231 linker to not dead code strip this symbol. */
|
|
|
232 void (*mark_decl_preserved) (const char *);
|
|
|
233
|
|
|
234 /* Output a record of the command line switches that have been passed. */
|
|
|
235 print_switch_fn_type record_gcc_switches;
|
|
|
236 /* The name of the section that the example ELF implementation of
|
|
|
237 record_gcc_switches will use to store the information. Target
|
|
|
238 specific versions of record_gcc_switches may or may not use
|
|
|
239 this information. */
|
|
|
240 const char * record_gcc_switches_section;
|
|
|
241
|
|
|
242 /* Output the definition of a section anchor. */
|
|
|
243 void (*output_anchor) (rtx);
|
|
|
244
|
|
|
245 /* Output a DTP-relative reference to a TLS symbol. */
|
|
|
246 void (*output_dwarf_dtprel) (FILE *file, int size, rtx x);
|
|
|
247
|
|
|
248 } asm_out;
|
|
|
249
|
|
|
250 /* Functions relating to instruction scheduling. */
|
|
|
251 struct sched
|
|
|
252 {
|
|
|
253 /* Given the current cost, COST, of an insn, INSN, calculate and
|
|
|
254 return a new cost based on its relationship to DEP_INSN through
|
|
|
255 the dependence LINK. The default is to make no adjustment. */
|
|
|
256 int (* adjust_cost) (rtx insn, rtx link, rtx dep_insn, int cost);
|
|
|
257
|
|
|
258 /* Adjust the priority of an insn as you see fit. Returns the new
|
|
|
259 priority. */
|
|
|
260 int (* adjust_priority) (rtx, int);
|
|
|
261
|
|
|
262 /* Function which returns the maximum number of insns that can be
|
|
|
263 scheduled in the same machine cycle. This must be constant
|
|
|
264 over an entire compilation. The default is 1. */
|
|
|
265 int (* issue_rate) (void);
|
|
|
266
|
|
|
267 /* Calculate how much this insn affects how many more insns we
|
|
|
268 can emit this cycle. Default is they all cost the same. */
|
|
|
269 int (* variable_issue) (FILE *, int, rtx, int);
|
|
|
270
|
|
|
271 /* Initialize machine-dependent scheduling code. */
|
|
|
272 void (* md_init) (FILE *, int, int);
|
|
|
273
|
|
|
274 /* Finalize machine-dependent scheduling code. */
|
|
|
275 void (* md_finish) (FILE *, int);
|
|
|
276
|
|
|
277 /* Initialize machine-dependent function wide scheduling code. */
|
|
|
278 void (* md_init_global) (FILE *, int, int);
|
|
|
279
|
|
|
280 /* Finalize machine-dependent function wide scheduling code. */
|
|
|
281 void (* md_finish_global) (FILE *, int);
|
|
|
282
|
|
|
283 /* Reorder insns in a machine-dependent fashion, in two different
|
|
|
284 places. Default does nothing. */
|
|
|
285 int (* reorder) (FILE *, int, rtx *, int *, int);
|
|
|
286 int (* reorder2) (FILE *, int, rtx *, int *, int);
|
|
|
287
|
|
|
288 /* The following member value is a pointer to a function called
|
|
|
289 after evaluation forward dependencies of insns in chain given
|
|
|
290 by two parameter values (head and tail correspondingly). */
|
|
|
291 void (* dependencies_evaluation_hook) (rtx, rtx);
|
|
|
292
|
|
|
293 /* The values of the following four members are pointers to
|
|
|
294 functions used to simplify the automaton descriptions.
|
|
|
295 dfa_pre_cycle_insn and dfa_post_cycle_insn give functions
|
|
|
296 returning insns which are used to change the pipeline hazard
|
|
|
297 recognizer state when the new simulated processor cycle
|
|
|
298 correspondingly starts and finishes. The function defined by
|
|
|
299 init_dfa_pre_cycle_insn and init_dfa_post_cycle_insn are used
|
|
|
300 to initialize the corresponding insns. The default values of
|
|
|
301 the members result in not changing the automaton state when
|
|
|
302 the new simulated processor cycle correspondingly starts and
|
|
|
303 finishes. */
|
|
|
304 void (* init_dfa_pre_cycle_insn) (void);
|
|
|
305 rtx (* dfa_pre_cycle_insn) (void);
|
|
|
306 void (* init_dfa_post_cycle_insn) (void);
|
|
|
307 rtx (* dfa_post_cycle_insn) (void);
|
|
|
308
|
|
|
309 /* The values of the following two members are pointers to
|
|
|
310 functions used to simplify the automaton descriptions.
|
|
|
311 dfa_pre_advance_cycle and dfa_post_advance_cycle are getting called
|
|
|
312 immediately before and after cycle is advanced. */
|
|
|
313 void (* dfa_pre_advance_cycle) (void);
|
|
|
314 void (* dfa_post_advance_cycle) (void);
|
|
|
315
|
|
|
316 /* The following member value is a pointer to a function returning value
|
|
|
317 which defines how many insns in queue `ready' will we try for
|
|
|
318 multi-pass scheduling. If the member value is nonzero and the
|
|
|
319 function returns positive value, the DFA based scheduler will make
|
|
|
320 multi-pass scheduling for the first cycle. In other words, we will
|
|
|
321 try to choose ready insn which permits to start maximum number of
|
|
|
322 insns on the same cycle. */
|
|
|
323 int (* first_cycle_multipass_dfa_lookahead) (void);
|
|
|
324
|
|
|
325 /* The following member value is pointer to a function controlling
|
|
|
326 what insns from the ready insn queue will be considered for the
|
|
|
327 multipass insn scheduling. If the hook returns zero for insn
|
|
|
328 passed as the parameter, the insn will be not chosen to be
|
|
|
329 issued. */
|
|
|
330 int (* first_cycle_multipass_dfa_lookahead_guard) (rtx);
|
|
|
331
|
|
|
332 /* The following member value is pointer to a function called by
|
|
|
333 the insn scheduler before issuing insn passed as the third
|
|
|
334 parameter on given cycle. If the hook returns nonzero, the
|
|
|
335 insn is not issued on given processors cycle. Instead of that,
|
|
|
336 the processor cycle is advanced. If the value passed through
|
|
|
337 the last parameter is zero, the insn ready queue is not sorted
|
|
|
338 on the new cycle start as usually. The first parameter passes
|
|
|
339 file for debugging output. The second one passes the scheduler
|
|
|
340 verbose level of the debugging output. The forth and the fifth
|
|
|
341 parameter values are correspondingly processor cycle on which
|
|
|
342 the previous insn has been issued and the current processor
|
|
|
343 cycle. */
|
|
|
344 int (* dfa_new_cycle) (FILE *, int, rtx, int, int, int *);
|
|
|
345
|
|
|
346 /* The following member value is a pointer to a function called by the
|
|
|
347 insn scheduler. It should return true if there exists a dependence
|
|
|
348 which is considered costly by the target, between the insn
|
|
|
349 DEP_PRO (&_DEP), and the insn DEP_CON (&_DEP). The first parameter is
|
|
|
350 the dep that represents the dependence between the two insns. The
|
|
|
351 second argument is the cost of the dependence as estimated by
|
|
|
352 the scheduler. The last argument is the distance in cycles
|
|
|
353 between the already scheduled insn (first parameter) and the
|
|
|
354 second insn (second parameter). */
|
|
|
355 bool (* is_costly_dependence) (struct _dep *_dep, int, int);
|
|
|
356
|
|
|
357 /* Given the current cost, COST, of an insn, INSN, calculate and
|
|
|
358 return a new cost based on its relationship to DEP_INSN through the
|
|
|
359 dependence of type DEP_TYPE. The default is to make no adjustment. */
|
|
|
360 int (* adjust_cost_2) (rtx insn, int, rtx dep_insn, int cost, int dw);
|
|
|
361
|
|
|
362 /* The following member value is a pointer to a function called
|
|
|
363 by the insn scheduler. This hook is called to notify the backend
|
|
|
364 that new instructions were emitted. */
|
|
|
365 void (* h_i_d_extended) (void);
|
|
|
366
|
|
|
367 /* Next 5 functions are for multi-point scheduling. */
|
|
|
368
|
|
|
369 /* Allocate memory for scheduler context. */
|
|
|
370 void *(* alloc_sched_context) (void);
|
|
|
371
|
|
|
372 /* Fills the context from the local machine scheduler context. */
|
|
|
373 void (* init_sched_context) (void *, bool);
|
|
|
374
|
|
|
375 /* Sets local machine scheduler context to a saved value. */
|
|
|
376 void (* set_sched_context) (void *);
|
|
|
377
|
|
|
378 /* Clears a scheduler context so it becomes like after init. */
|
|
|
379 void (* clear_sched_context) (void *);
|
|
|
380
|
|
|
381 /* Frees the scheduler context. */
|
|
|
382 void (* free_sched_context) (void *);
|
|
|
383
|
|
|
384 /* The following member value is a pointer to a function called
|
|
|
385 by the insn scheduler.
|
|
|
386 The first parameter is an instruction, the second parameter is the type
|
|
|
387 of the requested speculation, and the third parameter is a pointer to the
|
|
|
388 speculative pattern of the corresponding type (set if return value == 1).
|
|
|
389 It should return
|
|
|
390 -1, if there is no pattern, that will satisfy the requested speculation
|
|
|
391 type,
|
|
|
392 0, if current pattern satisfies the requested speculation type,
|
|
|
393 1, if pattern of the instruction should be changed to the newly
|
|
|
394 generated one. */
|
|
|
395 int (* speculate_insn) (rtx, int, rtx *);
|
|
|
396
|
|
|
397 /* The following member value is a pointer to a function called
|
|
|
398 by the insn scheduler. It should return true if the check instruction
|
|
|
399 passed as the parameter needs a recovery block. */
|
|
|
400 bool (* needs_block_p) (int);
|
|
|
401
|
|
|
402 /* The following member value is a pointer to a function called
|
|
|
403 by the insn scheduler. It should return a pattern for the check
|
|
|
404 instruction.
|
|
|
405 The first parameter is a speculative instruction, the second parameter
|
|
|
406 is the label of the corresponding recovery block (or null, if it is a
|
|
|
407 simple check). If the mutation of the check is requested (e.g. from
|
|
|
408 ld.c to chk.a), the third parameter is true - in this case the first
|
|
|
409 parameter is the previous check. */
|
|
|
410 rtx (* gen_spec_check) (rtx, rtx, int);
|
|
|
411
|
|
|
412 /* The following member value is a pointer to a function controlling
|
|
|
413 what insns from the ready insn queue will be considered for the
|
|
|
414 multipass insn scheduling. If the hook returns zero for the insn
|
|
|
415 passed as the parameter, the insn will not be chosen to be
|
|
|
416 issued. This hook is used to discard speculative instructions,
|
|
|
417 that stand at the first position of the ready list. */
|
|
|
418 bool (* first_cycle_multipass_dfa_lookahead_guard_spec) (const_rtx);
|
|
|
419
|
|
|
420 /* The following member value is a pointer to a function that provides
|
|
|
421 information about the speculation capabilities of the target.
|
|
|
422 The parameter is a pointer to spec_info variable. */
|
|
|
423 void (* set_sched_flags) (struct spec_info_def *);
|
|
|
424
|
|
|
425 /* Return speculation types of the instruction passed as the parameter. */
|
|
|
426 int (* get_insn_spec_ds) (rtx);
|
|
|
427
|
|
|
428 /* Return speculation types that are checked for the instruction passed as
|
|
|
429 the parameter. */
|
|
|
430 int (* get_insn_checked_ds) (rtx);
|
|
|
431
|
|
|
432 /* Return bool if rtx scanning should just skip current layer and
|
|
|
433 advance to the inner rtxes. */
|
|
|
434 bool (* skip_rtx_p) (const_rtx);
|
|
|
435
|
|
|
436 /* The following member value is a pointer to a function that provides
|
|
|
437 information about the target resource-based lower bound which is
|
|
|
438 used by the swing modulo scheduler. The parameter is a pointer
|
|
|
439 to ddg variable. */
|
|
|
440 int (* sms_res_mii) (struct ddg *);
|
|
|
441 } sched;
|
|
|
442
|
|
|
443 /* Functions relating to vectorization. */
|
|
|
444 struct vectorize
|
|
|
445 {
|
|
|
446 /* The following member value is a pointer to a function called
|
|
|
447 by the vectorizer, and return the decl of the target builtin
|
|
|
448 function. */
|
|
|
449 tree (* builtin_mask_for_load) (void);
|
|
|
450
|
|
|
451 /* Returns a code for builtin that realizes vectorized version of
|
|
|
452 function, or NULL_TREE if not available. */
|
|
|
453 tree (* builtin_vectorized_function) (unsigned, tree, tree);
|
|
|
454
|
|
|
455 /* Returns a code for builtin that realizes vectorized version of
|
|
|
456 conversion, or NULL_TREE if not available. */
|
|
|
457 tree (* builtin_conversion) (unsigned, tree);
|
|
|
458
|
|
|
459 /* Target builtin that implements vector widening multiplication.
|
|
|
460 builtin_mul_widen_eve computes the element-by-element products
|
|
|
461 for the even elements, and builtin_mul_widen_odd computes the
|
|
|
462 element-by-element products for the odd elements. */
|
|
|
463 tree (* builtin_mul_widen_even) (tree);
|
|
|
464 tree (* builtin_mul_widen_odd) (tree);
|
|
|
465
|
|
|
466 /* Returns the cost to be added to the overheads involved with
|
|
|
467 executing the vectorized version of a loop. */
|
|
|
468 int (*builtin_vectorization_cost) (bool);
|
|
|
469
|
|
|
470 /* Return true if vector alignment is reachable (by peeling N
|
|
|
471 iterations) for the given type. */
|
|
|
472 bool (* vector_alignment_reachable) (const_tree, bool);
|
|
|
473
|
|
|
474 /* Target builtin that implements vector permute. */
|
|
|
475 tree (* builtin_vec_perm) (tree, tree*);
|
|
|
476 } vectorize;
|
|
|
477
|
|
|
478 /* The initial value of target_flags. */
|
|
|
479 int default_target_flags;
|
|
|
480
|
|
|
481 /* Handle target switch CODE (an OPT_* value). ARG is the argument
|
|
|
482 passed to the switch; it is NULL if no argument was. VALUE is the
|
|
|
483 value of ARG if CODE specifies a UInteger option, otherwise it is
|
|
|
484 1 if the positive form of the switch was used and 0 if the negative
|
|
|
485 form was. Return true if the switch was valid. */
|
|
|
486 bool (* handle_option) (size_t code, const char *arg, int value);
|
|
|
487
|
|
|
488 /* Display extra, target specific information in response to a
|
|
|
489 --target-help switch. */
|
|
|
490 void (* target_help) (void);
|
|
|
491
|
|
|
492 /* Return machine mode for filter value. */
|
|
|
493 enum machine_mode (* eh_return_filter_mode) (void);
|
|
|
494
|
|
|
495 /* Return machine mode for libgcc expanded cmp instructions. */
|
|
|
496 enum machine_mode (* libgcc_cmp_return_mode) (void);
|
|
|
497
|
|
|
498 /* Return machine mode for libgcc expanded shift instructions. */
|
|
|
499 enum machine_mode (* libgcc_shift_count_mode) (void);
|
|
|
500
|
|
|
501 /* Return machine mode to be used for _Unwind_Word type. */
|
|
|
502 enum machine_mode (* unwind_word_mode) (void);
|
|
|
503
|
|
|
504 /* Given two decls, merge their attributes and return the result. */
|
|
|
505 tree (* merge_decl_attributes) (tree, tree);
|
|
|
506
|
|
|
507 /* Given two types, merge their attributes and return the result. */
|
|
|
508 tree (* merge_type_attributes) (tree, tree);
|
|
|
509
|
|
|
510 /* Table of machine attributes and functions to handle them.
|
|
|
511 Ignored if NULL. */
|
|
|
512 const struct attribute_spec *attribute_table;
|
|
|
513
|
|
|
514 /* Return zero if the attributes on TYPE1 and TYPE2 are incompatible,
|
|
|
515 one if they are compatible and two if they are nearly compatible
|
|
|
516 (which causes a warning to be generated). */
|
|
|
517 int (* comp_type_attributes) (const_tree type1, const_tree type2);
|
|
|
518
|
|
|
519 /* Assign default attributes to the newly defined TYPE. */
|
|
|
520 void (* set_default_type_attributes) (tree type);
|
|
|
521
|
|
|
522 /* Insert attributes on the newly created DECL. */
|
|
|
523 void (* insert_attributes) (tree decl, tree *attributes);
|
|
|
524
|
|
|
525 /* Return true if FNDECL (which has at least one machine attribute)
|
|
|
526 can be inlined despite its machine attributes, false otherwise. */
|
|
|
527 bool (* function_attribute_inlinable_p) (const_tree fndecl);
|
|
|
528
|
|
|
529 /* Return true if bitfields in RECORD_TYPE should follow the
|
|
|
530 Microsoft Visual C++ bitfield layout rules. */
|
|
|
531 bool (* ms_bitfield_layout_p) (const_tree record_type);
|
|
|
532
|
|
|
533 /* True if the target supports decimal floating point. */
|
|
|
534 bool (* decimal_float_supported_p) (void);
|
|
|
535
|
|
|
536 /* True if the target supports fixed-point. */
|
|
|
537 bool (* fixed_point_supported_p) (void);
|
|
|
538
|
|
|
539 /* Return true if anonymous bitfields affect structure alignment. */
|
|
|
540 bool (* align_anon_bitfield) (void);
|
|
|
541
|
|
|
542 /* Return true if volatile bitfields should use the narrowest type possible.
|
|
|
543 Return false if they should use the container type. */
|
|
|
544 bool (* narrow_volatile_bitfield) (void);
|
|
|
545
|
|
|
546 /* Set up target-specific built-in functions. */
|
|
|
547 void (* init_builtins) (void);
|
|
|
548
|
|
|
549 /* Expand a target-specific builtin. */
|
|
|
550 rtx (* expand_builtin) (tree exp, rtx target, rtx subtarget,
|
|
|
551 enum machine_mode mode, int ignore);
|
|
|
552
|
|
|
553 /* Select a replacement for a target-specific builtin. This is done
|
|
|
554 *before* regular type checking, and so allows the target to implement
|
|
|
555 a crude form of function overloading. The result is a complete
|
|
|
556 expression that implements the operation. */
|
|
|
557 tree (*resolve_overloaded_builtin) (tree decl, tree params);
|
|
|
558
|
|
|
559 /* Fold a target-specific builtin. */
|
|
|
560 tree (* fold_builtin) (tree fndecl, tree arglist, bool ignore);
|
|
|
561
|
|
|
562 /* Returns a code for a target-specific builtin that implements
|
|
|
563 reciprocal of the function, or NULL_TREE if not available. */
|
|
|
564 tree (* builtin_reciprocal) (unsigned, bool, bool);
|
|
|
565
|
|
|
566 /* For a vendor-specific TYPE, return a pointer to a statically-allocated
|
|
|
567 string containing the C++ mangling for TYPE. In all other cases, return
|
|
|
568 NULL. */
|
|
|
569 const char * (* mangle_type) (const_tree type);
|
|
|
570
|
|
|
571 /* Make any adjustments to libfunc names needed for this target. */
|
|
|
572 void (* init_libfuncs) (void);
|
|
|
573
|
|
|
574 /* Given a decl, a section name, and whether the decl initializer
|
|
|
575 has relocs, choose attributes for the section. */
|
|
|
576 /* ??? Should be merged with SELECT_SECTION and UNIQUE_SECTION. */
|
|
|
577 unsigned int (* section_type_flags) (tree, const char *, int);
|
|
|
578
|
|
|
579 /* True if new jumps cannot be created, to replace existing ones or
|
|
|
580 not, at the current point in the compilation. */
|
|
|
581 bool (* cannot_modify_jumps_p) (void);
|
|
|
582
|
|
|
583 /* Return a register class for which branch target register
|
|
|
584 optimizations should be applied. */
|
|
|
585 int (* branch_target_register_class) (void);
|
|
|
586
|
|
|
587 /* Return true if branch target register optimizations should include
|
|
|
588 callee-saved registers that are not already live during the current
|
|
|
589 function. AFTER_PE_GEN is true if prologues and epilogues have
|
|
|
590 already been generated. */
|
|
|
591 bool (* branch_target_register_callee_saved) (bool after_pe_gen);
|
|
|
592
|
|
|
593 /* True if the constant X cannot be placed in the constant pool. */
|
|
|
594 bool (* cannot_force_const_mem) (rtx);
|
|
|
595
|
|
|
596 /* True if the insn X cannot be duplicated. */
|
|
|
597 bool (* cannot_copy_insn_p) (rtx);
|
|
|
598
|
|
|
599 /* True if X is considered to be commutative. */
|
|
|
600 bool (* commutative_p) (const_rtx, int);
|
|
|
601
|
|
|
602 /* Given an address RTX, undo the effects of LEGITIMIZE_ADDRESS. */
|
|
|
603 rtx (* delegitimize_address) (rtx);
|
|
|
604
|
|
|
605 /* True if the given constant can be put into an object_block. */
|
|
|
606 bool (* use_blocks_for_constant_p) (enum machine_mode, const_rtx);
|
|
|
607
|
|
|
608 /* The minimum and maximum byte offsets for anchored addresses. */
|
|
|
609 HOST_WIDE_INT min_anchor_offset;
|
|
|
610 HOST_WIDE_INT max_anchor_offset;
|
|
|
611
|
|
|
612 /* True if section anchors can be used to access the given symbol. */
|
|
|
613 bool (* use_anchors_for_symbol_p) (const_rtx);
|
|
|
614
|
|
|
615 /* True if it is OK to do sibling call optimization for the specified
|
|
|
616 call expression EXP. DECL will be the called function, or NULL if
|
|
|
617 this is an indirect call. */
|
|
|
618 bool (*function_ok_for_sibcall) (tree decl, tree exp);
|
|
|
619
|
|
|
620 /* Establish appropriate back-end context for processing the function
|
|
|
621 FNDECL. The argument might be NULL to indicate processing at top
|
|
|
622 level, outside of any function scope. */
|
|
|
623 void (*set_current_function) (tree fndecl);
|
|
|
624
|
|
|
625 /* True if EXP should be placed in a "small data" section. */
|
|
|
626 bool (* in_small_data_p) (const_tree);
|
|
|
627
|
|
|
628 /* True if EXP names an object for which name resolution must resolve
|
|
|
629 to the current executable or shared library. */
|
|
|
630 bool (* binds_local_p) (const_tree);
|
|
|
631
|
|
|
632 /* Modify and return the identifier of a DECL's external name,
|
|
|
633 originally identified by ID, as required by the target,
|
|
|
634 (eg, append @nn to windows32 stdcall function names).
|
|
|
635 The default is to return ID without modification. */
|
|
|
636 tree (* mangle_decl_assembler_name) (tree decl, tree id);
|
|
|
637
|
|
|
638 /* Do something target-specific to record properties of the DECL into
|
|
|
639 the associated SYMBOL_REF. */
|
|
|
640 void (* encode_section_info) (tree, rtx, int);
|
|
|
641
|
|
|
642 /* Undo the effects of encode_section_info on the symbol string. */
|
|
|
643 const char * (* strip_name_encoding) (const char *);
|
|
|
644
|
|
|
645 /* If shift optabs for MODE are known to always truncate the shift count,
|
|
|
646 return the mask that they apply. Return 0 otherwise. */
|
|
|
647 unsigned HOST_WIDE_INT (* shift_truncation_mask) (enum machine_mode mode);
|
|
|
648
|
|
|
649 /* Return the number of divisions in the given MODE that should be present,
|
|
|
650 so that it is profitable to turn the division into a multiplication by
|
|
|
651 the reciprocal. */
|
|
|
652 unsigned int (* min_divisions_for_recip_mul) (enum machine_mode mode);
|
|
|
653
|
|
|
654 /* If the representation of integral MODE is such that values are
|
|
|
655 always sign-extended to a wider mode MODE_REP then return
|
|
|
656 SIGN_EXTEND. Return UNKNOWN otherwise. */
|
|
|
657 /* Note that the return type ought to be RTX_CODE, but that's not
|
|
|
658 necessarily defined at this point. */
|
|
|
659 int (* mode_rep_extended) (enum machine_mode mode,
|
|
|
660 enum machine_mode mode_rep);
|
|
|
661
|
|
|
662 /* True if MODE is valid for a pointer in __attribute__((mode("MODE"))). */
|
|
|
663 bool (* valid_pointer_mode) (enum machine_mode mode);
|
|
|
664
|
|
|
665 /* True if MODE is valid for the target. By "valid", we mean able to
|
|
|
666 be manipulated in non-trivial ways. In particular, this means all
|
|
|
667 the arithmetic is supported. */
|
|
|
668 bool (* scalar_mode_supported_p) (enum machine_mode mode);
|
|
|
669
|
|
|
670 /* Similarly for vector modes. "Supported" here is less strict. At
|
|
|
671 least some operations are supported; need to check optabs or builtins
|
|
|
672 for further details. */
|
|
|
673 bool (* vector_mode_supported_p) (enum machine_mode mode);
|
|
|
674
|
|
|
675 /* True if a vector is opaque. */
|
|
|
676 bool (* vector_opaque_p) (const_tree);
|
|
|
677
|
|
|
678 /* Compute a (partial) cost for rtx X. Return true if the complete
|
|
|
679 cost has been computed, and false if subexpressions should be
|
|
|
680 scanned. In either case, *TOTAL contains the cost result. */
|
|
|
681 /* Note that CODE and OUTER_CODE ought to be RTX_CODE, but that's
|
|
|
682 not necessarily defined at this point. */
|
|
|
683 bool (* rtx_costs) (rtx x, int code, int outer_code, int *total, bool speed);
|
|
|
684
|
|
|
685 /* Compute the cost of X, used as an address. Never called with
|
|
|
686 invalid addresses. */
|
|
|
687 int (* address_cost) (rtx x, bool speed);
|
|
|
688
|
|
|
689 /* Return where to allocate pseudo for a given hard register initial
|
|
|
690 value. */
|
|
|
691 rtx (* allocate_initial_value) (rtx x);
|
|
|
692
|
|
|
693 /* Return nonzero if evaluating UNSPEC[_VOLATILE] X might cause a trap.
|
|
|
694 FLAGS has the same meaning as in rtlanal.c: may_trap_p_1. */
|
|
|
695 int (* unspec_may_trap_p) (const_rtx x, unsigned flags);
|
|
|
696
|
|
|
697 /* Given a register, this hook should return a parallel of registers
|
|
|
698 to represent where to find the register pieces. Define this hook
|
|
|
699 if the register and its mode are represented in Dwarf in
|
|
|
700 non-contiguous locations, or if the register should be
|
|
|
701 represented in more than one register in Dwarf. Otherwise, this
|
|
|
702 hook should return NULL_RTX. */
|
|
|
703 rtx (* dwarf_register_span) (rtx);
|
|
|
704
|
|
|
705 /* If expand_builtin_init_dwarf_reg_sizes needs to fill in table
|
|
|
706 entries not corresponding directly to registers below
|
|
|
707 FIRST_PSEUDO_REGISTER, this hook should generate the necessary
|
|
|
708 code, given the address of the table. */
|
|
|
709 void (* init_dwarf_reg_sizes_extra) (tree);
|
|
|
710
|
|
|
711 /* Fetch the fixed register(s) which hold condition codes, for
|
|
|
712 targets where it makes sense to look for duplicate assignments to
|
|
|
713 the condition codes. This should return true if there is such a
|
|
|
714 register, false otherwise. The arguments should be set to the
|
|
|
715 fixed register numbers. Up to two condition code registers are
|
|
|
716 supported. If there is only one for this target, the int pointed
|
|
|
717 at by the second argument should be set to -1. */
|
|
|
718 bool (* fixed_condition_code_regs) (unsigned int *, unsigned int *);
|
|
|
719
|
|
|
720 /* If two condition code modes are compatible, return a condition
|
|
|
721 code mode which is compatible with both, such that a comparison
|
|
|
722 done in the returned mode will work for both of the original
|
|
|
723 modes. If the condition code modes are not compatible, return
|
|
|
724 VOIDmode. */
|
|
|
725 enum machine_mode (* cc_modes_compatible) (enum machine_mode,
|
|
|
726 enum machine_mode);
|
|
|
727
|
|
|
728 /* Do machine-dependent code transformations. Called just before
|
|
|
729 delayed-branch scheduling. */
|
|
|
730 void (* machine_dependent_reorg) (void);
|
|
|
731
|
|
|
732 /* Create the __builtin_va_list type. */
|
|
|
733 tree (* build_builtin_va_list) (void);
|
|
|
734
|
|
|
735 /* Get the cfun/fndecl calling abi __builtin_va_list type. */
|
|
|
736 tree (* fn_abi_va_list) (tree);
|
|
|
737
|
|
|
738 /* Get the __builtin_va_list type dependent on input type. */
|
|
|
739 tree (* canonical_va_list_type) (tree);
|
|
|
740
|
|
|
741 /* Expand the __builtin_va_start builtin. */
|
|
|
742 void (* expand_builtin_va_start) (tree valist, rtx nextarg);
|
|
|
743
|
|
|
744 /* Gimplifies a VA_ARG_EXPR. */
|
|
|
745 tree (* gimplify_va_arg_expr) (tree valist, tree type, gimple_seq *pre_p,
|
|
|
746 gimple_seq *post_p);
|
|
|
747
|
|
|
748 /* Validity-checking routines for PCH files, target-specific.
|
|
|
749 get_pch_validity returns a pointer to the data to be stored,
|
|
|
750 and stores the size in its argument. pch_valid_p gets the same
|
|
|
751 information back and returns NULL if the PCH is valid,
|
|
|
752 or an error message if not.
|
|
|
753 */
|
|
|
754 void * (* get_pch_validity) (size_t *);
|
|
|
755 const char * (* pch_valid_p) (const void *, size_t);
|
|
|
756
|
|
|
757 /* If nonnull, this function checks whether a PCH file with the
|
|
|
758 given set of target flags can be used. It returns NULL if so,
|
|
|
759 otherwise it returns an error message. */
|
|
|
760 const char *(*check_pch_target_flags) (int);
|
|
|
761
|
|
|
762 /* True if the compiler should give an enum type only as many
|
|
|
763 bytes as it takes to represent the range of possible values of
|
|
|
764 that type. */
|
|
|
765 bool (* default_short_enums) (void);
|
|
|
766
|
|
|
767 /* This target hook returns an rtx that is used to store the address
|
|
|
768 of the current frame into the built-in setjmp buffer. */
|
|
|
769 rtx (* builtin_setjmp_frame_value) (void);
|
|
|
770
|
|
|
771 /* This target hook should add STRING_CST trees for any hard regs
|
|
|
772 the port wishes to automatically clobber for an asm. */
|
|
|
773 tree (* md_asm_clobbers) (tree, tree, tree);
|
|
|
774
|
|
|
775 /* This target hook allows the backend to specify a calling convention
|
|
|
776 in the debug information. This function actually returns an
|
|
|
777 enum dwarf_calling_convention, but because of forward declarations
|
|
|
778 and not wanting to include dwarf2.h everywhere target.h is included
|
|
|
779 the function is being declared as an int. */
|
|
|
780 int (* dwarf_calling_convention) (const_tree);
|
|
|
781
|
|
|
782 /* This target hook allows the backend to emit frame-related insns that
|
|
|
783 contain UNSPECs or UNSPEC_VOLATILEs. The call frame debugging info
|
|
|
784 engine will invoke it on insns of the form
|
|
|
785 (set (reg) (unspec [...] UNSPEC_INDEX))
|
|
|
786 and
|
|
|
787 (set (reg) (unspec_volatile [...] UNSPECV_INDEX))
|
|
|
788 to let the backend emit the call frame instructions. */
|
|
|
789 void (* dwarf_handle_frame_unspec) (const char *, rtx, int);
|
|
|
790
|
|
|
791 /* Perform architecture specific checking of statements gimplified
|
|
|
792 from VA_ARG_EXPR. STMT is the statement. Returns true if the statement
|
|
|
793 doesn't need to be checked for va_list references. */
|
|
|
794 bool (* stdarg_optimize_hook) (struct stdarg_info *ai, const_gimple stmt);
|
|
|
795
|
|
|
796 /* This target hook allows the operating system to override the DECL
|
|
|
797 that represents the external variable that contains the stack
|
|
|
798 protection guard variable. The type of this DECL is ptr_type_node. */
|
|
|
799 tree (* stack_protect_guard) (void);
|
|
|
800
|
|
|
801 /* This target hook allows the operating system to override the CALL_EXPR
|
|
|
802 that is invoked when a check vs the guard variable fails. */
|
|
|
803 tree (* stack_protect_fail) (void);
|
|
|
804
|
|
|
805 /* Returns NULL if target supports the insn within a doloop block,
|
|
|
806 otherwise it returns an error message. */
|
|
|
807 const char * (*invalid_within_doloop) (const_rtx);
|
|
|
808
|
|
|
809 /* DECL is a variable or function with __attribute__((dllimport))
|
|
|
810 specified. Use this hook if the target needs to add extra validation
|
|
|
811 checks to handle_dll_attribute (). */
|
|
|
812 bool (* valid_dllimport_attribute_p) (const_tree decl);
|
|
|
813
|
|
|
814 /* Functions relating to calls - argument passing, returns, etc. */
|
|
|
815 struct calls {
|
|
|
816 bool (*promote_function_args) (const_tree fntype);
|
|
|
817 bool (*promote_function_return) (const_tree fntype);
|
|
|
818 bool (*promote_prototypes) (const_tree fntype);
|
|
|
819 rtx (*struct_value_rtx) (tree fndecl, int incoming);
|
|
|
820 bool (*return_in_memory) (const_tree type, const_tree fndecl);
|
|
|
821 bool (*return_in_msb) (const_tree type);
|
|
|
822
|
|
|
823 /* Return true if a parameter must be passed by reference. TYPE may
|
|
|
824 be null if this is a libcall. CA may be null if this query is
|
|
|
825 from __builtin_va_arg. */
|
|
|
826 bool (*pass_by_reference) (CUMULATIVE_ARGS *ca, enum machine_mode mode,
|
|
|
827 const_tree type, bool named_arg);
|
|
|
828
|
|
|
829 rtx (*expand_builtin_saveregs) (void);
|
|
|
830 /* Returns pretend_argument_size. */
|
|
|
831 void (*setup_incoming_varargs) (CUMULATIVE_ARGS *ca, enum machine_mode mode,
|
|
|
832 tree type, int *pretend_arg_size,
|
|
|
833 int second_time);
|
|
|
834 bool (*strict_argument_naming) (CUMULATIVE_ARGS *ca);
|
|
|
835 /* Returns true if we should use
|
|
|
836 targetm.calls.setup_incoming_varargs() and/or
|
|
|
837 targetm.calls.strict_argument_naming(). */
|
|
|
838 bool (*pretend_outgoing_varargs_named) (CUMULATIVE_ARGS *ca);
|
|
|
839
|
|
|
840 /* Given a complex type T, return true if a parameter of type T
|
|
|
841 should be passed as two scalars. */
|
|
|
842 bool (* split_complex_arg) (const_tree type);
|
|
|
843
|
|
|
844 /* Return true if type T, mode MODE, may not be passed in registers,
|
|
|
845 but must be passed on the stack. */
|
|
|
846 /* ??? This predicate should be applied strictly after pass-by-reference.
|
|
|
847 Need audit to verify that this is the case. */
|
|
|
848 bool (* must_pass_in_stack) (enum machine_mode mode, const_tree t);
|
|
|
849
|
|
|
850 /* Return true if type TYPE, mode MODE, which is passed by reference,
|
|
|
851 should have the object copy generated by the callee rather than
|
|
|
852 the caller. It is never called for TYPE requiring constructors. */
|
|
|
853 bool (* callee_copies) (CUMULATIVE_ARGS *ca, enum machine_mode mode,
|
|
|
854 const_tree type, bool named);
|
|
|
855
|
|
|
856 /* Return zero for arguments passed entirely on the stack or entirely
|
|
|
857 in registers. If passed in both, return the number of bytes passed
|
|
|
858 in registers; the balance is therefore passed on the stack. */
|
|
|
859 int (* arg_partial_bytes) (CUMULATIVE_ARGS *ca, enum machine_mode mode,
|
|
|
860 tree type, bool named);
|
|
|
861
|
|
|
862 /* Return the diagnostic message string if function without a prototype
|
|
|
863 is not allowed for this 'val' argument; NULL otherwise. */
|
|
|
864 const char *(*invalid_arg_for_unprototyped_fn) (const_tree typelist,
|
|
|
865 const_tree funcdecl,
|
|
|
866 const_tree val);
|
|
|
867
|
|
|
868 /* Return an rtx for the return value location of the function
|
|
|
869 specified by FN_DECL_OR_TYPE with a return type of RET_TYPE. */
|
|
|
870 rtx (*function_value) (const_tree ret_type, const_tree fn_decl_or_type,
|
|
|
871 bool outgoing);
|
|
|
872
|
|
|
873 /* Return an rtx for the argument pointer incoming to the
|
|
|
874 current function. */
|
|
|
875 rtx (*internal_arg_pointer) (void);
|
|
|
876
|
|
|
877 /* Update the current function stack boundary if needed. */
|
|
|
878 void (*update_stack_boundary) (void);
|
|
|
879
|
|
|
880 /* Handle stack alignment and return an rtx for Dynamic Realign
|
|
|
881 Argument Pointer if necessary. */
|
|
|
882 rtx (*get_drap_rtx) (void);
|
|
|
883
|
|
|
884 /* Return true if all function parameters should be spilled to the
|
|
|
885 stack. */
|
|
|
886 bool (*allocate_stack_slots_for_args) (void);
|
|
|
887
|
|
|
888 } calls;
|
|
|
889
|
|
|
890 /* Return the diagnostic message string if conversion from FROMTYPE
|
|
|
891 to TOTYPE is not allowed, NULL otherwise. */
|
|
|
892 const char *(*invalid_conversion) (const_tree fromtype, const_tree totype);
|
|
|
893
|
|
|
894 /* Return the diagnostic message string if the unary operation OP is
|
|
|
895 not permitted on TYPE, NULL otherwise. */
|
|
|
896 const char *(*invalid_unary_op) (int op, const_tree type);
|
|
|
897
|
|
|
898 /* Return the diagnostic message string if the binary operation OP
|
|
|
899 is not permitted on TYPE1 and TYPE2, NULL otherwise. */
|
|
|
900 const char *(*invalid_binary_op) (int op, const_tree type1, const_tree type2);
|
|
|
901
|
|
|
902 /* Return the array of IRA cover classes for the current target. */
|
|
|
903 const enum reg_class *(*ira_cover_classes) (void);
|
|
|
904
|
|
|
905 /* Return the class for a secondary reload, and fill in extra information. */
|
|
|
906 enum reg_class (*secondary_reload) (bool, rtx, enum reg_class,
|
|
|
907 enum machine_mode,
|
|
|
908 struct secondary_reload_info *);
|
|
|
909
|
|
|
910 /* This target hook allows the backend to perform additional
|
|
|
911 processing while initializing for variable expansion. */
|
|
|
912 void (* expand_to_rtl_hook) (void);
|
|
|
913
|
|
|
914 /* This target hook allows the backend to perform additional
|
|
|
915 instantiations on rtx that are not actually in insns yet,
|
|
|
916 but will be later. */
|
|
|
917 void (* instantiate_decls) (void);
|
|
|
918
|
|
|
919 /* Return true if is OK to use a hard register REGNO as scratch register
|
|
|
920 in peephole2. */
|
|
|
921 bool (* hard_regno_scratch_ok) (unsigned int regno);
|
|
|
922
|
|
|
923 /* Functions specific to the C family of frontends. */
|
|
|
924 struct c {
|
|
|
925 /* Return machine mode for non-standard suffix
|
|
|
926 or VOIDmode if non-standard suffixes are unsupported. */
|
|
|
927 enum machine_mode (*mode_for_suffix) (char);
|
|
|
928 } c;
|
|
|
929
|
|
|
930 /* Functions specific to the C++ frontend. */
|
|
|
931 struct cxx {
|
|
|
932 /* Return the integer type used for guard variables. */
|
|
|
933 tree (*guard_type) (void);
|
|
|
934 /* Return true if only the low bit of the guard should be tested. */
|
|
|
935 bool (*guard_mask_bit) (void);
|
|
|
936 /* Returns the size of the array cookie for an array of type. */
|
|
|
937 tree (*get_cookie_size) (tree);
|
|
|
938 /* Returns true if the element size should be stored in the
|
|
|
939 array cookie. */
|
|
|
940 bool (*cookie_has_size) (void);
|
|
|
941 /* Allows backends to perform additional processing when
|
|
|
942 deciding if a class should be exported or imported. */
|
|
|
943 int (*import_export_class) (tree, int);
|
|
|
944 /* Returns true if constructors and destructors return "this". */
|
|
|
945 bool (*cdtor_returns_this) (void);
|
|
|
946 /* Returns true if the key method for a class can be an inline
|
|
|
947 function, so long as it is not declared inline in the class
|
|
|
948 itself. Returning true is the behavior required by the Itanium
|
|
|
949 C++ ABI. */
|
|
|
950 bool (*key_method_may_be_inline) (void);
|
|
|
951 /* DECL is a virtual table, virtual table table, typeinfo object,
|
|
|
952 or other similar implicit class data object that will be
|
|
|
953 emitted with external linkage in this translation unit. No ELF
|
|
|
954 visibility has been explicitly specified. If the target needs
|
|
|
955 to specify a visibility other than that of the containing class,
|
|
|
956 use this hook to set DECL_VISIBILITY and
|
|
|
957 DECL_VISIBILITY_SPECIFIED. */
|
|
|
958 void (*determine_class_data_visibility) (tree decl);
|
|
|
959 /* Returns true (the default) if virtual tables and other
|
|
|
960 similar implicit class data objects are always COMDAT if they
|
|
|
961 have external linkage. If this hook returns false, then
|
|
|
962 class data for classes whose virtual table will be emitted in
|
|
|
963 only one translation unit will not be COMDAT. */
|
|
|
964 bool (*class_data_always_comdat) (void);
|
|
|
965 /* Returns true (the default) if the RTTI for the basic types,
|
|
|
966 which is always defined in the C++ runtime, should be COMDAT;
|
|
|
967 false if it should not be COMDAT. */
|
|
|
968 bool (*library_rtti_comdat) (void);
|
|
|
969 /* Returns true if __aeabi_atexit should be used to register static
|
|
|
970 destructors. */
|
|
|
971 bool (*use_aeabi_atexit) (void);
|
|
|
972 /* Returns true if target may use atexit in the same manner as
|
|
|
973 __cxa_atexit to register static destructors. */
|
|
|
974 bool (*use_atexit_for_cxa_atexit) (void);
|
|
|
975 /* TYPE is a C++ class (i.e., RECORD_TYPE or UNION_TYPE) that
|
|
|
976 has just been defined. Use this hook to make adjustments to the
|
|
|
977 class (eg, tweak visibility or perform any other required
|
|
|
978 target modifications). */
|
|
|
979 void (*adjust_class_at_definition) (tree type);
|
|
|
980 } cxx;
|
|
|
981
|
|
|
982 /* Functions and data for emulated TLS support. */
|
|
|
983 struct emutls {
|
|
|
984 /* Name of the address and common functions. */
|
|
|
985 const char *get_address;
|
|
|
986 const char *register_common;
|
|
|
987
|
|
|
988 /* Prefixes for proxy variable and template. */
|
|
|
989 const char *var_section;
|
|
|
990 const char *tmpl_section;
|
|
|
991
|
|
|
992 /* Prefixes for proxy variable and template. */
|
|
|
993 const char *var_prefix;
|
|
|
994 const char *tmpl_prefix;
|
|
|
995
|
|
|
996 /* Function to generate field definitions of the proxy variable. */
|
|
|
997 tree (*var_fields) (tree, tree *);
|
|
|
998
|
|
|
999 /* Function to initialize a proxy variable. */
|
|
|
1000 tree (*var_init) (tree, tree, tree);
|
|
|
1001
|
|
|
1002 /* Whether we are allowed to alter the usual alignment of the
|
|
|
1003 proxy variable. */
|
|
|
1004 bool var_align_fixed;
|
|
|
1005
|
|
|
1006 /* Whether we can emit debug information for TLS vars. */
|
|
|
1007 bool debug_form_tls_address;
|
|
|
1008 } emutls;
|
|
|
1009
|
|
|
1010 struct target_option_hooks {
|
|
|
1011 /* Function to validate the attribute((option(...))) strings or NULL. If
|
|
|
1012 the option is validated, it is assumed that DECL_FUNCTION_SPECIFIC will
|
|
|
1013 be filled in in the function decl node. */
|
|
|
1014 bool (*valid_attribute_p) (tree, tree, tree, int);
|
|
|
1015
|
|
|
1016 /* Function to save any extra target state in the target options
|
|
|
1017 structure. */
|
|
|
1018 void (*save) (struct cl_target_option *);
|
|
|
1019
|
|
|
1020 /* Function to restore any extra target state from the target options
|
|
|
1021 structure. */
|
|
|
1022 void (*restore) (struct cl_target_option *);
|
|
|
1023
|
|
|
1024 /* Function to print any extra target state from the target options
|
|
|
1025 structure. */
|
|
|
1026 void (*print) (FILE *, int, struct cl_target_option *);
|
|
|
1027
|
|
|
1028 /* Function to parse arguments to be validated for #pragma option, and to
|
|
|
1029 change the state if the options are valid. If the first argument is
|
|
|
1030 NULL, the second argument specifies the default options to use. Return
|
|
|
1031 true if the options are valid, and set the current state. */
|
|
|
1032 bool (*pragma_parse) (tree, tree);
|
|
|
1033
|
|
|
1034 /* Function to determine if one function can inline another function. */
|
|
|
1035 bool (*can_inline_p) (tree, tree);
|
|
|
1036 } target_option;
|
|
|
1037
|
|
|
1038 /* For targets that need to mark extra registers as live on entry to
|
|
|
1039 the function, they should define this target hook and set their
|
|
|
1040 bits in the bitmap passed in. */
|
|
|
1041 void (*live_on_entry) (bitmap);
|
|
|
1042
|
|
|
1043 /* True if unwinding tables should be generated by default. */
|
|
|
1044 bool unwind_tables_default;
|
|
|
1045
|
|
|
1046 /* Leave the boolean fields at the end. */
|
|
|
1047
|
|
|
1048 /* True if arbitrary sections are supported. */
|
|
|
1049 bool have_named_sections;
|
|
|
1050
|
|
|
1051 /* True if we can create zeroed data by switching to a BSS section
|
|
|
1052 and then using ASM_OUTPUT_SKIP to allocate the space. */
|
|
|
1053 bool have_switchable_bss_sections;
|
|
|
1054
|
|
|
1055 /* True if "native" constructors and destructors are supported,
|
|
|
1056 false if we're using collect2 for the job. */
|
|
|
1057 bool have_ctors_dtors;
|
|
|
1058
|
|
|
1059 /* True if thread-local storage is supported. */
|
|
|
1060 bool have_tls;
|
|
|
1061
|
|
|
1062 /* True if a small readonly data section is supported. */
|
|
|
1063 bool have_srodata_section;
|
|
|
1064
|
|
|
1065 /* True if EH frame info sections should be zero-terminated. */
|
|
|
1066 bool terminate_dw2_eh_frame_info;
|
|
|
1067
|
|
|
1068 /* True if #NO_APP should be emitted at the beginning of
|
|
|
1069 assembly output. */
|
|
|
1070 bool file_start_app_off;
|
|
|
1071
|
|
|
1072 /* True if output_file_directive should be called for main_input_filename
|
|
|
1073 at the beginning of assembly output. */
|
|
|
1074 bool file_start_file_directive;
|
|
|
1075
|
|
|
1076 /* True if #pragma redefine_extname is to be supported. */
|
|
|
1077 bool handle_pragma_redefine_extname;
|
|
|
1078
|
|
|
1079 /* True if #pragma extern_prefix is to be supported. */
|
|
|
1080 bool handle_pragma_extern_prefix;
|
|
|
1081
|
|
|
1082 /* True if the target is allowed to reorder memory accesses unless
|
|
|
1083 synchronization is explicitly requested. */
|
|
|
1084 bool relaxed_ordering;
|
|
|
1085
|
|
|
1086 /* Returns true if we should generate exception tables for use with the
|
|
|
1087 ARM EABI. The effects the encoding of function exception specifications.
|
|
|
1088 */
|
|
|
1089 bool arm_eabi_unwinder;
|
|
|
1090
|
|
|
1091 /* Leave the boolean fields at the end. */
|
|
|
1092 };
|
|
|
1093
|
|
|
1094 extern struct gcc_target targetm;
|
|
|
1095
|
|
|
1096 struct gcc_targetcm {
|
|
|
1097 /* Handle target switch CODE (an OPT_* value). ARG is the argument
|
|
|
1098 passed to the switch; it is NULL if no argument was. VALUE is the
|
|
|
1099 value of ARG if CODE specifies a UInteger option, otherwise it is
|
|
|
1100 1 if the positive form of the switch was used and 0 if the negative
|
|
|
1101 form was. Return true if the switch was valid. */
|
|
|
1102 bool (*handle_c_option) (size_t code, const char *arg, int value);
|
|
|
1103 };
|
|
|
1104
|
|
|
1105 /* Each target can provide their own. */
|
|
|
1106 extern struct gcc_targetcm targetcm;
|
|
|
1107
|
|
|
1108 #endif /* GCC_TARGET_H */
|
