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