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