1 | /* Data structure definitions for a generic GCC target. |
2 | Copyright (C) 2001-2023 Free Software Foundation, Inc. |
3 | |
4 | This program is free software; you can redistribute it and/or modify it |
5 | under the terms of the GNU General Public License as published by the |
6 | Free Software Foundation; either version 3, or (at your option) any |
7 | later version. |
8 | |
9 | This program is distributed in the hope that it will be useful, |
10 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
12 | GNU General Public License for more details. |
13 | |
14 | You should have received a copy of the GNU General Public License |
15 | along with this program; see the file COPYING3. If not see |
16 | <http://www.gnu.org/licenses/>. |
17 | |
18 | In other words, you are welcome to use, share and improve this program. |
19 | You are forbidden to forbid anyone else to use, share and improve |
20 | what you give them. Help stamp out software-hoarding! */ |
21 | |
22 | |
23 | /* This file contains a data structure that describes a GCC target. |
24 | At present it is incomplete, but in future it should grow to |
25 | contain most or all target machine and target O/S specific |
26 | information. |
27 | |
28 | This structure has its initializer declared in target-def.h in the |
29 | form of large macro TARGET_INITIALIZER that expands to many smaller |
30 | macros. |
31 | |
32 | The smaller macros each initialize one component of the structure, |
33 | and each has a default. Each target should have a file that |
34 | includes target.h and target-def.h, and overrides any inappropriate |
35 | defaults by undefining the relevant macro and defining a suitable |
36 | replacement. That file should then contain the definition of |
37 | "targetm" like so: |
38 | |
39 | struct gcc_target targetm = TARGET_INITIALIZER; |
40 | |
41 | Doing things this way allows us to bring together everything that |
42 | defines a GCC target. By supplying a default that is appropriate |
43 | to most targets, we can easily add new items without needing to |
44 | edit dozens of target configuration files. It should also allow us |
45 | to gradually reduce the amount of conditional compilation that is |
46 | scattered throughout GCC. */ |
47 | |
48 | #ifndef GCC_TARGET_H |
49 | #define GCC_TARGET_H |
50 | |
51 | #include "insn-codes.h" |
52 | #include "tm.h" |
53 | #include "hard-reg-set.h" |
54 | |
55 | #if CHECKING_P |
56 | |
57 | struct cumulative_args_t { void *magic; void *p; }; |
58 | |
59 | #else /* !CHECKING_P */ |
60 | |
61 | /* When using a GCC build compiler, we could use |
62 | __attribute__((transparent_union)) to get cumulative_args_t function |
63 | arguments passed like scalars where the ABI would mandate a less |
64 | efficient way of argument passing otherwise. However, that would come |
65 | at the cost of less type-safe !CHECKING_P compilation. */ |
66 | |
67 | union cumulative_args_t { void *p; }; |
68 | |
69 | #endif /* !CHECKING_P */ |
70 | |
71 | /* Target properties of _BitInt(N) type. _BitInt(N) is to be represented |
72 | as series of limb_mode CEIL (N, GET_MODE_PRECISION (limb_mode)) limbs, |
73 | ordered from least significant to most significant if !big_endian, |
74 | otherwise from most significant to least significant. If extended is |
75 | false, the bits above or equal to N are undefined when stored in a register |
76 | or memory, otherwise they are zero or sign extended depending on if |
77 | it is unsigned _BitInt(N) or _BitInt(N) / signed _BitInt(N). */ |
78 | |
79 | struct bitint_info { |
80 | machine_mode limb_mode; |
81 | bool big_endian; |
82 | bool extended; |
83 | }; |
84 | |
85 | /* Types of memory operation understood by the "by_pieces" infrastructure. |
86 | Used by the TARGET_USE_BY_PIECES_INFRASTRUCTURE_P target hook and |
87 | internally by the functions in expr.cc. */ |
88 | |
89 | enum by_pieces_operation |
90 | { |
91 | CLEAR_BY_PIECES, |
92 | MOVE_BY_PIECES, |
93 | SET_BY_PIECES, |
94 | STORE_BY_PIECES, |
95 | COMPARE_BY_PIECES |
96 | }; |
97 | |
98 | extern unsigned HOST_WIDE_INT by_pieces_ninsns (unsigned HOST_WIDE_INT, |
99 | unsigned int, |
100 | unsigned int, |
101 | by_pieces_operation); |
102 | |
103 | /* An example implementation for ELF targets. Defined in varasm.cc */ |
104 | extern void elf_record_gcc_switches (const char *); |
105 | |
106 | /* Some places still assume that all pointer or address modes are the |
107 | standard Pmode and ptr_mode. These optimizations become invalid if |
108 | the target actually supports multiple different modes. For now, |
109 | we disable such optimizations on such targets, using this function. */ |
110 | extern bool target_default_pointer_address_modes_p (void); |
111 | |
112 | /* For hooks which use the MOVE_RATIO macro, this gives the legacy default |
113 | behavior. */ |
114 | extern unsigned int get_move_ratio (bool); |
115 | |
116 | struct stdarg_info; |
117 | struct spec_info_def; |
118 | struct hard_reg_set_container; |
119 | struct cgraph_node; |
120 | struct cgraph_simd_clone; |
121 | |
122 | /* The struct used by the secondary_reload target hook. */ |
123 | struct secondary_reload_info |
124 | { |
125 | /* icode is actually an enum insn_code, but we don't want to force every |
126 | file that includes target.h to include optabs.h . */ |
127 | int icode; |
128 | int ; /* Cost for using (a) scratch register(s) to be taken |
129 | into account by copy_cost. */ |
130 | /* The next two members are for the use of the backward |
131 | compatibility hook. */ |
132 | struct secondary_reload_info *prev_sri; |
133 | int t_icode; /* Actually an enum insn_code - see above. */ |
134 | }; |
135 | |
136 | /* This is defined in sched-int.h . */ |
137 | struct _dep; |
138 | |
139 | /* This is defined in ddg.h . */ |
140 | struct ddg; |
141 | |
142 | /* This is defined in cfgloop.h . */ |
143 | class loop; |
144 | |
145 | /* This is defined in ifcvt.h. */ |
146 | struct noce_if_info; |
147 | |
148 | /* This is defined in tree-ssa-alias.h. */ |
149 | class ao_ref; |
150 | |
151 | /* This is defined in tree-vectorizer.h. */ |
152 | class _stmt_vec_info; |
153 | |
154 | /* This is defined in calls.h. */ |
155 | class function_arg_info; |
156 | |
157 | /* This is defined in function-abi.h. */ |
158 | class predefined_function_abi; |
159 | |
160 | /* These are defined in tree-vect-stmts.cc. */ |
161 | extern tree stmt_vectype (class _stmt_vec_info *); |
162 | extern bool stmt_in_inner_loop_p (class vec_info *, class _stmt_vec_info *); |
163 | |
164 | /* Assembler instructions for creating various kinds of integer object. */ |
165 | |
166 | struct asm_int_op |
167 | { |
168 | const char *hi; |
169 | const char *psi; |
170 | const char *si; |
171 | const char *pdi; |
172 | const char *di; |
173 | const char *pti; |
174 | const char *ti; |
175 | }; |
176 | |
177 | /* Types of costs for vectorizer cost model. */ |
178 | enum vect_cost_for_stmt |
179 | { |
180 | scalar_stmt, |
181 | scalar_load, |
182 | scalar_store, |
183 | vector_stmt, |
184 | vector_load, |
185 | vector_gather_load, |
186 | unaligned_load, |
187 | unaligned_store, |
188 | vector_store, |
189 | vector_scatter_store, |
190 | vec_to_scalar, |
191 | scalar_to_vec, |
192 | cond_branch_not_taken, |
193 | cond_branch_taken, |
194 | vec_perm, |
195 | vec_promote_demote, |
196 | vec_construct |
197 | }; |
198 | |
199 | /* Separate locations for which the vectorizer cost model should |
200 | track costs. */ |
201 | enum vect_cost_model_location { |
202 | vect_prologue = 0, |
203 | vect_body = 1, |
204 | vect_epilogue = 2 |
205 | }; |
206 | |
207 | class vec_perm_indices; |
208 | |
209 | /* The type to use for lists of vector sizes. */ |
210 | typedef vec<machine_mode> vector_modes; |
211 | |
212 | /* Same, but can be used to construct local lists that are |
213 | automatically freed. */ |
214 | typedef auto_vec<machine_mode, 8> auto_vector_modes; |
215 | |
216 | /* First argument of targetm.omp.device_kind_arch_isa. */ |
217 | enum omp_device_kind_arch_isa { |
218 | omp_device_kind, |
219 | omp_device_arch, |
220 | omp_device_isa |
221 | }; |
222 | |
223 | /* Flags returned by TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_MODES: |
224 | |
225 | VECT_COMPARE_COSTS |
226 | Tells the loop vectorizer to try all the provided modes and |
227 | pick the one with the lowest cost. By default the vectorizer |
228 | will choose the first mode that works. */ |
229 | const unsigned int VECT_COMPARE_COSTS = 1U << 0; |
230 | |
231 | /* The contexts in which the use of a type T can be checked by |
232 | TARGET_VERIFY_TYPE_CONTEXT. */ |
233 | enum type_context_kind { |
234 | /* Directly measuring the size of T. */ |
235 | TCTX_SIZEOF, |
236 | |
237 | /* Directly measuring the alignment of T. */ |
238 | TCTX_ALIGNOF, |
239 | |
240 | /* Creating objects of type T with static storage duration. */ |
241 | TCTX_STATIC_STORAGE, |
242 | |
243 | /* Creating objects of type T with thread-local storage duration. */ |
244 | TCTX_THREAD_STORAGE, |
245 | |
246 | /* Creating a field of type T. */ |
247 | TCTX_FIELD, |
248 | |
249 | /* Creating an array with elements of type T. */ |
250 | TCTX_ARRAY_ELEMENT, |
251 | |
252 | /* Adding to or subtracting from a pointer to T, or computing the |
253 | difference between two pointers when one of them is a pointer to T. */ |
254 | TCTX_POINTER_ARITH, |
255 | |
256 | /* Dynamically allocating objects of type T. */ |
257 | TCTX_ALLOCATION, |
258 | |
259 | /* Dynamically deallocating objects of type T. */ |
260 | TCTX_DEALLOCATION, |
261 | |
262 | /* Throwing or catching an object of type T. */ |
263 | TCTX_EXCEPTIONS, |
264 | |
265 | /* Capturing objects of type T by value in a closure. */ |
266 | TCTX_CAPTURE_BY_COPY |
267 | }; |
268 | |
269 | enum poly_value_estimate_kind |
270 | { |
271 | POLY_VALUE_MIN, |
272 | POLY_VALUE_MAX, |
273 | POLY_VALUE_LIKELY |
274 | }; |
275 | |
276 | typedef void (*emit_support_tinfos_callback) (tree); |
277 | |
278 | extern bool verify_type_context (location_t, type_context_kind, const_tree, |
279 | bool = false); |
280 | |
281 | /* The target structure. This holds all the backend hooks. */ |
282 | #define DEFHOOKPOD(NAME, DOC, TYPE, INIT) TYPE NAME; |
283 | #define DEFHOOK(NAME, DOC, TYPE, PARAMS, INIT) TYPE (* NAME) PARAMS; |
284 | #define DEFHOOK_UNDOC DEFHOOK |
285 | #define HOOKSTRUCT(FRAGMENT) FRAGMENT |
286 | |
287 | #include "target.def" |
288 | |
289 | extern struct gcc_target targetm; |
290 | |
291 | /* Return an estimate of the runtime value of X, for use in things |
292 | like cost calculations or profiling frequencies. Note that this |
293 | function should never be used in situations where the actual |
294 | runtime value is needed for correctness, since the function only |
295 | provides a rough guess. */ |
296 | |
297 | inline HOST_WIDE_INT |
298 | estimated_poly_value (poly_int64 x, |
299 | poly_value_estimate_kind kind = POLY_VALUE_LIKELY) |
300 | { |
301 | if (NUM_POLY_INT_COEFFS == 1) |
302 | return x.coeffs[0]; |
303 | else |
304 | return targetm.estimated_poly_value (x, kind); |
305 | } |
306 | |
307 | #ifdef GCC_TM_H |
308 | |
309 | #ifndef CUMULATIVE_ARGS_MAGIC |
310 | #define CUMULATIVE_ARGS_MAGIC ((void *) &targetm.calls) |
311 | #endif |
312 | |
313 | inline CUMULATIVE_ARGS * |
314 | get_cumulative_args (cumulative_args_t arg) |
315 | { |
316 | #if CHECKING_P |
317 | gcc_assert (arg.magic == CUMULATIVE_ARGS_MAGIC); |
318 | #endif /* CHECKING_P */ |
319 | return (CUMULATIVE_ARGS *) arg.p; |
320 | } |
321 | |
322 | inline cumulative_args_t |
323 | pack_cumulative_args (CUMULATIVE_ARGS *arg) |
324 | { |
325 | cumulative_args_t ret; |
326 | |
327 | #if CHECKING_P |
328 | ret.magic = CUMULATIVE_ARGS_MAGIC; |
329 | #endif /* CHECKING_P */ |
330 | ret.p = (void *) arg; |
331 | return ret; |
332 | } |
333 | #endif /* GCC_TM_H */ |
334 | |
335 | #endif /* GCC_TARGET_H */ |
336 | |