Branch data Line data Source code
1 : : /* Data structure definitions for a generic GCC target.
2 : : Copyright (C) 2001-2025 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 abi_limb_mode CEIL (N, GET_MODE_PRECISION (abi_limb_mode))
73 : : limbs, 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 : : limb_mode is either the same as abi_limb_mode, or some narrower mode
79 : : in which _BitInt lowering should actually perform operations in and
80 : : what libgcc _BitInt helpers should use.
81 : : E.g. abi_limb_mode could be TImode which is something some processor
82 : : specific ABI would specify to use, but it would be desirable to handle
83 : : it as an array of DImode instead for efficiency.
84 : : Note, abi_limb_mode can be different from limb_mode only if big_endian
85 : : matches WORDS_BIG_ENDIAN. */
86 : :
87 : : struct bitint_info {
88 : : machine_mode abi_limb_mode, limb_mode;
89 : : bool big_endian;
90 : : bool extended;
91 : : };
92 : :
93 : : /* Types of memory operation understood by the "by_pieces" infrastructure.
94 : : Used by the TARGET_USE_BY_PIECES_INFRASTRUCTURE_P target hook and
95 : : internally by the functions in expr.cc. */
96 : :
97 : : enum by_pieces_operation
98 : : {
99 : : CLEAR_BY_PIECES,
100 : : MOVE_BY_PIECES,
101 : : SET_BY_PIECES,
102 : : STORE_BY_PIECES,
103 : : COMPARE_BY_PIECES
104 : : };
105 : :
106 : : extern unsigned HOST_WIDE_INT by_pieces_ninsns (unsigned HOST_WIDE_INT,
107 : : unsigned int,
108 : : unsigned int,
109 : : by_pieces_operation);
110 : :
111 : : /* An example implementation for ELF targets. Defined in varasm.cc */
112 : : extern void elf_record_gcc_switches (const char *);
113 : :
114 : : /* Some places still assume that all pointer or address modes are the
115 : : standard Pmode and ptr_mode. These optimizations become invalid if
116 : : the target actually supports multiple different modes. For now,
117 : : we disable such optimizations on such targets, using this function. */
118 : : extern bool target_default_pointer_address_modes_p (void);
119 : :
120 : : /* For hooks which use the MOVE_RATIO macro, this gives the legacy default
121 : : behavior. */
122 : : extern unsigned int get_move_ratio (bool);
123 : :
124 : : struct stdarg_info;
125 : : struct spec_info_def;
126 : : struct hard_reg_set_container;
127 : : struct cgraph_node;
128 : : struct cgraph_simd_clone;
129 : :
130 : : /* The struct used by the secondary_reload target hook. */
131 : : struct secondary_reload_info
132 : : {
133 : : /* icode is actually an enum insn_code, but we don't want to force every
134 : : file that includes target.h to include optabs.h . */
135 : : int icode;
136 : : int extra_cost; /* Cost for using (a) scratch register(s) to be taken
137 : : into account by copy_cost. */
138 : : /* The next two members are for the use of the backward
139 : : compatibility hook. */
140 : : struct secondary_reload_info *prev_sri;
141 : : int t_icode; /* Actually an enum insn_code - see above. */
142 : : };
143 : :
144 : : /* This is defined in sched-int.h . */
145 : : struct _dep;
146 : :
147 : : /* This is defined in ddg.h . */
148 : : struct ddg;
149 : :
150 : : /* This is defined in cfgloop.h . */
151 : : class loop;
152 : :
153 : : /* This is defined in ifcvt.h. */
154 : : struct noce_if_info;
155 : :
156 : : /* This is defined in tree-ssa-alias.h. */
157 : : class ao_ref;
158 : :
159 : : /* This is defined in tree-vectorizer.h. */
160 : : class _stmt_vec_info;
161 : :
162 : : /* This is defined in calls.h. */
163 : : class function_arg_info;
164 : :
165 : : /* This is defined in function-abi.h. */
166 : : class predefined_function_abi;
167 : :
168 : : /* This is defined in avoid-store-forwarding.h. */
169 : : struct store_fwd_info;
170 : :
171 : : /* These are defined in tree-vect-stmts.cc. */
172 : : extern tree stmt_vectype (class _stmt_vec_info *);
173 : : extern bool stmt_in_inner_loop_p (class vec_info *, class _stmt_vec_info *);
174 : :
175 : : /* Assembler instructions for creating various kinds of integer object. */
176 : :
177 : : struct asm_int_op
178 : : {
179 : : const char *hi;
180 : : const char *psi;
181 : : const char *si;
182 : : const char *pdi;
183 : : const char *di;
184 : : const char *pti;
185 : : const char *ti;
186 : : };
187 : :
188 : : /* Types of costs for vectorizer cost model. */
189 : : enum vect_cost_for_stmt
190 : : {
191 : : scalar_stmt,
192 : : scalar_load,
193 : : scalar_store,
194 : : vector_stmt,
195 : : vector_load,
196 : : vector_gather_load,
197 : : unaligned_load,
198 : : unaligned_store,
199 : : vector_store,
200 : : vector_scatter_store,
201 : : vec_to_scalar,
202 : : scalar_to_vec,
203 : : cond_branch_not_taken,
204 : : cond_branch_taken,
205 : : vec_perm,
206 : : vec_promote_demote,
207 : : vec_construct
208 : : };
209 : :
210 : : /* Separate locations for which the vectorizer cost model should
211 : : track costs. */
212 : : enum vect_cost_model_location {
213 : : vect_prologue = 0,
214 : : vect_body = 1,
215 : : vect_epilogue = 2
216 : : };
217 : :
218 : : class vec_perm_indices;
219 : :
220 : : /* The type to use for lists of vector sizes. */
221 : : typedef vec<machine_mode> vector_modes;
222 : :
223 : : /* Same, but can be used to construct local lists that are
224 : : automatically freed. */
225 : : typedef auto_vec<machine_mode, 8> auto_vector_modes;
226 : :
227 : : /* First argument of targetm.omp.device_kind_arch_isa. */
228 : : enum omp_device_kind_arch_isa {
229 : : omp_device_kind,
230 : : omp_device_arch,
231 : : omp_device_isa
232 : : };
233 : :
234 : : /* Flags returned by TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_MODES:
235 : :
236 : : VECT_COMPARE_COSTS
237 : : Tells the loop vectorizer to try all the provided modes and
238 : : pick the one with the lowest cost. By default the vectorizer
239 : : will choose the first mode that works. */
240 : : const unsigned int VECT_COMPARE_COSTS = 1U << 0;
241 : :
242 : : /* The contexts in which the use of a type T can be checked by
243 : : TARGET_VERIFY_TYPE_CONTEXT. */
244 : : enum type_context_kind {
245 : : /* Directly measuring the size of T. */
246 : : TCTX_SIZEOF,
247 : :
248 : : /* Directly measuring the alignment of T. */
249 : : TCTX_ALIGNOF,
250 : :
251 : : /* Creating objects of type T with static storage duration. */
252 : : TCTX_STATIC_STORAGE,
253 : :
254 : : /* Creating objects of type T with thread-local storage duration. */
255 : : TCTX_THREAD_STORAGE,
256 : :
257 : : /* Creating a field of type T. */
258 : : TCTX_FIELD,
259 : :
260 : : /* Creating an array with elements of type T. */
261 : : TCTX_ARRAY_ELEMENT,
262 : :
263 : : /* Adding to or subtracting from a pointer to T, or computing the
264 : : difference between two pointers when one of them is a pointer to T. */
265 : : TCTX_POINTER_ARITH,
266 : :
267 : : /* Dynamically allocating objects of type T. */
268 : : TCTX_ALLOCATION,
269 : :
270 : : /* Dynamically deallocating objects of type T. */
271 : : TCTX_DEALLOCATION,
272 : :
273 : : /* Throwing or catching an object of type T. */
274 : : TCTX_EXCEPTIONS,
275 : :
276 : : /* Capturing objects of type T by value in a closure. */
277 : : TCTX_CAPTURE_BY_COPY
278 : : };
279 : :
280 : : enum poly_value_estimate_kind
281 : : {
282 : : POLY_VALUE_MIN,
283 : : POLY_VALUE_MAX,
284 : : POLY_VALUE_LIKELY
285 : : };
286 : :
287 : : enum class spill_cost_type
288 : : {
289 : : SAVE,
290 : : RESTORE
291 : : };
292 : :
293 : : enum class frame_cost_type
294 : : {
295 : : ALLOCATION,
296 : : DEALLOCATION
297 : : };
298 : :
299 : : typedef void (*emit_support_tinfos_callback) (tree);
300 : :
301 : : extern bool verify_type_context (location_t, type_context_kind, const_tree,
302 : : bool = false);
303 : :
304 : : /* The target structure. This holds all the backend hooks. */
305 : : #define DEFHOOKPOD(NAME, DOC, TYPE, INIT) TYPE NAME;
306 : : #define DEFHOOK(NAME, DOC, TYPE, PARAMS, INIT) TYPE (* NAME) PARAMS;
307 : : #define DEFHOOK_UNDOC DEFHOOK
308 : : #define HOOKSTRUCT(FRAGMENT) FRAGMENT
309 : :
310 : : #include "target.def"
311 : :
312 : : extern struct gcc_target targetm;
313 : :
314 : : /* Return an estimate of the runtime value of X, for use in things
315 : : like cost calculations or profiling frequencies. Note that this
316 : : function should never be used in situations where the actual
317 : : runtime value is needed for correctness, since the function only
318 : : provides a rough guess. */
319 : :
320 : : inline HOST_WIDE_INT
321 : 25557 : estimated_poly_value (poly_int64 x,
322 : : poly_value_estimate_kind kind = POLY_VALUE_LIKELY)
323 : : {
324 : 25557 : if (NUM_POLY_INT_COEFFS == 1)
325 : 25557 : return x.coeffs[0];
326 : : else
327 : : return targetm.estimated_poly_value (x, kind);
328 : : }
329 : :
330 : : /* Return true when MODE can be used to copy GET_MODE_BITSIZE bits
331 : : unchanged. */
332 : :
333 : : inline bool
334 : 5194779 : mode_can_transfer_bits (machine_mode mode)
335 : : {
336 : 5194779 : if (mode == BLKmode)
337 : : return true;
338 : 8771632 : if (maybe_ne (GET_MODE_BITSIZE (mode),
339 : 8771632 : GET_MODE_UNIT_PRECISION (mode) * GET_MODE_NUNITS (mode)))
340 : : return false;
341 : 4382177 : if (targetm.mode_can_transfer_bits)
342 : 4382177 : return targetm.mode_can_transfer_bits (mode);
343 : : return true;
344 : : }
345 : :
346 : : #ifdef GCC_TM_H
347 : :
348 : : #ifndef CUMULATIVE_ARGS_MAGIC
349 : : #define CUMULATIVE_ARGS_MAGIC ((void *) &targetm.calls)
350 : : #endif
351 : :
352 : : inline CUMULATIVE_ARGS *
353 : 82839382 : get_cumulative_args (cumulative_args_t arg)
354 : : {
355 : : #if CHECKING_P
356 : 82839382 : gcc_assert (arg.magic == CUMULATIVE_ARGS_MAGIC);
357 : : #endif /* CHECKING_P */
358 : 82839382 : return (CUMULATIVE_ARGS *) arg.p;
359 : : }
360 : :
361 : : inline cumulative_args_t
362 : 33695935 : pack_cumulative_args (CUMULATIVE_ARGS *arg)
363 : : {
364 : 33695935 : cumulative_args_t ret;
365 : :
366 : : #if CHECKING_P
367 : 33695935 : ret.magic = CUMULATIVE_ARGS_MAGIC;
368 : : #endif /* CHECKING_P */
369 : 33695935 : ret.p = (void *) arg;
370 : 33695935 : return ret;
371 : : }
372 : : #endif /* GCC_TM_H */
373 : :
374 : : #endif /* GCC_TARGET_H */
|
