|
111
|
1 /****************************************************************************
|
|
|
2 * *
|
|
|
3 * GNAT COMPILER COMPONENTS *
|
|
|
4 * *
|
|
|
5 * G I G I *
|
|
|
6 * *
|
|
|
7 * C Header File *
|
|
|
8 * *
|
|
131
|
9 * Copyright (C) 1992-2018, Free Software Foundation, Inc. *
|
|
111
|
10 * *
|
|
|
11 * GNAT is free software; you can redistribute it and/or modify it under *
|
|
|
12 * terms of the GNU General Public License as published by the Free Soft- *
|
|
|
13 * ware Foundation; either version 3, or (at your option) any later ver- *
|
|
|
14 * sion. GNAT is distributed in the hope that it will be useful, but WITH- *
|
|
|
15 * OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY *
|
|
|
16 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License *
|
|
|
17 * for more details. You should have received a copy of the GNU General *
|
|
|
18 * Public License distributed with GNAT; see file COPYING3. If not see *
|
|
|
19 * <http://www.gnu.org/licenses/>. *
|
|
|
20 * *
|
|
|
21 * GNAT was originally developed by the GNAT team at New York University. *
|
|
|
22 * Extensive contributions were provided by Ada Core Technologies Inc. *
|
|
|
23 * *
|
|
|
24 ****************************************************************************/
|
|
|
25
|
|
|
26 /* Declare all functions and types used by gigi. */
|
|
|
27
|
|
|
28 /* Given GNAT_ENTITY, a GNAT defining identifier node, which denotes some Ada
|
|
|
29 entity, this routine returns the equivalent GCC tree for that entity
|
|
|
30 (an ..._DECL node) and associates the ..._DECL node with the input GNAT
|
|
|
31 defining identifier.
|
|
|
32
|
|
|
33 If GNAT_ENTITY is a variable or a constant declaration, GNU_EXPR gives its
|
|
|
34 initial value (in GCC tree form). This is optional for variables.
|
|
|
35 For renamed entities, GNU_EXPR gives the object being renamed.
|
|
|
36
|
|
|
37 DEFINITION is true if this call is intended for a definition. This is used
|
|
|
38 for separate compilation where it is necessary to know whether an external
|
|
|
39 declaration or a definition must be created if the GCC equivalent was not
|
|
|
40 created previously. */
|
|
|
41 extern tree gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr,
|
|
|
42 bool definition);
|
|
|
43
|
|
|
44 /* Similar, but if the returned value is a COMPONENT_REF, return the
|
|
|
45 FIELD_DECL. */
|
|
|
46 extern tree gnat_to_gnu_field_decl (Entity_Id gnat_entity);
|
|
|
47
|
|
|
48 /* Similar, but GNAT_ENTITY is assumed to refer to a GNAT type. Return
|
|
|
49 the GCC type corresponding to that entity. */
|
|
|
50 extern tree gnat_to_gnu_type (Entity_Id gnat_entity);
|
|
|
51
|
|
|
52 /* Update the GCC tree previously built for the profiles involving GNU_TYPE,
|
|
|
53 a dummy type which appears in profiles. */
|
|
|
54 extern void update_profiles_with (tree gnu_type);
|
|
|
55
|
|
|
56 /* Start a new statement group chained to the previous group. */
|
|
|
57 extern void start_stmt_group (void);
|
|
|
58
|
|
|
59 /* Add GNU_STMT to the current statement group. If it is an expression with
|
|
|
60 no effects, it is ignored. */
|
|
|
61 extern void add_stmt (tree gnu_stmt);
|
|
|
62
|
|
|
63 /* Similar, but the statement is always added, regardless of side-effects. */
|
|
|
64 extern void add_stmt_force (tree gnu_stmt);
|
|
|
65
|
|
|
66 /* Like add_stmt, but set the location of GNU_STMT to that of GNAT_NODE. */
|
|
|
67 extern void add_stmt_with_node (tree gnu_stmt, Node_Id gnat_node);
|
|
|
68
|
|
|
69 /* Similar, but the statement is always added, regardless of side-effects. */
|
|
|
70 extern void add_stmt_with_node_force (tree gnu_stmt, Node_Id gnat_node);
|
|
|
71
|
|
|
72 /* Return code corresponding to the current code group. It is normally
|
|
|
73 a STATEMENT_LIST, but may also be a BIND_EXPR or TRY_FINALLY_EXPR if
|
|
|
74 BLOCK or cleanups were set. */
|
|
|
75 extern tree end_stmt_group (void);
|
|
|
76
|
|
|
77 /* Set the BLOCK node corresponding to the current code group to GNU_BLOCK. */
|
|
|
78 extern void set_block_for_group (tree);
|
|
|
79
|
|
131
|
80 /* Add a declaration statement for GNU_DECL to the current statement group.
|
|
|
81 Get the SLOC to be put onto the statement from GNAT_NODE. */
|
|
|
82 extern void add_decl_expr (tree gnu_decl, Node_Id gnat_node);
|
|
111
|
83
|
|
|
84 /* Mark nodes rooted at T with TREE_VISITED and types as having their
|
|
|
85 sized gimplified. We use this to indicate all variable sizes and
|
|
|
86 positions in global types may not be shared by any subprogram. */
|
|
|
87 extern void mark_visited (tree t);
|
|
|
88
|
|
|
89 /* This macro calls the above function but short-circuits the common
|
|
|
90 case of a constant to save time and also checks for NULL. */
|
|
|
91 #define MARK_VISITED(EXP) \
|
|
|
92 do { \
|
|
|
93 if((EXP) && !CONSTANT_CLASS_P (EXP)) \
|
|
|
94 mark_visited (EXP); \
|
|
|
95 } while (0)
|
|
|
96
|
|
|
97 /* Finalize the processing of From_Limited_With incomplete types. */
|
|
|
98 extern void finalize_from_limited_with (void);
|
|
|
99
|
|
|
100 /* Return the equivalent type to be used for GNAT_ENTITY, if it's a kind
|
|
|
101 of type (such E_Task_Type) that has a different type which Gigi uses
|
|
|
102 for its representation. If the type does not have a special type for
|
|
|
103 its representation, return GNAT_ENTITY. */
|
|
|
104 extern Entity_Id Gigi_Equivalent_Type (Entity_Id gnat_entity);
|
|
|
105
|
|
|
106 /* Given GNAT_ENTITY, elaborate all expressions that are required to
|
|
|
107 be elaborated at the point of its definition, but do nothing else. */
|
|
|
108 extern void elaborate_entity (Entity_Id gnat_entity);
|
|
|
109
|
|
|
110 /* Get the unpadded version of a GNAT type. */
|
|
|
111 extern tree get_unpadded_type (Entity_Id gnat_entity);
|
|
|
112
|
|
|
113 /* Create a record type that contains a SIZE bytes long field of TYPE with a
|
|
|
114 starting bit position so that it is aligned to ALIGN bits, and leaving at
|
|
|
115 least ROOM bytes free before the field. BASE_ALIGN is the alignment the
|
|
|
116 record is guaranteed to get. GNAT_NODE is used for the position of the
|
|
|
117 associated TYPE_DECL. */
|
|
|
118 extern tree make_aligning_type (tree type, unsigned int align, tree size,
|
|
|
119 unsigned int base_align, int room, Node_Id);
|
|
|
120
|
|
|
121 /* TYPE is a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE that is being used
|
|
|
122 as the field type of a packed record if IN_RECORD is true, or as the
|
|
|
123 component type of a packed array if IN_RECORD is false. See if we can
|
|
|
124 rewrite it either as a type that has a non-BLKmode, which we can pack
|
|
|
125 tighter in the packed record case, or as a smaller type with at most
|
|
|
126 MAX_ALIGN alignment if the value is non-zero. If so, return the new
|
|
|
127 type; if not, return the original type. */
|
|
|
128 extern tree make_packable_type (tree type, bool in_record,
|
|
|
129 unsigned int max_align = 0);
|
|
|
130
|
|
|
131 /* Given a type TYPE, return a new type whose size is appropriate for SIZE.
|
|
|
132 If TYPE is the best type, return it. Otherwise, make a new type. We
|
|
|
133 only support new integral and pointer types. FOR_BIASED is true if
|
|
|
134 we are making a biased type. */
|
|
|
135 extern tree make_type_from_size (tree type, tree size_tree, bool for_biased);
|
|
|
136
|
|
|
137 /* Ensure that TYPE has SIZE and ALIGN. Make and return a new padded type
|
|
|
138 if needed. We have already verified that SIZE and ALIGN are large enough.
|
|
|
139 GNAT_ENTITY is used to name the resulting record and to issue a warning.
|
|
|
140 IS_COMPONENT_TYPE is true if this is being done for the component type of
|
|
|
141 an array. IS_USER_TYPE is true if the original type needs to be completed.
|
|
|
142 DEFINITION is true if this type is being defined. SET_RM_SIZE is true if
|
|
|
143 the RM size of the resulting type is to be set to SIZE too; in this case,
|
|
|
144 the padded type is canonicalized before being returned. */
|
|
|
145 extern tree maybe_pad_type (tree type, tree size, unsigned int align,
|
|
|
146 Entity_Id gnat_entity, bool is_component_type,
|
|
|
147 bool is_user_type, bool definition,
|
|
|
148 bool set_rm_size);
|
|
|
149
|
|
131
|
150 /* Return true if padded TYPE was built with an RM size. */
|
|
|
151 extern bool pad_type_has_rm_size (tree type);
|
|
|
152
|
|
111
|
153 /* Return a copy of the padded TYPE but with reverse storage order. */
|
|
|
154 extern tree set_reverse_storage_order_on_pad_type (tree type);
|
|
|
155
|
|
|
156 enum alias_set_op
|
|
|
157 {
|
|
|
158 ALIAS_SET_COPY,
|
|
|
159 ALIAS_SET_SUBSET,
|
|
|
160 ALIAS_SET_SUPERSET
|
|
|
161 };
|
|
|
162
|
|
|
163 /* Relate the alias sets of GNU_NEW_TYPE and GNU_OLD_TYPE according to OP.
|
|
|
164 If this is a multi-dimensional array type, do this recursively.
|
|
|
165
|
|
|
166 OP may be
|
|
|
167 - ALIAS_SET_COPY: the new set is made a copy of the old one.
|
|
|
168 - ALIAS_SET_SUPERSET: the new set is made a superset of the old one.
|
|
|
169 - ALIAS_SET_SUBSET: the new set is made a subset of the old one. */
|
|
|
170 extern void relate_alias_sets (tree gnu_new_type, tree gnu_old_type,
|
|
|
171 enum alias_set_op op);
|
|
|
172
|
|
|
173 /* Given GNAT_ENTITY, an object (constant, variable, parameter, exception)
|
|
|
174 and GNU_TYPE, its corresponding GCC type, set Esize and Alignment to the
|
|
|
175 size and alignment used by Gigi. Prefer SIZE over TYPE_SIZE if non-null.
|
|
|
176 BY_REF is true if the object is used by reference. */
|
|
|
177 extern void annotate_object (Entity_Id gnat_entity, tree gnu_type, tree size,
|
|
|
178 bool by_ref);
|
|
|
179
|
|
|
180 /* Return the variant part of RECORD_TYPE, if any. Otherwise return NULL. */
|
|
|
181 extern tree get_variant_part (tree record_type);
|
|
|
182
|
|
|
183 /* Given a type T, a FIELD_DECL F, and a replacement value R, return a new
|
|
|
184 type with all size expressions that contain F updated by replacing F
|
|
|
185 with R. If F is NULL_TREE, always make a new RECORD_TYPE, even if
|
|
|
186 nothing has changed. */
|
|
|
187 extern tree substitute_in_type (tree t, tree f, tree r);
|
|
|
188
|
|
|
189 /* Return the RM size of GNU_TYPE. This is the actual number of bits
|
|
|
190 needed to represent the object. */
|
|
|
191 extern tree rm_size (tree gnu_type);
|
|
|
192
|
|
|
193 /* Return the name to be used for GNAT_ENTITY. If a type, create a
|
|
|
194 fully-qualified name, possibly with type information encoding.
|
|
|
195 Otherwise, return the name. */
|
|
|
196 extern tree get_entity_name (Entity_Id gnat_entity);
|
|
|
197
|
|
|
198 /* Return an identifier representing the external name to be used for
|
|
|
199 GNAT_ENTITY. If SUFFIX is specified, the name is followed by "___"
|
|
|
200 and the specified suffix. */
|
|
|
201 extern tree create_concat_name (Entity_Id gnat_entity, const char *suffix);
|
|
|
202
|
|
|
203 /* Given GNU_NAME, an IDENTIFIER_NODE containing a name and SUFFIX, a
|
|
|
204 string, return a new IDENTIFIER_NODE that is the concatenation of
|
|
|
205 the name followed by "___" and the specified suffix. */
|
|
|
206 extern tree concat_name (tree gnu_name, const char *suffix);
|
|
|
207
|
|
|
208 /* Initialize data structures of the decl.c module. */
|
|
|
209 extern void init_gnat_decl (void);
|
|
|
210
|
|
|
211 /* Destroy data structures of the decl.c module. */
|
|
|
212 extern void destroy_gnat_decl (void);
|
|
|
213
|
|
|
214 /* Highest number in the front-end node table. */
|
|
|
215 extern int max_gnat_nodes;
|
|
|
216
|
|
|
217 /* True when gigi is being called on an analyzed but unexpanded
|
|
|
218 tree, and the only purpose of the call is to properly annotate
|
|
|
219 types with representation information. */
|
|
|
220 extern bool type_annotate_only;
|
|
|
221
|
|
|
222 /* This structure must be kept synchronized with Call_Back_End. */
|
|
|
223 struct File_Info_Type
|
|
|
224 {
|
|
|
225 File_Name_Type File_Name;
|
|
|
226 Instance_Id Instance;
|
|
|
227 Nat Num_Source_Lines;
|
|
|
228 };
|
|
|
229
|
|
|
230 #ifdef __cplusplus
|
|
|
231 extern "C" {
|
|
|
232 #endif
|
|
|
233
|
|
|
234 /* This is the main program of the back-end. It sets up all the table
|
|
|
235 structures and then generates code. */
|
|
|
236 extern void gigi (Node_Id gnat_root,
|
|
|
237 int max_gnat_node,
|
|
|
238 int number_name,
|
|
|
239 struct Node *nodes_ptr,
|
|
|
240 struct Flags *Flags_Ptr,
|
|
|
241 Node_Id *next_node_ptr,
|
|
|
242 Node_Id *prev_node_ptr,
|
|
|
243 struct Elist_Header *elists_ptr,
|
|
|
244 struct Elmt_Item *elmts_ptr,
|
|
|
245 struct String_Entry *strings_ptr,
|
|
|
246 Char_Code *strings_chars_ptr,
|
|
|
247 struct List_Header *list_headers_ptr,
|
|
|
248 Nat number_file,
|
|
|
249 struct File_Info_Type *file_info_ptr,
|
|
|
250 Entity_Id standard_boolean,
|
|
|
251 Entity_Id standard_integer,
|
|
|
252 Entity_Id standard_character,
|
|
|
253 Entity_Id standard_long_long_float,
|
|
|
254 Entity_Id standard_exception_type,
|
|
|
255 Int gigi_operating_mode);
|
|
|
256
|
|
|
257 #ifdef __cplusplus
|
|
|
258 }
|
|
|
259 #endif
|
|
|
260
|
|
|
261 /* GNAT_NODE is the root of some GNAT tree. Return the root of the
|
|
|
262 GCC tree corresponding to that GNAT tree. */
|
|
|
263 extern tree gnat_to_gnu (Node_Id gnat_node);
|
|
|
264
|
|
|
265 /* Similar to gnat_to_gnu, but discard any object that might be created in
|
|
|
266 the course of the translation of GNAT_NODE, which must be an "external"
|
|
|
267 expression in the sense that it will be elaborated elsewhere. */
|
|
|
268 extern tree gnat_to_gnu_external (Node_Id gnat_node);
|
|
|
269
|
|
|
270 /* GNU_STMT is a statement. We generate code for that statement. */
|
|
|
271 extern void gnat_expand_stmt (tree gnu_stmt);
|
|
|
272
|
|
|
273 /* Generate GIMPLE in place for the expression at *EXPR_P. */
|
|
|
274 extern int gnat_gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *);
|
|
|
275
|
|
|
276 /* Do the processing for the declaration of a GNAT_ENTITY, a type. If
|
|
|
277 a separate Freeze node exists, delay the bulk of the processing. Otherwise
|
|
|
278 make a GCC type for GNAT_ENTITY and set up the correspondence. */
|
|
|
279 extern void process_type (Entity_Id gnat_entity);
|
|
|
280
|
|
|
281 /* Convert SLOC into LOCUS. Return true if SLOC corresponds to a source code
|
|
|
282 location and false if it doesn't. If CLEAR_COLUMN is true, set the column
|
|
|
283 information to 0. */
|
|
|
284 extern bool Sloc_to_locus (Source_Ptr Sloc, location_t *locus,
|
|
131
|
285 bool clear_column = false, const_tree decl = 0);
|
|
111
|
286
|
|
|
287 /* Post an error message. MSG is the error message, properly annotated.
|
|
|
288 NODE is the node at which to post the error and the node to use for the
|
|
|
289 '&' substitution. */
|
|
|
290 extern void post_error (const char *msg, Node_Id node);
|
|
|
291
|
|
|
292 /* Similar to post_error, but NODE is the node at which to post the error and
|
|
|
293 ENT is the node to use for the '&' substitution. */
|
|
|
294 extern void post_error_ne (const char *msg, Node_Id node, Entity_Id ent);
|
|
|
295
|
|
|
296 /* Similar to post_error_ne, but NUM is the number to use for the '^'. */
|
|
|
297 extern void post_error_ne_num (const char *msg, Node_Id node, Entity_Id ent,
|
|
|
298 int num);
|
|
|
299
|
|
|
300 /* Similar to post_error_ne, but T is a GCC tree representing the number to
|
|
|
301 write. If T represents a constant, the text inside curly brackets in
|
|
|
302 MSG will be output (presumably including a '^'). Otherwise it will not
|
|
|
303 be output and the text inside square brackets will be output instead. */
|
|
|
304 extern void post_error_ne_tree (const char *msg, Node_Id node, Entity_Id ent,
|
|
|
305 tree t);
|
|
|
306
|
|
|
307 /* Similar to post_error_ne_tree, but NUM is a second integer to write. */
|
|
|
308 extern void post_error_ne_tree_2 (const char *msg, Node_Id node, Entity_Id ent,
|
|
|
309 tree t, int num);
|
|
|
310
|
|
|
311 /* Return a label to branch to for the exception type in KIND or Empty
|
|
|
312 if none. */
|
|
|
313 extern Entity_Id get_exception_label (char kind);
|
|
|
314
|
|
|
315 /* If nonzero, pretend we are allocating at global level. */
|
|
|
316 extern int force_global;
|
|
|
317
|
|
|
318 /* The default alignment of "double" floating-point types, i.e. floating
|
|
|
319 point types whose size is equal to 64 bits, or 0 if this alignment is
|
|
|
320 not specifically capped. */
|
|
|
321 extern int double_float_alignment;
|
|
|
322
|
|
|
323 /* The default alignment of "double" or larger scalar types, i.e. scalar
|
|
|
324 types whose size is greater or equal to 64 bits, or 0 if this alignment
|
|
|
325 is not specifically capped. */
|
|
|
326 extern int double_scalar_alignment;
|
|
|
327
|
|
|
328 /* True if floating-point arithmetics may use wider intermediate results. */
|
|
|
329 extern bool fp_arith_may_widen;
|
|
|
330
|
|
|
331 /* Data structures used to represent attributes. */
|
|
|
332
|
|
|
333 enum attrib_type
|
|
|
334 {
|
|
|
335 ATTR_MACHINE_ATTRIBUTE,
|
|
|
336 ATTR_LINK_ALIAS,
|
|
|
337 ATTR_LINK_SECTION,
|
|
|
338 ATTR_LINK_CONSTRUCTOR,
|
|
|
339 ATTR_LINK_DESTRUCTOR,
|
|
|
340 ATTR_THREAD_LOCAL_STORAGE,
|
|
|
341 ATTR_WEAK_EXTERNAL
|
|
|
342 };
|
|
|
343
|
|
|
344 struct attrib
|
|
|
345 {
|
|
|
346 struct attrib *next;
|
|
|
347 enum attrib_type type;
|
|
|
348 tree name;
|
|
|
349 tree args;
|
|
|
350 Node_Id error_point;
|
|
|
351 };
|
|
|
352
|
|
|
353 /* Table of machine-independent internal attributes. */
|
|
|
354 extern const struct attribute_spec gnat_internal_attribute_table[];
|
|
|
355
|
|
|
356 /* Define the entries in the standard data array. */
|
|
|
357 enum standard_datatypes
|
|
|
358 {
|
|
|
359 /* The longest floating-point type. */
|
|
|
360 ADT_longest_float_type,
|
|
|
361
|
|
|
362 /* The type of an exception. */
|
|
|
363 ADT_except_type,
|
|
|
364
|
|
|
365 /* Function type declaration -- void T() */
|
|
|
366 ADT_void_ftype,
|
|
|
367
|
|
|
368 /* Type declaration node <==> typedef void *T() */
|
|
|
369 ADT_ptr_void_ftype,
|
|
|
370
|
|
|
371 /* Type declaration node <==> typedef virtual void *T() */
|
|
|
372 ADT_fdesc_type,
|
|
|
373
|
|
|
374 /* Null pointer for above type. */
|
|
|
375 ADT_null_fdesc,
|
|
|
376
|
|
|
377 /* Value 1 in signed bitsizetype. */
|
|
|
378 ADT_sbitsize_one_node,
|
|
|
379
|
|
|
380 /* Value BITS_PER_UNIT in signed bitsizetype. */
|
|
|
381 ADT_sbitsize_unit_node,
|
|
|
382
|
|
|
383 /* Function declaration node for run-time allocation function. */
|
|
|
384 ADT_malloc_decl,
|
|
|
385
|
|
|
386 /* Function declaration node for run-time freeing function. */
|
|
|
387 ADT_free_decl,
|
|
|
388
|
|
|
389 /* Function declaration node for run-time reallocation function. */
|
|
|
390 ADT_realloc_decl,
|
|
|
391
|
|
|
392 /* Function decl node for 64-bit multiplication with overflow checking. */
|
|
|
393 ADT_mulv64_decl,
|
|
|
394
|
|
|
395 /* Identifier for the name of the _Parent field in tagged record types. */
|
|
|
396 ADT_parent_name_id,
|
|
|
397
|
|
|
398 /* Identifier for the name of the Exception_Data type. */
|
|
|
399 ADT_exception_data_name_id,
|
|
|
400
|
|
|
401 /* Types and decls used by the SJLJ exception mechanism. */
|
|
|
402 ADT_jmpbuf_type,
|
|
|
403 ADT_jmpbuf_ptr_type,
|
|
|
404 ADT_get_jmpbuf_decl,
|
|
|
405 ADT_set_jmpbuf_decl,
|
|
|
406 ADT_get_excptr_decl,
|
|
|
407 ADT_not_handled_by_others_decl,
|
|
|
408 ADT_setjmp_decl,
|
|
|
409 ADT_update_setjmp_buf_decl,
|
|
|
410 ADT_raise_nodefer_decl,
|
|
|
411
|
|
|
412 /* Types and decls used by the ZCX exception mechanism. */
|
|
|
413 ADT_reraise_zcx_decl,
|
|
|
414 ADT_set_exception_parameter_decl,
|
|
|
415 ADT_begin_handler_decl,
|
|
|
416 ADT_end_handler_decl,
|
|
|
417 ADT_unhandled_except_decl,
|
|
|
418 ADT_others_decl,
|
|
|
419 ADT_all_others_decl,
|
|
|
420 ADT_unhandled_others_decl,
|
|
|
421
|
|
|
422 ADT_LAST
|
|
|
423 };
|
|
|
424
|
|
|
425 /* Define kind of exception information associated with raise statements. */
|
|
|
426 enum exception_info_kind
|
|
|
427 {
|
|
|
428 /* Simple exception information: file:line. */
|
|
|
429 exception_simple,
|
|
|
430 /* Range exception information: file:line + index, first, last. */
|
|
|
431 exception_range,
|
|
|
432 /* Column exception information: file:line:column. */
|
|
|
433 exception_column
|
|
|
434 };
|
|
|
435
|
|
|
436 /* Define the inline status of a subprogram. */
|
|
|
437 enum inline_status_t
|
|
|
438 {
|
|
|
439 /* Inlining is suppressed for the subprogram. */
|
|
|
440 is_suppressed,
|
|
|
441 /* No inlining is requested for the subprogram. */
|
|
|
442 is_disabled,
|
|
|
443 /* Inlining is requested for the subprogram. */
|
|
|
444 is_enabled,
|
|
|
445 /* Inlining is required for the subprogram. */
|
|
|
446 is_required
|
|
|
447 };
|
|
|
448
|
|
|
449 extern GTY(()) tree gnat_std_decls[(int) ADT_LAST];
|
|
|
450 extern GTY(()) tree gnat_raise_decls[(int) LAST_REASON_CODE + 1];
|
|
|
451 extern GTY(()) tree gnat_raise_decls_ext[(int) LAST_REASON_CODE + 1];
|
|
|
452
|
|
|
453 #define longest_float_type_node gnat_std_decls[(int) ADT_longest_float_type]
|
|
|
454 #define except_type_node gnat_std_decls[(int) ADT_except_type]
|
|
|
455 #define void_ftype gnat_std_decls[(int) ADT_void_ftype]
|
|
|
456 #define ptr_void_ftype gnat_std_decls[(int) ADT_ptr_void_ftype]
|
|
|
457 #define fdesc_type_node gnat_std_decls[(int) ADT_fdesc_type]
|
|
|
458 #define null_fdesc_node gnat_std_decls[(int) ADT_null_fdesc]
|
|
|
459 #define sbitsize_one_node gnat_std_decls[(int) ADT_sbitsize_one_node]
|
|
|
460 #define sbitsize_unit_node gnat_std_decls[(int) ADT_sbitsize_unit_node]
|
|
|
461 #define malloc_decl gnat_std_decls[(int) ADT_malloc_decl]
|
|
|
462 #define free_decl gnat_std_decls[(int) ADT_free_decl]
|
|
|
463 #define realloc_decl gnat_std_decls[(int) ADT_realloc_decl]
|
|
|
464 #define mulv64_decl gnat_std_decls[(int) ADT_mulv64_decl]
|
|
|
465 #define parent_name_id gnat_std_decls[(int) ADT_parent_name_id]
|
|
|
466 #define exception_data_name_id gnat_std_decls[(int) ADT_exception_data_name_id]
|
|
|
467 #define jmpbuf_type gnat_std_decls[(int) ADT_jmpbuf_type]
|
|
|
468 #define jmpbuf_ptr_type gnat_std_decls[(int) ADT_jmpbuf_ptr_type]
|
|
|
469 #define get_jmpbuf_decl gnat_std_decls[(int) ADT_get_jmpbuf_decl]
|
|
|
470 #define set_jmpbuf_decl gnat_std_decls[(int) ADT_set_jmpbuf_decl]
|
|
|
471 #define get_excptr_decl gnat_std_decls[(int) ADT_get_excptr_decl]
|
|
|
472 #define not_handled_by_others_decl \
|
|
|
473 gnat_std_decls[(int) ADT_not_handled_by_others_decl]
|
|
|
474 #define setjmp_decl gnat_std_decls[(int) ADT_setjmp_decl]
|
|
|
475 #define update_setjmp_buf_decl gnat_std_decls[(int) ADT_update_setjmp_buf_decl]
|
|
|
476 #define raise_nodefer_decl gnat_std_decls[(int) ADT_raise_nodefer_decl]
|
|
|
477 #define reraise_zcx_decl gnat_std_decls[(int) ADT_reraise_zcx_decl]
|
|
|
478 #define set_exception_parameter_decl \
|
|
|
479 gnat_std_decls[(int) ADT_set_exception_parameter_decl]
|
|
|
480 #define begin_handler_decl gnat_std_decls[(int) ADT_begin_handler_decl]
|
|
|
481 #define others_decl gnat_std_decls[(int) ADT_others_decl]
|
|
|
482 #define all_others_decl gnat_std_decls[(int) ADT_all_others_decl]
|
|
|
483 #define unhandled_others_decl gnat_std_decls[(int) ADT_unhandled_others_decl]
|
|
|
484 #define end_handler_decl gnat_std_decls[(int) ADT_end_handler_decl]
|
|
|
485 #define unhandled_except_decl gnat_std_decls[(int) ADT_unhandled_except_decl]
|
|
|
486
|
|
|
487 /* Routines expected by the gcc back-end. They must have exactly the same
|
|
|
488 prototype and names as below. */
|
|
|
489
|
|
|
490 /* Return true if we are in the global binding level. */
|
|
|
491 extern bool global_bindings_p (void);
|
|
|
492
|
|
|
493 /* Enter and exit a new binding level. */
|
|
|
494 extern void gnat_pushlevel (void);
|
|
|
495 extern void gnat_poplevel (void);
|
|
|
496 extern void gnat_zaplevel (void);
|
|
|
497
|
|
|
498 /* Set SUPERCONTEXT of the BLOCK for the current binding level to FNDECL
|
|
|
499 and point FNDECL to this BLOCK. */
|
|
|
500 extern void set_current_block_context (tree fndecl);
|
|
|
501
|
|
|
502 /* Set the jmpbuf_decl for the current binding level to DECL. */
|
|
|
503 extern void set_block_jmpbuf_decl (tree decl);
|
|
|
504
|
|
|
505 /* Get the setjmp_decl, if any, for the current binding level. */
|
|
|
506 extern tree get_block_jmpbuf_decl (void);
|
|
|
507
|
|
|
508 /* Record DECL as belonging to the current lexical scope and use GNAT_NODE
|
|
|
509 for location information and flag propagation. */
|
|
|
510 extern void gnat_pushdecl (tree decl, Node_Id gnat_node);
|
|
|
511
|
|
|
512 /* Initialize the GCC support for exception handling. */
|
|
|
513 extern void gnat_init_gcc_eh (void);
|
|
|
514
|
|
|
515 /* Initialize the GCC support for floating-point operations. */
|
|
|
516 extern void gnat_init_gcc_fp (void);
|
|
|
517
|
|
|
518 /* Install the builtin functions we might need. */
|
|
|
519 extern void gnat_install_builtins (void);
|
|
|
520
|
|
|
521 /* Return an integer type with the number of bits of precision given by
|
|
|
522 PRECISION. UNSIGNEDP is nonzero if the type is unsigned; otherwise
|
|
|
523 it is a signed type. */
|
|
|
524 extern tree gnat_type_for_size (unsigned precision, int unsignedp);
|
|
|
525
|
|
|
526 /* Return a data type that has machine mode MODE. UNSIGNEDP selects
|
|
|
527 an unsigned type; otherwise a signed type is returned. */
|
|
|
528 extern tree gnat_type_for_mode (machine_mode mode, int unsignedp);
|
|
|
529
|
|
|
530 /* Perform final processing on global declarations. */
|
|
|
531 extern void gnat_write_global_declarations (void);
|
|
|
532
|
|
|
533 /* Return the signed or unsigned version of TYPE_NODE, a scalar type, the
|
|
|
534 signedness being specified by UNSIGNEDP. */
|
|
|
535 extern tree gnat_signed_or_unsigned_type_for (int unsignedp, tree type_node);
|
|
|
536
|
|
|
537 /* Return 1 if the types T1 and T2 are compatible, i.e. if they can be
|
|
|
538 transparently converted to each other. */
|
|
|
539 extern int gnat_types_compatible_p (tree t1, tree t2);
|
|
|
540
|
|
|
541 /* Return true if EXPR is a useless type conversion. */
|
|
|
542 extern bool gnat_useless_type_conversion (tree expr);
|
|
|
543
|
|
131
|
544 /* Return true if T, a {FUNCTION,METHOD}_TYPE, has the specified flags. */
|
|
111
|
545 extern bool fntype_same_flags_p (const_tree, tree, bool, bool, bool);
|
|
|
546
|
|
|
547 /* Create an expression whose value is that of EXPR,
|
|
|
548 converted to type TYPE. The TREE_TYPE of the value
|
|
|
549 is always TYPE. This function implements all reasonable
|
|
|
550 conversions; callers should filter out those that are
|
|
|
551 not permitted by the language being compiled. */
|
|
|
552 extern tree convert (tree type, tree expr);
|
|
|
553
|
|
|
554 /* Create an expression whose value is that of EXPR converted to the common
|
|
|
555 index type, which is sizetype. */
|
|
|
556 extern tree convert_to_index_type (tree expr);
|
|
|
557
|
|
|
558 /* Routines created solely for the tree translator's sake. Their prototypes
|
|
|
559 can be changed as desired. */
|
|
|
560
|
|
|
561 /* Initialize data structures of the utils.c module. */
|
|
|
562 extern void init_gnat_utils (void);
|
|
|
563
|
|
|
564 /* Destroy data structures of the utils.c module. */
|
|
|
565 extern void destroy_gnat_utils (void);
|
|
|
566
|
|
|
567 /* GNAT_ENTITY is a GNAT tree node for a defining identifier.
|
|
|
568 GNU_DECL is the GCC tree which is to be associated with
|
|
|
569 GNAT_ENTITY. Such gnu tree node is always an ..._DECL node.
|
|
|
570 If NO_CHECK is nonzero, the latter check is suppressed.
|
|
|
571 If GNU_DECL is zero, a previous association is to be reset. */
|
|
|
572 extern void save_gnu_tree (Entity_Id gnat_entity, tree gnu_decl,
|
|
|
573 bool no_check);
|
|
|
574
|
|
|
575 /* GNAT_ENTITY is a GNAT tree node for a defining identifier.
|
|
|
576 Return the ..._DECL node that was associated with it. If there is no tree
|
|
|
577 node associated with GNAT_ENTITY, abort. */
|
|
|
578 extern tree get_gnu_tree (Entity_Id gnat_entity);
|
|
|
579
|
|
|
580 /* Return nonzero if a GCC tree has been associated with GNAT_ENTITY. */
|
|
|
581 extern bool present_gnu_tree (Entity_Id gnat_entity);
|
|
|
582
|
|
|
583 /* Make a dummy type corresponding to GNAT_TYPE. */
|
|
|
584 extern tree make_dummy_type (Entity_Id gnat_type);
|
|
|
585
|
|
|
586 /* Return the dummy type that was made for GNAT_TYPE, if any. */
|
|
|
587 extern tree get_dummy_type (Entity_Id gnat_type);
|
|
|
588
|
|
|
589 /* Build dummy fat and thin pointer types whose designated type is specified
|
|
|
590 by GNAT_DESIG_TYPE/GNU_DESIG_TYPE and attach them to the latter. */
|
|
|
591 extern void build_dummy_unc_pointer_types (Entity_Id gnat_desig_type,
|
|
|
592 tree gnu_desig_type);
|
|
|
593
|
|
|
594 /* Record TYPE as a builtin type for Ada. NAME is the name of the type.
|
|
|
595 ARTIFICIAL_P is true if the type was generated by the compiler. */
|
|
|
596 extern void record_builtin_type (const char *name, tree type,
|
|
|
597 bool artificial_p);
|
|
|
598
|
|
|
599 /* Finish constructing the character type CHAR_TYPE. */
|
|
|
600 extern void finish_character_type (tree char_type);
|
|
|
601
|
|
|
602 /* Given a record type RECORD_TYPE and a list of FIELD_DECL nodes FIELD_LIST,
|
|
|
603 finish constructing the record type as a fat pointer type. */
|
|
|
604 extern void finish_fat_pointer_type (tree record_type, tree field_list);
|
|
|
605
|
|
|
606 /* Given a record type RECORD_TYPE and a list of FIELD_DECL nodes FIELD_LIST,
|
|
|
607 finish constructing the record or union type. If REP_LEVEL is zero, this
|
|
|
608 record has no representation clause and so will be entirely laid out here.
|
|
|
609 If REP_LEVEL is one, this record has a representation clause and has been
|
|
|
610 laid out already; only set the sizes and alignment. If REP_LEVEL is two,
|
|
|
611 this record is derived from a parent record and thus inherits its layout;
|
|
|
612 only make a pass on the fields to finalize them. DEBUG_INFO_P is true if
|
|
|
613 additional debug info needs to be output for this type. */
|
|
|
614 extern void finish_record_type (tree record_type, tree field_list,
|
|
|
615 int rep_level, bool debug_info_p);
|
|
|
616
|
|
|
617 /* Wrap up compilation of RECORD_TYPE, i.e. output additional debug info
|
|
|
618 associated with it. It need not be invoked directly in most cases as
|
|
|
619 finish_record_type takes care of doing so. */
|
|
|
620 extern void rest_of_record_type_compilation (tree record_type);
|
|
|
621
|
|
|
622 /* Append PARALLEL_TYPE on the chain of parallel types for TYPE. */
|
|
|
623 extern void add_parallel_type (tree type, tree parallel_type);
|
|
|
624
|
|
|
625 /* Return a copy of TYPE, but safe to modify in any way. */
|
|
|
626 extern tree copy_type (tree type);
|
|
|
627
|
|
|
628 /* Return a subtype of sizetype with range MIN to MAX and whose
|
|
|
629 TYPE_INDEX_TYPE is INDEX. GNAT_NODE is used for the position
|
|
|
630 of the associated TYPE_DECL. */
|
|
|
631 extern tree create_index_type (tree min, tree max, tree index,
|
|
|
632 Node_Id gnat_node);
|
|
|
633
|
|
|
634 /* Return a subtype of TYPE with range MIN to MAX. If TYPE is NULL,
|
|
|
635 sizetype is used. */
|
|
|
636 extern tree create_range_type (tree type, tree min, tree max);
|
|
|
637
|
|
|
638 /* Return a TYPE_DECL node suitable for the TYPE_STUB_DECL field of TYPE.
|
|
|
639 NAME gives the name of the type to be used in the declaration. */
|
|
|
640 extern tree create_type_stub_decl (tree name, tree type);
|
|
|
641
|
|
|
642 /* Return a TYPE_DECL node for TYPE. NAME gives the name of the type to be
|
|
|
643 used in the declaration. ARTIFICIAL_P is true if the declaration was
|
|
|
644 generated by the compiler. DEBUG_INFO_P is true if we need to write
|
|
|
645 debug information about this type. GNAT_NODE is used for the position
|
|
|
646 of the decl. */
|
|
|
647 extern tree create_type_decl (tree name, tree type, bool artificial_p,
|
|
|
648 bool debug_info_p, Node_Id gnat_node);
|
|
|
649
|
|
|
650 /* Return a VAR_DECL or CONST_DECL node.
|
|
|
651
|
|
|
652 NAME gives the name of the variable. ASM_NAME is its assembler name
|
|
|
653 (if provided). TYPE is its data type (a GCC ..._TYPE node). INIT is
|
|
|
654 the GCC tree for an optional initial expression; NULL_TREE if none.
|
|
|
655
|
|
|
656 CONST_FLAG is true if this variable is constant, in which case we might
|
|
|
657 return a CONST_DECL node unless CONST_DECL_ALLOWED_P is false.
|
|
|
658
|
|
|
659 PUBLIC_FLAG is true if this is for a reference to a public entity or for a
|
|
|
660 definition to be made visible outside of the current compilation unit, for
|
|
|
661 instance variable definitions in a package specification.
|
|
|
662
|
|
|
663 EXTERN_FLAG is true when processing an external variable declaration (as
|
|
|
664 opposed to a definition: no storage is to be allocated for the variable).
|
|
|
665
|
|
|
666 STATIC_FLAG is only relevant when not at top level and indicates whether
|
|
|
667 to always allocate storage to the variable.
|
|
|
668
|
|
|
669 VOLATILE_FLAG is true if this variable is declared as volatile.
|
|
|
670
|
|
|
671 ARTIFICIAL_P is true if the variable was generated by the compiler.
|
|
|
672
|
|
|
673 DEBUG_INFO_P is true if we need to write debug information for it.
|
|
|
674
|
|
|
675 ATTR_LIST is the list of attributes to be attached to the variable.
|
|
|
676
|
|
|
677 GNAT_NODE is used for the position of the decl. */
|
|
|
678 extern tree create_var_decl (tree name, tree asm_name, tree type, tree init,
|
|
|
679 bool const_flag, bool public_flag,
|
|
|
680 bool extern_flag, bool static_flag,
|
|
|
681 bool volatile_flag,
|
|
|
682 bool artificial_p, bool debug_info_p,
|
|
|
683 struct attrib *attr_list, Node_Id gnat_node,
|
|
|
684 bool const_decl_allowed_p = true);
|
|
|
685
|
|
|
686 /* Return a FIELD_DECL node. NAME is the field's name, TYPE is its type and
|
|
|
687 RECORD_TYPE is the type of the enclosing record. If SIZE is nonzero, it
|
|
|
688 is the specified size of the field. If POS is nonzero, it is the bit
|
|
|
689 position. PACKED is 1 if the enclosing record is packed, -1 if it has
|
|
|
690 Component_Alignment of Storage_Unit. If ADDRESSABLE is nonzero, it
|
|
|
691 means we are allowed to take the address of the field; if it is negative,
|
|
|
692 we should not make a bitfield, which is used by make_aligning_type. */
|
|
|
693 extern tree create_field_decl (tree name, tree type, tree record_type,
|
|
|
694 tree size, tree pos, int packed,
|
|
|
695 int addressable);
|
|
|
696
|
|
|
697 /* Return a PARM_DECL node with NAME and TYPE. */
|
|
|
698 extern tree create_param_decl (tree name, tree type);
|
|
|
699
|
|
|
700 /* Return a LABEL_DECL with NAME. GNAT_NODE is used for the position of
|
|
|
701 the decl. */
|
|
|
702 extern tree create_label_decl (tree name, Node_Id gnat_node);
|
|
|
703
|
|
|
704 /* Return a FUNCTION_DECL node. NAME is the name of the subprogram, ASM_NAME
|
|
|
705 its assembler name, TYPE its type (a FUNCTION_TYPE node), PARAM_DECL_LIST
|
|
|
706 the list of its parameters (a list of PARM_DECL nodes chained through the
|
|
|
707 DECL_CHAIN field).
|
|
|
708
|
|
|
709 INLINE_STATUS describes the inline flags to be set on the FUNCTION_DECL.
|
|
|
710
|
|
|
711 PUBLIC_FLAG is true if this is for a reference to a public entity or for a
|
|
|
712 definition to be made visible outside of the current compilation unit.
|
|
|
713
|
|
|
714 EXTERN_FLAG is true when processing an external subprogram declaration.
|
|
|
715
|
|
|
716 ARTIFICIAL_P is true if the subprogram was generated by the compiler.
|
|
|
717
|
|
|
718 DEBUG_INFO_P is true if we need to write debug information for it.
|
|
|
719
|
|
|
720 DEFINITION is true if the subprogram is to be considered as a definition.
|
|
|
721
|
|
|
722 ATTR_LIST is the list of attributes to be attached to the subprogram.
|
|
|
723
|
|
|
724 GNAT_NODE is used for the position of the decl. */
|
|
|
725 extern tree create_subprog_decl (tree name, tree asm_name, tree type,
|
|
|
726 tree param_decl_list,
|
|
|
727 enum inline_status_t inline_status,
|
|
|
728 bool public_flag, bool extern_flag,
|
|
|
729 bool artificial_p, bool debug_info_p,
|
|
|
730 bool definition, struct attrib *attr_list,
|
|
|
731 Node_Id gnat_node);
|
|
|
732
|
|
|
733 /* Given a subprogram declaration DECL, its assembler name and its type,
|
|
|
734 finish constructing the subprogram declaration from ASM_NAME and TYPE. */
|
|
|
735 extern void finish_subprog_decl (tree decl, tree asm_name, tree type);
|
|
|
736
|
|
|
737 /* Process the attributes in ATTR_LIST for NODE, which is either a DECL or
|
|
|
738 a TYPE. If IN_PLACE is true, the tree pointed to by NODE should not be
|
|
|
739 changed. GNAT_NODE is used for the position of error messages. */
|
|
|
740 extern void process_attributes (tree *node, struct attrib **attr_list,
|
|
|
741 bool in_place, Node_Id gnat_node);
|
|
|
742
|
|
|
743 /* Set up the framework for generating code for SUBPROG_DECL, a subprogram
|
|
|
744 body. This routine needs to be invoked before processing the declarations
|
|
|
745 appearing in the subprogram. */
|
|
|
746 extern void begin_subprog_body (tree subprog_decl);
|
|
|
747
|
|
|
748 /* Finish translating the current subprogram and set its BODY. */
|
|
|
749 extern void end_subprog_body (tree body);
|
|
|
750
|
|
|
751 /* Wrap up compilation of SUBPROG_DECL, a subprogram body. */
|
|
|
752 extern void rest_of_subprog_body_compilation (tree subprog_decl);
|
|
|
753
|
|
|
754 /* Build a template of type TEMPLATE_TYPE from the array bounds of ARRAY_TYPE.
|
|
|
755 EXPR is an expression that we can use to locate any PLACEHOLDER_EXPRs.
|
|
|
756 Return a constructor for the template. */
|
|
|
757 extern tree build_template (tree template_type, tree array_type, tree expr);
|
|
|
758
|
|
|
759 /* Build a type to be used to represent an aliased object whose nominal type
|
|
|
760 is an unconstrained array. This consists of a RECORD_TYPE containing a
|
|
|
761 field of TEMPLATE_TYPE and a field of OBJECT_TYPE, which is an ARRAY_TYPE.
|
|
|
762 If ARRAY_TYPE is that of an unconstrained array, this is used to represent
|
|
|
763 an arbitrary unconstrained object. Use NAME as the name of the record.
|
|
|
764 DEBUG_INFO_P is true if we need to write debug information for the type. */
|
|
|
765 extern tree build_unc_object_type (tree template_type, tree object_type,
|
|
|
766 tree name, bool debug_info_p);
|
|
|
767
|
|
|
768 /* Same as build_unc_object_type, but taking a thin or fat pointer type
|
|
|
769 instead of the template type. */
|
|
|
770 extern tree build_unc_object_type_from_ptr (tree thin_fat_ptr_type,
|
|
|
771 tree object_type, tree name,
|
|
|
772 bool debug_info_p);
|
|
|
773
|
|
|
774 /* Update anything previously pointing to OLD_TYPE to point to NEW_TYPE. In
|
|
|
775 the normal case this is just two adjustments, but we have more to do
|
|
|
776 if NEW is an UNCONSTRAINED_ARRAY_TYPE. */
|
|
|
777 extern void update_pointer_to (tree old_type, tree new_type);
|
|
|
778
|
|
|
779 /* EXP is an expression for the size of an object. If this size contains
|
|
|
780 discriminant references, replace them with the maximum (if MAX_P) or
|
|
|
781 minimum (if !MAX_P) possible value of the discriminant. */
|
|
|
782 extern tree max_size (tree exp, bool max_p);
|
|
|
783
|
|
|
784 /* Remove all conversions that are done in EXP. This includes converting
|
|
|
785 from a padded type or to a left-justified modular type. If TRUE_ADDRESS
|
|
|
786 is true, always return the address of the containing object even if
|
|
|
787 the address is not bit-aligned. */
|
|
|
788 extern tree remove_conversions (tree exp, bool true_address);
|
|
|
789
|
|
|
790 /* If EXP's type is an UNCONSTRAINED_ARRAY_TYPE, return an expression that
|
|
|
791 refers to the underlying array. If its type has TYPE_CONTAINS_TEMPLATE_P,
|
|
|
792 likewise return an expression pointing to the underlying array. */
|
|
|
793 extern tree maybe_unconstrained_array (tree exp);
|
|
|
794
|
|
|
795 /* Return an expression that does an unchecked conversion of EXPR to TYPE.
|
|
|
796 If NOTRUNC_P is true, truncation operations should be suppressed. */
|
|
|
797 extern tree unchecked_convert (tree type, tree expr, bool notrunc_p);
|
|
|
798
|
|
|
799 /* Return the appropriate GCC tree code for the specified GNAT_TYPE,
|
|
|
800 the latter being a record type as predicated by Is_Record_Type. */
|
|
|
801 extern enum tree_code tree_code_for_record_type (Entity_Id gnat_type);
|
|
|
802
|
|
|
803 /* Return true if GNAT_TYPE is a "double" floating-point type, i.e. whose
|
|
|
804 size is equal to 64 bits, or an array of such a type. Set ALIGN_CLAUSE
|
|
|
805 according to the presence of an alignment clause on the type or, if it
|
|
|
806 is an array, on the component type. */
|
|
|
807 extern bool is_double_float_or_array (Entity_Id gnat_type,
|
|
|
808 bool *align_clause);
|
|
|
809
|
|
|
810 /* Return true if GNAT_TYPE is a "double" or larger scalar type, i.e. whose
|
|
|
811 size is greater or equal to 64 bits, or an array of such a type. Set
|
|
|
812 ALIGN_CLAUSE according to the presence of an alignment clause on the
|
|
|
813 type or, if it is an array, on the component type. */
|
|
|
814 extern bool is_double_scalar_or_array (Entity_Id gnat_type,
|
|
|
815 bool *align_clause);
|
|
|
816
|
|
|
817 /* Return true if GNU_TYPE is suitable as the type of a non-aliased
|
|
|
818 component of an aggregate type. */
|
|
|
819 extern bool type_for_nonaliased_component_p (tree gnu_type);
|
|
|
820
|
|
|
821 /* Return true if TYPE is a smaller form of ORIG_TYPE. */
|
|
|
822 extern bool smaller_form_type_p (tree type, tree orig_type);
|
|
|
823
|
|
|
824 /* Return the base type of TYPE. */
|
|
|
825 extern tree get_base_type (tree type);
|
|
|
826
|
|
|
827 /* EXP is a GCC tree representing an address. See if we can find how
|
|
|
828 strictly the object at that address is aligned. Return that alignment
|
|
|
829 strictly the object at that address is aligned. Return that alignment
|
|
|
830 in bits. If we don't know anything about the alignment, return 0. */
|
|
|
831 extern unsigned int known_alignment (tree exp);
|
|
|
832
|
|
|
833 /* Return true if VALUE is a multiple of FACTOR. FACTOR must be a power
|
|
|
834 of 2. */
|
|
|
835 extern bool value_factor_p (tree value, HOST_WIDE_INT factor);
|
|
|
836
|
|
|
837 /* Build an atomic load for the underlying atomic object in SRC. SYNC is
|
|
|
838 true if the load requires synchronization. */
|
|
|
839 extern tree build_atomic_load (tree src, bool sync);
|
|
|
840
|
|
|
841 /* Build an atomic store from SRC to the underlying atomic object in DEST.
|
|
|
842 SYNC is true if the store requires synchronization. */
|
|
|
843 extern tree build_atomic_store (tree dest, tree src, bool sync);
|
|
|
844
|
|
|
845 /* Build a load-modify-store sequence from SRC to DEST. GNAT_NODE is used for
|
|
|
846 the location of the sequence. Note that, even if the load and the store are
|
|
|
847 both atomic, the sequence itself is not atomic. */
|
|
|
848 extern tree build_load_modify_store (tree dest, tree src, Node_Id gnat_node);
|
|
|
849
|
|
|
850 /* Make a binary operation of kind OP_CODE. RESULT_TYPE is the type
|
|
|
851 desired for the result. Usually the operation is to be performed
|
|
|
852 in that type. For MODIFY_EXPR and ARRAY_REF, RESULT_TYPE may be 0
|
|
|
853 in which case the type to be used will be derived from the operands.
|
|
|
854 Don't fold the result if NO_FOLD is true. */
|
|
|
855 extern tree build_binary_op (enum tree_code op_code, tree result_type,
|
|
|
856 tree left_operand, tree right_operand,
|
|
|
857 bool no_fold=false);
|
|
|
858
|
|
|
859 /* Similar, but make unary operation. */
|
|
|
860 extern tree build_unary_op (enum tree_code op_code, tree result_type,
|
|
|
861 tree operand);
|
|
|
862
|
|
|
863 /* Similar, but for COND_EXPR. */
|
|
|
864 extern tree build_cond_expr (tree result_type, tree condition_operand,
|
|
|
865 tree true_operand, tree false_operand);
|
|
|
866
|
|
|
867 /* Similar, but for COMPOUND_EXPR. */
|
|
|
868 extern tree build_compound_expr (tree result_type, tree stmt_operand,
|
|
|
869 tree expr_operand);
|
|
|
870
|
|
|
871 /* Conveniently construct a function call expression. FNDECL names the
|
|
|
872 function to be called, N is the number of arguments, and the "..."
|
|
|
873 parameters are the argument expressions. Unlike build_call_expr
|
|
|
874 this doesn't fold the call, hence it will always return a CALL_EXPR. */
|
|
|
875 extern tree build_call_n_expr (tree fndecl, int n, ...);
|
|
|
876
|
|
|
877 /* Build a call to a function that raises an exception and passes file name
|
|
|
878 and line number, if requested. MSG says which exception function to call.
|
|
|
879 GNAT_NODE is the node conveying the source location for which the error
|
|
|
880 should be signaled, or Empty in which case the error is signaled for the
|
|
|
881 current location. KIND says which kind of exception node this is for,
|
|
|
882 among N_Raise_{Constraint,Storage,Program}_Error. */
|
|
|
883 extern tree build_call_raise (int msg, Node_Id gnat_node, char kind);
|
|
|
884
|
|
|
885 /* Similar to build_call_raise, with extra information about the column
|
|
|
886 where the check failed. */
|
|
|
887 extern tree build_call_raise_column (int msg, Node_Id gnat_node, char kind);
|
|
|
888
|
|
|
889 /* Similar to build_call_raise_column, for an index or range check exception ,
|
|
|
890 with extra information of the form "INDEX out of range FIRST..LAST". */
|
|
|
891 extern tree build_call_raise_range (int msg, Node_Id gnat_node, char kind,
|
|
|
892 tree index, tree first, tree last);
|
|
|
893
|
|
|
894 /* Return a CONSTRUCTOR of TYPE whose elements are V. This is not the
|
|
|
895 same as build_constructor in the language-independent tree.c. */
|
|
|
896 extern tree gnat_build_constructor (tree type, vec<constructor_elt, va_gc> *v);
|
|
|
897
|
|
|
898 /* Return a COMPONENT_REF to access FIELD in RECORD, or NULL_EXPR and generate
|
|
|
899 a Constraint_Error if the field is not found in the record. Don't fold the
|
|
|
900 result if NO_FOLD is true. */
|
|
|
901 extern tree build_component_ref (tree record, tree field, bool no_fold);
|
|
|
902
|
|
|
903 /* Build a GCC tree to call an allocation or deallocation function.
|
|
|
904 If GNU_OBJ is nonzero, it is an object to deallocate. Otherwise,
|
|
|
905 generate an allocator.
|
|
|
906
|
|
|
907 GNU_SIZE is the number of bytes to allocate and GNU_TYPE is the contained
|
|
|
908 object type, used to determine the to-be-honored address alignment.
|
|
|
909 GNAT_PROC, if present, is a procedure to call and GNAT_POOL is the storage
|
|
|
910 pool to use. If not present, malloc and free are used. GNAT_NODE is used
|
|
|
911 to provide an error location for restriction violation messages. */
|
|
|
912 extern tree build_call_alloc_dealloc (tree gnu_obj, tree gnu_size,
|
|
|
913 tree gnu_type, Entity_Id gnat_proc,
|
|
|
914 Entity_Id gnat_pool, Node_Id gnat_node);
|
|
|
915
|
|
|
916 /* Build a GCC tree to correspond to allocating an object of TYPE whose
|
|
|
917 initial value if INIT, if INIT is nonzero. Convert the expression to
|
|
|
918 RESULT_TYPE, which must be some type of pointer. Return the tree.
|
|
|
919
|
|
|
920 GNAT_PROC and GNAT_POOL optionally give the procedure to call and
|
|
|
921 the storage pool to use. GNAT_NODE is used to provide an error
|
|
|
922 location for restriction violation messages. If IGNORE_INIT_TYPE is
|
|
|
923 true, ignore the type of INIT for the purpose of determining the size;
|
|
|
924 this will cause the maximum size to be allocated if TYPE is of
|
|
|
925 self-referential size. */
|
|
|
926 extern tree build_allocator (tree type, tree init, tree result_type,
|
|
|
927 Entity_Id gnat_proc, Entity_Id gnat_pool,
|
|
|
928 Node_Id gnat_node, bool);
|
|
|
929
|
|
|
930 /* Indicate that we need to take the address of T and that it therefore
|
|
|
931 should not be allocated in a register. Returns true if successful. */
|
|
|
932 extern bool gnat_mark_addressable (tree t);
|
|
|
933
|
|
|
934 /* Save EXP for later use or reuse. This is equivalent to save_expr in tree.c
|
|
|
935 but we know how to handle our own nodes. */
|
|
|
936 extern tree gnat_save_expr (tree exp);
|
|
|
937
|
|
|
938 /* Protect EXP for immediate reuse. This is a variant of gnat_save_expr that
|
|
|
939 is optimized under the assumption that EXP's value doesn't change before
|
|
|
940 its subsequent reuse(s) except through its potential reevaluation. */
|
|
|
941 extern tree gnat_protect_expr (tree exp);
|
|
|
942
|
|
|
943 /* This is equivalent to stabilize_reference in tree.c but we know how to
|
|
|
944 handle our own nodes and we take extra arguments. FORCE says whether to
|
|
|
945 force evaluation of everything in REF. INIT is set to the first arm of
|
|
|
946 a COMPOUND_EXPR present in REF, if any. */
|
|
|
947 extern tree gnat_stabilize_reference (tree ref, bool force, tree *init);
|
|
|
948
|
|
|
949 /* Rewrite reference REF and call FUNC on each expression within REF in the
|
|
|
950 process. DATA is passed unmodified to FUNC. INIT is set to the first
|
|
|
951 arm of a COMPOUND_EXPR present in REF, if any. */
|
|
|
952 typedef tree (*rewrite_fn) (tree, void *);
|
|
|
953 extern tree gnat_rewrite_reference (tree ref, rewrite_fn func, void *data,
|
|
|
954 tree *init);
|
|
|
955
|
|
|
956 /* This is equivalent to get_inner_reference in expr.c but it returns the
|
|
|
957 ultimate containing object only if the reference (lvalue) is constant,
|
|
|
958 i.e. if it doesn't depend on the context in which it is evaluated. */
|
|
|
959 extern tree get_inner_constant_reference (tree exp);
|
|
|
960
|
|
|
961 /* Return true if EXPR is the addition or the subtraction of a constant and,
|
|
|
962 if so, set *ADD to the addend, *CST to the constant and *MINUS_P to true
|
|
|
963 if this is a subtraction. */
|
|
|
964 extern bool is_simple_additive_expression (tree expr, tree *add, tree *cst,
|
|
|
965 bool *minus_p);
|
|
|
966
|
|
|
967 /* If EXPR is an expression that is invariant in the current function, in the
|
|
|
968 sense that it can be evaluated anywhere in the function and any number of
|
|
|
969 times, return EXPR or an equivalent expression. Otherwise return NULL. */
|
|
|
970 extern tree gnat_invariant_expr (tree expr);
|
|
|
971
|
|
|
972 /* Implementation of the builtin_function langhook. */
|
|
|
973 extern tree gnat_builtin_function (tree decl);
|
|
|
974
|
|
|
975 /* Search the chain of currently reachable declarations for a builtin
|
|
|
976 FUNCTION_DECL node corresponding to function NAME (an IDENTIFIER_NODE).
|
|
|
977 Return the first node found, if any, or NULL_TREE otherwise. */
|
|
|
978 extern tree builtin_decl_for (tree name);
|
|
|
979
|
|
|
980 /* GNU_TYPE is a type. Determine if it should be passed by reference by
|
|
|
981 default. */
|
|
|
982 extern bool default_pass_by_ref (tree gnu_type);
|
|
|
983
|
|
|
984 /* GNU_TYPE is the type of a subprogram parameter. Determine from the type
|
|
|
985 if it should be passed by reference. */
|
|
|
986 extern bool must_pass_by_ref (tree gnu_type);
|
|
|
987
|
|
|
988 /* Return the size of the FP mode with precision PREC. */
|
|
|
989 extern int fp_prec_to_size (int prec);
|
|
|
990
|
|
|
991 /* Return the precision of the FP mode with size SIZE. */
|
|
|
992 extern int fp_size_to_prec (int size);
|
|
|
993
|
|
|
994 /* Return whether GNAT_NODE is a defining identifier for a renaming that comes
|
|
|
995 from the parameter association for the instantiation of a generic. We do
|
|
|
996 not want to emit source location for them: the code generated for their
|
|
|
997 initialization is likely to disturb debugging. */
|
|
|
998 extern bool renaming_from_instantiation_p (Node_Id gnat_node);
|
|
|
999
|
|
|
1000 /* Try to process all nodes in the deferred context queue. Keep in the queue
|
|
|
1001 the ones that cannot be processed yet, remove the other ones. If FORCE is
|
|
|
1002 true, force the processing for all nodes, use the global context when nodes
|
|
|
1003 don't have a GNU translation. */
|
|
|
1004 extern void process_deferred_decl_context (bool force);
|
|
|
1005
|
|
|
1006 /* Return the innermost scope, starting at GNAT_NODE, we are be interested in
|
|
|
1007 the debug info, or Empty if there is no such scope. If not NULL, set
|
|
|
1008 IS_SUBPROGRAM to whether the returned entity is a subprogram. */
|
|
|
1009 extern Entity_Id get_debug_scope (Node_Id gnat_node, bool *is_subprogram);
|
|
|
1010
|
|
|
1011 /* Return whether EXPR, which is the renamed object in an object renaming
|
|
|
1012 declaration, can be materialized as a reference (REFERENCE_TYPE). This
|
|
|
1013 should be synchronized with Exp_Dbug.Debug_Renaming_Declaration. */
|
|
|
1014 extern bool can_materialize_object_renaming_p (Node_Id expr);
|
|
|
1015
|
|
|
1016 #ifdef __cplusplus
|
|
|
1017 extern "C" {
|
|
|
1018 #endif
|
|
|
1019
|
|
|
1020 /* These functions return the basic data type sizes and related parameters
|
|
|
1021 about the target machine. */
|
|
|
1022 extern Pos get_target_bits_per_unit (void);
|
|
|
1023 extern Pos get_target_bits_per_word (void);
|
|
|
1024 extern Pos get_target_char_size (void);
|
|
|
1025 extern Pos get_target_wchar_t_size (void);
|
|
|
1026 extern Pos get_target_short_size (void);
|
|
|
1027 extern Pos get_target_int_size (void);
|
|
|
1028 extern Pos get_target_long_size (void);
|
|
|
1029 extern Pos get_target_long_long_size (void);
|
|
|
1030 extern Pos get_target_pointer_size (void);
|
|
|
1031 extern Pos get_target_maximum_default_alignment (void);
|
|
|
1032 extern Pos get_target_system_allocator_alignment (void);
|
|
|
1033 extern Pos get_target_maximum_allowed_alignment (void);
|
|
|
1034 extern Pos get_target_maximum_alignment (void);
|
|
|
1035 extern Nat get_target_float_words_be (void);
|
|
|
1036 extern Nat get_target_words_be (void);
|
|
|
1037 extern Nat get_target_bytes_be (void);
|
|
|
1038 extern Nat get_target_bits_be (void);
|
|
|
1039 extern Nat get_target_strict_alignment (void);
|
|
|
1040 extern Nat get_target_double_float_alignment (void);
|
|
|
1041 extern Nat get_target_double_scalar_alignment (void);
|
|
|
1042
|
|
|
1043 /* This function is called by the front-end to enumerate all the supported
|
|
|
1044 modes for the machine, as well as some predefined C types. */
|
|
|
1045 extern void enumerate_modes (void (*f) (const char *, int, int, int, int, int,
|
|
|
1046 int, int));
|
|
|
1047
|
|
|
1048 #ifdef __cplusplus
|
|
|
1049 }
|
|
|
1050 #endif
|
|
|
1051
|
|
|
1052 /* If EXP's type is a VECTOR_TYPE, return EXP converted to the associated
|
|
|
1053 TYPE_REPRESENTATIVE_ARRAY. */
|
|
|
1054
|
|
|
1055 static inline tree
|
|
|
1056 maybe_vector_array (tree exp)
|
|
|
1057 {
|
|
|
1058 tree etype = TREE_TYPE (exp);
|
|
|
1059
|
|
|
1060 if (VECTOR_TYPE_P (etype))
|
|
|
1061 exp = convert (TYPE_REPRESENTATIVE_ARRAY (etype), exp);
|
|
|
1062
|
|
|
1063 return exp;
|
|
|
1064 }
|
|
|
1065
|
|
|
1066 /* Return the smallest power of 2 larger than X. */
|
|
|
1067
|
|
|
1068 static inline unsigned HOST_WIDE_INT
|
|
|
1069 ceil_pow2 (unsigned HOST_WIDE_INT x)
|
|
|
1070 {
|
|
131
|
1071 return (unsigned HOST_WIDE_INT) 1 << ceil_log2 (x);
|
|
111
|
1072 }
|
|
|
1073
|
|
|
1074 /* Return true if EXP, a CALL_EXPR, is an atomic load. */
|
|
|
1075
|
|
|
1076 static inline bool
|
|
|
1077 call_is_atomic_load (tree exp)
|
|
|
1078 {
|
|
|
1079 tree fndecl = get_callee_fndecl (exp);
|
|
|
1080
|
|
131
|
1081 if (!(fndecl && fndecl_built_in_p (fndecl, BUILT_IN_NORMAL)))
|
|
111
|
1082 return false;
|
|
|
1083
|
|
|
1084 enum built_in_function code = DECL_FUNCTION_CODE (fndecl);
|
|
|
1085 return BUILT_IN_ATOMIC_LOAD_N <= code && code <= BUILT_IN_ATOMIC_LOAD_16;
|
|
|
1086 }
|
|
|
1087
|
|
|
1088 /* Return true if TYPE is padding a self-referential type. */
|
|
|
1089
|
|
|
1090 static inline bool
|
|
|
1091 type_is_padding_self_referential (tree type)
|
|
|
1092 {
|
|
|
1093 if (!TYPE_IS_PADDING_P (type))
|
|
|
1094 return false;
|
|
|
1095
|
|
|
1096 return CONTAINS_PLACEHOLDER_P (DECL_SIZE (TYPE_FIELDS (type)));
|
|
|
1097 }
|
|
|
1098
|
|
|
1099 /* Return true if a function returning TYPE doesn't return a fixed size. */
|
|
|
1100
|
|
|
1101 static inline bool
|
|
|
1102 return_type_with_variable_size_p (tree type)
|
|
|
1103 {
|
|
|
1104 if (TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
|
|
|
1105 return true;
|
|
|
1106
|
|
|
1107 /* Return true for an unconstrained type with default discriminant, see
|
|
|
1108 the E_Subprogram_Type case of gnat_to_gnu_entity. */
|
|
|
1109 if (type_is_padding_self_referential (type))
|
|
|
1110 return true;
|
|
|
1111
|
|
|
1112 return false;
|
|
|
1113 }
|
|
|
1114
|
|
|
1115 /* Return the unsigned version of TYPE_NODE, a scalar type. */
|
|
|
1116
|
|
|
1117 static inline tree
|
|
|
1118 gnat_unsigned_type_for (tree type_node)
|
|
|
1119 {
|
|
|
1120 return gnat_signed_or_unsigned_type_for (1, type_node);
|
|
|
1121 }
|
|
|
1122
|
|
|
1123 /* Return the signed version of TYPE_NODE, a scalar type. */
|
|
|
1124
|
|
|
1125 static inline tree
|
|
|
1126 gnat_signed_type_for (tree type_node)
|
|
|
1127 {
|
|
|
1128 return gnat_signed_or_unsigned_type_for (0, type_node);
|
|
|
1129 }
|
|
|
1130
|
|
|
1131 /* Adjust the character type TYPE if need be. */
|
|
|
1132
|
|
|
1133 static inline tree
|
|
|
1134 maybe_character_type (tree type)
|
|
|
1135 {
|
|
|
1136 if (TYPE_STRING_FLAG (type) && !TYPE_UNSIGNED (type))
|
|
|
1137 type = gnat_unsigned_type_for (type);
|
|
|
1138
|
|
|
1139 return type;
|
|
|
1140 }
|
|
|
1141
|
|
|
1142 /* Adjust the character value EXPR if need be. */
|
|
|
1143
|
|
|
1144 static inline tree
|
|
|
1145 maybe_character_value (tree expr)
|
|
|
1146 {
|
|
|
1147 tree type = TREE_TYPE (expr);
|
|
|
1148
|
|
|
1149 if (TYPE_STRING_FLAG (type) && !TYPE_UNSIGNED (type))
|
|
|
1150 {
|
|
|
1151 type = gnat_unsigned_type_for (type);
|
|
|
1152 expr = convert (type, expr);
|
|
|
1153 }
|
|
|
1154
|
|
|
1155 return expr;
|
|
|
1156 }
|
|
|
1157
|
|
|
1158 /* Return the debug type of TYPE if it exists, otherwise TYPE itself. */
|
|
|
1159
|
|
|
1160 static inline tree
|
|
|
1161 maybe_debug_type (tree type)
|
|
|
1162 {
|
|
|
1163 if (TYPE_CAN_HAVE_DEBUG_TYPE_P (type) && TYPE_DEBUG_TYPE (type))
|
|
|
1164 type = TYPE_DEBUG_TYPE (type);
|
|
|
1165
|
|
|
1166 return type;
|
|
|
1167 }
|
|
131
|
1168
|
|
|
1169 /* Like build_qualified_type, but TYPE_QUALS is added to the existing
|
|
|
1170 qualifiers on TYPE. */
|
|
|
1171
|
|
|
1172 static inline tree
|
|
|
1173 change_qualified_type (tree type, int type_quals)
|
|
|
1174 {
|
|
|
1175 /* Qualifiers must be put on the associated array type. */
|
|
|
1176 if (TREE_CODE (type) == UNCONSTRAINED_ARRAY_TYPE)
|
|
|
1177 return type;
|
|
|
1178
|
|
|
1179 return build_qualified_type (type, TYPE_QUALS (type) | type_quals);
|
|
|
1180 }
|
