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