]>
Commit | Line | Data |
---|---|---|
38cbfe40 RK |
1 | /**************************************************************************** |
2 | * * | |
3 | * GNAT COMPILER COMPONENTS * | |
4 | * * | |
5 | * G I G I * | |
6 | * * | |
7 | * C Header File * | |
8 | * * | |
08ffbdad | 9 | * Copyright (C) 1992-2008, Free Software Foundation, Inc. * |
38cbfe40 RK |
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 2, 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 COPYING. If not, write * | |
cb5fee25 KC |
19 | * to the Free Software Foundation, 51 Franklin Street, Fifth Floor, * |
20 | * Boston, MA 02110-1301, USA. * | |
38cbfe40 RK |
21 | * * |
22 | * As a special exception, if you link this file with other files to * | |
23 | * produce an executable, this file does not by itself cause the resulting * | |
24 | * executable to be covered by the GNU General Public License. This except- * | |
25 | * ion does not however invalidate any other reasons why the executable * | |
26 | * file might be covered by the GNU Public License. * | |
27 | * * | |
28 | * GNAT was originally developed by the GNAT team at New York University. * | |
71ff80dc | 29 | * Extensive contributions were provided by Ada Core Technologies Inc. * |
38cbfe40 RK |
30 | * * |
31 | ****************************************************************************/ | |
32 | ||
c6823a20 EB |
33 | /* Declare all functions and types used by gigi. */ |
34 | ||
fbf5a39b AC |
35 | /* The largest alignment, in bits, that is needed for using the widest |
36 | move instruction. */ | |
37 | extern unsigned int largest_move_alignment; | |
38 | ||
fbf5a39b AC |
39 | /* Compute the alignment of the largest mode that can be used for copying |
40 | objects. */ | |
c2edc52b | 41 | extern void gnat_compute_largest_alignment (void); |
fbf5a39b | 42 | |
38cbfe40 RK |
43 | /* GNU_TYPE is a type. Determine if it should be passed by reference by |
44 | default. */ | |
c6823a20 | 45 | extern bool default_pass_by_ref (tree gnu_type); |
38cbfe40 | 46 | |
07fc65c4 GB |
47 | /* GNU_TYPE is the type of a subprogram parameter. Determine from the type |
48 | if it should be passed by reference. */ | |
c6823a20 | 49 | extern bool must_pass_by_ref (tree gnu_type); |
38cbfe40 RK |
50 | |
51 | /* Initialize DUMMY_NODE_TABLE. */ | |
c2edc52b | 52 | extern void init_dummy_type (void); |
38cbfe40 | 53 | |
09ef48fe GD |
54 | /* Given GNAT_ENTITY, an entity in the incoming GNAT tree, return a |
55 | GCC type corresponding to that entity. GNAT_ENTITY is assumed to | |
56 | refer to an Ada type. */ | |
57 | extern tree gnat_to_gnu_type (Entity_Id gnat_entity); | |
58 | ||
38cbfe40 RK |
59 | /* Given GNAT_ENTITY, a GNAT defining identifier node, which denotes some Ada |
60 | entity, this routine returns the equivalent GCC tree for that entity | |
61 | (an ..._DECL node) and associates the ..._DECL node with the input GNAT | |
62 | defining identifier. | |
63 | ||
64 | If GNAT_ENTITY is a variable or a constant declaration, GNU_EXPR gives its | |
65 | initial value (in GCC tree form). This is optional for variables. | |
66 | For renamed entities, GNU_EXPR gives the object being renamed. | |
67 | ||
68 | DEFINITION is nonzero if this call is intended for a definition. This is | |
69 | used for separate compilation where it necessary to know whether an | |
70 | external declaration or a definition should be created if the GCC equivalent | |
ce2e12c2 | 71 | was not created previously. The value of 1 is normally used for a nonzero |
38cbfe40 RK |
72 | DEFINITION, but a value of 2 is used in special circumstances, defined in |
73 | the code. */ | |
c6823a20 EB |
74 | extern tree gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, |
75 | int definition); | |
76 | ||
77 | /* Similar, but if the returned value is a COMPONENT_REF, return the | |
78 | FIELD_DECL. */ | |
79 | extern tree gnat_to_gnu_field_decl (Entity_Id gnat_entity); | |
38cbfe40 | 80 | |
09ef48fe GD |
81 | /* Wrap up compilation of T, a TYPE_DECL, possibly deferring it. */ |
82 | extern void rest_of_type_decl_compilation (tree t); | |
83 | ||
84 | /* Start a new statement group chained to the previous group. */ | |
85 | extern void start_stmt_group (void); | |
38cbfe40 | 86 | |
b5e792e2 | 87 | /* Add GNU_STMT to the current BLOCK_STMT node. */ |
c6823a20 | 88 | extern void add_stmt (tree gnu_stmt); |
b5e792e2 | 89 | |
821e1ea1 | 90 | /* Similar, but set the location of GNU_STMT to that of GNAT_NODE. */ |
c6823a20 | 91 | extern void add_stmt_with_node (tree gnu_stmt, Node_Id gnat_node); |
821e1ea1 | 92 | |
09ef48fe GD |
93 | /* Return code corresponding to the current code group. It is normally |
94 | a STATEMENT_LIST, but may also be a BIND_EXPR or TRY_FINALLY_EXPR if | |
95 | BLOCK or cleanups were set. */ | |
96 | extern tree end_stmt_group (void); | |
97 | ||
821e1ea1 RK |
98 | /* Set the BLOCK node corresponding to the current code group to GNU_BLOCK. */ |
99 | extern void set_block_for_group (tree); | |
100 | ||
b5e792e2 | 101 | /* Add a declaration statement for GNU_DECL to the current BLOCK_STMT node. |
c6823a20 EB |
102 | Get SLOC from GNAT_ENTITY. */ |
103 | extern void add_decl_expr (tree gnu_decl, Entity_Id gnat_entity); | |
b5e792e2 | 104 | |
4c8125f4 EB |
105 | /* Mark nodes rooted at *TP with TREE_VISITED and types as having their |
106 | sized gimplified. We use this to indicate all variable sizes and | |
c654b659 | 107 | positions in global types may not be shared by any subprogram. */ |
4c8125f4 EB |
108 | extern void mark_visited (tree *); |
109 | ||
09ef48fe GD |
110 | /* Finalize any From_With_Type incomplete types. We do this after processing |
111 | our compilation unit and after processing its spec, if this is a body. */ | |
112 | extern void finalize_from_with_types (void); | |
113 | ||
114 | /* Return the equivalent type to be used for GNAT_ENTITY, if it's a | |
115 | kind of type (such E_Task_Type) that has a different type which Gigi | |
116 | uses for its representation. If the type does not have a special type | |
117 | for its representation, return GNAT_ENTITY. If a type is supposed to | |
118 | exist, but does not, abort unless annotating types, in which case | |
119 | return Empty. If GNAT_ENTITY is Empty, return Empty. */ | |
120 | extern Entity_Id Gigi_Equivalent_Type (Entity_Id); | |
121 | ||
38cbfe40 RK |
122 | /* Given GNAT_ENTITY, elaborate all expressions that are required to |
123 | be elaborated at the point of its definition, but do nothing else. */ | |
c6823a20 | 124 | extern void elaborate_entity (Entity_Id gnat_entity); |
38cbfe40 RK |
125 | |
126 | /* Mark GNAT_ENTITY as going out of scope at this point. Recursively mark | |
127 | any entities on its entity chain similarly. */ | |
c6823a20 | 128 | extern void mark_out_of_scope (Entity_Id gnat_entity); |
38cbfe40 RK |
129 | |
130 | /* Make a dummy type corresponding to GNAT_TYPE. */ | |
c6823a20 | 131 | extern tree make_dummy_type (Entity_Id gnat_type); |
38cbfe40 RK |
132 | |
133 | /* Get the unpadded version of a GNAT type. */ | |
c6823a20 | 134 | extern tree get_unpadded_type (Entity_Id gnat_entity); |
38cbfe40 RK |
135 | |
136 | /* Called when we need to protect a variable object using a save_expr. */ | |
c6823a20 | 137 | extern tree maybe_variable (tree gnu_operand); |
38cbfe40 | 138 | |
09ef48fe GD |
139 | /* Create a record type that contains a SIZE bytes long field of TYPE with a |
140 | starting bit position so that it is aligned to ALIGN bits, and leaving at | |
141 | least ROOM bytes free before the field. BASE_ALIGN is the alignment the | |
142 | record is guaranteed to get. */ | |
143 | extern tree make_aligning_type (tree type, unsigned int align, tree size, | |
144 | unsigned int base_align, int room); | |
38cbfe40 | 145 | |
c885d7a1 AC |
146 | /* Ensure that TYPE has SIZE and ALIGN. Make and return a new padded type |
147 | if needed. We have already verified that SIZE and TYPE are large enough. | |
148 | ||
149 | GNAT_ENTITY and NAME_TRAILER are used to name the resulting record and | |
150 | to issue a warning. | |
151 | ||
152 | IS_USER_TYPE is true if we must be sure we complete the original type. | |
153 | ||
154 | DEFINITION is true if this type is being defined. | |
155 | ||
156 | SAME_RM_SIZE is true if the RM_Size of the resulting type is to be | |
157 | set to its TYPE_SIZE; otherwise, it's set to the RM_Size of the original | |
158 | type. */ | |
c6823a20 EB |
159 | extern tree maybe_pad_type (tree type, tree size, unsigned int align, |
160 | Entity_Id gnat_entity, const char *name_trailer, | |
161 | bool is_user_type, bool definition, | |
162 | bool same_rm_size); | |
c885d7a1 | 163 | |
38cbfe40 RK |
164 | /* Given a GNU tree and a GNAT list of choices, generate an expression to test |
165 | the value passed against the list of choices. */ | |
c6823a20 | 166 | extern tree choices_to_gnu (tree operand, Node_Id choices); |
38cbfe40 | 167 | |
1bbf8502 DS |
168 | /* Given a type T, a FIELD_DECL F, and a replacement value R, return a new |
169 | type with all size expressions that contain F updated by replacing F | |
170 | with R. If F is NULL_TREE, always make a new RECORD_TYPE, even if | |
171 | nothing has changed. */ | |
172 | extern tree substitute_in_type (tree t, tree f, tree r); | |
38cbfe40 RK |
173 | |
174 | /* Return the "RM size" of GNU_TYPE. This is the actual number of bits | |
175 | needed to represent the object. */ | |
c6823a20 | 176 | extern tree rm_size (tree gnu_type); |
38cbfe40 | 177 | |
c6823a20 | 178 | /* Given GNU_ID, an IDENTIFIER_NODE containing a name, and SUFFIX, a |
38cbfe40 RK |
179 | string, return a new IDENTIFIER_NODE that is the concatenation of |
180 | the name in GNU_ID and SUFFIX. */ | |
c6823a20 | 181 | extern tree concat_id_with_name (tree gnu_id, const char *suffix); |
38cbfe40 | 182 | |
fbf5a39b | 183 | /* Return the name to be used for GNAT_ENTITY. If a type, create a |
38cbfe40 RK |
184 | fully-qualified name, possibly with type information encoding. |
185 | Otherwise, return the name. */ | |
c6823a20 | 186 | extern tree get_entity_name (Entity_Id gnat_entity); |
38cbfe40 RK |
187 | |
188 | /* Return a name for GNAT_ENTITY concatenated with two underscores and | |
189 | SUFFIX. */ | |
c6823a20 | 190 | extern tree create_concat_name (Entity_Id gnat_entity, const char *suffix); |
38cbfe40 | 191 | |
821e1ea1 RK |
192 | /* If true, then gigi is being called on an analyzed but unexpanded tree, and |
193 | the only purpose of the call is to properly annotate types with | |
194 | representation information. */ | |
615cbd95 | 195 | extern bool type_annotate_only; |
38cbfe40 RK |
196 | |
197 | /* Current file name without path */ | |
198 | extern const char *ref_filename; | |
199 | ||
c3048783 EB |
200 | /* This structure must be kept synchronized with Call_Back_End. */ |
201 | struct File_Info_Type | |
202 | { | |
203 | File_Name_Type File_Name; | |
204 | Nat Num_Source_Lines; | |
205 | }; | |
206 | ||
38cbfe40 | 207 | /* This is the main program of the back-end. It sets up all the table |
c6823a20 EB |
208 | structures and then generates code. |
209 | ||
210 | ??? Needs parameter descriptions */ | |
211 | ||
212 | extern void gigi (Node_Id gnat_root, int max_gnat_node, int number_name, | |
213 | struct Node *nodes_ptr, Node_Id *next_node_ptr, | |
214 | Node_Id *prev_node_ptr, struct Elist_Header *elists_ptr, | |
215 | struct Elmt_Item *elmts_ptr, | |
216 | struct String_Entry *strings_ptr, | |
217 | Char_Code *strings_chars_ptr, | |
218 | struct List_Header *list_headers_ptr, | |
c3048783 | 219 | Nat number_file, |
c654b659 | 220 | struct File_Info_Type *file_info_ptr, |
c6823a20 EB |
221 | Entity_Id standard_integer, |
222 | Entity_Id standard_long_long_float, | |
223 | Entity_Id standard_exception_type, | |
224 | Int gigi_operating_mode); | |
38cbfe40 | 225 | |
38cbfe40 RK |
226 | /* GNAT_NODE is the root of some GNAT tree. Return the root of the |
227 | GCC tree corresponding to that GNAT tree. Normally, no code is generated; | |
228 | we just return an equivalent tree which is used elsewhere to generate | |
229 | code. */ | |
c6823a20 | 230 | extern tree gnat_to_gnu (Node_Id gnat_node); |
38cbfe40 | 231 | |
657a9dd9 | 232 | /* GNU_STMT is a statement. We generate code for that statement. */ |
c6823a20 | 233 | extern void gnat_expand_stmt (tree gnu_stmt); |
657a9dd9 | 234 | |
c6823a20 | 235 | /* ??? missing documentation */ |
726a989a RB |
236 | extern int gnat_gimplify_expr (tree *expr_p, gimple_seq *pre_p, |
237 | gimple_seq *post_p ATTRIBUTE_UNUSED); | |
821e1ea1 | 238 | |
38cbfe40 RK |
239 | /* Do the processing for the declaration of a GNAT_ENTITY, a type. If |
240 | a separate Freeze node exists, delay the bulk of the processing. Otherwise | |
45f7cb60 | 241 | make a GCC type for GNAT_ENTITY and set up the correspondence. */ |
c6823a20 | 242 | extern void process_type (Entity_Id gnat_entity); |
38cbfe40 | 243 | |
c3048783 EB |
244 | /* Convert SLOC into LOCUS. Return true if SLOC corresponds to a source code |
245 | location and false if it doesn't. In the former case, set the Gigi global | |
246 | variable REF_FILENAME to the simple debug file name as given by sinput. */ | |
c6823a20 | 247 | extern bool Sloc_to_locus (Source_Ptr Sloc, location_t *locus); |
657a9dd9 | 248 | |
38cbfe40 RK |
249 | /* Post an error message. MSG is the error message, properly annotated. |
250 | NODE is the node at which to post the error and the node to use for the | |
251 | "&" substitution. */ | |
c2edc52b | 252 | extern void post_error (const char *, Node_Id); |
38cbfe40 RK |
253 | |
254 | /* Similar, but NODE is the node at which to post the error and ENT | |
255 | is the node to use for the "&" substitution. */ | |
c6823a20 | 256 | extern void post_error_ne (const char *msg, Node_Id node, Entity_Id ent); |
38cbfe40 RK |
257 | |
258 | /* Similar, but NODE is the node at which to post the error, ENT is the node | |
259 | to use for the "&" substitution, and N is the number to use for the ^. */ | |
c6823a20 EB |
260 | extern void post_error_ne_num (const char *msg, Node_Id node, Entity_Id ent, |
261 | int n); | |
38cbfe40 RK |
262 | |
263 | /* Similar to post_error_ne_num, but T is a GCC tree representing the number | |
264 | to write. If the tree represents a constant that fits within a | |
265 | host integer, the text inside curly brackets in MSG will be output | |
266 | (presumably including a '^'). Otherwise that text will not be output | |
267 | and the text inside square brackets will be output instead. */ | |
c6823a20 EB |
268 | extern void post_error_ne_tree (const char *msg, Node_Id node, Entity_Id ent, |
269 | tree t); | |
38cbfe40 RK |
270 | |
271 | /* Similar to post_error_ne_tree, except that NUM is a second | |
272 | integer to write in the message. */ | |
c6823a20 EB |
273 | extern void post_error_ne_tree_2 (const char *msg, Node_Id node, Entity_Id ent, |
274 | tree t, int num); | |
38cbfe40 | 275 | |
07fc65c4 | 276 | /* Protect EXP from multiple evaluation. This may make a SAVE_EXPR. */ |
c6823a20 | 277 | extern tree protect_multiple_eval (tree exp); |
38cbfe40 | 278 | |
09ef48fe GD |
279 | /* Return a label to branch to for the exception type in KIND or NULL_TREE |
280 | if none. */ | |
281 | extern tree get_exception_label (char); | |
282 | ||
38cbfe40 RK |
283 | /* Current node being treated, in case gigi_abort or Check_Elaboration_Code |
284 | called. */ | |
285 | extern Node_Id error_gnat_node; | |
286 | ||
09ef48fe GD |
287 | /* This is equivalent to stabilize_reference in tree.c, but we know how to |
288 | handle our own nodes and we take extra arguments. FORCE says whether to | |
289 | force evaluation of everything. We set SUCCESS to true unless we walk | |
290 | through something we don't know how to stabilize. */ | |
291 | extern tree maybe_stabilize_reference (tree ref, bool force, bool *success); | |
38cbfe40 RK |
292 | |
293 | /* Highest number in the front-end node table. */ | |
294 | extern int max_gnat_nodes; | |
295 | ||
296 | /* If nonzero, pretend we are allocating at global level. */ | |
297 | extern int force_global; | |
298 | ||
299 | /* Standard data type sizes. Most of these are not used. */ | |
300 | ||
301 | #ifndef CHAR_TYPE_SIZE | |
302 | #define CHAR_TYPE_SIZE BITS_PER_UNIT | |
303 | #endif | |
304 | ||
305 | #ifndef SHORT_TYPE_SIZE | |
306 | #define SHORT_TYPE_SIZE (BITS_PER_UNIT * MIN ((UNITS_PER_WORD + 1) / 2, 2)) | |
307 | #endif | |
308 | ||
309 | #ifndef INT_TYPE_SIZE | |
310 | #define INT_TYPE_SIZE BITS_PER_WORD | |
311 | #endif | |
312 | ||
313 | #ifndef LONG_TYPE_SIZE | |
314 | #define LONG_TYPE_SIZE BITS_PER_WORD | |
315 | #endif | |
316 | ||
317 | #ifndef LONG_LONG_TYPE_SIZE | |
318 | #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2) | |
319 | #endif | |
320 | ||
321 | #ifndef FLOAT_TYPE_SIZE | |
322 | #define FLOAT_TYPE_SIZE BITS_PER_WORD | |
323 | #endif | |
324 | ||
325 | #ifndef DOUBLE_TYPE_SIZE | |
326 | #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2) | |
327 | #endif | |
328 | ||
329 | #ifndef LONG_DOUBLE_TYPE_SIZE | |
330 | #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2) | |
331 | #endif | |
332 | ||
333 | /* The choice of SIZE_TYPE here is very problematic. We need a signed | |
334 | type whose bit width is Pmode. Assume "long" is such a type here. */ | |
335 | #undef SIZE_TYPE | |
336 | #define SIZE_TYPE "long int" | |
38cbfe40 RK |
337 | \f |
338 | /* Data structures used to represent attributes. */ | |
339 | ||
d9e0a587 EB |
340 | enum attr_type |
341 | { | |
342 | ATTR_MACHINE_ATTRIBUTE, | |
343 | ATTR_LINK_ALIAS, | |
344 | ATTR_LINK_SECTION, | |
345 | ATTR_LINK_CONSTRUCTOR, | |
346 | ATTR_LINK_DESTRUCTOR, | |
347 | ATTR_WEAK_EXTERNAL | |
348 | }; | |
38cbfe40 RK |
349 | |
350 | struct attrib | |
351 | { | |
352 | struct attrib *next; | |
353 | enum attr_type type; | |
354 | tree name; | |
ee575992 | 355 | tree args; |
38cbfe40 RK |
356 | Node_Id error_point; |
357 | }; | |
358 | ||
2655f1c6 EB |
359 | /* Table of machine-independent internal attributes. */ |
360 | extern const struct attribute_spec gnat_internal_attribute_table[]; | |
361 | ||
38cbfe40 RK |
362 | /* Define the entries in the standard data array. */ |
363 | enum standard_datatypes | |
364 | { | |
365 | /* Various standard data types and nodes. */ | |
366 | ADT_longest_float_type, | |
367 | ADT_void_type_decl, | |
368 | ||
369 | /* The type of an exception. */ | |
370 | ADT_except_type, | |
371 | ||
372 | /* Type declaration node <==> typedef void *T */ | |
373 | ADT_ptr_void_type, | |
374 | ||
375 | /* Function type declaration -- void T() */ | |
376 | ADT_void_ftype, | |
377 | ||
378 | /* Type declaration node <==> typedef void *T() */ | |
379 | ADT_ptr_void_ftype, | |
380 | ||
581edf92 EB |
381 | /* Type declaration node <==> typedef virtual void *T() */ |
382 | ADT_fdesc_type, | |
383 | ||
384 | /* Null pointer for above type */ | |
385 | ADT_null_fdesc, | |
386 | ||
6d21c8af DR |
387 | /* Function declaration nodes for run-time functions for allocating memory. |
388 | Ada allocators cause calls to these functions to be generated. Malloc32 | |
389 | is used only on 64bit systems needing to allocate 32bit memory. */ | |
38cbfe40 | 390 | ADT_malloc_decl, |
6d21c8af | 391 | ADT_malloc32_decl, |
38cbfe40 RK |
392 | |
393 | /* Likewise for freeing memory. */ | |
394 | ADT_free_decl, | |
395 | ||
396 | /* Types and decls used by our temporary exception mechanism. See | |
397 | init_gigi_decls for details. */ | |
398 | ADT_jmpbuf_type, | |
399 | ADT_jmpbuf_ptr_type, | |
400 | ADT_get_jmpbuf_decl, | |
401 | ADT_set_jmpbuf_decl, | |
402 | ADT_get_excptr_decl, | |
403 | ADT_setjmp_decl, | |
404 | ADT_longjmp_decl, | |
f2c9e65a | 405 | ADT_update_setjmp_buf_decl, |
38cbfe40 | 406 | ADT_raise_nodefer_decl, |
fbf5a39b AC |
407 | ADT_begin_handler_decl, |
408 | ADT_end_handler_decl, | |
ee575992 AC |
409 | ADT_others_decl, |
410 | ADT_all_others_decl, | |
38cbfe40 RK |
411 | ADT_LAST}; |
412 | ||
e2500fed GK |
413 | extern GTY(()) tree gnat_std_decls[(int) ADT_LAST]; |
414 | extern GTY(()) tree gnat_raise_decls[(int) LAST_REASON_CODE + 1]; | |
38cbfe40 RK |
415 | |
416 | #define longest_float_type_node gnat_std_decls[(int) ADT_longest_float_type] | |
417 | #define void_type_decl_node gnat_std_decls[(int) ADT_void_type_decl] | |
418 | #define except_type_node gnat_std_decls[(int) ADT_except_type] | |
419 | #define ptr_void_type_node gnat_std_decls[(int) ADT_ptr_void_type] | |
420 | #define void_ftype gnat_std_decls[(int) ADT_void_ftype] | |
421 | #define ptr_void_ftype gnat_std_decls[(int) ADT_ptr_void_ftype] | |
581edf92 EB |
422 | #define fdesc_type_node gnat_std_decls[(int) ADT_fdesc_type] |
423 | #define null_fdesc_node gnat_std_decls[(int) ADT_null_fdesc] | |
38cbfe40 | 424 | #define malloc_decl gnat_std_decls[(int) ADT_malloc_decl] |
6d21c8af | 425 | #define malloc32_decl gnat_std_decls[(int) ADT_malloc32_decl] |
38cbfe40 RK |
426 | #define free_decl gnat_std_decls[(int) ADT_free_decl] |
427 | #define jmpbuf_type gnat_std_decls[(int) ADT_jmpbuf_type] | |
428 | #define jmpbuf_ptr_type gnat_std_decls[(int) ADT_jmpbuf_ptr_type] | |
429 | #define get_jmpbuf_decl gnat_std_decls[(int) ADT_get_jmpbuf_decl] | |
430 | #define set_jmpbuf_decl gnat_std_decls[(int) ADT_set_jmpbuf_decl] | |
431 | #define get_excptr_decl gnat_std_decls[(int) ADT_get_excptr_decl] | |
432 | #define setjmp_decl gnat_std_decls[(int) ADT_setjmp_decl] | |
433 | #define longjmp_decl gnat_std_decls[(int) ADT_longjmp_decl] | |
f2c9e65a | 434 | #define update_setjmp_buf_decl gnat_std_decls[(int) ADT_update_setjmp_buf_decl] |
38cbfe40 | 435 | #define raise_nodefer_decl gnat_std_decls[(int) ADT_raise_nodefer_decl] |
fbf5a39b | 436 | #define begin_handler_decl gnat_std_decls[(int) ADT_begin_handler_decl] |
ee575992 AC |
437 | #define others_decl gnat_std_decls[(int) ADT_others_decl] |
438 | #define all_others_decl gnat_std_decls[(int) ADT_all_others_decl] | |
fbf5a39b | 439 | #define end_handler_decl gnat_std_decls[(int) ADT_end_handler_decl] |
38cbfe40 RK |
440 | |
441 | /* Routines expected by the gcc back-end. They must have exactly the same | |
442 | prototype and names as below. */ | |
443 | ||
ce2e12c2 | 444 | /* Returns nonzero if we are currently in the global binding level. */ |
c2edc52b | 445 | extern int global_bindings_p (void); |
38cbfe40 | 446 | |
821e1ea1 | 447 | /* Enter and exit a new binding level. */ |
b5e792e2 | 448 | extern void gnat_pushlevel (void); |
821e1ea1 RK |
449 | extern void gnat_poplevel (void); |
450 | ||
909f21b3 RK |
451 | /* Set SUPERCONTEXT of the BLOCK for the current binding level to FNDECL |
452 | and point FNDECL to this BLOCK. */ | |
c6823a20 | 453 | extern void set_current_block_context (tree fndecl); |
909f21b3 | 454 | |
821e1ea1 | 455 | /* Set the jmpbuf_decl for the current binding level to DECL. */ |
c6823a20 | 456 | extern void set_block_jmpbuf_decl (tree decl); |
821e1ea1 RK |
457 | |
458 | /* Get the setjmp_decl, if any, for the current binding level. */ | |
459 | extern tree get_block_jmpbuf_decl (void); | |
38cbfe40 | 460 | |
909f21b3 | 461 | /* Records a ..._DECL node DECL as belonging to the current lexical scope |
c6823a20 EB |
462 | and uses GNAT_NODE for location information. */ |
463 | extern void gnat_pushdecl (tree decl, Node_Id gnat_node); | |
38cbfe40 | 464 | |
c2edc52b | 465 | extern void gnat_init_decl_processing (void); |
c6823a20 | 466 | extern void init_gigi_decls (tree long_long_float_type, tree exception_type); |
c2edc52b | 467 | extern void gnat_init_gcc_eh (void); |
38cbfe40 | 468 | |
fbf5a39b | 469 | /* Return an integer type with the number of bits of precision given by |
38cbfe40 RK |
470 | PRECISION. UNSIGNEDP is nonzero if the type is unsigned; otherwise |
471 | it is a signed type. */ | |
c6823a20 | 472 | extern tree gnat_type_for_size (unsigned precision, int unsignedp); |
38cbfe40 RK |
473 | |
474 | /* Return a data type that has machine mode MODE. UNSIGNEDP selects | |
475 | an unsigned type; otherwise a signed type is returned. */ | |
c6823a20 | 476 | extern tree gnat_type_for_mode (enum machine_mode mode, int unsignedp); |
38cbfe40 | 477 | |
c8945d56 EB |
478 | /* Emit debug info for all global variable declarations. */ |
479 | extern void gnat_write_global_declarations (void); | |
480 | ||
38cbfe40 | 481 | /* Return the unsigned version of a TYPE_NODE, a scalar type. */ |
c6823a20 | 482 | extern tree gnat_unsigned_type (tree type_node); |
38cbfe40 RK |
483 | |
484 | /* Return the signed version of a TYPE_NODE, a scalar type. */ | |
c6823a20 | 485 | extern tree gnat_signed_type (tree type_node); |
38cbfe40 | 486 | |
ba3f46d0 EB |
487 | /* Return 1 if the types T1 and T2 are compatible, i.e. if they can be |
488 | transparently converted to each other. */ | |
489 | extern int gnat_types_compatible_p (tree t1, tree t2); | |
490 | ||
38cbfe40 RK |
491 | /* Create an expression whose value is that of EXPR, |
492 | converted to type TYPE. The TREE_TYPE of the value | |
493 | is always TYPE. This function implements all reasonable | |
494 | conversions; callers should filter out those that are | |
495 | not permitted by the language being compiled. */ | |
c6823a20 | 496 | extern tree convert (tree type, tree expr); |
38cbfe40 RK |
497 | |
498 | /* Routines created solely for the tree translator's sake. Their prototypes | |
499 | can be changed as desired. */ | |
500 | ||
501 | /* GNAT_ENTITY is a GNAT tree node for a defining identifier. | |
502 | GNU_DECL is the GCC tree which is to be associated with | |
503 | GNAT_ENTITY. Such gnu tree node is always an ..._DECL node. | |
fbf5a39b | 504 | If NO_CHECK is nonzero, the latter check is suppressed. |
38cbfe40 | 505 | If GNU_DECL is zero, a previous association is to be reset. */ |
c6823a20 EB |
506 | extern void save_gnu_tree (Entity_Id gnat_entity, tree gnu_decl, |
507 | bool no_check); | |
38cbfe40 RK |
508 | |
509 | /* GNAT_ENTITY is a GNAT tree node for a defining identifier. | |
510 | Return the ..._DECL node that was associated with it. If there is no tree | |
511 | node associated with GNAT_ENTITY, abort. */ | |
c6823a20 | 512 | extern tree get_gnu_tree (Entity_Id gnat_entity); |
38cbfe40 RK |
513 | |
514 | /* Return nonzero if a GCC tree has been associated with GNAT_ENTITY. */ | |
c6823a20 | 515 | extern bool present_gnu_tree (Entity_Id gnat_entity); |
38cbfe40 RK |
516 | |
517 | /* Initialize tables for above routines. */ | |
c2edc52b | 518 | extern void init_gnat_to_gnu (void); |
38cbfe40 | 519 | |
09ef48fe GD |
520 | /* Given a record type RECORD_TYPE and a chain of FIELD_DECL nodes FIELDLIST, |
521 | finish constructing the record or union type. If REP_LEVEL is zero, this | |
522 | record has no representation clause and so will be entirely laid out here. | |
523 | If REP_LEVEL is one, this record has a representation clause and has been | |
524 | laid out already; only set the sizes and alignment. If REP_LEVEL is two, | |
525 | this record is derived from a parent record and thus inherits its layout; | |
526 | only make a pass on the fields to finalize them. If DO_NOT_FINALIZE is | |
527 | true, the record type is expected to be modified afterwards so it will | |
528 | not be sent to the back-end for finalization. */ | |
c6823a20 | 529 | extern void finish_record_type (tree record_type, tree fieldlist, |
09ef48fe | 530 | int rep_level, bool do_not_finalize); |
c6823a20 | 531 | |
09ef48fe GD |
532 | /* Wrap up compilation of RECORD_TYPE, i.e. most notably output all |
533 | the debug information associated with it. It need not be invoked | |
534 | directly in most cases since finish_record_type takes care of doing | |
535 | so, unless explicitly requested not to through DO_NOT_FINALIZE. */ | |
536 | extern void rest_of_record_type_compilation (tree record_type); | |
38cbfe40 | 537 | |
081a52ed NS |
538 | /* Append PARALLEL_TYPE on the chain of parallel types for decl. */ |
539 | extern void add_parallel_type (tree decl, tree parallel_type); | |
540 | ||
541 | /* Return the parallel type associated to a type, if any. */ | |
542 | extern tree get_parallel_type (tree type); | |
543 | ||
38cbfe40 RK |
544 | /* Returns a FUNCTION_TYPE node. RETURN_TYPE is the type returned by the |
545 | subprogram. If it is void_type_node, then we are dealing with a procedure, | |
546 | otherwise we are dealing with a function. PARAM_DECL_LIST is a list of | |
547 | PARM_DECL nodes that are the subprogram arguments. CICO_LIST is the | |
fbf5a39b | 548 | copy-in/copy-out list to be stored into TYPE_CI_CO_LIST. |
615cbd95 AC |
549 | RETURNS_UNCONSTRAINED is true if the function returns an unconstrained |
550 | object. RETURNS_BY_REF is true if the function returns by reference. | |
9dd9bf80 EB |
551 | RETURNS_BY_TARGET_PTR is true if the function is to be passed (as its |
552 | first parameter) the address of the place to copy its result. */ | |
c6823a20 EB |
553 | extern tree create_subprog_type (tree return_type, tree param_decl_list, |
554 | tree cico_list, bool returns_unconstrained, | |
9dd9bf80 | 555 | bool returns_by_ref, |
c6823a20 | 556 | bool returns_by_target_ptr); |
38cbfe40 RK |
557 | |
558 | /* Return a copy of TYPE, but safe to modify in any way. */ | |
c6823a20 | 559 | extern tree copy_type (tree type); |
38cbfe40 RK |
560 | |
561 | /* Return an INTEGER_TYPE of SIZETYPE with range MIN to MAX and whose | |
09ef48fe GD |
562 | TYPE_INDEX_TYPE is INDEX. GNAT_NODE is used for the position of |
563 | the decl. */ | |
564 | extern tree create_index_type (tree min, tree max, tree index, | |
565 | Node_Id gnat_node); | |
38cbfe40 RK |
566 | |
567 | /* Return a TYPE_DECL node. TYPE_NAME gives the name of the type (a character | |
fbf5a39b | 568 | string) and TYPE is a ..._TYPE node giving its data type. |
615cbd95 AC |
569 | ARTIFICIAL_P is true if this is a declaration that was generated |
570 | by the compiler. DEBUG_INFO_P is true if we need to write debugging | |
909f21b3 RK |
571 | information about this type. GNAT_NODE is used for the position of |
572 | the decl. */ | |
c6823a20 EB |
573 | extern tree create_type_decl (tree type_name, tree type, |
574 | struct attrib *attr_list, | |
575 | bool artificial_p, bool debug_info_p, | |
576 | Node_Id gnat_node); | |
38cbfe40 | 577 | |
0cb5c2a7 | 578 | /* Return a VAR_DECL or CONST_DECL node. |
c8945d56 EB |
579 | |
580 | VAR_NAME gives the name of the variable. ASM_NAME is its assembler name | |
581 | (if provided). TYPE is its data type (a GCC ..._TYPE node). VAR_INIT is | |
582 | the GCC tree for an optional initial expression; NULL_TREE if none. | |
38cbfe40 | 583 | |
0cb5c2a7 EB |
584 | CONST_FLAG is true if this variable is constant, in which case we might |
585 | return a CONST_DECL node unless CONST_DECL_ALLOWED_P is false. | |
38cbfe40 | 586 | |
615cbd95 | 587 | PUBLIC_FLAG is true if this definition is to be made visible outside of |
38cbfe40 | 588 | the current compilation unit. This flag should be set when processing the |
0cb5c2a7 EB |
589 | variable definitions in a package specification. |
590 | ||
591 | EXTERN_FLAG is nonzero when processing an external variable declaration (as | |
592 | opposed to a definition: no storage is to be allocated for the variable). | |
615cbd95 | 593 | |
38cbfe40 | 594 | STATIC_FLAG is only relevant when not at top level. In that case |
909f21b3 RK |
595 | it indicates whether to always allocate storage to the variable. |
596 | ||
597 | GNAT_NODE is used for the position of the decl. */ | |
0cb5c2a7 EB |
598 | tree |
599 | create_var_decl_1 (tree var_name, tree asm_name, tree type, tree var_init, | |
600 | bool const_flag, bool public_flag, bool extern_flag, | |
601 | bool static_flag, bool const_decl_allowed_p, | |
602 | struct attrib *attr_list, Node_Id gnat_node); | |
603 | ||
604 | /* Wrapper around create_var_decl_1 for cases where we don't care whether | |
605 | a VAR or a CONST decl node is created. */ | |
606 | #define create_var_decl(var_name, asm_name, type, var_init, \ | |
607 | const_flag, public_flag, extern_flag, \ | |
608 | static_flag, attr_list, gnat_node) \ | |
609 | create_var_decl_1 (var_name, asm_name, type, var_init, \ | |
610 | const_flag, public_flag, extern_flag, \ | |
611 | static_flag, true, attr_list, gnat_node) | |
612 | ||
613 | /* Wrapper around create_var_decl_1 for cases where a VAR_DECL node is | |
614 | required. The primary intent is for DECL_CONST_CORRESPONDING_VARs, which | |
615 | must be VAR_DECLs and on which we want TREE_READONLY set to have them | |
616 | possibly assigned to a readonly data section. */ | |
617 | #define create_true_var_decl(var_name, asm_name, type, var_init, \ | |
618 | const_flag, public_flag, extern_flag, \ | |
619 | static_flag, attr_list, gnat_node) \ | |
620 | create_var_decl_1 (var_name, asm_name, type, var_init, \ | |
621 | const_flag, public_flag, extern_flag, \ | |
622 | static_flag, false, attr_list, gnat_node) | |
c8945d56 | 623 | |
38cbfe40 | 624 | /* Given a DECL and ATTR_LIST, apply the listed attributes. */ |
c6823a20 | 625 | extern void process_attributes (tree decl, struct attrib *attr_list); |
38cbfe40 | 626 | |
c8945d56 EB |
627 | /* Record a global renaming pointer. */ |
628 | void record_global_renaming_pointer (tree); | |
629 | ||
630 | /* Invalidate the global renaming pointers. */ | |
631 | void invalidate_global_renaming_pointers (void); | |
632 | ||
38cbfe40 RK |
633 | /* Returns a FIELD_DECL node. FIELD_NAME the field name, FIELD_TYPE is its |
634 | type, and RECORD_TYPE is the type of the parent. PACKED is nonzero if | |
635 | this field is in a record type with a "pragma pack". If SIZE is nonzero | |
636 | it is the specified size for this field. If POS is nonzero, it is the bit | |
637 | position. If ADDRESSABLE is nonzero, it means we are allowed to take | |
638 | the address of this field for aliasing purposes. */ | |
c6823a20 EB |
639 | extern tree create_field_decl (tree field_name, tree field_type, |
640 | tree record_type, int packed, tree size, | |
641 | tree pos, int addressable); | |
38cbfe40 RK |
642 | |
643 | /* Returns a PARM_DECL node. PARAM_NAME is the name of the parameter, | |
615cbd95 | 644 | PARAM_TYPE is its type. READONLY is true if the parameter is |
08ffbdad | 645 | readonly (either an In parameter or an address of a pass-by-ref |
38cbfe40 | 646 | parameter). */ |
c6823a20 EB |
647 | extern tree create_param_decl (tree param_name, tree param_type, |
648 | bool readonly); | |
38cbfe40 RK |
649 | |
650 | /* Returns a FUNCTION_DECL node. SUBPROG_NAME is the name of the subprogram, | |
651 | ASM_NAME is its assembler name, SUBPROG_TYPE is its type (a FUNCTION_TYPE | |
652 | node), PARAM_DECL_LIST is the list of the subprogram arguments (a list of | |
653 | PARM_DECL nodes chained through the TREE_CHAIN field). | |
654 | ||
909f21b3 | 655 | INLINE_FLAG, PUBLIC_FLAG, EXTERN_FLAG, and ATTR_LIST are used to set the |
615cbd95 | 656 | appropriate fields in the FUNCTION_DECL. GNAT_NODE gives the location. */ |
c6823a20 EB |
657 | extern tree create_subprog_decl (tree subprog_name, tree asm_name, |
658 | tree subprog_type, tree param_decl_list, | |
659 | bool inlinee_flag, bool public_flag, | |
660 | bool extern_flag, | |
661 | struct attrib *attr_list, Node_Id gnat_node); | |
38cbfe40 RK |
662 | |
663 | /* Returns a LABEL_DECL node for LABEL_NAME. */ | |
c6823a20 | 664 | extern tree create_label_decl (tree label_name); |
38cbfe40 RK |
665 | |
666 | /* Set up the framework for generating code for SUBPROG_DECL, a subprogram | |
667 | body. This routine needs to be invoked before processing the declarations | |
668 | appearing in the subprogram. */ | |
c6823a20 | 669 | extern void begin_subprog_body (tree subprog_decl); |
38cbfe40 | 670 | |
726a989a RB |
671 | /* Finish the definition of the current subprogram BODY and compile it all the |
672 | way to assembler language output. ELAB_P tells if this is called for an | |
673 | elaboration routine, to be entirely discarded if empty. */ | |
674 | extern void end_subprog_body (tree body, bool elab_p); | |
38cbfe40 RK |
675 | |
676 | /* Build a template of type TEMPLATE_TYPE from the array bounds of ARRAY_TYPE. | |
677 | EXPR is an expression that we can use to locate any PLACEHOLDER_EXPRs. | |
678 | Return a constructor for the template. */ | |
c6823a20 | 679 | extern tree build_template (tree template_type, tree array_type, tree expr); |
38cbfe40 RK |
680 | |
681 | /* Build a VMS descriptor from a Mechanism_Type, which must specify | |
682 | a descriptor type, and the GCC type of an object. Each FIELD_DECL | |
683 | in the type contains in its DECL_INITIAL the expression to use when | |
684 | a constructor is made for the type. GNAT_ENTITY is a gnat node used | |
685 | to print out an error message if the mechanism cannot be applied to | |
686 | an object of that type and also for the name. */ | |
c6823a20 EB |
687 | extern tree build_vms_descriptor (tree type, Mechanism_Type mech, |
688 | Entity_Id gnat_entity); | |
38cbfe40 | 689 | |
09ef48fe GD |
690 | /* Build a stub for the subprogram specified by the GCC tree GNU_SUBPROG |
691 | and the GNAT node GNAT_SUBPROG. */ | |
692 | extern void build_function_stub (tree gnu_subprog, Entity_Id gnat_subprog); | |
693 | ||
38cbfe40 RK |
694 | /* Build a type to be used to represent an aliased object whose nominal |
695 | type is an unconstrained array. This consists of a RECORD_TYPE containing | |
696 | a field of TEMPLATE_TYPE and a field of OBJECT_TYPE, which is an | |
697 | ARRAY_TYPE. If ARRAY_TYPE is that of the unconstrained array, this | |
698 | is used to represent an arbitrary unconstrained object. Use NAME | |
699 | as the name of the record. */ | |
c6823a20 EB |
700 | extern tree build_unc_object_type (tree template_type, tree object_type, |
701 | tree name); | |
38cbfe40 | 702 | |
5e61ef09 TQ |
703 | /* Same as build_unc_object_type, but taking a thin or fat pointer type |
704 | instead of the template type. */ | |
705 | extern tree build_unc_object_type_from_ptr (tree thin_fat_ptr_type, | |
706 | tree object_type, tree name); | |
707 | ||
09ef48fe GD |
708 | /* Shift the component offsets within an unconstrained object TYPE to make it |
709 | suitable for use as a designated type for thin pointers. */ | |
710 | extern void shift_unc_components_for_thin_pointers (tree type); | |
711 | ||
38cbfe40 RK |
712 | /* Update anything previously pointing to OLD_TYPE to point to NEW_TYPE. In |
713 | the normal case this is just two adjustments, but we have more to do | |
714 | if NEW is an UNCONSTRAINED_ARRAY_TYPE. */ | |
c6823a20 | 715 | extern void update_pointer_to (tree old_type, tree new_type); |
38cbfe40 RK |
716 | |
717 | /* EXP is an expression for the size of an object. If this size contains | |
718 | discriminant references, replace them with the maximum (if MAX_P) or | |
615cbd95 | 719 | minimum (if !MAX_P) possible value of the discriminant. */ |
c6823a20 | 720 | extern tree max_size (tree exp, bool max_p); |
38cbfe40 RK |
721 | |
722 | /* Remove all conversions that are done in EXP. This includes converting | |
07fc65c4 | 723 | from a padded type or to a left-justified modular type. If TRUE_ADDRESS |
615cbd95 | 724 | is true, always return the address of the containing object even if |
07fc65c4 | 725 | the address is not bit-aligned. */ |
c6823a20 | 726 | extern tree remove_conversions (tree exp, bool true_address); |
38cbfe40 RK |
727 | |
728 | /* If EXP's type is an UNCONSTRAINED_ARRAY_TYPE, return an expression that | |
729 | refers to the underlying array. If its type has TYPE_CONTAINS_TEMPLATE_P, | |
730 | likewise return an expression pointing to the underlying array. */ | |
c6823a20 | 731 | extern tree maybe_unconstrained_array (tree exp); |
38cbfe40 | 732 | |
45f7cb60 | 733 | /* Return an expression that does an unchecked conversion of EXPR to TYPE. |
615cbd95 | 734 | If NOTRUNC_P is true, truncation operations should be suppressed. */ |
c6823a20 | 735 | extern tree unchecked_convert (tree type, tree expr, bool notrunc_p); |
38cbfe40 | 736 | |
c8945d56 EB |
737 | /* Return the appropriate GCC tree code for the specified GNAT type, |
738 | the latter being a record type as predicated by Is_Record_Type. */ | |
739 | extern enum tree_code tree_code_for_record_type (Entity_Id); | |
740 | ||
fa89b6ec EB |
741 | /* Return true if GNU_TYPE is suitable as the type of a non-aliased |
742 | component of an aggregate type. */ | |
743 | extern bool type_for_nonaliased_component_p (tree); | |
744 | ||
38cbfe40 RK |
745 | /* Prepare expr to be an argument of a TRUTH_NOT_EXPR or other logical |
746 | operation. | |
747 | ||
748 | This preparation consists of taking the ordinary | |
c6823a20 EB |
749 | representation of an expression EXPR and producing a valid tree |
750 | boolean expression describing whether EXPR is nonzero. We could | |
38cbfe40 RK |
751 | simply always do build_binary_op (NE_EXPR, expr, integer_zero_node, 1), |
752 | but we optimize comparisons, &&, ||, and !. | |
753 | ||
754 | The resulting type should always be the same as the input type. | |
755 | This function is simpler than the corresponding C version since | |
756 | the only possible operands will be things of Boolean type. */ | |
c6823a20 | 757 | extern tree gnat_truthvalue_conversion (tree expr); |
38cbfe40 RK |
758 | |
759 | /* Return the base type of TYPE. */ | |
c6823a20 | 760 | extern tree get_base_type (tree type); |
38cbfe40 | 761 | |
38cbfe40 RK |
762 | /* EXP is a GCC tree representing an address. See if we can find how |
763 | strictly the object at that address is aligned. Return that alignment | |
764 | strictly the object at that address is aligned. Return that alignment | |
765 | in bits. If we don't know anything about the alignment, return 0. */ | |
c6823a20 | 766 | extern unsigned int known_alignment (tree exp); |
38cbfe40 | 767 | |
5b47742c RK |
768 | /* Return true if VALUE is a multiple of FACTOR. FACTOR must be a power |
769 | of 2. */ | |
770 | extern bool value_factor_p (tree value, HOST_WIDE_INT factor); | |
771 | ||
38cbfe40 RK |
772 | /* Make a binary operation of kind OP_CODE. RESULT_TYPE is the type |
773 | desired for the result. Usually the operation is to be performed | |
774 | in that type. For MODIFY_EXPR and ARRAY_REF, RESULT_TYPE may be 0 | |
775 | in which case the type to be used will be derived from the operands. */ | |
c6823a20 EB |
776 | extern tree build_binary_op (enum tree_code op_code, tree retult_type, |
777 | tree left_operand, tree right_operand); | |
38cbfe40 RK |
778 | |
779 | /* Similar, but make unary operation. */ | |
c6823a20 EB |
780 | extern tree build_unary_op (enum tree_code op_code, tree result_type, |
781 | tree operand); | |
38cbfe40 RK |
782 | |
783 | /* Similar, but for COND_EXPR. */ | |
c6823a20 EB |
784 | extern tree build_cond_expr (tree result_type, tree condition_operand, |
785 | tree true_operand, tree false_operand); | |
38cbfe40 | 786 | |
552725e3 EB |
787 | /* Similar, but for RETURN_EXPR. */ |
788 | extern tree build_return_expr (tree result_decl, tree ret_val); | |
789 | ||
38cbfe40 RK |
790 | /* Build a CALL_EXPR to call FUNDECL with one argument, ARG. Return |
791 | the CALL_EXPR. */ | |
c6823a20 | 792 | extern tree build_call_1_expr (tree fundecl, tree arg); |
38cbfe40 RK |
793 | |
794 | /* Build a CALL_EXPR to call FUNDECL with two argument, ARG1 & ARG2. Return | |
795 | the CALL_EXPR. */ | |
c6823a20 | 796 | extern tree build_call_2_expr (tree fundecl, tree arg1, tree arg2); |
38cbfe40 RK |
797 | |
798 | /* Likewise to call FUNDECL with no arguments. */ | |
c6823a20 | 799 | extern tree build_call_0_expr (tree fundecl); |
38cbfe40 | 800 | |
07fc65c4 | 801 | /* Call a function that raises an exception and pass the line number and file |
d1586072 OH |
802 | name, if requested. MSG says which exception function to call. |
803 | ||
804 | GNAT_NODE is the gnat node conveying the source location for which the | |
805 | error should be signaled, or Empty in which case the error is signaled on | |
09ef48fe GD |
806 | the current ref_file_name/input_line. |
807 | ||
808 | KIND says which kind of exception this is for | |
809 | (N_Raise_{Constraint,Storage,Program}_Error). */ | |
810 | extern tree build_call_raise (int msg, Node_Id gnat_node, char kind); | |
38cbfe40 | 811 | |
dcf92453 ZW |
812 | /* Return a CONSTRUCTOR of TYPE whose list is LIST. This is not the |
813 | same as build_constructor in the language-independent tree.c. */ | |
c6823a20 | 814 | extern tree gnat_build_constructor (tree type, tree list); |
38cbfe40 RK |
815 | |
816 | /* Return a COMPONENT_REF to access a field that is given by COMPONENT, | |
817 | an IDENTIFIER_NODE giving the name of the field, FIELD, a FIELD_DECL, | |
657a9dd9 | 818 | for the field, or both. Don't fold the result if NO_FOLD_P. */ |
c6823a20 EB |
819 | extern tree build_component_ref (tree record_variable, tree component, |
820 | tree field, bool no_fold_p); | |
38cbfe40 RK |
821 | |
822 | /* Build a GCC tree to call an allocation or deallocation function. | |
823 | If GNU_OBJ is nonzero, it is an object to deallocate. Otherwise, | |
dec55d76 | 824 | generate an allocator. |
38cbfe40 RK |
825 | |
826 | GNU_SIZE is the size of the object and ALIGN is the alignment. | |
827 | GNAT_PROC, if present is a procedure to call and GNAT_POOL is the | |
828 | storage pool to use. If not preset, malloc and free will be used. */ | |
c6823a20 EB |
829 | extern tree build_call_alloc_dealloc (tree gnu_obj, tree gnu_size, |
830 | unsigned align, Entity_Id gnat_proc, | |
831 | Entity_Id gnat_pool, Node_Id gnat_node); | |
38cbfe40 RK |
832 | |
833 | /* Build a GCC tree to correspond to allocating an object of TYPE whose | |
834 | initial value if INIT, if INIT is nonzero. Convert the expression to | |
fbf5a39b | 835 | RESULT_TYPE, which must be some type of pointer. Return the tree. |
38cbfe40 | 836 | GNAT_PROC and GNAT_POOL optionally give the procedure to call and |
fbf5a39b | 837 | the storage pool to use. GNAT_NODE is used to provide an error |
ea6ac859 EB |
838 | location for restriction violations messages. If IGNORE_INIT_TYPE is |
839 | true, ignore the type of INIT for the purpose of determining the size; | |
840 | this will cause the maximum size to be allocated if TYPE is of | |
841 | self-referential size. */ | |
c6823a20 EB |
842 | extern tree build_allocator (tree type, tree init, tree result_type, |
843 | Entity_Id gnat_proc, Entity_Id gnat_pool, | |
ea6ac859 | 844 | Node_Id gnat_node, bool); |
38cbfe40 | 845 | |
fbf5a39b | 846 | /* Fill in a VMS descriptor for EXPR and return a constructor for it. |
38cbfe40 RK |
847 | GNAT_FORMAL is how we find the descriptor record. */ |
848 | ||
c6823a20 | 849 | extern tree fill_vms_descriptor (tree expr, Entity_Id gnat_formal); |
38cbfe40 RK |
850 | |
851 | /* Indicate that we need to make the address of EXPR_NODE and it therefore | |
dffd7eb6 | 852 | should not be allocated in a register. Return true if successful. */ |
c6823a20 | 853 | extern bool gnat_mark_addressable (tree expr_node); |
38cbfe40 | 854 | |
6e34d3a3 | 855 | /* Implementation of the builtin_function langhook. */ |
c79efc4d | 856 | extern tree gnat_builtin_function (tree decl); |
6e34d3a3 | 857 | |
c5e12904 AC |
858 | /* Search the chain of currently reachable declarations for a builtin |
859 | FUNCTION_DECL node corresponding to function NAME (an IDENTIFIER_NODE). | |
860 | Return the first node found, if any, or NULL_TREE otherwise. */ | |
c654b659 | 861 | extern tree builtin_decl_for (tree name); |
c5e12904 | 862 | |
12e0c41c AC |
863 | /* This function is called by the front end to enumerate all the supported |
864 | modes for the machine. We pass a function which is called back with | |
865 | the following integer parameters: | |
866 | ||
867 | FLOAT_P nonzero if this represents a floating-point mode | |
868 | COMPLEX_P nonzero is this represents a complex mode | |
869 | COUNT count of number of items, nonzero for vector mode | |
870 | PRECISION number of bits in data representation | |
871 | MANTISSA number of bits in mantissa, if FP and known, else zero. | |
872 | SIZE number of bits used to store data | |
873 | ALIGN number of bits to which mode is aligned. */ | |
874 | extern void enumerate_modes (void (*f) (int, int, int, int, int, int, | |
875 | unsigned int)); | |
876 | ||
877 | /* These are temporary function to deal with recent GCC changes related to | |
878 | FP type sizes and precisions. */ | |
c6823a20 EB |
879 | extern int fp_prec_to_size (int prec); |
880 | extern int fp_size_to_prec (int size); | |
12e0c41c | 881 | |
38cbfe40 RK |
882 | /* These functions return the basic data type sizes and related parameters |
883 | about the target machine. */ | |
884 | ||
c2edc52b KC |
885 | extern Pos get_target_bits_per_unit (void); |
886 | extern Pos get_target_bits_per_word (void); | |
887 | extern Pos get_target_char_size (void); | |
888 | extern Pos get_target_wchar_t_size (void); | |
889 | extern Pos get_target_short_size (void); | |
890 | extern Pos get_target_int_size (void); | |
891 | extern Pos get_target_long_size (void); | |
892 | extern Pos get_target_long_long_size (void); | |
893 | extern Pos get_target_float_size (void); | |
894 | extern Pos get_target_double_size (void); | |
895 | extern Pos get_target_long_double_size (void); | |
896 | extern Pos get_target_pointer_size (void); | |
897 | extern Pos get_target_maximum_alignment (void); | |
3355aa3e OH |
898 | extern Pos get_target_default_allocator_alignment (void); |
899 | extern Pos get_target_maximum_default_alignment (void); | |
900 | extern Pos get_target_maximum_allowed_alignment (void); | |
c2edc52b KC |
901 | extern Nat get_float_words_be (void); |
902 | extern Nat get_words_be (void); | |
903 | extern Nat get_bytes_be (void); | |
904 | extern Nat get_bits_be (void); | |
905 | extern Nat get_strict_alignment (void); |