1 /****************************************************************************
3 * GNAT COMPILER COMPONENTS *
9 * Copyright (C) 1992-2004 Free Software Foundation, Inc. *
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 *
19 * to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, *
20 * MA 02111-1307, USA. *
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. *
28 * GNAT was originally developed by the GNAT team at New York University. *
29 * Extensive contributions were provided by Ada Core Technologies Inc. *
31 ****************************************************************************/
33 /* The largest alignment, in bits, that is needed for using the widest
35 extern unsigned int largest_move_alignment;
37 /* Declare all functions and types used by gigi. */
39 /* Compute the alignment of the largest mode that can be used for copying
41 extern void gnat_compute_largest_alignment (void);
43 /* Routine called by gcc for emitting a stack check. GNU_EXPR is the
44 expression that contains the last address on the stack to check. */
45 extern tree emit_stack_check (tree);
47 /* GNU_TYPE is a type. Determine if it should be passed by reference by
49 extern bool default_pass_by_ref (tree);
51 /* GNU_TYPE is the type of a subprogram parameter. Determine from the type
52 if it should be passed by reference. */
53 extern bool must_pass_by_ref (tree);
55 /* Elaboration routines for the front end. */
56 extern void elab_all_gnat (void);
58 /* Initialize DUMMY_NODE_TABLE. */
59 extern void init_dummy_type (void);
61 /* Given GNAT_ENTITY, a GNAT defining identifier node, which denotes some Ada
62 entity, this routine returns the equivalent GCC tree for that entity
63 (an ..._DECL node) and associates the ..._DECL node with the input GNAT
66 If GNAT_ENTITY is a variable or a constant declaration, GNU_EXPR gives its
67 initial value (in GCC tree form). This is optional for variables.
68 For renamed entities, GNU_EXPR gives the object being renamed.
70 DEFINITION is nonzero if this call is intended for a definition. This is
71 used for separate compilation where it necessary to know whether an
72 external declaration or a definition should be created if the GCC equivalent
73 was not created previously. The value of 1 is normally used for a non-zero
74 DEFINITION, but a value of 2 is used in special circumstances, defined in
76 extern tree gnat_to_gnu_entity (Entity_Id, tree, int);
78 /* Given GNAT_ENTITY, an entity in the incoming GNAT tree, return a
79 GCC type corresponding to that entity. GNAT_ENTITY is assumed to
80 refer to an Ada type. */
81 extern tree gnat_to_gnu_type (Entity_Id);
83 /* Add GNU_STMT to the current BLOCK_STMT node. */
84 extern void add_stmt (tree);
86 /* Similar, but set the location of GNU_STMT to that of GNAT_NODE. */
87 extern void add_stmt_with_node (tree, Node_Id);
89 /* Set the BLOCK node corresponding to the current code group to GNU_BLOCK. */
90 extern void set_block_for_group (tree);
92 /* Add a declaration statement for GNU_DECL to the current BLOCK_STMT node.
93 Get SLOC from Entity_Id. */
94 extern void add_decl_expr (tree, Entity_Id);
96 /* Given GNAT_ENTITY, elaborate all expressions that are required to
97 be elaborated at the point of its definition, but do nothing else. */
98 extern void elaborate_entity (Entity_Id);
100 /* Mark GNAT_ENTITY as going out of scope at this point. Recursively mark
101 any entities on its entity chain similarly. */
102 extern void mark_out_of_scope (Entity_Id);
104 /* Make a dummy type corresponding to GNAT_TYPE. */
105 extern tree make_dummy_type (Entity_Id);
107 /* Get the unpadded version of a GNAT type. */
108 extern tree get_unpadded_type (Entity_Id);
110 /* Called when we need to protect a variable object using a save_expr. */
111 extern tree maybe_variable (tree);
113 /* Create a record type that contains a field of TYPE with a starting bit
114 position so that it is aligned to ALIGN bits and is SIZE bytes long. */
115 extern tree make_aligning_type (tree, int, tree);
117 /* Given a GNU tree and a GNAT list of choices, generate an expression to test
118 the value passed against the list of choices. */
119 extern tree choices_to_gnu (tree, Node_Id);
121 /* Given a type T, a FIELD_DECL F, and a replacement value R,
122 return a new type with all size expressions that contain F
123 updated by replacing F with R. This is identical to GCC's
124 substitute_in_type except that it knows about TYPE_INDEX_TYPE. */
125 extern tree gnat_substitute_in_type (tree, tree, tree);
127 /* Return the "RM size" of GNU_TYPE. This is the actual number of bits
128 needed to represent the object. */
129 extern tree rm_size (tree);
131 /* Given GNU_ID, an IDENTIFIER_NODE containing a name and SUFFIX, a
132 string, return a new IDENTIFIER_NODE that is the concatenation of
133 the name in GNU_ID and SUFFIX. */
134 extern tree concat_id_with_name (tree, const char *);
136 /* Return the name to be used for GNAT_ENTITY. If a type, create a
137 fully-qualified name, possibly with type information encoding.
138 Otherwise, return the name. */
139 extern tree get_entity_name (Entity_Id);
141 /* Return a name for GNAT_ENTITY concatenated with two underscores and
143 extern tree create_concat_name (Entity_Id, const char *);
145 /* If true, then gigi is being called on an analyzed but unexpanded tree, and
146 the only purpose of the call is to properly annotate types with
147 representation information. */
148 extern bool type_annotate_only;
150 /* Current file name without path */
151 extern const char *ref_filename;
153 /* This is the main program of the back-end. It sets up all the table
154 structures and then generates code. */
156 extern void gigi (Node_Id, int, int, struct Node *, Node_Id *, Node_Id *,
157 struct Elist_Header *, struct Elmt_Item *,
158 struct String_Entry *, Char_Code *, struct List_Header *,
159 Int, char *, Entity_Id, Entity_Id, Entity_Id, Int);
161 /* GNAT_NODE is the root of some GNAT tree. Return the root of the
162 GCC tree corresponding to that GNAT tree. Normally, no code is generated;
163 we just return an equivalent tree which is used elsewhere to generate
165 extern tree gnat_to_gnu (Node_Id);
167 /* GNU_STMT is a statement. We generate code for that statement. */
168 extern void gnat_expand_stmt (tree);
170 extern int gnat_gimplify_expr (tree *, tree *, tree *);
172 /* Do the processing for the declaration of a GNAT_ENTITY, a type. If
173 a separate Freeze node exists, delay the bulk of the processing. Otherwise
174 make a GCC type for GNAT_ENTITY and set up the correspondance. */
176 extern void process_type (Entity_Id);
178 /* Convert Sloc into *LOCUS (a location_t). Return true if this Sloc
179 corresponds to a source code location and false if it doesn't. In the
180 latter case, we don't update *LOCUS. We also set the Gigi global variable
181 REF_FILENAME to the reference file name as given by sinput (i.e no
183 extern bool Sloc_to_locus (Source_Ptr, location_t *);
185 /* Post an error message. MSG is the error message, properly annotated.
186 NODE is the node at which to post the error and the node to use for the
188 extern void post_error (const char *, Node_Id);
190 /* Similar, but NODE is the node at which to post the error and ENT
191 is the node to use for the "&" substitution. */
192 extern void post_error_ne (const char *, Node_Id, Entity_Id);
194 /* Similar, but NODE is the node at which to post the error, ENT is the node
195 to use for the "&" substitution, and N is the number to use for the ^. */
196 extern void post_error_ne_num (const char *, Node_Id, Entity_Id, int);
198 /* Similar to post_error_ne_num, but T is a GCC tree representing the number
199 to write. If the tree represents a constant that fits within a
200 host integer, the text inside curly brackets in MSG will be output
201 (presumably including a '^'). Otherwise that text will not be output
202 and the text inside square brackets will be output instead. */
203 extern void post_error_ne_tree (const char *, Node_Id, Entity_Id, tree);
205 /* Similar to post_error_ne_tree, except that NUM is a second
206 integer to write in the message. */
207 extern void post_error_ne_tree_2 (const char *, Node_Id, Entity_Id, tree, int);
209 /* Set the node for a second '&' in the error message. */
210 extern void set_second_error_entity (Entity_Id);
212 /* Protect EXP from multiple evaluation. This may make a SAVE_EXPR. */
213 extern tree protect_multiple_eval (tree);
215 /* Initialize the table that maps GNAT codes to GCC codes for simple
216 binary and unary operations. */
217 extern void init_code_table (void);
219 /* Current node being treated, in case gigi_abort or Check_Elaboration_Code
221 extern Node_Id error_gnat_node;
223 /* This is equivalent to stabilize_reference in GCC's tree.c, but we know
224 how to handle our new nodes and we take an extra argument that says
225 whether to force evaluation of everything. */
226 extern tree gnat_stabilize_reference (tree, bool);
228 /* Highest number in the front-end node table. */
229 extern int max_gnat_nodes;
231 /* If nonzero, pretend we are allocating at global level. */
232 extern int force_global;
234 /* Standard data type sizes. Most of these are not used. */
236 #ifndef CHAR_TYPE_SIZE
237 #define CHAR_TYPE_SIZE BITS_PER_UNIT
240 #ifndef SHORT_TYPE_SIZE
241 #define SHORT_TYPE_SIZE (BITS_PER_UNIT * MIN ((UNITS_PER_WORD + 1) / 2, 2))
244 #ifndef INT_TYPE_SIZE
245 #define INT_TYPE_SIZE BITS_PER_WORD
248 #ifndef LONG_TYPE_SIZE
249 #define LONG_TYPE_SIZE BITS_PER_WORD
252 #ifndef LONG_LONG_TYPE_SIZE
253 #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2)
256 #ifndef FLOAT_TYPE_SIZE
257 #define FLOAT_TYPE_SIZE BITS_PER_WORD
260 #ifndef DOUBLE_TYPE_SIZE
261 #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
264 #ifndef LONG_DOUBLE_TYPE_SIZE
265 #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
268 /* The choice of SIZE_TYPE here is very problematic. We need a signed
269 type whose bit width is Pmode. Assume "long" is such a type here. */
271 #define SIZE_TYPE "long int"
274 /* Data structures used to represent attributes. */
276 enum attr_type {ATTR_MACHINE_ATTRIBUTE, ATTR_LINK_ALIAS,
277 ATTR_LINK_SECTION, ATTR_WEAK_EXTERNAL};
288 /* Define the entries in the standard data array. */
289 enum standard_datatypes
291 /* Various standard data types and nodes. */
292 ADT_longest_float_type,
295 /* The type of an exception. */
298 /* Type declaration node <==> typedef void *T */
301 /* Function type declaration -- void T() */
304 /* Type declaration node <==> typedef void *T() */
307 /* A function declaration node for a run-time function for allocating memory.
308 Ada allocators cause calls to this function to be generated. */
311 /* Likewise for freeing memory. */
314 /* Types and decls used by our temporary exception mechanism. See
315 init_gigi_decls for details. */
323 ADT_update_setjmp_buf_decl,
324 ADT_raise_nodefer_decl,
325 ADT_begin_handler_decl,
326 ADT_end_handler_decl,
329 extern GTY(()) tree gnat_std_decls[(int) ADT_LAST];
330 extern GTY(()) tree gnat_raise_decls[(int) LAST_REASON_CODE + 1];
332 #define longest_float_type_node gnat_std_decls[(int) ADT_longest_float_type]
333 #define void_type_decl_node gnat_std_decls[(int) ADT_void_type_decl]
334 #define except_type_node gnat_std_decls[(int) ADT_except_type]
335 #define ptr_void_type_node gnat_std_decls[(int) ADT_ptr_void_type]
336 #define void_ftype gnat_std_decls[(int) ADT_void_ftype]
337 #define ptr_void_ftype gnat_std_decls[(int) ADT_ptr_void_ftype]
338 #define malloc_decl gnat_std_decls[(int) ADT_malloc_decl]
339 #define free_decl gnat_std_decls[(int) ADT_free_decl]
340 #define jmpbuf_type gnat_std_decls[(int) ADT_jmpbuf_type]
341 #define jmpbuf_ptr_type gnat_std_decls[(int) ADT_jmpbuf_ptr_type]
342 #define get_jmpbuf_decl gnat_std_decls[(int) ADT_get_jmpbuf_decl]
343 #define set_jmpbuf_decl gnat_std_decls[(int) ADT_set_jmpbuf_decl]
344 #define get_excptr_decl gnat_std_decls[(int) ADT_get_excptr_decl]
345 #define setjmp_decl gnat_std_decls[(int) ADT_setjmp_decl]
346 #define longjmp_decl gnat_std_decls[(int) ADT_longjmp_decl]
347 #define update_setjmp_buf_decl gnat_std_decls[(int) ADT_update_setjmp_buf_decl]
348 #define raise_nodefer_decl gnat_std_decls[(int) ADT_raise_nodefer_decl]
349 #define begin_handler_decl gnat_std_decls[(int) ADT_begin_handler_decl]
350 #define end_handler_decl gnat_std_decls[(int) ADT_end_handler_decl]
352 /* Routines expected by the gcc back-end. They must have exactly the same
353 prototype and names as below. */
355 /* Returns non-zero if we are currently in the global binding level */
356 extern int global_bindings_p (void);
358 /* Enter and exit a new binding level. */
359 extern void gnat_pushlevel (void);
360 extern void gnat_poplevel (void);
362 /* Set SUPERCONTEXT of the BLOCK for the current binding level to FNDECL
363 and point FNDECL to this BLOCK. */
364 extern void set_current_block_context (tree);
366 /* Set the jmpbuf_decl for the current binding level to DECL. */
367 extern void set_block_jmpbuf_decl (tree);
369 /* Get the setjmp_decl, if any, for the current binding level. */
370 extern tree get_block_jmpbuf_decl (void);
372 /* Insert BLOCK at the end of the list of subblocks of the
373 current binding level. This is used when a BIND_EXPR is expanded,
374 to handle the BLOCK node inside the BIND_EXPR. */
375 extern void insert_block (tree);
377 /* Records a ..._DECL node DECL as belonging to the current lexical scope
378 and uses GNAT_ENTITY for location information. */
379 extern void gnat_pushdecl (tree, Entity_Id);
381 extern void gnat_init_stmt_group (void);
382 extern void gnat_init_decl_processing (void);
383 extern void init_gigi_decls (tree, tree);
384 extern void gnat_init_gcc_eh (void);
386 /* Return an integer type with the number of bits of precision given by
387 PRECISION. UNSIGNEDP is nonzero if the type is unsigned; otherwise
388 it is a signed type. */
389 extern tree gnat_type_for_size (unsigned, int);
391 /* Return a data type that has machine mode MODE. UNSIGNEDP selects
392 an unsigned type; otherwise a signed type is returned. */
393 extern tree gnat_type_for_mode (enum machine_mode, int);
395 /* Return the unsigned version of a TYPE_NODE, a scalar type. */
396 extern tree gnat_unsigned_type (tree);
398 /* Return the signed version of a TYPE_NODE, a scalar type. */
399 extern tree gnat_signed_type (tree);
401 /* Return a type the same as TYPE except unsigned or signed according to
403 extern tree gnat_signed_or_unsigned_type (int, tree);
405 /* Create an expression whose value is that of EXPR,
406 converted to type TYPE. The TREE_TYPE of the value
407 is always TYPE. This function implements all reasonable
408 conversions; callers should filter out those that are
409 not permitted by the language being compiled. */
410 extern tree convert (tree, tree);
412 /* Routines created solely for the tree translator's sake. Their prototypes
413 can be changed as desired. */
415 /* GNAT_ENTITY is a GNAT tree node for a defining identifier.
416 GNU_DECL is the GCC tree which is to be associated with
417 GNAT_ENTITY. Such gnu tree node is always an ..._DECL node.
418 If NO_CHECK is nonzero, the latter check is suppressed.
419 If GNU_DECL is zero, a previous association is to be reset. */
420 extern void save_gnu_tree (Entity_Id, tree, bool);
422 /* GNAT_ENTITY is a GNAT tree node for a defining identifier.
423 Return the ..._DECL node that was associated with it. If there is no tree
424 node associated with GNAT_ENTITY, abort. */
425 extern tree get_gnu_tree (Entity_Id);
427 /* Return nonzero if a GCC tree has been associated with GNAT_ENTITY. */
428 extern bool present_gnu_tree (Entity_Id);
430 /* Initialize tables for above routines. */
431 extern void init_gnat_to_gnu (void);
433 /* Given a record type (RECORD_TYPE) and a chain of FIELD_DECL
434 nodes (FIELDLIST), finish constructing the record or union type.
435 If HAS_REP is true, this record has a rep clause; don't call
436 layout_type but merely set the size and alignment ourselves.
437 If DEFER_DEBUG is true, do not call the debugging routines
438 on this type; it will be done later. */
439 extern void finish_record_type (tree, tree, bool, bool);
441 /* Returns a FUNCTION_TYPE node. RETURN_TYPE is the type returned by the
442 subprogram. If it is void_type_node, then we are dealing with a procedure,
443 otherwise we are dealing with a function. PARAM_DECL_LIST is a list of
444 PARM_DECL nodes that are the subprogram arguments. CICO_LIST is the
445 copy-in/copy-out list to be stored into TYPE_CI_CO_LIST.
446 RETURNS_UNCONSTRAINED is true if the function returns an unconstrained
447 object. RETURNS_BY_REF is true if the function returns by reference.
448 RETURNS_WITH_DSP is true if the function is to return with a
449 depressed stack pointer. */
450 extern tree create_subprog_type (tree, tree, tree, bool, bool, bool);
452 /* Return a copy of TYPE, but safe to modify in any way. */
453 extern tree copy_type (tree);
455 /* Return an INTEGER_TYPE of SIZETYPE with range MIN to MAX and whose
456 TYPE_INDEX_TYPE is INDEX. */
457 extern tree create_index_type (tree, tree, tree);
459 /* Return a TYPE_DECL node. TYPE_NAME gives the name of the type (a character
460 string) and TYPE is a ..._TYPE node giving its data type.
461 ARTIFICIAL_P is true if this is a declaration that was generated
462 by the compiler. DEBUG_INFO_P is true if we need to write debugging
463 information about this type. GNAT_NODE is used for the position of
465 extern tree create_type_decl (tree, tree, struct attrib *, bool, bool,
468 /* Returns a GCC VAR_DECL node. VAR_NAME gives the name of the variable.
469 ASM_NAME is its assembler name (if provided). TYPE is
470 its data type (a GCC ..._TYPE node). VAR_INIT is the GCC tree for an
471 optional initial expression; NULL_TREE if none.
473 CONST_FLAG is true if this variable is constant.
475 PUBLIC_FLAG is true if this definition is to be made visible outside of
476 the current compilation unit. This flag should be set when processing the
477 variable definitions in a package specification. EXTERN_FLAG is nonzero
478 when processing an external variable declaration (as opposed to a
479 definition: no storage is to be allocated for the variable here).
481 STATIC_FLAG is only relevant when not at top level. In that case
482 it indicates whether to always allocate storage to the variable.
484 GNAT_NODE is used for the position of the decl. */
485 extern tree create_var_decl (tree, tree, tree, tree, bool, bool, bool, bool,
486 struct attrib *, Node_Id);
488 /* Given a DECL and ATTR_LIST, apply the listed attributes. */
489 extern void process_attributes (tree, struct attrib *);
491 /* Returns a FIELD_DECL node. FIELD_NAME the field name, FIELD_TYPE is its
492 type, and RECORD_TYPE is the type of the parent. PACKED is nonzero if
493 this field is in a record type with a "pragma pack". If SIZE is nonzero
494 it is the specified size for this field. If POS is nonzero, it is the bit
495 position. If ADDRESSABLE is nonzero, it means we are allowed to take
496 the address of this field for aliasing purposes. */
497 extern tree create_field_decl (tree, tree, tree, int, tree, tree, int);
499 /* Returns a PARM_DECL node. PARAM_NAME is the name of the parameter,
500 PARAM_TYPE is its type. READONLY is true if the parameter is
501 readonly (either an IN parameter or an address of a pass-by-ref
503 extern tree create_param_decl (tree, tree, bool);
505 /* Returns a FUNCTION_DECL node. SUBPROG_NAME is the name of the subprogram,
506 ASM_NAME is its assembler name, SUBPROG_TYPE is its type (a FUNCTION_TYPE
507 node), PARAM_DECL_LIST is the list of the subprogram arguments (a list of
508 PARM_DECL nodes chained through the TREE_CHAIN field).
510 INLINE_FLAG, PUBLIC_FLAG, EXTERN_FLAG, and ATTR_LIST are used to set the
511 appropriate fields in the FUNCTION_DECL. GNAT_NODE gives the location. */
512 extern tree create_subprog_decl (tree, tree, tree, tree, bool, bool, bool,
513 struct attrib *, Node_Id);
515 /* Returns a LABEL_DECL node for LABEL_NAME. */
516 extern tree create_label_decl (tree);
518 /* Set up the framework for generating code for SUBPROG_DECL, a subprogram
519 body. This routine needs to be invoked before processing the declarations
520 appearing in the subprogram. */
521 extern void begin_subprog_body (tree);
523 /* Finish the definition of the current subprogram and compile it all the way
524 to assembler language output. BODY is the tree corresponding to
526 extern void end_subprog_body (tree);
528 /* Build a template of type TEMPLATE_TYPE from the array bounds of ARRAY_TYPE.
529 EXPR is an expression that we can use to locate any PLACEHOLDER_EXPRs.
530 Return a constructor for the template. */
531 extern tree build_template (tree, tree, tree);
533 /* Build a VMS descriptor from a Mechanism_Type, which must specify
534 a descriptor type, and the GCC type of an object. Each FIELD_DECL
535 in the type contains in its DECL_INITIAL the expression to use when
536 a constructor is made for the type. GNAT_ENTITY is a gnat node used
537 to print out an error message if the mechanism cannot be applied to
538 an object of that type and also for the name. */
540 extern tree build_vms_descriptor (tree, Mechanism_Type, Entity_Id);
542 /* Build a type to be used to represent an aliased object whose nominal
543 type is an unconstrained array. This consists of a RECORD_TYPE containing
544 a field of TEMPLATE_TYPE and a field of OBJECT_TYPE, which is an
545 ARRAY_TYPE. If ARRAY_TYPE is that of the unconstrained array, this
546 is used to represent an arbitrary unconstrained object. Use NAME
547 as the name of the record. */
548 extern tree build_unc_object_type (tree, tree, tree);
550 /* Update anything previously pointing to OLD_TYPE to point to NEW_TYPE. In
551 the normal case this is just two adjustments, but we have more to do
552 if NEW is an UNCONSTRAINED_ARRAY_TYPE. */
553 extern void update_pointer_to (tree, tree);
555 /* EXP is an expression for the size of an object. If this size contains
556 discriminant references, replace them with the maximum (if MAX_P) or
557 minimum (if !MAX_P) possible value of the discriminant. */
558 extern tree max_size (tree, bool);
560 /* Remove all conversions that are done in EXP. This includes converting
561 from a padded type or to a left-justified modular type. If TRUE_ADDRESS
562 is true, always return the address of the containing object even if
563 the address is not bit-aligned. */
564 extern tree remove_conversions (tree, bool);
566 /* If EXP's type is an UNCONSTRAINED_ARRAY_TYPE, return an expression that
567 refers to the underlying array. If its type has TYPE_CONTAINS_TEMPLATE_P,
568 likewise return an expression pointing to the underlying array. */
569 extern tree maybe_unconstrained_array (tree);
571 /* Return an expression that does an unchecked converstion of EXPR to TYPE.
572 If NOTRUNC_P is true, truncation operations should be suppressed. */
573 extern tree unchecked_convert (tree, tree, bool);
575 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR or other logical
578 This preparation consists of taking the ordinary
579 representation of an expression expr and producing a valid tree
580 boolean expression describing whether expr is nonzero. We could
581 simply always do build_binary_op (NE_EXPR, expr, integer_zero_node, 1),
582 but we optimize comparisons, &&, ||, and !.
584 The resulting type should always be the same as the input type.
585 This function is simpler than the corresponding C version since
586 the only possible operands will be things of Boolean type. */
587 extern tree gnat_truthvalue_conversion (tree);
589 /* Return the base type of TYPE. */
590 extern tree get_base_type (tree);
592 /* Likewise, but only return types known at Ada source. */
593 extern tree get_ada_base_type (tree);
595 /* EXP is a GCC tree representing an address. See if we can find how
596 strictly the object at that address is aligned. Return that alignment
597 strictly the object at that address is aligned. Return that alignment
598 in bits. If we don't know anything about the alignment, return 0. */
599 extern unsigned int known_alignment (tree);
601 /* Make a binary operation of kind OP_CODE. RESULT_TYPE is the type
602 desired for the result. Usually the operation is to be performed
603 in that type. For MODIFY_EXPR and ARRAY_REF, RESULT_TYPE may be 0
604 in which case the type to be used will be derived from the operands. */
605 extern tree build_binary_op (enum tree_code, tree, tree, tree);
607 /* Similar, but make unary operation. */
608 extern tree build_unary_op (enum tree_code, tree, tree);
610 /* Similar, but for COND_EXPR. */
611 extern tree build_cond_expr (tree, tree, tree, tree);
613 /* Build a CALL_EXPR to call FUNDECL with one argument, ARG. Return
615 extern tree build_call_1_expr (tree, tree);
617 /* Build a CALL_EXPR to call FUNDECL with two argument, ARG1 & ARG2. Return
619 extern tree build_call_2_expr (tree, tree, tree);
621 /* Likewise to call FUNDECL with no arguments. */
622 extern tree build_call_0_expr (tree);
624 /* Call a function that raises an exception and pass the line number and file
625 name, if requested. MSG says which exception function to call. */
626 extern tree build_call_raise (int);
628 /* Return a CONSTRUCTOR of TYPE whose list is LIST. This is not the
629 same as build_constructor in the language-independent tree.c. */
630 extern tree gnat_build_constructor (tree, tree);
632 /* Return a COMPONENT_REF to access a field that is given by COMPONENT,
633 an IDENTIFIER_NODE giving the name of the field, FIELD, a FIELD_DECL,
634 for the field, or both. Don't fold the result if NO_FOLD_P. */
635 extern tree build_component_ref (tree, tree, tree, bool);
637 /* Build a GCC tree to call an allocation or deallocation function.
638 If GNU_OBJ is nonzero, it is an object to deallocate. Otherwise,
639 genrate an allocator.
641 GNU_SIZE is the size of the object and ALIGN is the alignment.
642 GNAT_PROC, if present is a procedure to call and GNAT_POOL is the
643 storage pool to use. If not preset, malloc and free will be used. */
644 extern tree build_call_alloc_dealloc (tree, tree, unsigned int, Entity_Id,
647 /* Build a GCC tree to correspond to allocating an object of TYPE whose
648 initial value if INIT, if INIT is nonzero. Convert the expression to
649 RESULT_TYPE, which must be some type of pointer. Return the tree.
650 GNAT_PROC and GNAT_POOL optionally give the procedure to call and
651 the storage pool to use. GNAT_NODE is used to provide an error
652 location for restriction violations messages. */
653 extern tree build_allocator (tree, tree, tree, Entity_Id, Entity_Id, Node_Id);
655 /* Fill in a VMS descriptor for EXPR and return a constructor for it.
656 GNAT_FORMAL is how we find the descriptor record. */
658 extern tree fill_vms_descriptor (tree, Entity_Id);
660 /* Indicate that we need to make the address of EXPR_NODE and it therefore
661 should not be allocated in a register. Return true if successful. */
662 extern bool gnat_mark_addressable (tree);
664 /* Implementation of the builtin_function langhook. */
665 extern tree builtin_function (const char *, tree, int, enum built_in_class,
668 /* This function is called by the front end to enumerate all the supported
669 modes for the machine. We pass a function which is called back with
670 the following integer parameters:
672 FLOAT_P nonzero if this represents a floating-point mode
673 COMPLEX_P nonzero is this represents a complex mode
674 COUNT count of number of items, nonzero for vector mode
675 PRECISION number of bits in data representation
676 MANTISSA number of bits in mantissa, if FP and known, else zero.
677 SIZE number of bits used to store data
678 ALIGN number of bits to which mode is aligned. */
679 extern void enumerate_modes (void (*f) (int, int, int, int, int, int,
682 /* These are temporary function to deal with recent GCC changes related to
683 FP type sizes and precisions. */
684 extern int fp_prec_to_size (int);
685 extern int fp_size_to_prec (int);
687 /* These functions return the basic data type sizes and related parameters
688 about the target machine. */
690 extern Pos get_target_bits_per_unit (void);
691 extern Pos get_target_bits_per_word (void);
692 extern Pos get_target_char_size (void);
693 extern Pos get_target_wchar_t_size (void);
694 extern Pos get_target_short_size (void);
695 extern Pos get_target_int_size (void);
696 extern Pos get_target_long_size (void);
697 extern Pos get_target_long_long_size (void);
698 extern Pos get_target_float_size (void);
699 extern Pos get_target_double_size (void);
700 extern Pos get_target_long_double_size (void);
701 extern Pos get_target_pointer_size (void);
702 extern Pos get_target_maximum_alignment (void);
703 extern Nat get_float_words_be (void);
704 extern Nat get_words_be (void);
705 extern Nat get_bytes_be (void);
706 extern Nat get_bits_be (void);
707 extern Nat get_strict_alignment (void);