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