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