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
57struct 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
67union 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
79struct 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
89enum 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
98extern 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 */
104extern 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. */
110extern 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. */
114extern unsigned int get_move_ratio (bool);
115
116struct stdarg_info;
117struct spec_info_def;
118struct hard_reg_set_container;
119struct cgraph_node;
120struct cgraph_simd_clone;
121
122/* The struct used by the secondary_reload target hook. */
123struct 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 extra_cost; /* 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 . */
137struct _dep;
138
139/* This is defined in ddg.h . */
140struct ddg;
141
142/* This is defined in cfgloop.h . */
143class loop;
144
145/* This is defined in ifcvt.h. */
146struct noce_if_info;
147
148/* This is defined in tree-ssa-alias.h. */
149class ao_ref;
150
151/* This is defined in tree-vectorizer.h. */
152class _stmt_vec_info;
153
154/* This is defined in calls.h. */
155class function_arg_info;
156
157/* This is defined in function-abi.h. */
158class predefined_function_abi;
159
160/* These are defined in tree-vect-stmts.cc. */
161extern tree stmt_vectype (class _stmt_vec_info *);
162extern 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
166struct 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. */
178enum 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. */
201enum vect_cost_model_location {
202 vect_prologue = 0,
203 vect_body = 1,
204 vect_epilogue = 2
205};
206
207class vec_perm_indices;
208
209/* The type to use for lists of vector sizes. */
210typedef vec<machine_mode> vector_modes;
211
212/* Same, but can be used to construct local lists that are
213 automatically freed. */
214typedef auto_vec<machine_mode, 8> auto_vector_modes;
215
216/* First argument of targetm.omp.device_kind_arch_isa. */
217enum 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. */
229const 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. */
233enum 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
269enum poly_value_estimate_kind
270{
271 POLY_VALUE_MIN,
272 POLY_VALUE_MAX,
273 POLY_VALUE_LIKELY
274};
275
276typedef void (*emit_support_tinfos_callback) (tree);
277
278extern 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
289extern 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
297inline HOST_WIDE_INT
298estimated_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
313inline CUMULATIVE_ARGS *
314get_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
322inline cumulative_args_t
323pack_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

source code of gcc/target.h