1 /****************************************************************************
3 * GNAT COMPILER COMPONENTS *
7 * C Implementation File *
9 * Copyright (C) 1992-2009, 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 3, or (at your option) any later ver- *
14 * sion. GNAT is distributed in the hope that it will be useful, but WITH- *
15 * OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY *
16 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License *
17 * for more details. You should have received a copy of the GNU General *
18 * Public License along with GCC; see the file COPYING3. If not see *
19 * <http://www.gnu.org/licenses/>. *
21 * GNAT was originally developed by the GNAT team at New York University. *
22 * Extensive contributions were provided by Ada Core Technologies Inc. *
24 ****************************************************************************/
26 /* We have attribute handlers using C specific format specifiers in warning
27 messages. Make sure they are properly recognized. */
28 #define GCC_DIAG_STYLE __gcc_cdiag__
32 #include "coretypes.h"
45 #include "tree-inline.h"
46 #include "tree-iterator.h"
48 #include "tree-dump.h"
49 #include "pointer-set.h"
50 #include "langhooks.h"
67 #ifndef MAX_FIXED_MODE_SIZE
68 #define MAX_FIXED_MODE_SIZE GET_MODE_BITSIZE (DImode)
71 #ifndef MAX_BITS_PER_WORD
72 #define MAX_BITS_PER_WORD BITS_PER_WORD
75 /* If nonzero, pretend we are allocating at global level. */
78 /* Tree nodes for the various types and decls we create. */
79 tree gnat_std_decls[(int) ADT_LAST];
81 /* Functions to call for each of the possible raise reasons. */
82 tree gnat_raise_decls[(int) LAST_REASON_CODE + 1];
84 /* Forward declarations for handlers of attributes. */
85 static tree handle_const_attribute (tree *, tree, tree, int, bool *);
86 static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
87 static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
88 static tree handle_novops_attribute (tree *, tree, tree, int, bool *);
89 static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
90 static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);
91 static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
92 static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
93 static tree handle_type_generic_attribute (tree *, tree, tree, int, bool *);
95 /* Fake handler for attributes we don't properly support, typically because
96 they'd require dragging a lot of the common-c front-end circuitry. */
97 static tree fake_attribute_handler (tree *, tree, tree, int, bool *);
99 /* Table of machine-independent internal attributes for Ada. We support
100 this minimal set of attributes to accommodate the needs of builtins. */
101 const struct attribute_spec gnat_internal_attribute_table[] =
103 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
104 { "const", 0, 0, true, false, false, handle_const_attribute },
105 { "nothrow", 0, 0, true, false, false, handle_nothrow_attribute },
106 { "pure", 0, 0, true, false, false, handle_pure_attribute },
107 { "no vops", 0, 0, true, false, false, handle_novops_attribute },
108 { "nonnull", 0, -1, false, true, true, handle_nonnull_attribute },
109 { "sentinel", 0, 1, false, true, true, handle_sentinel_attribute },
110 { "noreturn", 0, 0, true, false, false, handle_noreturn_attribute },
111 { "malloc", 0, 0, true, false, false, handle_malloc_attribute },
112 { "type generic", 0, 0, false, true, true, handle_type_generic_attribute },
114 /* ??? format and format_arg are heavy and not supported, which actually
115 prevents support for stdio builtins, which we however declare as part
116 of the common builtins.def contents. */
117 { "format", 3, 3, false, true, true, fake_attribute_handler },
118 { "format_arg", 1, 1, false, true, true, fake_attribute_handler },
120 { NULL, 0, 0, false, false, false, NULL }
123 /* Associates a GNAT tree node to a GCC tree node. It is used in
124 `save_gnu_tree', `get_gnu_tree' and `present_gnu_tree'. See documentation
125 of `save_gnu_tree' for more info. */
126 static GTY((length ("max_gnat_nodes"))) tree *associate_gnat_to_gnu;
128 #define GET_GNU_TREE(GNAT_ENTITY) \
129 associate_gnat_to_gnu[(GNAT_ENTITY) - First_Node_Id]
131 #define SET_GNU_TREE(GNAT_ENTITY,VAL) \
132 associate_gnat_to_gnu[(GNAT_ENTITY) - First_Node_Id] = (VAL)
134 #define PRESENT_GNU_TREE(GNAT_ENTITY) \
135 (associate_gnat_to_gnu[(GNAT_ENTITY) - First_Node_Id] != NULL_TREE)
137 /* Associates a GNAT entity to a GCC tree node used as a dummy, if any. */
138 static GTY((length ("max_gnat_nodes"))) tree *dummy_node_table;
140 #define GET_DUMMY_NODE(GNAT_ENTITY) \
141 dummy_node_table[(GNAT_ENTITY) - First_Node_Id]
143 #define SET_DUMMY_NODE(GNAT_ENTITY,VAL) \
144 dummy_node_table[(GNAT_ENTITY) - First_Node_Id] = (VAL)
146 #define PRESENT_DUMMY_NODE(GNAT_ENTITY) \
147 (dummy_node_table[(GNAT_ENTITY) - First_Node_Id] != NULL_TREE)
149 /* This variable keeps a table for types for each precision so that we only
150 allocate each of them once. Signed and unsigned types are kept separate.
152 Note that these types are only used when fold-const requests something
153 special. Perhaps we should NOT share these types; we'll see how it
155 static GTY(()) tree signed_and_unsigned_types[2 * MAX_BITS_PER_WORD + 1][2];
157 /* Likewise for float types, but record these by mode. */
158 static GTY(()) tree float_types[NUM_MACHINE_MODES];
160 /* For each binding contour we allocate a binding_level structure to indicate
161 the binding depth. */
163 struct gnat_binding_level GTY((chain_next ("%h.chain")))
165 /* The binding level containing this one (the enclosing binding level). */
166 struct gnat_binding_level *chain;
167 /* The BLOCK node for this level. */
169 /* If nonzero, the setjmp buffer that needs to be updated for any
170 variable-sized definition within this context. */
174 /* The binding level currently in effect. */
175 static GTY(()) struct gnat_binding_level *current_binding_level;
177 /* A chain of gnat_binding_level structures awaiting reuse. */
178 static GTY((deletable)) struct gnat_binding_level *free_binding_level;
180 /* An array of global declarations. */
181 static GTY(()) VEC(tree,gc) *global_decls;
183 /* An array of builtin function declarations. */
184 static GTY(()) VEC(tree,gc) *builtin_decls;
186 /* An array of global renaming pointers. */
187 static GTY(()) VEC(tree,gc) *global_renaming_pointers;
189 /* A chain of unused BLOCK nodes. */
190 static GTY((deletable)) tree free_block_chain;
192 static tree merge_sizes (tree, tree, tree, bool, bool);
193 static tree compute_related_constant (tree, tree);
194 static tree split_plus (tree, tree *);
195 static void gnat_gimplify_function (tree);
196 static tree float_type_for_precision (int, enum machine_mode);
197 static tree convert_to_fat_pointer (tree, tree);
198 static tree convert_to_thin_pointer (tree, tree);
199 static tree make_descriptor_field (const char *,tree, tree, tree);
200 static bool potential_alignment_gap (tree, tree, tree);
202 /* Initialize the association of GNAT nodes to GCC trees. */
205 init_gnat_to_gnu (void)
207 associate_gnat_to_gnu
208 = (tree *) ggc_alloc_cleared (max_gnat_nodes * sizeof (tree));
211 /* GNAT_ENTITY is a GNAT tree node for an entity. GNU_DECL is the GCC tree
212 which is to be associated with GNAT_ENTITY. Such GCC tree node is always
213 a ..._DECL node. If NO_CHECK is true, the latter check is suppressed.
215 If GNU_DECL is zero, a previous association is to be reset. */
218 save_gnu_tree (Entity_Id gnat_entity, tree gnu_decl, bool no_check)
220 /* Check that GNAT_ENTITY is not already defined and that it is being set
221 to something which is a decl. Raise gigi 401 if not. Usually, this
222 means GNAT_ENTITY is defined twice, but occasionally is due to some
224 gcc_assert (!(gnu_decl
225 && (PRESENT_GNU_TREE (gnat_entity)
226 || (!no_check && !DECL_P (gnu_decl)))));
228 SET_GNU_TREE (gnat_entity, gnu_decl);
231 /* GNAT_ENTITY is a GNAT tree node for a defining identifier.
232 Return the ..._DECL node that was associated with it. If there is no tree
233 node associated with GNAT_ENTITY, abort.
235 In some cases, such as delayed elaboration or expressions that need to
236 be elaborated only once, GNAT_ENTITY is really not an entity. */
239 get_gnu_tree (Entity_Id gnat_entity)
241 gcc_assert (PRESENT_GNU_TREE (gnat_entity));
242 return GET_GNU_TREE (gnat_entity);
245 /* Return nonzero if a GCC tree has been associated with GNAT_ENTITY. */
248 present_gnu_tree (Entity_Id gnat_entity)
250 return PRESENT_GNU_TREE (gnat_entity);
253 /* Initialize the association of GNAT nodes to GCC trees as dummies. */
256 init_dummy_type (void)
259 = (tree *) ggc_alloc_cleared (max_gnat_nodes * sizeof (tree));
262 /* Make a dummy type corresponding to GNAT_TYPE. */
265 make_dummy_type (Entity_Id gnat_type)
267 Entity_Id gnat_underlying = Gigi_Equivalent_Type (gnat_type);
270 /* If there is an equivalent type, get its underlying type. */
271 if (Present (gnat_underlying))
272 gnat_underlying = Underlying_Type (gnat_underlying);
274 /* If there was no equivalent type (can only happen when just annotating
275 types) or underlying type, go back to the original type. */
276 if (No (gnat_underlying))
277 gnat_underlying = gnat_type;
279 /* If it there already a dummy type, use that one. Else make one. */
280 if (PRESENT_DUMMY_NODE (gnat_underlying))
281 return GET_DUMMY_NODE (gnat_underlying);
283 /* If this is a record, make a RECORD_TYPE or UNION_TYPE; else make
285 gnu_type = make_node (Is_Record_Type (gnat_underlying)
286 ? tree_code_for_record_type (gnat_underlying)
288 TYPE_NAME (gnu_type) = get_entity_name (gnat_type);
289 TYPE_DUMMY_P (gnu_type) = 1;
290 TYPE_STUB_DECL (gnu_type)
291 = create_type_stub_decl (TYPE_NAME (gnu_type), gnu_type);
292 if (AGGREGATE_TYPE_P (gnu_type))
293 TYPE_BY_REFERENCE_P (gnu_type) = Is_By_Reference_Type (gnat_type);
295 SET_DUMMY_NODE (gnat_underlying, gnu_type);
300 /* Return nonzero if we are currently in the global binding level. */
303 global_bindings_p (void)
305 return ((force_global || !current_function_decl) ? -1 : 0);
308 /* Enter a new binding level. */
313 struct gnat_binding_level *newlevel = NULL;
315 /* Reuse a struct for this binding level, if there is one. */
316 if (free_binding_level)
318 newlevel = free_binding_level;
319 free_binding_level = free_binding_level->chain;
323 = (struct gnat_binding_level *)
324 ggc_alloc (sizeof (struct gnat_binding_level));
326 /* Use a free BLOCK, if any; otherwise, allocate one. */
327 if (free_block_chain)
329 newlevel->block = free_block_chain;
330 free_block_chain = BLOCK_CHAIN (free_block_chain);
331 BLOCK_CHAIN (newlevel->block) = NULL_TREE;
334 newlevel->block = make_node (BLOCK);
336 /* Point the BLOCK we just made to its parent. */
337 if (current_binding_level)
338 BLOCK_SUPERCONTEXT (newlevel->block) = current_binding_level->block;
340 BLOCK_VARS (newlevel->block) = BLOCK_SUBBLOCKS (newlevel->block) = NULL_TREE;
341 TREE_USED (newlevel->block) = 1;
343 /* Add this level to the front of the chain (stack) of levels that are
345 newlevel->chain = current_binding_level;
346 newlevel->jmpbuf_decl = NULL_TREE;
347 current_binding_level = newlevel;
350 /* Set SUPERCONTEXT of the BLOCK for the current binding level to FNDECL
351 and point FNDECL to this BLOCK. */
354 set_current_block_context (tree fndecl)
356 BLOCK_SUPERCONTEXT (current_binding_level->block) = fndecl;
357 DECL_INITIAL (fndecl) = current_binding_level->block;
360 /* Set the jmpbuf_decl for the current binding level to DECL. */
363 set_block_jmpbuf_decl (tree decl)
365 current_binding_level->jmpbuf_decl = decl;
368 /* Get the jmpbuf_decl, if any, for the current binding level. */
371 get_block_jmpbuf_decl ()
373 return current_binding_level->jmpbuf_decl;
376 /* Exit a binding level. Set any BLOCK into the current code group. */
381 struct gnat_binding_level *level = current_binding_level;
382 tree block = level->block;
384 BLOCK_VARS (block) = nreverse (BLOCK_VARS (block));
385 BLOCK_SUBBLOCKS (block) = nreverse (BLOCK_SUBBLOCKS (block));
387 /* If this is a function-level BLOCK don't do anything. Otherwise, if there
388 are no variables free the block and merge its subblocks into those of its
389 parent block. Otherwise, add it to the list of its parent. */
390 if (TREE_CODE (BLOCK_SUPERCONTEXT (block)) == FUNCTION_DECL)
392 else if (BLOCK_VARS (block) == NULL_TREE)
394 BLOCK_SUBBLOCKS (level->chain->block)
395 = chainon (BLOCK_SUBBLOCKS (block),
396 BLOCK_SUBBLOCKS (level->chain->block));
397 BLOCK_CHAIN (block) = free_block_chain;
398 free_block_chain = block;
402 BLOCK_CHAIN (block) = BLOCK_SUBBLOCKS (level->chain->block);
403 BLOCK_SUBBLOCKS (level->chain->block) = block;
404 TREE_USED (block) = 1;
405 set_block_for_group (block);
408 /* Free this binding structure. */
409 current_binding_level = level->chain;
410 level->chain = free_binding_level;
411 free_binding_level = level;
415 /* Records a ..._DECL node DECL as belonging to the current lexical scope
416 and uses GNAT_NODE for location information and propagating flags. */
419 gnat_pushdecl (tree decl, Node_Id gnat_node)
421 /* If this decl is public external or at toplevel, there is no context.
422 But PARM_DECLs always go in the level of its function. */
423 if (TREE_CODE (decl) != PARM_DECL
424 && ((DECL_EXTERNAL (decl) && TREE_PUBLIC (decl))
425 || global_bindings_p ()))
426 DECL_CONTEXT (decl) = 0;
429 DECL_CONTEXT (decl) = current_function_decl;
431 /* Functions imported in another function are not really nested. */
432 if (TREE_CODE (decl) == FUNCTION_DECL && TREE_PUBLIC (decl))
433 DECL_NO_STATIC_CHAIN (decl) = 1;
436 TREE_NO_WARNING (decl) = (gnat_node == Empty || Warnings_Off (gnat_node));
438 /* Set the location of DECL and emit a declaration for it. */
439 if (Present (gnat_node))
440 Sloc_to_locus (Sloc (gnat_node), &DECL_SOURCE_LOCATION (decl));
441 add_decl_expr (decl, gnat_node);
443 /* Put the declaration on the list. The list of declarations is in reverse
444 order. The list will be reversed later. Put global variables in the
445 globals list and builtin functions in a dedicated list to speed up
446 further lookups. Don't put TYPE_DECLs for UNCONSTRAINED_ARRAY_TYPE into
447 the list, as they will cause trouble with the debugger and aren't needed
449 if (TREE_CODE (decl) != TYPE_DECL
450 || TREE_CODE (TREE_TYPE (decl)) != UNCONSTRAINED_ARRAY_TYPE)
452 if (global_bindings_p ())
454 VEC_safe_push (tree, gc, global_decls, decl);
456 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl))
457 VEC_safe_push (tree, gc, builtin_decls, decl);
461 TREE_CHAIN (decl) = BLOCK_VARS (current_binding_level->block);
462 BLOCK_VARS (current_binding_level->block) = decl;
466 /* For the declaration of a type, set its name if it either is not already
467 set or if the previous type name was not derived from a source name.
468 We'd rather have the type named with a real name and all the pointer
469 types to the same object have the same POINTER_TYPE node. Code in the
470 equivalent function of c-decl.c makes a copy of the type node here, but
471 that may cause us trouble with incomplete types. We make an exception
472 for fat pointer types because the compiler automatically builds them
473 for unconstrained array types and the debugger uses them to represent
474 both these and pointers to these. */
475 if (TREE_CODE (decl) == TYPE_DECL && DECL_NAME (decl))
477 tree t = TREE_TYPE (decl);
479 if (!(TYPE_NAME (t) && TREE_CODE (TYPE_NAME (t)) == TYPE_DECL))
481 else if (TYPE_FAT_POINTER_P (t))
483 tree tt = build_variant_type_copy (t);
484 TYPE_NAME (tt) = decl;
485 TREE_USED (tt) = TREE_USED (t);
486 TREE_TYPE (decl) = tt;
487 DECL_ORIGINAL_TYPE (decl) = t;
490 else if (DECL_ARTIFICIAL (TYPE_NAME (t)) && !DECL_ARTIFICIAL (decl))
495 /* Propagate the name to all the variants. This is needed for
496 the type qualifiers machinery to work properly. */
498 for (t = TYPE_MAIN_VARIANT (t); t; t = TYPE_NEXT_VARIANT (t))
499 TYPE_NAME (t) = decl;
503 /* Do little here. Set up the standard declarations later after the
504 front end has been run. */
507 gnat_init_decl_processing (void)
509 /* Make the binding_level structure for global names. */
510 current_function_decl = 0;
511 current_binding_level = 0;
512 free_binding_level = 0;
515 build_common_tree_nodes (true, true);
517 /* In Ada, we use a signed type for SIZETYPE. Use the signed type
518 corresponding to the size of Pmode. In most cases when ptr_mode and
519 Pmode differ, C will use the width of ptr_mode as sizetype. But we get
520 far better code using the width of Pmode. Make this here since we need
521 this before we can expand the GNAT types. */
522 size_type_node = gnat_type_for_size (GET_MODE_BITSIZE (Pmode), 0);
523 set_sizetype (size_type_node);
525 /* In Ada, we use an unsigned 8-bit type for the default boolean type. */
526 boolean_type_node = make_node (BOOLEAN_TYPE);
527 TYPE_PRECISION (boolean_type_node) = 1;
528 fixup_unsigned_type (boolean_type_node);
529 TYPE_RM_SIZE_NUM (boolean_type_node) = bitsize_int (1);
531 build_common_tree_nodes_2 (0);
533 ptr_void_type_node = build_pointer_type (void_type_node);
536 /* Record TYPE as a builtin type for Ada. NAME is the name of the type. */
539 record_builtin_type (const char *name, tree type)
541 tree type_decl = build_decl (TYPE_DECL, get_identifier (name), type);
543 gnat_pushdecl (type_decl, Empty);
545 if (debug_hooks->type_decl)
546 debug_hooks->type_decl (type_decl, false);
549 /* Given a record type RECORD_TYPE and a chain of FIELD_DECL nodes FIELDLIST,
550 finish constructing the record or union type. If REP_LEVEL is zero, this
551 record has no representation clause and so will be entirely laid out here.
552 If REP_LEVEL is one, this record has a representation clause and has been
553 laid out already; only set the sizes and alignment. If REP_LEVEL is two,
554 this record is derived from a parent record and thus inherits its layout;
555 only make a pass on the fields to finalize them. If DO_NOT_FINALIZE is
556 true, the record type is expected to be modified afterwards so it will
557 not be sent to the back-end for finalization. */
560 finish_record_type (tree record_type, tree fieldlist, int rep_level,
561 bool do_not_finalize)
563 enum tree_code code = TREE_CODE (record_type);
564 tree name = TYPE_NAME (record_type);
565 tree ada_size = bitsize_zero_node;
566 tree size = bitsize_zero_node;
567 bool had_size = TYPE_SIZE (record_type) != 0;
568 bool had_size_unit = TYPE_SIZE_UNIT (record_type) != 0;
569 bool had_align = TYPE_ALIGN (record_type) != 0;
572 TYPE_FIELDS (record_type) = fieldlist;
574 /* Always attach the TYPE_STUB_DECL for a record type. It is required to
575 generate debug info and have a parallel type. */
576 if (name && TREE_CODE (name) == TYPE_DECL)
577 name = DECL_NAME (name);
578 TYPE_STUB_DECL (record_type) = create_type_stub_decl (name, record_type);
580 /* Globally initialize the record first. If this is a rep'ed record,
581 that just means some initializations; otherwise, layout the record. */
584 TYPE_ALIGN (record_type) = MAX (BITS_PER_UNIT, TYPE_ALIGN (record_type));
585 SET_TYPE_MODE (record_type, BLKmode);
588 TYPE_SIZE_UNIT (record_type) = size_zero_node;
590 TYPE_SIZE (record_type) = bitsize_zero_node;
592 /* For all-repped records with a size specified, lay the QUAL_UNION_TYPE
593 out just like a UNION_TYPE, since the size will be fixed. */
594 else if (code == QUAL_UNION_TYPE)
599 /* Ensure there isn't a size already set. There can be in an error
600 case where there is a rep clause but all fields have errors and
601 no longer have a position. */
602 TYPE_SIZE (record_type) = 0;
603 layout_type (record_type);
606 /* At this point, the position and size of each field is known. It was
607 either set before entry by a rep clause, or by laying out the type above.
609 We now run a pass over the fields (in reverse order for QUAL_UNION_TYPEs)
610 to compute the Ada size; the GCC size and alignment (for rep'ed records
611 that are not padding types); and the mode (for rep'ed records). We also
612 clear the DECL_BIT_FIELD indication for the cases we know have not been
613 handled yet, and adjust DECL_NONADDRESSABLE_P accordingly. */
615 if (code == QUAL_UNION_TYPE)
616 fieldlist = nreverse (fieldlist);
618 for (field = fieldlist; field; field = TREE_CHAIN (field))
620 tree type = TREE_TYPE (field);
621 tree pos = bit_position (field);
622 tree this_size = DECL_SIZE (field);
625 if ((TREE_CODE (type) == RECORD_TYPE
626 || TREE_CODE (type) == UNION_TYPE
627 || TREE_CODE (type) == QUAL_UNION_TYPE)
628 && !TYPE_IS_FAT_POINTER_P (type)
629 && !TYPE_CONTAINS_TEMPLATE_P (type)
630 && TYPE_ADA_SIZE (type))
631 this_ada_size = TYPE_ADA_SIZE (type);
633 this_ada_size = this_size;
635 /* Clear DECL_BIT_FIELD for the cases layout_decl does not handle. */
636 if (DECL_BIT_FIELD (field)
637 && operand_equal_p (this_size, TYPE_SIZE (type), 0))
639 unsigned int align = TYPE_ALIGN (type);
641 /* In the general case, type alignment is required. */
642 if (value_factor_p (pos, align))
644 /* The enclosing record type must be sufficiently aligned.
645 Otherwise, if no alignment was specified for it and it
646 has been laid out already, bump its alignment to the
647 desired one if this is compatible with its size. */
648 if (TYPE_ALIGN (record_type) >= align)
650 DECL_ALIGN (field) = MAX (DECL_ALIGN (field), align);
651 DECL_BIT_FIELD (field) = 0;
655 && value_factor_p (TYPE_SIZE (record_type), align))
657 TYPE_ALIGN (record_type) = align;
658 DECL_ALIGN (field) = MAX (DECL_ALIGN (field), align);
659 DECL_BIT_FIELD (field) = 0;
663 /* In the non-strict alignment case, only byte alignment is. */
664 if (!STRICT_ALIGNMENT
665 && DECL_BIT_FIELD (field)
666 && value_factor_p (pos, BITS_PER_UNIT))
667 DECL_BIT_FIELD (field) = 0;
670 /* If we still have DECL_BIT_FIELD set at this point, we know the field
671 is technically not addressable. Except that it can actually be
672 addressed if the field is BLKmode and happens to be properly
674 DECL_NONADDRESSABLE_P (field)
675 |= DECL_BIT_FIELD (field) && DECL_MODE (field) != BLKmode;
677 /* A type must be as aligned as its most aligned field that is not
678 a bit-field. But this is already enforced by layout_type. */
679 if (rep_level > 0 && !DECL_BIT_FIELD (field))
680 TYPE_ALIGN (record_type)
681 = MAX (TYPE_ALIGN (record_type), DECL_ALIGN (field));
686 ada_size = size_binop (MAX_EXPR, ada_size, this_ada_size);
687 size = size_binop (MAX_EXPR, size, this_size);
690 case QUAL_UNION_TYPE:
692 = fold_build3 (COND_EXPR, bitsizetype, DECL_QUALIFIER (field),
693 this_ada_size, ada_size);
694 size = fold_build3 (COND_EXPR, bitsizetype, DECL_QUALIFIER (field),
699 /* Since we know here that all fields are sorted in order of
700 increasing bit position, the size of the record is one
701 higher than the ending bit of the last field processed
702 unless we have a rep clause, since in that case we might
703 have a field outside a QUAL_UNION_TYPE that has a higher ending
704 position. So use a MAX in that case. Also, if this field is a
705 QUAL_UNION_TYPE, we need to take into account the previous size in
706 the case of empty variants. */
708 = merge_sizes (ada_size, pos, this_ada_size,
709 TREE_CODE (type) == QUAL_UNION_TYPE, rep_level > 0);
711 = merge_sizes (size, pos, this_size,
712 TREE_CODE (type) == QUAL_UNION_TYPE, rep_level > 0);
720 if (code == QUAL_UNION_TYPE)
721 nreverse (fieldlist);
723 /* If the type is discriminated, it can be used to access all its
724 constrained subtypes, so force structural equality checks. */
725 if (CONTAINS_PLACEHOLDER_P (size))
726 SET_TYPE_STRUCTURAL_EQUALITY (record_type);
730 /* If this is a padding record, we never want to make the size smaller
731 than what was specified in it, if any. */
732 if (TREE_CODE (record_type) == RECORD_TYPE
733 && TYPE_IS_PADDING_P (record_type) && TYPE_SIZE (record_type))
734 size = TYPE_SIZE (record_type);
736 /* Now set any of the values we've just computed that apply. */
737 if (!TYPE_IS_FAT_POINTER_P (record_type)
738 && !TYPE_CONTAINS_TEMPLATE_P (record_type))
739 SET_TYPE_ADA_SIZE (record_type, ada_size);
743 tree size_unit = had_size_unit
744 ? TYPE_SIZE_UNIT (record_type)
746 size_binop (CEIL_DIV_EXPR, size,
748 unsigned int align = TYPE_ALIGN (record_type);
750 TYPE_SIZE (record_type) = variable_size (round_up (size, align));
751 TYPE_SIZE_UNIT (record_type)
752 = variable_size (round_up (size_unit, align / BITS_PER_UNIT));
754 compute_record_mode (record_type);
758 if (!do_not_finalize)
759 rest_of_record_type_compilation (record_type);
762 /* Wrap up compilation of RECORD_TYPE, i.e. most notably output all
763 the debug information associated with it. It need not be invoked
764 directly in most cases since finish_record_type takes care of doing
765 so, unless explicitly requested not to through DO_NOT_FINALIZE. */
768 rest_of_record_type_compilation (tree record_type)
770 tree fieldlist = TYPE_FIELDS (record_type);
772 enum tree_code code = TREE_CODE (record_type);
773 bool var_size = false;
775 for (field = fieldlist; field; field = TREE_CHAIN (field))
777 /* We need to make an XVE/XVU record if any field has variable size,
778 whether or not the record does. For example, if we have a union,
779 it may be that all fields, rounded up to the alignment, have the
780 same size, in which case we'll use that size. But the debug
781 output routines (except Dwarf2) won't be able to output the fields,
782 so we need to make the special record. */
783 if (TREE_CODE (DECL_SIZE (field)) != INTEGER_CST
784 /* If a field has a non-constant qualifier, the record will have
785 variable size too. */
786 || (code == QUAL_UNION_TYPE
787 && TREE_CODE (DECL_QUALIFIER (field)) != INTEGER_CST))
794 /* If this record is of variable size, rename it so that the
795 debugger knows it is and make a new, parallel, record
796 that tells the debugger how the record is laid out. See
797 exp_dbug.ads. But don't do this for records that are padding
798 since they confuse GDB. */
800 && !(TREE_CODE (record_type) == RECORD_TYPE
801 && TYPE_IS_PADDING_P (record_type)))
804 = make_node (TREE_CODE (record_type) == QUAL_UNION_TYPE
805 ? UNION_TYPE : TREE_CODE (record_type));
806 tree orig_name = TYPE_NAME (record_type);
808 = (TREE_CODE (orig_name) == TYPE_DECL ? DECL_NAME (orig_name)
811 = concat_id_with_name (orig_id,
812 TREE_CODE (record_type) == QUAL_UNION_TYPE
814 tree last_pos = bitsize_zero_node;
816 tree prev_old_field = 0;
818 TYPE_NAME (new_record_type) = new_id;
819 TYPE_ALIGN (new_record_type) = BIGGEST_ALIGNMENT;
820 TYPE_STUB_DECL (new_record_type)
821 = create_type_stub_decl (new_id, new_record_type);
822 DECL_IGNORED_P (TYPE_STUB_DECL (new_record_type))
823 = DECL_IGNORED_P (TYPE_STUB_DECL (record_type));
824 TYPE_SIZE (new_record_type) = size_int (TYPE_ALIGN (record_type));
825 TYPE_SIZE_UNIT (new_record_type)
826 = size_int (TYPE_ALIGN (record_type) / BITS_PER_UNIT);
828 add_parallel_type (TYPE_STUB_DECL (record_type), new_record_type);
830 /* Now scan all the fields, replacing each field with a new
831 field corresponding to the new encoding. */
832 for (old_field = TYPE_FIELDS (record_type); old_field;
833 old_field = TREE_CHAIN (old_field))
835 tree field_type = TREE_TYPE (old_field);
836 tree field_name = DECL_NAME (old_field);
838 tree curpos = bit_position (old_field);
840 unsigned int align = 0;
843 /* See how the position was modified from the last position.
845 There are two basic cases we support: a value was added
846 to the last position or the last position was rounded to
847 a boundary and they something was added. Check for the
848 first case first. If not, see if there is any evidence
849 of rounding. If so, round the last position and try
852 If this is a union, the position can be taken as zero. */
854 /* Some computations depend on the shape of the position expression,
855 so strip conversions to make sure it's exposed. */
856 curpos = remove_conversions (curpos, true);
858 if (TREE_CODE (new_record_type) == UNION_TYPE)
859 pos = bitsize_zero_node, align = 0;
861 pos = compute_related_constant (curpos, last_pos);
863 if (!pos && TREE_CODE (curpos) == MULT_EXPR
864 && host_integerp (TREE_OPERAND (curpos, 1), 1))
866 tree offset = TREE_OPERAND (curpos, 0);
867 align = tree_low_cst (TREE_OPERAND (curpos, 1), 1);
869 /* An offset which is a bitwise AND with a negative power of 2
870 means an alignment corresponding to this power of 2. */
871 offset = remove_conversions (offset, true);
872 if (TREE_CODE (offset) == BIT_AND_EXPR
873 && host_integerp (TREE_OPERAND (offset, 1), 0)
874 && tree_int_cst_sgn (TREE_OPERAND (offset, 1)) < 0)
877 = - tree_low_cst (TREE_OPERAND (offset, 1), 0);
878 if (exact_log2 (pow) > 0)
882 pos = compute_related_constant (curpos,
883 round_up (last_pos, align));
885 else if (!pos && TREE_CODE (curpos) == PLUS_EXPR
886 && TREE_CODE (TREE_OPERAND (curpos, 1)) == INTEGER_CST
887 && TREE_CODE (TREE_OPERAND (curpos, 0)) == MULT_EXPR
888 && host_integerp (TREE_OPERAND
889 (TREE_OPERAND (curpos, 0), 1),
894 (TREE_OPERAND (TREE_OPERAND (curpos, 0), 1), 1);
895 pos = compute_related_constant (curpos,
896 round_up (last_pos, align));
898 else if (potential_alignment_gap (prev_old_field, old_field,
901 align = TYPE_ALIGN (field_type);
902 pos = compute_related_constant (curpos,
903 round_up (last_pos, align));
906 /* If we can't compute a position, set it to zero.
908 ??? We really should abort here, but it's too much work
909 to get this correct for all cases. */
912 pos = bitsize_zero_node;
914 /* See if this type is variable-sized and make a pointer type
915 and indicate the indirection if so. Beware that the debug
916 back-end may adjust the position computed above according
917 to the alignment of the field type, i.e. the pointer type
918 in this case, if we don't preventively counter that. */
919 if (TREE_CODE (DECL_SIZE (old_field)) != INTEGER_CST)
921 field_type = build_pointer_type (field_type);
922 if (align != 0 && TYPE_ALIGN (field_type) > align)
924 field_type = copy_node (field_type);
925 TYPE_ALIGN (field_type) = align;
930 /* Make a new field name, if necessary. */
931 if (var || align != 0)
936 sprintf (suffix, "XV%c%u", var ? 'L' : 'A',
937 align / BITS_PER_UNIT);
939 strcpy (suffix, "XVL");
941 field_name = concat_id_with_name (field_name, suffix);
944 new_field = create_field_decl (field_name, field_type,
946 DECL_SIZE (old_field), pos, 0);
947 TREE_CHAIN (new_field) = TYPE_FIELDS (new_record_type);
948 TYPE_FIELDS (new_record_type) = new_field;
950 /* If old_field is a QUAL_UNION_TYPE, take its size as being
951 zero. The only time it's not the last field of the record
952 is when there are other components at fixed positions after
953 it (meaning there was a rep clause for every field) and we
954 want to be able to encode them. */
955 last_pos = size_binop (PLUS_EXPR, bit_position (old_field),
956 (TREE_CODE (TREE_TYPE (old_field))
959 : DECL_SIZE (old_field));
960 prev_old_field = old_field;
963 TYPE_FIELDS (new_record_type)
964 = nreverse (TYPE_FIELDS (new_record_type));
966 rest_of_type_decl_compilation (TYPE_STUB_DECL (new_record_type));
969 rest_of_type_decl_compilation (TYPE_STUB_DECL (record_type));
972 /* Append PARALLEL_TYPE on the chain of parallel types for decl. */
975 add_parallel_type (tree decl, tree parallel_type)
979 while (DECL_PARALLEL_TYPE (d))
980 d = TYPE_STUB_DECL (DECL_PARALLEL_TYPE (d));
982 SET_DECL_PARALLEL_TYPE (d, parallel_type);
985 /* Return the parallel type associated to a type, if any. */
988 get_parallel_type (tree type)
990 if (TYPE_STUB_DECL (type))
991 return DECL_PARALLEL_TYPE (TYPE_STUB_DECL (type));
996 /* Utility function of above to merge LAST_SIZE, the previous size of a record
997 with FIRST_BIT and SIZE that describe a field. SPECIAL is true if this
998 represents a QUAL_UNION_TYPE in which case we must look for COND_EXPRs and
999 replace a value of zero with the old size. If HAS_REP is true, we take the
1000 MAX of the end position of this field with LAST_SIZE. In all other cases,
1001 we use FIRST_BIT plus SIZE. Return an expression for the size. */
1004 merge_sizes (tree last_size, tree first_bit, tree size, bool special,
1007 tree type = TREE_TYPE (last_size);
1010 if (!special || TREE_CODE (size) != COND_EXPR)
1012 new = size_binop (PLUS_EXPR, first_bit, size);
1014 new = size_binop (MAX_EXPR, last_size, new);
1018 new = fold_build3 (COND_EXPR, type, TREE_OPERAND (size, 0),
1019 integer_zerop (TREE_OPERAND (size, 1))
1020 ? last_size : merge_sizes (last_size, first_bit,
1021 TREE_OPERAND (size, 1),
1023 integer_zerop (TREE_OPERAND (size, 2))
1024 ? last_size : merge_sizes (last_size, first_bit,
1025 TREE_OPERAND (size, 2),
1028 /* We don't need any NON_VALUE_EXPRs and they can confuse us (especially
1029 when fed through substitute_in_expr) into thinking that a constant
1030 size is not constant. */
1031 while (TREE_CODE (new) == NON_LVALUE_EXPR)
1032 new = TREE_OPERAND (new, 0);
1037 /* Utility function of above to see if OP0 and OP1, both of SIZETYPE, are
1038 related by the addition of a constant. Return that constant if so. */
1041 compute_related_constant (tree op0, tree op1)
1043 tree op0_var, op1_var;
1044 tree op0_con = split_plus (op0, &op0_var);
1045 tree op1_con = split_plus (op1, &op1_var);
1046 tree result = size_binop (MINUS_EXPR, op0_con, op1_con);
1048 if (operand_equal_p (op0_var, op1_var, 0))
1050 else if (operand_equal_p (op0, size_binop (PLUS_EXPR, op1_var, result), 0))
1056 /* Utility function of above to split a tree OP which may be a sum, into a
1057 constant part, which is returned, and a variable part, which is stored
1058 in *PVAR. *PVAR may be bitsize_zero_node. All operations must be of
1062 split_plus (tree in, tree *pvar)
1064 /* Strip NOPS in order to ease the tree traversal and maximize the
1065 potential for constant or plus/minus discovery. We need to be careful
1066 to always return and set *pvar to bitsizetype trees, but it's worth
1070 *pvar = convert (bitsizetype, in);
1072 if (TREE_CODE (in) == INTEGER_CST)
1074 *pvar = bitsize_zero_node;
1075 return convert (bitsizetype, in);
1077 else if (TREE_CODE (in) == PLUS_EXPR || TREE_CODE (in) == MINUS_EXPR)
1079 tree lhs_var, rhs_var;
1080 tree lhs_con = split_plus (TREE_OPERAND (in, 0), &lhs_var);
1081 tree rhs_con = split_plus (TREE_OPERAND (in, 1), &rhs_var);
1083 if (lhs_var == TREE_OPERAND (in, 0)
1084 && rhs_var == TREE_OPERAND (in, 1))
1085 return bitsize_zero_node;
1087 *pvar = size_binop (TREE_CODE (in), lhs_var, rhs_var);
1088 return size_binop (TREE_CODE (in), lhs_con, rhs_con);
1091 return bitsize_zero_node;
1094 /* Return a FUNCTION_TYPE node. RETURN_TYPE is the type returned by the
1095 subprogram. If it is void_type_node, then we are dealing with a procedure,
1096 otherwise we are dealing with a function. PARAM_DECL_LIST is a list of
1097 PARM_DECL nodes that are the subprogram arguments. CICO_LIST is the
1098 copy-in/copy-out list to be stored into TYPE_CICO_LIST.
1099 RETURNS_UNCONSTRAINED is true if the function returns an unconstrained
1100 object. RETURNS_BY_REF is true if the function returns by reference.
1101 RETURNS_BY_TARGET_PTR is true if the function is to be passed (as its
1102 first parameter) the address of the place to copy its result. */
1105 create_subprog_type (tree return_type, tree param_decl_list, tree cico_list,
1106 bool returns_unconstrained, bool returns_by_ref,
1107 bool returns_by_target_ptr)
1109 /* A chain of TREE_LIST nodes whose TREE_VALUEs are the data type nodes of
1110 the subprogram formal parameters. This list is generated by traversing the
1111 input list of PARM_DECL nodes. */
1112 tree param_type_list = NULL;
1116 for (param_decl = param_decl_list; param_decl;
1117 param_decl = TREE_CHAIN (param_decl))
1118 param_type_list = tree_cons (NULL_TREE, TREE_TYPE (param_decl),
1121 /* The list of the function parameter types has to be terminated by the void
1122 type to signal to the back-end that we are not dealing with a variable
1123 parameter subprogram, but that the subprogram has a fixed number of
1125 param_type_list = tree_cons (NULL_TREE, void_type_node, param_type_list);
1127 /* The list of argument types has been created in reverse
1129 param_type_list = nreverse (param_type_list);
1131 type = build_function_type (return_type, param_type_list);
1133 /* TYPE may have been shared since GCC hashes types. If it has a CICO_LIST
1134 or the new type should, make a copy of TYPE. Likewise for
1135 RETURNS_UNCONSTRAINED and RETURNS_BY_REF. */
1136 if (TYPE_CI_CO_LIST (type) || cico_list
1137 || TYPE_RETURNS_UNCONSTRAINED_P (type) != returns_unconstrained
1138 || TYPE_RETURNS_BY_REF_P (type) != returns_by_ref
1139 || TYPE_RETURNS_BY_TARGET_PTR_P (type) != returns_by_target_ptr)
1140 type = copy_type (type);
1142 TYPE_CI_CO_LIST (type) = cico_list;
1143 TYPE_RETURNS_UNCONSTRAINED_P (type) = returns_unconstrained;
1144 TYPE_RETURNS_BY_REF_P (type) = returns_by_ref;
1145 TYPE_RETURNS_BY_TARGET_PTR_P (type) = returns_by_target_ptr;
1149 /* Return a copy of TYPE but safe to modify in any way. */
1152 copy_type (tree type)
1154 tree new = copy_node (type);
1156 /* copy_node clears this field instead of copying it, because it is
1157 aliased with TREE_CHAIN. */
1158 TYPE_STUB_DECL (new) = TYPE_STUB_DECL (type);
1160 TYPE_POINTER_TO (new) = 0;
1161 TYPE_REFERENCE_TO (new) = 0;
1162 TYPE_MAIN_VARIANT (new) = new;
1163 TYPE_NEXT_VARIANT (new) = 0;
1168 /* Return an INTEGER_TYPE of SIZETYPE with range MIN to MAX and whose
1169 TYPE_INDEX_TYPE is INDEX. GNAT_NODE is used for the position of
1173 create_index_type (tree min, tree max, tree index, Node_Id gnat_node)
1175 /* First build a type for the desired range. */
1176 tree type = build_index_2_type (min, max);
1178 /* If this type has the TYPE_INDEX_TYPE we want, return it. Otherwise, if it
1179 doesn't have TYPE_INDEX_TYPE set, set it to INDEX. If TYPE_INDEX_TYPE
1180 is set, but not to INDEX, make a copy of this type with the requested
1181 index type. Note that we have no way of sharing these types, but that's
1182 only a small hole. */
1183 if (TYPE_INDEX_TYPE (type) == index)
1185 else if (TYPE_INDEX_TYPE (type))
1186 type = copy_type (type);
1188 SET_TYPE_INDEX_TYPE (type, index);
1189 create_type_decl (NULL_TREE, type, NULL, true, false, gnat_node);
1193 /* Return a TYPE_DECL node suitable for the TYPE_STUB_DECL field of a type.
1194 TYPE_NAME gives the name of the type and TYPE is a ..._TYPE node giving
1198 create_type_stub_decl (tree type_name, tree type)
1200 /* Using a named TYPE_DECL ensures that a type name marker is emitted in
1201 STABS while setting DECL_ARTIFICIAL ensures that no DW_TAG_typedef is
1202 emitted in DWARF. */
1203 tree type_decl = build_decl (TYPE_DECL, type_name, type);
1204 DECL_ARTIFICIAL (type_decl) = 1;
1208 /* Return a TYPE_DECL node. TYPE_NAME gives the name of the type and TYPE
1209 is a ..._TYPE node giving its data type. ARTIFICIAL_P is true if this
1210 is a declaration that was generated by the compiler. DEBUG_INFO_P is
1211 true if we need to write debug information about this type. GNAT_NODE
1212 is used for the position of the decl. */
1215 create_type_decl (tree type_name, tree type, struct attrib *attr_list,
1216 bool artificial_p, bool debug_info_p, Node_Id gnat_node)
1218 enum tree_code code = TREE_CODE (type);
1219 bool named = TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL;
1222 /* Only the builtin TYPE_STUB_DECL should be used for dummy types. */
1223 gcc_assert (!TYPE_IS_DUMMY_P (type));
1225 /* If the type hasn't been named yet, we're naming it; preserve an existing
1226 TYPE_STUB_DECL that has been attached to it for some purpose. */
1227 if (!named && TYPE_STUB_DECL (type))
1229 type_decl = TYPE_STUB_DECL (type);
1230 DECL_NAME (type_decl) = type_name;
1233 type_decl = build_decl (TYPE_DECL, type_name, type);
1235 DECL_ARTIFICIAL (type_decl) = artificial_p;
1236 gnat_pushdecl (type_decl, gnat_node);
1237 process_attributes (type_decl, attr_list);
1239 /* If we're naming the type, equate the TYPE_STUB_DECL to the name.
1240 This causes the name to be also viewed as a "tag" by the debug
1241 back-end, with the advantage that no DW_TAG_typedef is emitted
1242 for artificial "tagged" types in DWARF. */
1244 TYPE_STUB_DECL (type) = type_decl;
1246 /* Pass the type declaration to the debug back-end unless this is an
1247 UNCONSTRAINED_ARRAY_TYPE that the back-end does not support, an
1248 ENUMERAL_TYPE or RECORD_TYPE which are handled separately, or a
1249 type for which debugging information was not requested. */
1250 if (code == UNCONSTRAINED_ARRAY_TYPE || !debug_info_p)
1251 DECL_IGNORED_P (type_decl) = 1;
1252 else if (code != ENUMERAL_TYPE
1253 && (code != RECORD_TYPE || TYPE_IS_FAT_POINTER_P (type))
1254 && !((code == POINTER_TYPE || code == REFERENCE_TYPE)
1255 && TYPE_IS_DUMMY_P (TREE_TYPE (type))))
1256 rest_of_type_decl_compilation (type_decl);
1261 /* Return a VAR_DECL or CONST_DECL node.
1263 VAR_NAME gives the name of the variable. ASM_NAME is its assembler name
1264 (if provided). TYPE is its data type (a GCC ..._TYPE node). VAR_INIT is
1265 the GCC tree for an optional initial expression; NULL_TREE if none.
1267 CONST_FLAG is true if this variable is constant, in which case we might
1268 return a CONST_DECL node unless CONST_DECL_ALLOWED_P is false.
1270 PUBLIC_FLAG is true if this is for a reference to a public entity or for a
1271 definition to be made visible outside of the current compilation unit, for
1272 instance variable definitions in a package specification.
1274 EXTERN_FLAG is true when processing an external variable declaration (as
1275 opposed to a definition: no storage is to be allocated for the variable).
1277 STATIC_FLAG is only relevant when not at top level. In that case
1278 it indicates whether to always allocate storage to the variable.
1280 GNAT_NODE is used for the position of the decl. */
1283 create_var_decl_1 (tree var_name, tree asm_name, tree type, tree var_init,
1284 bool const_flag, bool public_flag, bool extern_flag,
1285 bool static_flag, bool const_decl_allowed_p,
1286 struct attrib *attr_list, Node_Id gnat_node)
1290 && gnat_types_compatible_p (type, TREE_TYPE (var_init))
1291 && (global_bindings_p () || static_flag
1292 ? initializer_constant_valid_p (var_init, TREE_TYPE (var_init)) != 0
1293 : TREE_CONSTANT (var_init)));
1295 /* Whether we will make TREE_CONSTANT the DECL we produce here, in which
1296 case the initializer may be used in-lieu of the DECL node (as done in
1297 Identifier_to_gnu). This is useful to prevent the need of elaboration
1298 code when an identifier for which such a decl is made is in turn used as
1299 an initializer. We used to rely on CONST vs VAR_DECL for this purpose,
1300 but extra constraints apply to this choice (see below) and are not
1301 relevant to the distinction we wish to make. */
1302 bool constant_p = const_flag && init_const;
1304 /* The actual DECL node. CONST_DECL was initially intended for enumerals
1305 and may be used for scalars in general but not for aggregates. */
1307 = build_decl ((constant_p && const_decl_allowed_p
1308 && !AGGREGATE_TYPE_P (type)) ? CONST_DECL : VAR_DECL,
1311 /* If this is external, throw away any initializations (they will be done
1312 elsewhere) unless this is a constant for which we would like to remain
1313 able to get the initializer. If we are defining a global here, leave a
1314 constant initialization and save any variable elaborations for the
1315 elaboration routine. If we are just annotating types, throw away the
1316 initialization if it isn't a constant. */
1317 if ((extern_flag && !constant_p)
1318 || (type_annotate_only && var_init && !TREE_CONSTANT (var_init)))
1319 var_init = NULL_TREE;
1321 /* At the global level, an initializer requiring code to be generated
1322 produces elaboration statements. Check that such statements are allowed,
1323 that is, not violating a No_Elaboration_Code restriction. */
1324 if (global_bindings_p () && var_init != 0 && ! init_const)
1325 Check_Elaboration_Code_Allowed (gnat_node);
1327 /* Ada doesn't feature Fortran-like COMMON variables so we shouldn't
1328 try to fiddle with DECL_COMMON. However, on platforms that don't
1329 support global BSS sections, uninitialized global variables would
1330 go in DATA instead, thus increasing the size of the executable. */
1332 && TREE_CODE (var_decl) == VAR_DECL
1333 && !have_global_bss_p ())
1334 DECL_COMMON (var_decl) = 1;
1335 DECL_INITIAL (var_decl) = var_init;
1336 TREE_READONLY (var_decl) = const_flag;
1337 DECL_EXTERNAL (var_decl) = extern_flag;
1338 TREE_PUBLIC (var_decl) = public_flag || extern_flag;
1339 TREE_CONSTANT (var_decl) = constant_p;
1340 TREE_THIS_VOLATILE (var_decl) = TREE_SIDE_EFFECTS (var_decl)
1341 = TYPE_VOLATILE (type);
1343 /* If it's public and not external, always allocate storage for it.
1344 At the global binding level we need to allocate static storage for the
1345 variable if and only if it's not external. If we are not at the top level
1346 we allocate automatic storage unless requested not to. */
1347 TREE_STATIC (var_decl)
1348 = !extern_flag && (public_flag || static_flag || global_bindings_p ());
1350 if (asm_name && VAR_OR_FUNCTION_DECL_P (var_decl))
1351 SET_DECL_ASSEMBLER_NAME (var_decl, asm_name);
1353 process_attributes (var_decl, attr_list);
1355 /* Add this decl to the current binding level. */
1356 gnat_pushdecl (var_decl, gnat_node);
1358 if (TREE_SIDE_EFFECTS (var_decl))
1359 TREE_ADDRESSABLE (var_decl) = 1;
1361 if (TREE_CODE (var_decl) != CONST_DECL)
1363 if (global_bindings_p ())
1364 rest_of_decl_compilation (var_decl, true, 0);
1367 expand_decl (var_decl);
1372 /* Return true if TYPE, an aggregate type, contains (or is) an array. */
1375 aggregate_type_contains_array_p (tree type)
1377 switch (TREE_CODE (type))
1381 case QUAL_UNION_TYPE:
1384 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1385 if (AGGREGATE_TYPE_P (TREE_TYPE (field))
1386 && aggregate_type_contains_array_p (TREE_TYPE (field)))
1399 /* Returns a FIELD_DECL node. FIELD_NAME the field name, FIELD_TYPE is its
1400 type, and RECORD_TYPE is the type of the parent. PACKED is nonzero if
1401 this field is in a record type with a "pragma pack". If SIZE is nonzero
1402 it is the specified size for this field. If POS is nonzero, it is the bit
1403 position. If ADDRESSABLE is nonzero, it means we are allowed to take
1404 the address of this field for aliasing purposes. If it is negative, we
1405 should not make a bitfield, which is used by make_aligning_type. */
1408 create_field_decl (tree field_name, tree field_type, tree record_type,
1409 int packed, tree size, tree pos, int addressable)
1411 tree field_decl = build_decl (FIELD_DECL, field_name, field_type);
1413 DECL_CONTEXT (field_decl) = record_type;
1414 TREE_READONLY (field_decl) = TYPE_READONLY (field_type);
1416 /* If FIELD_TYPE is BLKmode, we must ensure this is aligned to at least a
1417 byte boundary since GCC cannot handle less-aligned BLKmode bitfields.
1418 Likewise for an aggregate without specified position that contains an
1419 array, because in this case slices of variable length of this array
1420 must be handled by GCC and variable-sized objects need to be aligned
1421 to at least a byte boundary. */
1422 if (packed && (TYPE_MODE (field_type) == BLKmode
1424 && AGGREGATE_TYPE_P (field_type)
1425 && aggregate_type_contains_array_p (field_type))))
1426 DECL_ALIGN (field_decl) = BITS_PER_UNIT;
1428 /* If a size is specified, use it. Otherwise, if the record type is packed
1429 compute a size to use, which may differ from the object's natural size.
1430 We always set a size in this case to trigger the checks for bitfield
1431 creation below, which is typically required when no position has been
1434 size = convert (bitsizetype, size);
1435 else if (packed == 1)
1437 size = rm_size (field_type);
1439 /* For a constant size larger than MAX_FIXED_MODE_SIZE, round up to
1441 if (TREE_CODE (size) == INTEGER_CST
1442 && compare_tree_int (size, MAX_FIXED_MODE_SIZE) > 0)
1443 size = round_up (size, BITS_PER_UNIT);
1446 /* If we may, according to ADDRESSABLE, make a bitfield if a size is
1447 specified for two reasons: first if the size differs from the natural
1448 size. Second, if the alignment is insufficient. There are a number of
1449 ways the latter can be true.
1451 We never make a bitfield if the type of the field has a nonconstant size,
1452 because no such entity requiring bitfield operations should reach here.
1454 We do *preventively* make a bitfield when there might be the need for it
1455 but we don't have all the necessary information to decide, as is the case
1456 of a field with no specified position in a packed record.
1458 We also don't look at STRICT_ALIGNMENT here, and rely on later processing
1459 in layout_decl or finish_record_type to clear the bit_field indication if
1460 it is in fact not needed. */
1461 if (addressable >= 0
1463 && TREE_CODE (size) == INTEGER_CST
1464 && TREE_CODE (TYPE_SIZE (field_type)) == INTEGER_CST
1465 && (!tree_int_cst_equal (size, TYPE_SIZE (field_type))
1466 || (pos && !value_factor_p (pos, TYPE_ALIGN (field_type)))
1468 || (TYPE_ALIGN (record_type) != 0
1469 && TYPE_ALIGN (record_type) < TYPE_ALIGN (field_type))))
1471 DECL_BIT_FIELD (field_decl) = 1;
1472 DECL_SIZE (field_decl) = size;
1473 if (!packed && !pos)
1474 DECL_ALIGN (field_decl)
1475 = (TYPE_ALIGN (record_type) != 0
1476 ? MIN (TYPE_ALIGN (record_type), TYPE_ALIGN (field_type))
1477 : TYPE_ALIGN (field_type));
1480 DECL_PACKED (field_decl) = pos ? DECL_BIT_FIELD (field_decl) : packed;
1482 /* Bump the alignment if need be, either for bitfield/packing purposes or
1483 to satisfy the type requirements if no such consideration applies. When
1484 we get the alignment from the type, indicate if this is from an explicit
1485 user request, which prevents stor-layout from lowering it later on. */
1487 unsigned int bit_align
1488 = (DECL_BIT_FIELD (field_decl) ? 1
1489 : packed && TYPE_MODE (field_type) != BLKmode ? BITS_PER_UNIT : 0);
1491 if (bit_align > DECL_ALIGN (field_decl))
1492 DECL_ALIGN (field_decl) = bit_align;
1493 else if (!bit_align && TYPE_ALIGN (field_type) > DECL_ALIGN (field_decl))
1495 DECL_ALIGN (field_decl) = TYPE_ALIGN (field_type);
1496 DECL_USER_ALIGN (field_decl) = TYPE_USER_ALIGN (field_type);
1502 /* We need to pass in the alignment the DECL is known to have.
1503 This is the lowest-order bit set in POS, but no more than
1504 the alignment of the record, if one is specified. Note
1505 that an alignment of 0 is taken as infinite. */
1506 unsigned int known_align;
1508 if (host_integerp (pos, 1))
1509 known_align = tree_low_cst (pos, 1) & - tree_low_cst (pos, 1);
1511 known_align = BITS_PER_UNIT;
1513 if (TYPE_ALIGN (record_type)
1514 && (known_align == 0 || known_align > TYPE_ALIGN (record_type)))
1515 known_align = TYPE_ALIGN (record_type);
1517 layout_decl (field_decl, known_align);
1518 SET_DECL_OFFSET_ALIGN (field_decl,
1519 host_integerp (pos, 1) ? BIGGEST_ALIGNMENT
1521 pos_from_bit (&DECL_FIELD_OFFSET (field_decl),
1522 &DECL_FIELD_BIT_OFFSET (field_decl),
1523 DECL_OFFSET_ALIGN (field_decl), pos);
1525 DECL_HAS_REP_P (field_decl) = 1;
1528 /* In addition to what our caller says, claim the field is addressable if we
1529 know that its type is not suitable.
1531 The field may also be "technically" nonaddressable, meaning that even if
1532 we attempt to take the field's address we will actually get the address
1533 of a copy. This is the case for true bitfields, but the DECL_BIT_FIELD
1534 value we have at this point is not accurate enough, so we don't account
1535 for this here and let finish_record_type decide. */
1536 if (!addressable && !type_for_nonaliased_component_p (field_type))
1539 DECL_NONADDRESSABLE_P (field_decl) = !addressable;
1544 /* Returns a PARM_DECL node. PARAM_NAME is the name of the parameter,
1545 PARAM_TYPE is its type. READONLY is true if the parameter is
1546 readonly (either an In parameter or an address of a pass-by-ref
1550 create_param_decl (tree param_name, tree param_type, bool readonly)
1552 tree param_decl = build_decl (PARM_DECL, param_name, param_type);
1554 /* Honor targetm.calls.promote_prototypes(), as not doing so can
1555 lead to various ABI violations. */
1556 if (targetm.calls.promote_prototypes (param_type)
1557 && (TREE_CODE (param_type) == INTEGER_TYPE
1558 || TREE_CODE (param_type) == ENUMERAL_TYPE
1559 || TREE_CODE (param_type) == BOOLEAN_TYPE)
1560 && TYPE_PRECISION (param_type) < TYPE_PRECISION (integer_type_node))
1562 /* We have to be careful about biased types here. Make a subtype
1563 of integer_type_node with the proper biasing. */
1564 if (TREE_CODE (param_type) == INTEGER_TYPE
1565 && TYPE_BIASED_REPRESENTATION_P (param_type))
1568 = copy_type (build_range_type (integer_type_node,
1569 TYPE_MIN_VALUE (param_type),
1570 TYPE_MAX_VALUE (param_type)));
1572 TYPE_BIASED_REPRESENTATION_P (param_type) = 1;
1575 param_type = integer_type_node;
1578 DECL_ARG_TYPE (param_decl) = param_type;
1579 TREE_READONLY (param_decl) = readonly;
1583 /* Given a DECL and ATTR_LIST, process the listed attributes. */
1586 process_attributes (tree decl, struct attrib *attr_list)
1588 for (; attr_list; attr_list = attr_list->next)
1589 switch (attr_list->type)
1591 case ATTR_MACHINE_ATTRIBUTE:
1592 decl_attributes (&decl, tree_cons (attr_list->name, attr_list->args,
1594 ATTR_FLAG_TYPE_IN_PLACE);
1597 case ATTR_LINK_ALIAS:
1598 if (! DECL_EXTERNAL (decl))
1600 TREE_STATIC (decl) = 1;
1601 assemble_alias (decl, attr_list->name);
1605 case ATTR_WEAK_EXTERNAL:
1607 declare_weak (decl);
1609 post_error ("?weak declarations not supported on this target",
1610 attr_list->error_point);
1613 case ATTR_LINK_SECTION:
1614 if (targetm.have_named_sections)
1616 DECL_SECTION_NAME (decl)
1617 = build_string (IDENTIFIER_LENGTH (attr_list->name),
1618 IDENTIFIER_POINTER (attr_list->name));
1619 DECL_COMMON (decl) = 0;
1622 post_error ("?section attributes are not supported for this target",
1623 attr_list->error_point);
1626 case ATTR_LINK_CONSTRUCTOR:
1627 DECL_STATIC_CONSTRUCTOR (decl) = 1;
1628 TREE_USED (decl) = 1;
1631 case ATTR_LINK_DESTRUCTOR:
1632 DECL_STATIC_DESTRUCTOR (decl) = 1;
1633 TREE_USED (decl) = 1;
1636 case ATTR_THREAD_LOCAL_STORAGE:
1637 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
1638 DECL_COMMON (decl) = 0;
1643 /* Record a global renaming pointer. */
1646 record_global_renaming_pointer (tree decl)
1648 gcc_assert (DECL_RENAMED_OBJECT (decl));
1649 VEC_safe_push (tree, gc, global_renaming_pointers, decl);
1652 /* Invalidate the global renaming pointers. */
1655 invalidate_global_renaming_pointers (void)
1660 for (i = 0; VEC_iterate(tree, global_renaming_pointers, i, iter); i++)
1661 SET_DECL_RENAMED_OBJECT (iter, NULL_TREE);
1663 VEC_free (tree, gc, global_renaming_pointers);
1666 /* Return true if VALUE is a known to be a multiple of FACTOR, which must be
1670 value_factor_p (tree value, HOST_WIDE_INT factor)
1672 if (host_integerp (value, 1))
1673 return tree_low_cst (value, 1) % factor == 0;
1675 if (TREE_CODE (value) == MULT_EXPR)
1676 return (value_factor_p (TREE_OPERAND (value, 0), factor)
1677 || value_factor_p (TREE_OPERAND (value, 1), factor));
1682 /* Given 2 consecutive field decls PREV_FIELD and CURR_FIELD, return true
1683 unless we can prove these 2 fields are laid out in such a way that no gap
1684 exist between the end of PREV_FIELD and the beginning of CURR_FIELD. OFFSET
1685 is the distance in bits between the end of PREV_FIELD and the starting
1686 position of CURR_FIELD. It is ignored if null. */
1689 potential_alignment_gap (tree prev_field, tree curr_field, tree offset)
1691 /* If this is the first field of the record, there cannot be any gap */
1695 /* If the previous field is a union type, then return False: The only
1696 time when such a field is not the last field of the record is when
1697 there are other components at fixed positions after it (meaning there
1698 was a rep clause for every field), in which case we don't want the
1699 alignment constraint to override them. */
1700 if (TREE_CODE (TREE_TYPE (prev_field)) == QUAL_UNION_TYPE)
1703 /* If the distance between the end of prev_field and the beginning of
1704 curr_field is constant, then there is a gap if the value of this
1705 constant is not null. */
1706 if (offset && host_integerp (offset, 1))
1707 return !integer_zerop (offset);
1709 /* If the size and position of the previous field are constant,
1710 then check the sum of this size and position. There will be a gap
1711 iff it is not multiple of the current field alignment. */
1712 if (host_integerp (DECL_SIZE (prev_field), 1)
1713 && host_integerp (bit_position (prev_field), 1))
1714 return ((tree_low_cst (bit_position (prev_field), 1)
1715 + tree_low_cst (DECL_SIZE (prev_field), 1))
1716 % DECL_ALIGN (curr_field) != 0);
1718 /* If both the position and size of the previous field are multiples
1719 of the current field alignment, there cannot be any gap. */
1720 if (value_factor_p (bit_position (prev_field), DECL_ALIGN (curr_field))
1721 && value_factor_p (DECL_SIZE (prev_field), DECL_ALIGN (curr_field)))
1724 /* Fallback, return that there may be a potential gap */
1728 /* Returns a LABEL_DECL node for LABEL_NAME. */
1731 create_label_decl (tree label_name)
1733 tree label_decl = build_decl (LABEL_DECL, label_name, void_type_node);
1735 DECL_CONTEXT (label_decl) = current_function_decl;
1736 DECL_MODE (label_decl) = VOIDmode;
1737 DECL_SOURCE_LOCATION (label_decl) = input_location;
1742 /* Returns a FUNCTION_DECL node. SUBPROG_NAME is the name of the subprogram,
1743 ASM_NAME is its assembler name, SUBPROG_TYPE is its type (a FUNCTION_TYPE
1744 node), PARAM_DECL_LIST is the list of the subprogram arguments (a list of
1745 PARM_DECL nodes chained through the TREE_CHAIN field).
1747 INLINE_FLAG, PUBLIC_FLAG, EXTERN_FLAG, and ATTR_LIST are used to set the
1748 appropriate fields in the FUNCTION_DECL. GNAT_NODE gives the location. */
1751 create_subprog_decl (tree subprog_name, tree asm_name,
1752 tree subprog_type, tree param_decl_list, bool inline_flag,
1753 bool public_flag, bool extern_flag,
1754 struct attrib *attr_list, Node_Id gnat_node)
1756 tree return_type = TREE_TYPE (subprog_type);
1757 tree subprog_decl = build_decl (FUNCTION_DECL, subprog_name, subprog_type);
1759 /* If this is a non-inline function nested inside an inlined external
1760 function, we cannot honor both requests without cloning the nested
1761 function in the current unit since it is private to the other unit.
1762 We could inline the nested function as well but it's probably better
1763 to err on the side of too little inlining. */
1765 && current_function_decl
1766 && DECL_DECLARED_INLINE_P (current_function_decl)
1767 && DECL_EXTERNAL (current_function_decl))
1768 DECL_DECLARED_INLINE_P (current_function_decl) = 0;
1770 DECL_EXTERNAL (subprog_decl) = extern_flag;
1771 TREE_PUBLIC (subprog_decl) = public_flag;
1772 TREE_STATIC (subprog_decl) = 1;
1773 TREE_READONLY (subprog_decl) = TYPE_READONLY (subprog_type);
1774 TREE_THIS_VOLATILE (subprog_decl) = TYPE_VOLATILE (subprog_type);
1775 TREE_SIDE_EFFECTS (subprog_decl) = TYPE_VOLATILE (subprog_type);
1776 DECL_DECLARED_INLINE_P (subprog_decl) = inline_flag;
1777 DECL_ARGUMENTS (subprog_decl) = param_decl_list;
1778 DECL_RESULT (subprog_decl) = build_decl (RESULT_DECL, 0, return_type);
1779 DECL_ARTIFICIAL (DECL_RESULT (subprog_decl)) = 1;
1780 DECL_IGNORED_P (DECL_RESULT (subprog_decl)) = 1;
1782 /* TREE_ADDRESSABLE is set on the result type to request the use of the
1783 target by-reference return mechanism. This is not supported all the
1784 way down to RTL expansion with GCC 4, which ICEs on temporary creation
1785 attempts with such a type and expects DECL_BY_REFERENCE to be set on
1786 the RESULT_DECL instead - see gnat_genericize for more details. */
1787 if (TREE_ADDRESSABLE (TREE_TYPE (DECL_RESULT (subprog_decl))))
1789 tree result_decl = DECL_RESULT (subprog_decl);
1791 TREE_ADDRESSABLE (TREE_TYPE (result_decl)) = 0;
1792 DECL_BY_REFERENCE (result_decl) = 1;
1797 SET_DECL_ASSEMBLER_NAME (subprog_decl, asm_name);
1799 /* The expand_main_function circuitry expects "main_identifier_node" to
1800 designate the DECL_NAME of the 'main' entry point, in turn expected
1801 to be declared as the "main" function literally by default. Ada
1802 program entry points are typically declared with a different name
1803 within the binder generated file, exported as 'main' to satisfy the
1804 system expectations. Redirect main_identifier_node in this case. */
1805 if (asm_name == main_identifier_node)
1806 main_identifier_node = DECL_NAME (subprog_decl);
1809 process_attributes (subprog_decl, attr_list);
1811 /* Add this decl to the current binding level. */
1812 gnat_pushdecl (subprog_decl, gnat_node);
1814 /* Output the assembler code and/or RTL for the declaration. */
1815 rest_of_decl_compilation (subprog_decl, global_bindings_p (), 0);
1817 return subprog_decl;
1820 /* Set up the framework for generating code for SUBPROG_DECL, a subprogram
1821 body. This routine needs to be invoked before processing the declarations
1822 appearing in the subprogram. */
1825 begin_subprog_body (tree subprog_decl)
1829 current_function_decl = subprog_decl;
1830 announce_function (subprog_decl);
1832 /* Enter a new binding level and show that all the parameters belong to
1835 for (param_decl = DECL_ARGUMENTS (subprog_decl); param_decl;
1836 param_decl = TREE_CHAIN (param_decl))
1837 DECL_CONTEXT (param_decl) = subprog_decl;
1839 make_decl_rtl (subprog_decl);
1841 /* We handle pending sizes via the elaboration of types, so we don't need to
1842 save them. This causes them to be marked as part of the outer function
1843 and then discarded. */
1844 get_pending_sizes ();
1848 /* Helper for the genericization callback. Return a dereference of VAL
1849 if it is of a reference type. */
1852 convert_from_reference (tree val)
1854 tree value_type, ref;
1856 if (TREE_CODE (TREE_TYPE (val)) != REFERENCE_TYPE)
1859 value_type = TREE_TYPE (TREE_TYPE (val));
1860 ref = build1 (INDIRECT_REF, value_type, val);
1862 /* See if what we reference is CONST or VOLATILE, which requires
1863 looking into array types to get to the component type. */
1865 while (TREE_CODE (value_type) == ARRAY_TYPE)
1866 value_type = TREE_TYPE (value_type);
1869 = (TYPE_QUALS (value_type) & TYPE_QUAL_CONST);
1870 TREE_THIS_VOLATILE (ref)
1871 = (TYPE_QUALS (value_type) & TYPE_QUAL_VOLATILE);
1873 TREE_SIDE_EFFECTS (ref)
1874 = (TREE_THIS_VOLATILE (ref) || TREE_SIDE_EFFECTS (val));
1879 /* Helper for the genericization callback. Returns true if T denotes
1880 a RESULT_DECL with DECL_BY_REFERENCE set. */
1883 is_byref_result (tree t)
1885 return (TREE_CODE (t) == RESULT_DECL && DECL_BY_REFERENCE (t));
1889 /* Tree walking callback for gnat_genericize. Currently ...
1891 o Adjust references to the function's DECL_RESULT if it is marked
1892 DECL_BY_REFERENCE and so has had its type turned into a reference
1893 type at the end of the function compilation. */
1896 gnat_genericize_r (tree *stmt_p, int *walk_subtrees, void *data)
1898 /* This implementation is modeled after what the C++ front-end is
1899 doing, basis of the downstream passes behavior. */
1901 tree stmt = *stmt_p;
1902 struct pointer_set_t *p_set = (struct pointer_set_t*) data;
1904 /* If we have a direct mention of the result decl, dereference. */
1905 if (is_byref_result (stmt))
1907 *stmt_p = convert_from_reference (stmt);
1912 /* Otherwise, no need to walk the same tree twice. */
1913 if (pointer_set_contains (p_set, stmt))
1919 /* If we are taking the address of what now is a reference, just get the
1921 if (TREE_CODE (stmt) == ADDR_EXPR
1922 && is_byref_result (TREE_OPERAND (stmt, 0)))
1924 *stmt_p = convert (TREE_TYPE (stmt), TREE_OPERAND (stmt, 0));
1928 /* Don't dereference an by-reference RESULT_DECL inside a RETURN_EXPR. */
1929 else if (TREE_CODE (stmt) == RETURN_EXPR
1930 && TREE_OPERAND (stmt, 0)
1931 && is_byref_result (TREE_OPERAND (stmt, 0)))
1934 /* Don't look inside trees that cannot embed references of interest. */
1935 else if (IS_TYPE_OR_DECL_P (stmt))
1938 pointer_set_insert (p_set, *stmt_p);
1943 /* Perform lowering of Ada trees to GENERIC. In particular:
1945 o Turn a DECL_BY_REFERENCE RESULT_DECL into a real by-reference decl
1946 and adjust all the references to this decl accordingly. */
1949 gnat_genericize (tree fndecl)
1951 /* Prior to GCC 4, an explicit By_Reference result mechanism for a function
1952 was handled by simply setting TREE_ADDRESSABLE on the result type.
1953 Everything required to actually pass by invisible ref using the target
1954 mechanism (e.g. extra parameter) was handled at RTL expansion time.
1956 This doesn't work with GCC 4 any more for several reasons. First, the
1957 gimplification process might need the creation of temporaries of this
1958 type, and the gimplifier ICEs on such attempts. Second, the middle-end
1959 now relies on a different attribute for such cases (DECL_BY_REFERENCE on
1960 RESULT/PARM_DECLs), and expects the user invisible by-reference-ness to
1961 be explicitly accounted for by the front-end in the function body.
1963 We achieve the complete transformation in two steps:
1965 1/ create_subprog_decl performs early attribute tweaks: it clears
1966 TREE_ADDRESSABLE from the result type and sets DECL_BY_REFERENCE on
1967 the result decl. The former ensures that the bit isn't set in the GCC
1968 tree saved for the function, so prevents ICEs on temporary creation.
1969 The latter we use here to trigger the rest of the processing.
1971 2/ This function performs the type transformation on the result decl
1972 and adjusts all the references to this decl from the function body
1975 Clearing TREE_ADDRESSABLE from the type differs from the C++ front-end
1976 strategy, which escapes the gimplifier temporary creation issues by
1977 creating it's own temporaries using TARGET_EXPR nodes. Our way relies
1978 on simple specific support code in aggregate_value_p to look at the
1979 target function result decl explicitly. */
1981 struct pointer_set_t *p_set;
1982 tree decl_result = DECL_RESULT (fndecl);
1984 if (!DECL_BY_REFERENCE (decl_result))
1987 /* Make the DECL_RESULT explicitly by-reference and adjust all the
1988 occurrences in the function body using the common tree-walking facility.
1989 We want to see every occurrence of the result decl to adjust the
1990 referencing tree, so need to use our own pointer set to control which
1991 trees should be visited again or not. */
1993 p_set = pointer_set_create ();
1995 TREE_TYPE (decl_result) = build_reference_type (TREE_TYPE (decl_result));
1996 TREE_ADDRESSABLE (decl_result) = 0;
1997 relayout_decl (decl_result);
1999 walk_tree (&DECL_SAVED_TREE (fndecl), gnat_genericize_r, p_set, NULL);
2001 pointer_set_destroy (p_set);
2004 /* Finish the definition of the current subprogram BODY and compile it all the
2005 way to assembler language output. ELAB_P tells if this is called for an
2006 elaboration routine, to be entirely discarded if empty. */
2009 end_subprog_body (tree body, bool elab_p)
2011 tree fndecl = current_function_decl;
2013 /* Mark the BLOCK for this level as being for this function and pop the
2014 level. Since the vars in it are the parameters, clear them. */
2015 BLOCK_VARS (current_binding_level->block) = 0;
2016 BLOCK_SUPERCONTEXT (current_binding_level->block) = fndecl;
2017 DECL_INITIAL (fndecl) = current_binding_level->block;
2020 /* We handle pending sizes via the elaboration of types, so we don't
2021 need to save them. */
2022 get_pending_sizes ();
2024 /* Mark the RESULT_DECL as being in this subprogram. */
2025 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
2027 DECL_SAVED_TREE (fndecl) = body;
2029 current_function_decl = DECL_CONTEXT (fndecl);
2032 /* We cannot track the location of errors past this point. */
2033 error_gnat_node = Empty;
2035 /* If we're only annotating types, don't actually compile this function. */
2036 if (type_annotate_only)
2039 /* Perform the required pre-gimplification transformations on the tree. */
2040 gnat_genericize (fndecl);
2042 /* We do different things for nested and non-nested functions.
2043 ??? This should be in cgraph. */
2044 if (!DECL_CONTEXT (fndecl))
2046 gnat_gimplify_function (fndecl);
2048 /* If this is an empty elaboration proc, just discard the node.
2049 Otherwise, compile further. */
2050 if (elab_p && empty_body_p (gimple_body (fndecl)))
2051 cgraph_remove_node (cgraph_node (fndecl));
2053 cgraph_finalize_function (fndecl, false);
2056 /* Register this function with cgraph just far enough to get it
2057 added to our parent's nested function list. */
2058 (void) cgraph_node (fndecl);
2061 /* Convert FNDECL's code to GIMPLE and handle any nested functions. */
2064 gnat_gimplify_function (tree fndecl)
2066 struct cgraph_node *cgn;
2068 dump_function (TDI_original, fndecl);
2069 gimplify_function_tree (fndecl);
2070 dump_function (TDI_generic, fndecl);
2072 /* Convert all nested functions to GIMPLE now. We do things in this order
2073 so that items like VLA sizes are expanded properly in the context of the
2074 correct function. */
2075 cgn = cgraph_node (fndecl);
2076 for (cgn = cgn->nested; cgn; cgn = cgn->next_nested)
2077 gnat_gimplify_function (cgn->decl);
2081 gnat_builtin_function (tree decl)
2083 gnat_pushdecl (decl, Empty);
2087 /* Return an integer type with the number of bits of precision given by
2088 PRECISION. UNSIGNEDP is nonzero if the type is unsigned; otherwise
2089 it is a signed type. */
2092 gnat_type_for_size (unsigned precision, int unsignedp)
2097 if (precision <= 2 * MAX_BITS_PER_WORD
2098 && signed_and_unsigned_types[precision][unsignedp])
2099 return signed_and_unsigned_types[precision][unsignedp];
2102 t = make_unsigned_type (precision);
2104 t = make_signed_type (precision);
2106 if (precision <= 2 * MAX_BITS_PER_WORD)
2107 signed_and_unsigned_types[precision][unsignedp] = t;
2111 sprintf (type_name, "%sSIGNED_%d", unsignedp ? "UN" : "", precision);
2112 TYPE_NAME (t) = get_identifier (type_name);
2118 /* Likewise for floating-point types. */
2121 float_type_for_precision (int precision, enum machine_mode mode)
2126 if (float_types[(int) mode])
2127 return float_types[(int) mode];
2129 float_types[(int) mode] = t = make_node (REAL_TYPE);
2130 TYPE_PRECISION (t) = precision;
2133 gcc_assert (TYPE_MODE (t) == mode);
2136 sprintf (type_name, "FLOAT_%d", precision);
2137 TYPE_NAME (t) = get_identifier (type_name);
2143 /* Return a data type that has machine mode MODE. UNSIGNEDP selects
2144 an unsigned type; otherwise a signed type is returned. */
2147 gnat_type_for_mode (enum machine_mode mode, int unsignedp)
2149 if (mode == BLKmode)
2151 else if (mode == VOIDmode)
2152 return void_type_node;
2153 else if (COMPLEX_MODE_P (mode))
2155 else if (SCALAR_FLOAT_MODE_P (mode))
2156 return float_type_for_precision (GET_MODE_PRECISION (mode), mode);
2157 else if (SCALAR_INT_MODE_P (mode))
2158 return gnat_type_for_size (GET_MODE_BITSIZE (mode), unsignedp);
2163 /* Return the unsigned version of a TYPE_NODE, a scalar type. */
2166 gnat_unsigned_type (tree type_node)
2168 tree type = gnat_type_for_size (TYPE_PRECISION (type_node), 1);
2170 if (TREE_CODE (type_node) == INTEGER_TYPE && TYPE_MODULAR_P (type_node))
2172 type = copy_node (type);
2173 TREE_TYPE (type) = type_node;
2175 else if (TREE_TYPE (type_node)
2176 && TREE_CODE (TREE_TYPE (type_node)) == INTEGER_TYPE
2177 && TYPE_MODULAR_P (TREE_TYPE (type_node)))
2179 type = copy_node (type);
2180 TREE_TYPE (type) = TREE_TYPE (type_node);
2186 /* Return the signed version of a TYPE_NODE, a scalar type. */
2189 gnat_signed_type (tree type_node)
2191 tree type = gnat_type_for_size (TYPE_PRECISION (type_node), 0);
2193 if (TREE_CODE (type_node) == INTEGER_TYPE && TYPE_MODULAR_P (type_node))
2195 type = copy_node (type);
2196 TREE_TYPE (type) = type_node;
2198 else if (TREE_TYPE (type_node)
2199 && TREE_CODE (TREE_TYPE (type_node)) == INTEGER_TYPE
2200 && TYPE_MODULAR_P (TREE_TYPE (type_node)))
2202 type = copy_node (type);
2203 TREE_TYPE (type) = TREE_TYPE (type_node);
2209 /* Return 1 if the types T1 and T2 are compatible, i.e. if they can be
2210 transparently converted to each other. */
2213 gnat_types_compatible_p (tree t1, tree t2)
2215 enum tree_code code;
2217 /* This is the default criterion. */
2218 if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
2221 /* We only check structural equivalence here. */
2222 if ((code = TREE_CODE (t1)) != TREE_CODE (t2))
2225 /* Array types are also compatible if they are constrained and have
2226 the same component type and the same domain. */
2227 if (code == ARRAY_TYPE
2228 && TREE_TYPE (t1) == TREE_TYPE (t2)
2229 && (TYPE_DOMAIN (t1) == TYPE_DOMAIN (t2)
2230 || (TYPE_DOMAIN (t1)
2232 && tree_int_cst_equal (TYPE_MIN_VALUE (TYPE_DOMAIN (t1)),
2233 TYPE_MIN_VALUE (TYPE_DOMAIN (t2)))
2234 && tree_int_cst_equal (TYPE_MAX_VALUE (TYPE_DOMAIN (t1)),
2235 TYPE_MAX_VALUE (TYPE_DOMAIN (t2))))))
2238 /* Padding record types are also compatible if they pad the same
2239 type and have the same constant size. */
2240 if (code == RECORD_TYPE
2241 && TYPE_IS_PADDING_P (t1) && TYPE_IS_PADDING_P (t2)
2242 && TREE_TYPE (TYPE_FIELDS (t1)) == TREE_TYPE (TYPE_FIELDS (t2))
2243 && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
2249 /* EXP is an expression for the size of an object. If this size contains
2250 discriminant references, replace them with the maximum (if MAX_P) or
2251 minimum (if !MAX_P) possible value of the discriminant. */
2254 max_size (tree exp, bool max_p)
2256 enum tree_code code = TREE_CODE (exp);
2257 tree type = TREE_TYPE (exp);
2259 switch (TREE_CODE_CLASS (code))
2261 case tcc_declaration:
2266 if (code == CALL_EXPR)
2269 int i, n = call_expr_nargs (exp);
2272 argarray = (tree *) alloca (n * sizeof (tree));
2273 for (i = 0; i < n; i++)
2274 argarray[i] = max_size (CALL_EXPR_ARG (exp, i), max_p);
2275 return build_call_array (type, CALL_EXPR_FN (exp), n, argarray);
2280 /* If this contains a PLACEHOLDER_EXPR, it is the thing we want to
2281 modify. Otherwise, we treat it like a variable. */
2282 if (!CONTAINS_PLACEHOLDER_P (exp))
2285 type = TREE_TYPE (TREE_OPERAND (exp, 1));
2287 max_size (max_p ? TYPE_MAX_VALUE (type) : TYPE_MIN_VALUE (type), true);
2289 case tcc_comparison:
2290 return max_p ? size_one_node : size_zero_node;
2294 case tcc_expression:
2295 switch (TREE_CODE_LENGTH (code))
2298 if (code == NON_LVALUE_EXPR)
2299 return max_size (TREE_OPERAND (exp, 0), max_p);
2302 fold_build1 (code, type,
2303 max_size (TREE_OPERAND (exp, 0),
2304 code == NEGATE_EXPR ? !max_p : max_p));
2307 if (code == COMPOUND_EXPR)
2308 return max_size (TREE_OPERAND (exp, 1), max_p);
2310 /* Calculate "(A ? B : C) - D" as "A ? B - D : C - D" which
2311 may provide a tighter bound on max_size. */
2312 if (code == MINUS_EXPR
2313 && TREE_CODE (TREE_OPERAND (exp, 0)) == COND_EXPR)
2315 tree lhs = fold_build2 (MINUS_EXPR, type,
2316 TREE_OPERAND (TREE_OPERAND (exp, 0), 1),
2317 TREE_OPERAND (exp, 1));
2318 tree rhs = fold_build2 (MINUS_EXPR, type,
2319 TREE_OPERAND (TREE_OPERAND (exp, 0), 2),
2320 TREE_OPERAND (exp, 1));
2321 return fold_build2 (max_p ? MAX_EXPR : MIN_EXPR, type,
2322 max_size (lhs, max_p),
2323 max_size (rhs, max_p));
2327 tree lhs = max_size (TREE_OPERAND (exp, 0), max_p);
2328 tree rhs = max_size (TREE_OPERAND (exp, 1),
2329 code == MINUS_EXPR ? !max_p : max_p);
2331 /* Special-case wanting the maximum value of a MIN_EXPR.
2332 In that case, if one side overflows, return the other.
2333 sizetype is signed, but we know sizes are non-negative.
2334 Likewise, handle a MINUS_EXPR or PLUS_EXPR with the LHS
2335 overflowing or the maximum possible value and the RHS
2339 && TREE_CODE (rhs) == INTEGER_CST
2340 && TREE_OVERFLOW (rhs))
2344 && TREE_CODE (lhs) == INTEGER_CST
2345 && TREE_OVERFLOW (lhs))
2347 else if ((code == MINUS_EXPR || code == PLUS_EXPR)
2348 && ((TREE_CODE (lhs) == INTEGER_CST
2349 && TREE_OVERFLOW (lhs))
2350 || operand_equal_p (lhs, TYPE_MAX_VALUE (type), 0))
2351 && !TREE_CONSTANT (rhs))
2354 return fold_build2 (code, type, lhs, rhs);
2358 if (code == SAVE_EXPR)
2360 else if (code == COND_EXPR)
2361 return fold_build2 (max_p ? MAX_EXPR : MIN_EXPR, type,
2362 max_size (TREE_OPERAND (exp, 1), max_p),
2363 max_size (TREE_OPERAND (exp, 2), max_p));
2366 /* Other tree classes cannot happen. */
2374 /* Build a template of type TEMPLATE_TYPE from the array bounds of ARRAY_TYPE.
2375 EXPR is an expression that we can use to locate any PLACEHOLDER_EXPRs.
2376 Return a constructor for the template. */
2379 build_template (tree template_type, tree array_type, tree expr)
2381 tree template_elts = NULL_TREE;
2382 tree bound_list = NULL_TREE;
2385 while (TREE_CODE (array_type) == RECORD_TYPE
2386 && (TYPE_IS_PADDING_P (array_type)
2387 || TYPE_JUSTIFIED_MODULAR_P (array_type)))
2388 array_type = TREE_TYPE (TYPE_FIELDS (array_type));
2390 if (TREE_CODE (array_type) == ARRAY_TYPE
2391 || (TREE_CODE (array_type) == INTEGER_TYPE
2392 && TYPE_HAS_ACTUAL_BOUNDS_P (array_type)))
2393 bound_list = TYPE_ACTUAL_BOUNDS (array_type);
2395 /* First make the list for a CONSTRUCTOR for the template. Go down the
2396 field list of the template instead of the type chain because this
2397 array might be an Ada array of arrays and we can't tell where the
2398 nested arrays stop being the underlying object. */
2400 for (field = TYPE_FIELDS (template_type); field;
2402 ? (bound_list = TREE_CHAIN (bound_list))
2403 : (array_type = TREE_TYPE (array_type))),
2404 field = TREE_CHAIN (TREE_CHAIN (field)))
2406 tree bounds, min, max;
2408 /* If we have a bound list, get the bounds from there. Likewise
2409 for an ARRAY_TYPE. Otherwise, if expr is a PARM_DECL with
2410 DECL_BY_COMPONENT_PTR_P, use the bounds of the field in the template.
2411 This will give us a maximum range. */
2413 bounds = TREE_VALUE (bound_list);
2414 else if (TREE_CODE (array_type) == ARRAY_TYPE)
2415 bounds = TYPE_INDEX_TYPE (TYPE_DOMAIN (array_type));
2416 else if (expr && TREE_CODE (expr) == PARM_DECL
2417 && DECL_BY_COMPONENT_PTR_P (expr))
2418 bounds = TREE_TYPE (field);
2422 min = convert (TREE_TYPE (field), TYPE_MIN_VALUE (bounds));
2423 max = convert (TREE_TYPE (TREE_CHAIN (field)), TYPE_MAX_VALUE (bounds));
2425 /* If either MIN or MAX involve a PLACEHOLDER_EXPR, we must
2426 substitute it from OBJECT. */
2427 min = SUBSTITUTE_PLACEHOLDER_IN_EXPR (min, expr);
2428 max = SUBSTITUTE_PLACEHOLDER_IN_EXPR (max, expr);
2430 template_elts = tree_cons (TREE_CHAIN (field), max,
2431 tree_cons (field, min, template_elts));
2434 return gnat_build_constructor (template_type, nreverse (template_elts));
2437 /* Build a 32bit VMS descriptor from a Mechanism_Type, which must specify
2438 a descriptor type, and the GCC type of an object. Each FIELD_DECL
2439 in the type contains in its DECL_INITIAL the expression to use when
2440 a constructor is made for the type. GNAT_ENTITY is an entity used
2441 to print out an error message if the mechanism cannot be applied to
2442 an object of that type and also for the name. */
2445 build_vms_descriptor32 (tree type, Mechanism_Type mech, Entity_Id gnat_entity)
2447 tree record_type = make_node (RECORD_TYPE);
2448 tree pointer32_type;
2449 tree field_list = 0;
2458 /* If TYPE is an unconstrained array, use the underlying array type. */
2459 if (TREE_CODE (type) == UNCONSTRAINED_ARRAY_TYPE)
2460 type = TREE_TYPE (TREE_TYPE (TYPE_FIELDS (TREE_TYPE (type))));
2462 /* If this is an array, compute the number of dimensions in the array,
2463 get the index types, and point to the inner type. */
2464 if (TREE_CODE (type) != ARRAY_TYPE)
2467 for (ndim = 1, inner_type = type;
2468 TREE_CODE (TREE_TYPE (inner_type)) == ARRAY_TYPE
2469 && TYPE_MULTI_ARRAY_P (TREE_TYPE (inner_type));
2470 ndim++, inner_type = TREE_TYPE (inner_type))
2473 idx_arr = (tree *) alloca (ndim * sizeof (tree));
2475 if (mech != By_Descriptor_NCA && mech != By_Short_Descriptor_NCA
2476 && TREE_CODE (type) == ARRAY_TYPE && TYPE_CONVENTION_FORTRAN_P (type))
2477 for (i = ndim - 1, inner_type = type;
2479 i--, inner_type = TREE_TYPE (inner_type))
2480 idx_arr[i] = TYPE_DOMAIN (inner_type);
2482 for (i = 0, inner_type = type;
2484 i++, inner_type = TREE_TYPE (inner_type))
2485 idx_arr[i] = TYPE_DOMAIN (inner_type);
2487 /* Now get the DTYPE value. */
2488 switch (TREE_CODE (type))
2493 if (TYPE_VAX_FLOATING_POINT_P (type))
2494 switch (tree_low_cst (TYPE_DIGITS_VALUE (type), 1))
2507 switch (GET_MODE_BITSIZE (TYPE_MODE (type)))
2510 dtype = TYPE_UNSIGNED (type) ? 2 : 6;
2513 dtype = TYPE_UNSIGNED (type) ? 3 : 7;
2516 dtype = TYPE_UNSIGNED (type) ? 4 : 8;
2519 dtype = TYPE_UNSIGNED (type) ? 5 : 9;
2522 dtype = TYPE_UNSIGNED (type) ? 25 : 26;
2528 dtype = GET_MODE_BITSIZE (TYPE_MODE (type)) == 32 ? 52 : 53;
2532 if (TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE
2533 && TYPE_VAX_FLOATING_POINT_P (type))
2534 switch (tree_low_cst (TYPE_DIGITS_VALUE (type), 1))
2546 dtype = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (type))) == 32 ? 54: 55;
2557 /* Get the CLASS value. */
2560 case By_Descriptor_A:
2561 case By_Short_Descriptor_A:
2564 case By_Descriptor_NCA:
2565 case By_Short_Descriptor_NCA:
2568 case By_Descriptor_SB:
2569 case By_Short_Descriptor_SB:
2573 case By_Short_Descriptor:
2574 case By_Descriptor_S:
2575 case By_Short_Descriptor_S:
2581 /* Make the type for a descriptor for VMS. The first four fields
2582 are the same for all types. */
2585 = chainon (field_list,
2586 make_descriptor_field
2587 ("LENGTH", gnat_type_for_size (16, 1), record_type,
2588 size_in_bytes ((mech == By_Descriptor_A ||
2589 mech == By_Short_Descriptor_A)
2590 ? inner_type : type)));
2592 field_list = chainon (field_list,
2593 make_descriptor_field ("DTYPE",
2594 gnat_type_for_size (8, 1),
2595 record_type, size_int (dtype)));
2596 field_list = chainon (field_list,
2597 make_descriptor_field ("CLASS",
2598 gnat_type_for_size (8, 1),
2599 record_type, size_int (class)));
2601 /* Of course this will crash at run-time if the address space is not
2602 within the low 32 bits, but there is nothing else we can do. */
2603 pointer32_type = build_pointer_type_for_mode (type, SImode, false);
2606 = chainon (field_list,
2607 make_descriptor_field
2608 ("POINTER", pointer32_type, record_type,
2609 build_unary_op (ADDR_EXPR,
2611 build0 (PLACEHOLDER_EXPR, type))));
2616 case By_Short_Descriptor:
2617 case By_Descriptor_S:
2618 case By_Short_Descriptor_S:
2621 case By_Descriptor_SB:
2622 case By_Short_Descriptor_SB:
2624 = chainon (field_list,
2625 make_descriptor_field
2626 ("SB_L1", gnat_type_for_size (32, 1), record_type,
2627 TREE_CODE (type) == ARRAY_TYPE
2628 ? TYPE_MIN_VALUE (TYPE_DOMAIN (type)) : size_zero_node));
2630 = chainon (field_list,
2631 make_descriptor_field
2632 ("SB_U1", gnat_type_for_size (32, 1), record_type,
2633 TREE_CODE (type) == ARRAY_TYPE
2634 ? TYPE_MAX_VALUE (TYPE_DOMAIN (type)) : size_zero_node));
2637 case By_Descriptor_A:
2638 case By_Short_Descriptor_A:
2639 case By_Descriptor_NCA:
2640 case By_Short_Descriptor_NCA:
2641 field_list = chainon (field_list,
2642 make_descriptor_field ("SCALE",
2643 gnat_type_for_size (8, 1),
2647 field_list = chainon (field_list,
2648 make_descriptor_field ("DIGITS",
2649 gnat_type_for_size (8, 1),
2654 = chainon (field_list,
2655 make_descriptor_field
2656 ("AFLAGS", gnat_type_for_size (8, 1), record_type,
2657 size_int ((mech == By_Descriptor_NCA ||
2658 mech == By_Short_Descriptor_NCA)
2660 /* Set FL_COLUMN, FL_COEFF, and FL_BOUNDS. */
2661 : (TREE_CODE (type) == ARRAY_TYPE
2662 && TYPE_CONVENTION_FORTRAN_P (type)
2665 field_list = chainon (field_list,
2666 make_descriptor_field ("DIMCT",
2667 gnat_type_for_size (8, 1),
2671 field_list = chainon (field_list,
2672 make_descriptor_field ("ARSIZE",
2673 gnat_type_for_size (32, 1),
2675 size_in_bytes (type)));
2677 /* Now build a pointer to the 0,0,0... element. */
2678 tem = build0 (PLACEHOLDER_EXPR, type);
2679 for (i = 0, inner_type = type; i < ndim;
2680 i++, inner_type = TREE_TYPE (inner_type))
2681 tem = build4 (ARRAY_REF, TREE_TYPE (inner_type), tem,
2682 convert (TYPE_DOMAIN (inner_type), size_zero_node),
2683 NULL_TREE, NULL_TREE);
2686 = chainon (field_list,
2687 make_descriptor_field
2689 build_pointer_type_for_mode (inner_type, SImode, false),
2692 build_pointer_type_for_mode (inner_type, SImode,
2696 /* Next come the addressing coefficients. */
2697 tem = size_one_node;
2698 for (i = 0; i < ndim; i++)
2702 = size_binop (MULT_EXPR, tem,
2703 size_binop (PLUS_EXPR,
2704 size_binop (MINUS_EXPR,
2705 TYPE_MAX_VALUE (idx_arr[i]),
2706 TYPE_MIN_VALUE (idx_arr[i])),
2709 fname[0] = ((mech == By_Descriptor_NCA ||
2710 mech == By_Short_Descriptor_NCA) ? 'S' : 'M');
2711 fname[1] = '0' + i, fname[2] = 0;
2713 = chainon (field_list,
2714 make_descriptor_field (fname,
2715 gnat_type_for_size (32, 1),
2716 record_type, idx_length));
2718 if (mech == By_Descriptor_NCA || mech == By_Short_Descriptor_NCA)
2722 /* Finally here are the bounds. */
2723 for (i = 0; i < ndim; i++)
2727 fname[0] = 'L', fname[1] = '0' + i, fname[2] = 0;
2729 = chainon (field_list,
2730 make_descriptor_field
2731 (fname, gnat_type_for_size (32, 1), record_type,
2732 TYPE_MIN_VALUE (idx_arr[i])));
2736 = chainon (field_list,
2737 make_descriptor_field
2738 (fname, gnat_type_for_size (32, 1), record_type,
2739 TYPE_MAX_VALUE (idx_arr[i])));
2744 post_error ("unsupported descriptor type for &", gnat_entity);
2747 TYPE_NAME (record_type) = create_concat_name (gnat_entity, "DESC");
2748 finish_record_type (record_type, field_list, 0, true);
2752 /* Build a 64bit VMS descriptor from a Mechanism_Type, which must specify
2753 a descriptor type, and the GCC type of an object. Each FIELD_DECL
2754 in the type contains in its DECL_INITIAL the expression to use when
2755 a constructor is made for the type. GNAT_ENTITY is an entity used
2756 to print out an error message if the mechanism cannot be applied to
2757 an object of that type and also for the name. */
2760 build_vms_descriptor (tree type, Mechanism_Type mech, Entity_Id gnat_entity)
2762 tree record64_type = make_node (RECORD_TYPE);
2763 tree pointer64_type;
2764 tree field_list64 = 0;
2773 /* If TYPE is an unconstrained array, use the underlying array type. */
2774 if (TREE_CODE (type) == UNCONSTRAINED_ARRAY_TYPE)
2775 type = TREE_TYPE (TREE_TYPE (TYPE_FIELDS (TREE_TYPE (type))));
2777 /* If this is an array, compute the number of dimensions in the array,
2778 get the index types, and point to the inner type. */
2779 if (TREE_CODE (type) != ARRAY_TYPE)
2782 for (ndim = 1, inner_type = type;
2783 TREE_CODE (TREE_TYPE (inner_type)) == ARRAY_TYPE
2784 && TYPE_MULTI_ARRAY_P (TREE_TYPE (inner_type));
2785 ndim++, inner_type = TREE_TYPE (inner_type))
2788 idx_arr = (tree *) alloca (ndim * sizeof (tree));
2790 if (mech != By_Descriptor_NCA
2791 && TREE_CODE (type) == ARRAY_TYPE && TYPE_CONVENTION_FORTRAN_P (type))
2792 for (i = ndim - 1, inner_type = type;
2794 i--, inner_type = TREE_TYPE (inner_type))
2795 idx_arr[i] = TYPE_DOMAIN (inner_type);
2797 for (i = 0, inner_type = type;
2799 i++, inner_type = TREE_TYPE (inner_type))
2800 idx_arr[i] = TYPE_DOMAIN (inner_type);
2802 /* Now get the DTYPE value. */
2803 switch (TREE_CODE (type))
2808 if (TYPE_VAX_FLOATING_POINT_P (type))
2809 switch (tree_low_cst (TYPE_DIGITS_VALUE (type), 1))
2822 switch (GET_MODE_BITSIZE (TYPE_MODE (type)))
2825 dtype = TYPE_UNSIGNED (type) ? 2 : 6;
2828 dtype = TYPE_UNSIGNED (type) ? 3 : 7;
2831 dtype = TYPE_UNSIGNED (type) ? 4 : 8;
2834 dtype = TYPE_UNSIGNED (type) ? 5 : 9;
2837 dtype = TYPE_UNSIGNED (type) ? 25 : 26;
2843 dtype = GET_MODE_BITSIZE (TYPE_MODE (type)) == 32 ? 52 : 53;
2847 if (TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE
2848 && TYPE_VAX_FLOATING_POINT_P (type))
2849 switch (tree_low_cst (TYPE_DIGITS_VALUE (type), 1))
2861 dtype = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (type))) == 32 ? 54: 55;
2872 /* Get the CLASS value. */
2875 case By_Descriptor_A:
2878 case By_Descriptor_NCA:
2881 case By_Descriptor_SB:
2885 case By_Descriptor_S:
2891 /* Make the type for a 64bit descriptor for VMS. The first six fields
2892 are the same for all types. */
2894 field_list64 = chainon (field_list64,
2895 make_descriptor_field ("MBO",
2896 gnat_type_for_size (16, 1),
2897 record64_type, size_int (1)));
2899 field_list64 = chainon (field_list64,
2900 make_descriptor_field ("DTYPE",
2901 gnat_type_for_size (8, 1),
2902 record64_type, size_int (dtype)));
2903 field_list64 = chainon (field_list64,
2904 make_descriptor_field ("CLASS",
2905 gnat_type_for_size (8, 1),
2906 record64_type, size_int (class)));
2908 field_list64 = chainon (field_list64,
2909 make_descriptor_field ("MBMO",
2910 gnat_type_for_size (32, 1),
2911 record64_type, ssize_int (-1)));
2914 = chainon (field_list64,
2915 make_descriptor_field
2916 ("LENGTH", gnat_type_for_size (64, 1), record64_type,
2917 size_in_bytes (mech == By_Descriptor_A ? inner_type : type)));
2919 pointer64_type = build_pointer_type_for_mode (type, DImode, false);
2922 = chainon (field_list64,
2923 make_descriptor_field
2924 ("POINTER", pointer64_type, record64_type,
2925 build_unary_op (ADDR_EXPR,
2927 build0 (PLACEHOLDER_EXPR, type))));
2932 case By_Descriptor_S:
2935 case By_Descriptor_SB:
2937 = chainon (field_list64,
2938 make_descriptor_field
2939 ("SB_L1", gnat_type_for_size (64, 1), record64_type,
2940 TREE_CODE (type) == ARRAY_TYPE
2941 ? TYPE_MIN_VALUE (TYPE_DOMAIN (type)) : size_zero_node));
2943 = chainon (field_list64,
2944 make_descriptor_field
2945 ("SB_U1", gnat_type_for_size (64, 1), record64_type,
2946 TREE_CODE (type) == ARRAY_TYPE
2947 ? TYPE_MAX_VALUE (TYPE_DOMAIN (type)) : size_zero_node));
2950 case By_Descriptor_A:
2951 case By_Descriptor_NCA:
2952 field_list64 = chainon (field_list64,
2953 make_descriptor_field ("SCALE",
2954 gnat_type_for_size (8, 1),
2958 field_list64 = chainon (field_list64,
2959 make_descriptor_field ("DIGITS",
2960 gnat_type_for_size (8, 1),
2965 = chainon (field_list64,
2966 make_descriptor_field
2967 ("AFLAGS", gnat_type_for_size (8, 1), record64_type,
2968 size_int (mech == By_Descriptor_NCA
2970 /* Set FL_COLUMN, FL_COEFF, and FL_BOUNDS. */
2971 : (TREE_CODE (type) == ARRAY_TYPE
2972 && TYPE_CONVENTION_FORTRAN_P (type)
2975 field_list64 = chainon (field_list64,
2976 make_descriptor_field ("DIMCT",
2977 gnat_type_for_size (8, 1),
2981 field_list64 = chainon (field_list64,
2982 make_descriptor_field ("MBZ",
2983 gnat_type_for_size (32, 1),
2986 field_list64 = chainon (field_list64,
2987 make_descriptor_field ("ARSIZE",
2988 gnat_type_for_size (64, 1),
2990 size_in_bytes (type)));
2992 /* Now build a pointer to the 0,0,0... element. */
2993 tem = build0 (PLACEHOLDER_EXPR, type);
2994 for (i = 0, inner_type = type; i < ndim;
2995 i++, inner_type = TREE_TYPE (inner_type))
2996 tem = build4 (ARRAY_REF, TREE_TYPE (inner_type), tem,
2997 convert (TYPE_DOMAIN (inner_type), size_zero_node),
2998 NULL_TREE, NULL_TREE);
3001 = chainon (field_list64,
3002 make_descriptor_field
3004 build_pointer_type_for_mode (inner_type, DImode, false),
3007 build_pointer_type_for_mode (inner_type, DImode,
3011 /* Next come the addressing coefficients. */
3012 tem = size_one_node;
3013 for (i = 0; i < ndim; i++)
3017 = size_binop (MULT_EXPR, tem,
3018 size_binop (PLUS_EXPR,
3019 size_binop (MINUS_EXPR,
3020 TYPE_MAX_VALUE (idx_arr[i]),
3021 TYPE_MIN_VALUE (idx_arr[i])),
3024 fname[0] = (mech == By_Descriptor_NCA ? 'S' : 'M');
3025 fname[1] = '0' + i, fname[2] = 0;
3027 = chainon (field_list64,
3028 make_descriptor_field (fname,
3029 gnat_type_for_size (64, 1),
3030 record64_type, idx_length));
3032 if (mech == By_Descriptor_NCA)
3036 /* Finally here are the bounds. */
3037 for (i = 0; i < ndim; i++)
3041 fname[0] = 'L', fname[1] = '0' + i, fname[2] = 0;
3043 = chainon (field_list64,
3044 make_descriptor_field
3045 (fname, gnat_type_for_size (64, 1), record64_type,
3046 TYPE_MIN_VALUE (idx_arr[i])));
3050 = chainon (field_list64,
3051 make_descriptor_field
3052 (fname, gnat_type_for_size (64, 1), record64_type,
3053 TYPE_MAX_VALUE (idx_arr[i])));
3058 post_error ("unsupported descriptor type for &", gnat_entity);
3061 TYPE_NAME (record64_type) = create_concat_name (gnat_entity, "DESC64");
3062 finish_record_type (record64_type, field_list64, 0, true);
3063 return record64_type;
3066 /* Utility routine for above code to make a field. */
3069 make_descriptor_field (const char *name, tree type,
3070 tree rec_type, tree initial)
3073 = create_field_decl (get_identifier (name), type, rec_type, 0, 0, 0, 0);
3075 DECL_INITIAL (field) = initial;
3079 /* Convert GNU_EXPR, a pointer to a 64bit VMS descriptor, to GNU_TYPE, a
3080 regular pointer or fat pointer type. GNAT_SUBPROG is the subprogram to
3081 which the VMS descriptor is passed. */
3084 convert_vms_descriptor64 (tree gnu_type, tree gnu_expr, Entity_Id gnat_subprog)
3086 tree desc_type = TREE_TYPE (TREE_TYPE (gnu_expr));
3087 tree desc = build1 (INDIRECT_REF, desc_type, gnu_expr);
3088 /* The CLASS field is the 3rd field in the descriptor. */
3089 tree class = TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (desc_type)));
3090 /* The POINTER field is the 6th field in the descriptor. */
3091 tree pointer64 = TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (class)));
3093 /* Retrieve the value of the POINTER field. */
3095 = build3 (COMPONENT_REF, TREE_TYPE (pointer64), desc, pointer64, NULL_TREE);
3097 if (POINTER_TYPE_P (gnu_type))
3098 return convert (gnu_type, gnu_expr64);
3100 else if (TYPE_FAT_POINTER_P (gnu_type))
3102 tree p_array_type = TREE_TYPE (TYPE_FIELDS (gnu_type));
3103 tree p_bounds_type = TREE_TYPE (TREE_CHAIN (TYPE_FIELDS (gnu_type)));
3104 tree template_type = TREE_TYPE (p_bounds_type);
3105 tree min_field = TYPE_FIELDS (template_type);
3106 tree max_field = TREE_CHAIN (TYPE_FIELDS (template_type));
3107 tree template, template_addr, aflags, dimct, t, u;
3108 /* See the head comment of build_vms_descriptor. */
3109 int iclass = TREE_INT_CST_LOW (DECL_INITIAL (class));
3110 tree lfield, ufield;
3112 /* Convert POINTER to the type of the P_ARRAY field. */
3113 gnu_expr64 = convert (p_array_type, gnu_expr64);
3117 case 1: /* Class S */
3118 case 15: /* Class SB */
3119 /* Build {1, LENGTH} template; LENGTH64 is the 5th field. */
3120 t = TREE_CHAIN (TREE_CHAIN (class));
3121 t = build3 (COMPONENT_REF, TREE_TYPE (t), desc, t, NULL_TREE);
3122 t = tree_cons (min_field,
3123 convert (TREE_TYPE (min_field), integer_one_node),
3124 tree_cons (max_field,
3125 convert (TREE_TYPE (max_field), t),
3127 template = gnat_build_constructor (template_type, t);
3128 template_addr = build_unary_op (ADDR_EXPR, NULL_TREE, template);
3130 /* For class S, we are done. */
3134 /* Test that we really have a SB descriptor, like DEC Ada. */
3135 t = build3 (COMPONENT_REF, TREE_TYPE (class), desc, class, NULL);
3136 u = convert (TREE_TYPE (class), DECL_INITIAL (class));
3137 u = build_binary_op (EQ_EXPR, integer_type_node, t, u);
3138 /* If so, there is already a template in the descriptor and
3139 it is located right after the POINTER field. The fields are
3140 64bits so they must be repacked. */
3141 t = TREE_CHAIN (pointer64);
3142 lfield = build3 (COMPONENT_REF, TREE_TYPE (t), desc, t, NULL_TREE);
3143 lfield = convert (TREE_TYPE (TYPE_FIELDS (template_type)), lfield);
3146 ufield = build3 (COMPONENT_REF, TREE_TYPE (t), desc, t, NULL_TREE);
3148 (TREE_TYPE (TREE_CHAIN (TYPE_FIELDS (template_type))), ufield);
3150 /* Build the template in the form of a constructor. */
3151 t = tree_cons (TYPE_FIELDS (template_type), lfield,
3152 tree_cons (TREE_CHAIN (TYPE_FIELDS (template_type)),
3153 ufield, NULL_TREE));
3154 template = gnat_build_constructor (template_type, t);
3156 /* Otherwise use the {1, LENGTH} template we build above. */
3157 template_addr = build3 (COND_EXPR, p_bounds_type, u,
3158 build_unary_op (ADDR_EXPR, p_bounds_type,
3163 case 4: /* Class A */
3164 /* The AFLAGS field is the 3rd field after the pointer in the
3166 t = TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (pointer64)));
3167 aflags = build3 (COMPONENT_REF, TREE_TYPE (t), desc, t, NULL_TREE);
3168 /* The DIMCT field is the next field in the descriptor after
3171 dimct = build3 (COMPONENT_REF, TREE_TYPE (t), desc, t, NULL_TREE);
3172 /* Raise CONSTRAINT_ERROR if either more than 1 dimension
3173 or FL_COEFF or FL_BOUNDS not set. */
3174 u = build_int_cst (TREE_TYPE (aflags), 192);
3175 u = build_binary_op (TRUTH_OR_EXPR, integer_type_node,
3176 build_binary_op (NE_EXPR, integer_type_node,
3178 convert (TREE_TYPE (dimct),
3180 build_binary_op (NE_EXPR, integer_type_node,
3181 build2 (BIT_AND_EXPR,
3185 /* There is already a template in the descriptor and it is located
3186 in block 3. The fields are 64bits so they must be repacked. */
3187 t = TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (TREE_CHAIN
3189 lfield = build3 (COMPONENT_REF, TREE_TYPE (t), desc, t, NULL_TREE);
3190 lfield = convert (TREE_TYPE (TYPE_FIELDS (template_type)), lfield);
3193 ufield = build3 (COMPONENT_REF, TREE_TYPE (t), desc, t, NULL_TREE);
3195 (TREE_TYPE (TREE_CHAIN (TYPE_FIELDS (template_type))), ufield);
3197 /* Build the template in the form of a constructor. */
3198 t = tree_cons (TYPE_FIELDS (template_type), lfield,
3199 tree_cons (TREE_CHAIN (TYPE_FIELDS (template_type)),
3200 ufield, NULL_TREE));
3201 template = gnat_build_constructor (template_type, t);
3202 template = build3 (COND_EXPR, p_bounds_type, u,
3203 build_call_raise (CE_Length_Check_Failed, Empty,
3204 N_Raise_Constraint_Error),
3206 template_addr = build_unary_op (ADDR_EXPR, p_bounds_type, template);
3209 case 10: /* Class NCA */
3211 post_error ("unsupported descriptor type for &", gnat_subprog);
3212 template_addr = integer_zero_node;
3216 /* Build the fat pointer in the form of a constructor. */
3217 t = tree_cons (TYPE_FIELDS (gnu_type), gnu_expr64,
3218 tree_cons (TREE_CHAIN (TYPE_FIELDS (gnu_type)),
3219 template_addr, NULL_TREE));
3220 return gnat_build_constructor (gnu_type, t);
3227 /* Convert GNU_EXPR, a pointer to a 32bit VMS descriptor, to GNU_TYPE, a
3228 regular pointer or fat pointer type. GNAT_SUBPROG is the subprogram to
3229 which the VMS descriptor is passed. */
3232 convert_vms_descriptor32 (tree gnu_type, tree gnu_expr, Entity_Id gnat_subprog)
3234 tree desc_type = TREE_TYPE (TREE_TYPE (gnu_expr));
3235 tree desc = build1 (INDIRECT_REF, desc_type, gnu_expr);
3236 /* The CLASS field is the 3rd field in the descriptor. */
3237 tree class = TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (desc_type)));
3238 /* The POINTER field is the 4th field in the descriptor. */
3239 tree pointer = TREE_CHAIN (class);
3241 /* Retrieve the value of the POINTER field. */
3243 = build3 (COMPONENT_REF, TREE_TYPE (pointer), desc, pointer, NULL_TREE);
3245 if (POINTER_TYPE_P (gnu_type))
3246 return convert (gnu_type, gnu_expr32);
3248 else if (TYPE_FAT_POINTER_P (gnu_type))
3250 tree p_array_type = TREE_TYPE (TYPE_FIELDS (gnu_type));
3251 tree p_bounds_type = TREE_TYPE (TREE_CHAIN (TYPE_FIELDS (gnu_type)));
3252 tree template_type = TREE_TYPE (p_bounds_type);
3253 tree min_field = TYPE_FIELDS (template_type);
3254 tree max_field = TREE_CHAIN (TYPE_FIELDS (template_type));
3255 tree template, template_addr, aflags, dimct, t, u;
3256 /* See the head comment of build_vms_descriptor. */
3257 int iclass = TREE_INT_CST_LOW (DECL_INITIAL (class));
3259 /* Convert POINTER to the type of the P_ARRAY field. */
3260 gnu_expr32 = convert (p_array_type, gnu_expr32);
3264 case 1: /* Class S */
3265 case 15: /* Class SB */
3266 /* Build {1, LENGTH} template; LENGTH is the 1st field. */
3267 t = TYPE_FIELDS (desc_type);
3268 t = build3 (COMPONENT_REF, TREE_TYPE (t), desc, t, NULL_TREE);
3269 t = tree_cons (min_field,
3270 convert (TREE_TYPE (min_field), integer_one_node),
3271 tree_cons (max_field,
3272 convert (TREE_TYPE (max_field), t),
3274 template = gnat_build_constructor (template_type, t);
3275 template_addr = build_unary_op (ADDR_EXPR, NULL_TREE, template);
3277 /* For class S, we are done. */
3281 /* Test that we really have a SB descriptor, like DEC Ada. */
3282 t = build3 (COMPONENT_REF, TREE_TYPE (class), desc, class, NULL);
3283 u = convert (TREE_TYPE (class), DECL_INITIAL (class));
3284 u = build_binary_op (EQ_EXPR, integer_type_node, t, u);
3285 /* If so, there is already a template in the descriptor and
3286 it is located right after the POINTER field. */
3287 t = TREE_CHAIN (pointer);
3288 template = build3 (COMPONENT_REF, TREE_TYPE (t), desc, t, NULL_TREE);
3289 /* Otherwise use the {1, LENGTH} template we build above. */
3290 template_addr = build3 (COND_EXPR, p_bounds_type, u,
3291 build_unary_op (ADDR_EXPR, p_bounds_type,
3296 case 4: /* Class A */
3297 /* The AFLAGS field is the 7th field in the descriptor. */
3298 t = TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (pointer)));
3299 aflags = build3 (COMPONENT_REF, TREE_TYPE (t), desc, t, NULL_TREE);
3300 /* The DIMCT field is the 8th field in the descriptor. */
3302 dimct = build3 (COMPONENT_REF, TREE_TYPE (t), desc, t, NULL_TREE);
3303 /* Raise CONSTRAINT_ERROR if either more than 1 dimension
3304 or FL_COEFF or FL_BOUNDS not set. */
3305 u = build_int_cst (TREE_TYPE (aflags), 192);
3306 u = build_binary_op (TRUTH_OR_EXPR, integer_type_node,
3307 build_binary_op (NE_EXPR, integer_type_node,
3309 convert (TREE_TYPE (dimct),
3311 build_binary_op (NE_EXPR, integer_type_node,
3312 build2 (BIT_AND_EXPR,
3316 /* There is already a template in the descriptor and it is
3317 located at the start of block 3 (12th field). */
3318 t = TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (t))));
3319 template = build3 (COMPONENT_REF, TREE_TYPE (t), desc, t, NULL_TREE);
3320 template = build3 (COND_EXPR, p_bounds_type, u,
3321 build_call_raise (CE_Length_Check_Failed, Empty,
3322 N_Raise_Constraint_Error),
3324 template_addr = build_unary_op (ADDR_EXPR, p_bounds_type, template);
3327 case 10: /* Class NCA */
3329 post_error ("unsupported descriptor type for &", gnat_subprog);
3330 template_addr = integer_zero_node;
3334 /* Build the fat pointer in the form of a constructor. */
3335 t = tree_cons (TYPE_FIELDS (gnu_type), gnu_expr32,
3336 tree_cons (TREE_CHAIN (TYPE_FIELDS (gnu_type)),
3337 template_addr, NULL_TREE));
3339 return gnat_build_constructor (gnu_type, t);
3346 /* Convert GNU_EXPR, a pointer to a VMS descriptor, to GNU_TYPE, a regular
3347 pointer or fat pointer type. GNU_EXPR_ALT_TYPE is the alternate (32-bit)
3348 pointer type of GNU_EXPR. GNAT_SUBPROG is the subprogram to which the
3349 VMS descriptor is passed. */
3352 convert_vms_descriptor (tree gnu_type, tree gnu_expr, tree gnu_expr_alt_type,
3353 Entity_Id gnat_subprog)
3355 tree desc_type = TREE_TYPE (TREE_TYPE (gnu_expr));
3356 tree desc = build1 (INDIRECT_REF, desc_type, gnu_expr);
3357 tree mbo = TYPE_FIELDS (desc_type);
3358 const char *mbostr = IDENTIFIER_POINTER (DECL_NAME (mbo));
3359 tree mbmo = TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (mbo)));
3360 tree is64bit, gnu_expr32, gnu_expr64;
3362 /* If the field name is not MBO, it must be 32-bit and no alternate.
3363 Otherwise primary must be 64-bit and alternate 32-bit. */
3364 if (strcmp (mbostr, "MBO") != 0)
3365 return convert_vms_descriptor32 (gnu_type, gnu_expr, gnat_subprog);
3367 /* Build the test for 64-bit descriptor. */
3368 mbo = build3 (COMPONENT_REF, TREE_TYPE (mbo), desc, mbo, NULL_TREE);
3369 mbmo = build3 (COMPONENT_REF, TREE_TYPE (mbmo), desc, mbmo, NULL_TREE);
3371 = build_binary_op (TRUTH_ANDIF_EXPR, integer_type_node,
3372 build_binary_op (EQ_EXPR, integer_type_node,
3373 convert (integer_type_node, mbo),
3375 build_binary_op (EQ_EXPR, integer_type_node,
3376 convert (integer_type_node, mbmo),
3377 integer_minus_one_node));
3379 /* Build the 2 possible end results. */
3380 gnu_expr64 = convert_vms_descriptor64 (gnu_type, gnu_expr, gnat_subprog);
3381 gnu_expr = fold_convert (gnu_expr_alt_type, gnu_expr);
3382 gnu_expr32 = convert_vms_descriptor32 (gnu_type, gnu_expr, gnat_subprog);
3384 return build3 (COND_EXPR, gnu_type, is64bit, gnu_expr64, gnu_expr32);
3387 /* Build a stub for the subprogram specified by the GCC tree GNU_SUBPROG
3388 and the GNAT node GNAT_SUBPROG. */
3391 build_function_stub (tree gnu_subprog, Entity_Id gnat_subprog)
3393 tree gnu_subprog_type, gnu_subprog_addr, gnu_subprog_call;
3394 tree gnu_stub_param, gnu_param_list, gnu_arg_types, gnu_param;
3395 tree gnu_stub_decl = DECL_FUNCTION_STUB (gnu_subprog);
3398 gnu_subprog_type = TREE_TYPE (gnu_subprog);
3399 gnu_param_list = NULL_TREE;
3401 begin_subprog_body (gnu_stub_decl);
3404 start_stmt_group ();
3406 /* Loop over the parameters of the stub and translate any of them
3407 passed by descriptor into a by reference one. */
3408 for (gnu_stub_param = DECL_ARGUMENTS (gnu_stub_decl),
3409 gnu_arg_types = TYPE_ARG_TYPES (gnu_subprog_type);
3411 gnu_stub_param = TREE_CHAIN (gnu_stub_param),
3412 gnu_arg_types = TREE_CHAIN (gnu_arg_types))
3414 if (DECL_BY_DESCRIPTOR_P (gnu_stub_param))
3416 = convert_vms_descriptor (TREE_VALUE (gnu_arg_types),
3418 DECL_PARM_ALT_TYPE (gnu_stub_param),
3421 gnu_param = gnu_stub_param;
3423 gnu_param_list = tree_cons (NULL_TREE, gnu_param, gnu_param_list);
3426 gnu_body = end_stmt_group ();
3428 /* Invoke the internal subprogram. */
3429 gnu_subprog_addr = build1 (ADDR_EXPR, build_pointer_type (gnu_subprog_type),
3431 gnu_subprog_call = build_call_list (TREE_TYPE (gnu_subprog_type),
3433 nreverse (gnu_param_list));
3435 /* Propagate the return value, if any. */
3436 if (VOID_TYPE_P (TREE_TYPE (gnu_subprog_type)))
3437 append_to_statement_list (gnu_subprog_call, &gnu_body);
3439 append_to_statement_list (build_return_expr (DECL_RESULT (gnu_stub_decl),
3445 allocate_struct_function (gnu_stub_decl, false);
3446 end_subprog_body (gnu_body, false);
3449 /* Build a type to be used to represent an aliased object whose nominal
3450 type is an unconstrained array. This consists of a RECORD_TYPE containing
3451 a field of TEMPLATE_TYPE and a field of OBJECT_TYPE, which is an
3452 ARRAY_TYPE. If ARRAY_TYPE is that of the unconstrained array, this
3453 is used to represent an arbitrary unconstrained object. Use NAME
3454 as the name of the record. */
3457 build_unc_object_type (tree template_type, tree object_type, tree name)
3459 tree type = make_node (RECORD_TYPE);
3460 tree template_field = create_field_decl (get_identifier ("BOUNDS"),
3461 template_type, type, 0, 0, 0, 1);
3462 tree array_field = create_field_decl (get_identifier ("ARRAY"), object_type,
3465 TYPE_NAME (type) = name;
3466 TYPE_CONTAINS_TEMPLATE_P (type) = 1;
3467 finish_record_type (type,
3468 chainon (chainon (NULL_TREE, template_field),
3475 /* Same, taking a thin or fat pointer type instead of a template type. */
3478 build_unc_object_type_from_ptr (tree thin_fat_ptr_type, tree object_type,
3483 gcc_assert (TYPE_FAT_OR_THIN_POINTER_P (thin_fat_ptr_type));
3486 = (TYPE_FAT_POINTER_P (thin_fat_ptr_type)
3487 ? TREE_TYPE (TREE_TYPE (TREE_CHAIN (TYPE_FIELDS (thin_fat_ptr_type))))
3488 : TREE_TYPE (TYPE_FIELDS (TREE_TYPE (thin_fat_ptr_type))));
3489 return build_unc_object_type (template_type, object_type, name);
3492 /* Shift the component offsets within an unconstrained object TYPE to make it
3493 suitable for use as a designated type for thin pointers. */
3496 shift_unc_components_for_thin_pointers (tree type)
3498 /* Thin pointer values designate the ARRAY data of an unconstrained object,
3499 allocated past the BOUNDS template. The designated type is adjusted to
3500 have ARRAY at position zero and the template at a negative offset, so
3501 that COMPONENT_REFs on (*thin_ptr) designate the proper location. */
3503 tree bounds_field = TYPE_FIELDS (type);
3504 tree array_field = TREE_CHAIN (TYPE_FIELDS (type));
3506 DECL_FIELD_OFFSET (bounds_field)
3507 = size_binop (MINUS_EXPR, size_zero_node, byte_position (array_field));
3509 DECL_FIELD_OFFSET (array_field) = size_zero_node;
3510 DECL_FIELD_BIT_OFFSET (array_field) = bitsize_zero_node;
3513 /* Update anything previously pointing to OLD_TYPE to point to NEW_TYPE.
3514 In the normal case this is just two adjustments, but we have more to
3515 do if NEW_TYPE is an UNCONSTRAINED_ARRAY_TYPE. */
3518 update_pointer_to (tree old_type, tree new_type)
3520 tree ptr = TYPE_POINTER_TO (old_type);
3521 tree ref = TYPE_REFERENCE_TO (old_type);
3525 /* If this is the main variant, process all the other variants first. */
3526 if (TYPE_MAIN_VARIANT (old_type) == old_type)
3527 for (type = TYPE_NEXT_VARIANT (old_type); type;
3528 type = TYPE_NEXT_VARIANT (type))
3529 update_pointer_to (type, new_type);
3531 /* If no pointers and no references, we are done. */
3535 /* Merge the old type qualifiers in the new type.
3537 Each old variant has qualifiers for specific reasons, and the new
3538 designated type as well. Each set of qualifiers represents useful
3539 information grabbed at some point, and merging the two simply unifies
3540 these inputs into the final type description.
3542 Consider for instance a volatile type frozen after an access to constant
3543 type designating it; after the designated type's freeze, we get here with
3544 a volatile NEW_TYPE and a dummy OLD_TYPE with a readonly variant, created
3545 when the access type was processed. We will make a volatile and readonly
3546 designated type, because that's what it really is.
3548 We might also get here for a non-dummy OLD_TYPE variant with different
3549 qualifiers than those of NEW_TYPE, for instance in some cases of pointers
3550 to private record type elaboration (see the comments around the call to
3551 this routine in gnat_to_gnu_entity <E_Access_Type>). We have to merge
3552 the qualifiers in those cases too, to avoid accidentally discarding the
3553 initial set, and will often end up with OLD_TYPE == NEW_TYPE then. */
3555 = build_qualified_type (new_type,
3556 TYPE_QUALS (old_type) | TYPE_QUALS (new_type));
3558 /* If old type and new type are identical, there is nothing to do. */
3559 if (old_type == new_type)
3562 /* Otherwise, first handle the simple case. */
3563 if (TREE_CODE (new_type) != UNCONSTRAINED_ARRAY_TYPE)
3565 TYPE_POINTER_TO (new_type) = ptr;
3566 TYPE_REFERENCE_TO (new_type) = ref;
3568 for (; ptr; ptr = TYPE_NEXT_PTR_TO (ptr))
3569 for (ptr1 = TYPE_MAIN_VARIANT (ptr); ptr1;
3570 ptr1 = TYPE_NEXT_VARIANT (ptr1))
3571 TREE_TYPE (ptr1) = new_type;
3573 for (; ref; ref = TYPE_NEXT_REF_TO (ref))
3574 for (ref1 = TYPE_MAIN_VARIANT (ref); ref1;
3575 ref1 = TYPE_NEXT_VARIANT (ref1))
3576 TREE_TYPE (ref1) = new_type;
3579 /* Now deal with the unconstrained array case. In this case the "pointer"
3580 is actually a RECORD_TYPE where both fields are pointers to dummy nodes.
3581 Turn them into pointers to the correct types using update_pointer_to. */
3582 else if (!TYPE_FAT_POINTER_P (ptr))
3587 tree new_obj_rec = TYPE_OBJECT_RECORD_TYPE (new_type);
3588 tree array_field = TYPE_FIELDS (ptr);
3589 tree bounds_field = TREE_CHAIN (TYPE_FIELDS (ptr));
3590 tree new_ptr = TYPE_POINTER_TO (new_type);
3594 /* Make pointers to the dummy template point to the real template. */
3596 (TREE_TYPE (TREE_TYPE (bounds_field)),
3597 TREE_TYPE (TREE_TYPE (TREE_CHAIN (TYPE_FIELDS (new_ptr)))));
3599 /* The references to the template bounds present in the array type
3600 are made through a PLACEHOLDER_EXPR of type NEW_PTR. Since we
3601 are updating PTR to make it a full replacement for NEW_PTR as
3602 pointer to NEW_TYPE, we must rework the PLACEHOLDER_EXPR so as
3603 to make it of type PTR. */
3604 new_ref = build3 (COMPONENT_REF, TREE_TYPE (bounds_field),
3605 build0 (PLACEHOLDER_EXPR, ptr),
3606 bounds_field, NULL_TREE);
3608 /* Create the new array for the new PLACEHOLDER_EXPR and make pointers
3609 to the dummy array point to it.
3611 ??? This is now the only use of substitute_in_type, which is a very
3612 "heavy" routine to do this, it should be replaced at some point. */
3614 (TREE_TYPE (TREE_TYPE (array_field)),
3615 substitute_in_type (TREE_TYPE (TREE_TYPE (TYPE_FIELDS (new_ptr))),
3616 TREE_CHAIN (TYPE_FIELDS (new_ptr)), new_ref));
3618 /* Make PTR the pointer to NEW_TYPE. */
3619 TYPE_POINTER_TO (new_type) = TYPE_REFERENCE_TO (new_type)
3620 = TREE_TYPE (new_type) = ptr;
3622 for (var = TYPE_MAIN_VARIANT (ptr); var; var = TYPE_NEXT_VARIANT (var))
3623 SET_TYPE_UNCONSTRAINED_ARRAY (var, new_type);
3625 /* Now handle updating the allocation record, what the thin pointer
3626 points to. Update all pointers from the old record into the new
3627 one, update the type of the array field, and recompute the size. */
3628 update_pointer_to (TYPE_OBJECT_RECORD_TYPE (old_type), new_obj_rec);
3630 TREE_TYPE (TREE_CHAIN (TYPE_FIELDS (new_obj_rec)))
3631 = TREE_TYPE (TREE_TYPE (array_field));
3633 /* The size recomputation needs to account for alignment constraints, so
3634 we let layout_type work it out. This will reset the field offsets to
3635 what they would be in a regular record, so we shift them back to what
3636 we want them to be for a thin pointer designated type afterwards. */
3637 DECL_SIZE (TYPE_FIELDS (new_obj_rec)) = 0;
3638 DECL_SIZE (TREE_CHAIN (TYPE_FIELDS (new_obj_rec))) = 0;
3639 TYPE_SIZE (new_obj_rec) = 0;
3640 layout_type (new_obj_rec);
3642 shift_unc_components_for_thin_pointers (new_obj_rec);
3644 /* We are done, at last. */
3645 rest_of_record_type_compilation (ptr);
3649 /* Convert EXPR, a pointer to a constrained array, into a pointer to an
3650 unconstrained one. This involves making or finding a template. */
3653 convert_to_fat_pointer (tree type, tree expr)
3655 tree template_type = TREE_TYPE (TREE_TYPE (TREE_CHAIN (TYPE_FIELDS (type))));
3656 tree p_array_type = TREE_TYPE (TYPE_FIELDS (type));
3657 tree etype = TREE_TYPE (expr);
3660 /* If EXPR is null, make a fat pointer that contains null pointers to the
3661 template and array. */
3662 if (integer_zerop (expr))
3664 gnat_build_constructor
3666 tree_cons (TYPE_FIELDS (type),
3667 convert (p_array_type, expr),
3668 tree_cons (TREE_CHAIN (TYPE_FIELDS (type)),
3669 convert (build_pointer_type (template_type),
3673 /* If EXPR is a thin pointer, make template and data from the record.. */
3674 else if (TYPE_THIN_POINTER_P (etype))
3676 tree fields = TYPE_FIELDS (TREE_TYPE (etype));
3678 expr = save_expr (expr);
3679 if (TREE_CODE (expr) == ADDR_EXPR)
3680 expr = TREE_OPERAND (expr, 0);
3682 expr = build1 (INDIRECT_REF, TREE_TYPE (etype), expr);
3684 template = build_component_ref (expr, NULL_TREE, fields, false);
3685 expr = build_unary_op (ADDR_EXPR, NULL_TREE,
3686 build_component_ref (expr, NULL_TREE,
3687 TREE_CHAIN (fields), false));
3690 /* Otherwise, build the constructor for the template. */
3692 template = build_template (template_type, TREE_TYPE (etype), expr);
3694 /* The final result is a constructor for the fat pointer.
3696 If EXPR is an argument of a foreign convention subprogram, the type it
3697 points to is directly the component type. In this case, the expression
3698 type may not match the corresponding FIELD_DECL type at this point, so we
3699 call "convert" here to fix that up if necessary. This type consistency is
3700 required, for instance because it ensures that possible later folding of
3701 COMPONENT_REFs against this constructor always yields something of the
3702 same type as the initial reference.
3704 Note that the call to "build_template" above is still fine because it
3705 will only refer to the provided TEMPLATE_TYPE in this case. */
3707 gnat_build_constructor
3709 tree_cons (TYPE_FIELDS (type),
3710 convert (p_array_type, expr),
3711 tree_cons (TREE_CHAIN (TYPE_FIELDS (type)),
3712 build_unary_op (ADDR_EXPR, NULL_TREE, template),
3716 /* Convert to a thin pointer type, TYPE. The only thing we know how to convert
3717 is something that is a fat pointer, so convert to it first if it EXPR
3718 is not already a fat pointer. */
3721 convert_to_thin_pointer (tree type, tree expr)
3723 if (!TYPE_FAT_POINTER_P (TREE_TYPE (expr)))
3725 = convert_to_fat_pointer
3726 (TREE_TYPE (TYPE_UNCONSTRAINED_ARRAY (TREE_TYPE (type))), expr);
3728 /* We get the pointer to the data and use a NOP_EXPR to make it the
3730 expr = build_component_ref (expr, NULL_TREE, TYPE_FIELDS (TREE_TYPE (expr)),
3732 expr = build1 (NOP_EXPR, type, expr);
3737 /* Create an expression whose value is that of EXPR,
3738 converted to type TYPE. The TREE_TYPE of the value
3739 is always TYPE. This function implements all reasonable
3740 conversions; callers should filter out those that are
3741 not permitted by the language being compiled. */
3744 convert (tree type, tree expr)
3746 enum tree_code code = TREE_CODE (type);
3747 tree etype = TREE_TYPE (expr);
3748 enum tree_code ecode = TREE_CODE (etype);
3750 /* If EXPR is already the right type, we are done. */
3754 /* If both input and output have padding and are of variable size, do this
3755 as an unchecked conversion. Likewise if one is a mere variant of the
3756 other, so we avoid a pointless unpad/repad sequence. */
3757 else if (code == RECORD_TYPE && ecode == RECORD_TYPE
3758 && TYPE_IS_PADDING_P (type) && TYPE_IS_PADDING_P (etype)
3759 && (!TREE_CONSTANT (TYPE_SIZE (type))
3760 || !TREE_CONSTANT (TYPE_SIZE (etype))
3761 || gnat_types_compatible_p (type, etype)
3762 || TYPE_NAME (TREE_TYPE (TYPE_FIELDS (type)))
3763 == TYPE_NAME (TREE_TYPE (TYPE_FIELDS (etype)))))
3766 /* If the output type has padding, convert to the inner type and
3767 make a constructor to build the record. */
3768 else if (code == RECORD_TYPE && TYPE_IS_PADDING_P (type))
3770 /* If we previously converted from another type and our type is
3771 of variable size, remove the conversion to avoid the need for
3772 variable-size temporaries. Likewise for a conversion between
3773 original and packable version. */
3774 if (TREE_CODE (expr) == VIEW_CONVERT_EXPR
3775 && (!TREE_CONSTANT (TYPE_SIZE (type))
3776 || (ecode == RECORD_TYPE
3777 && TYPE_NAME (etype)
3778 == TYPE_NAME (TREE_TYPE (TREE_OPERAND (expr, 0))))))
3779 expr = TREE_OPERAND (expr, 0);
3781 /* If we are just removing the padding from expr, convert the original
3782 object if we have variable size in order to avoid the need for some
3783 variable-size temporaries. Likewise if the padding is a mere variant
3784 of the other, so we avoid a pointless unpad/repad sequence. */
3785 if (TREE_CODE (expr) == COMPONENT_REF
3786 && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == RECORD_TYPE
3787 && TYPE_IS_PADDING_P (TREE_TYPE (TREE_OPERAND (expr, 0)))
3788 && (!TREE_CONSTANT (TYPE_SIZE (type))
3789 || gnat_types_compatible_p (type,
3790 TREE_TYPE (TREE_OPERAND (expr, 0)))
3791 || (ecode == RECORD_TYPE
3792 && TYPE_NAME (etype)
3793 == TYPE_NAME (TREE_TYPE (TYPE_FIELDS (type))))))
3794 return convert (type, TREE_OPERAND (expr, 0));
3796 /* If the result type is a padded type with a self-referentially-sized
3797 field and the expression type is a record, do this as an
3798 unchecked conversion. */
3799 else if (TREE_CODE (etype) == RECORD_TYPE
3800 && CONTAINS_PLACEHOLDER_P (DECL_SIZE (TYPE_FIELDS (type))))
3801 return unchecked_convert (type, expr, false);
3805 gnat_build_constructor (type,
3806 tree_cons (TYPE_FIELDS (type),
3808 (TYPE_FIELDS (type)),
3813 /* If the input type has padding, remove it and convert to the output type.
3814 The conditions ordering is arranged to ensure that the output type is not
3815 a padding type here, as it is not clear whether the conversion would
3816 always be correct if this was to happen. */
3817 else if (ecode == RECORD_TYPE && TYPE_IS_PADDING_P (etype))
3821 /* If we have just converted to this padded type, just get the
3822 inner expression. */
3823 if (TREE_CODE (expr) == CONSTRUCTOR
3824 && !VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (expr))
3825 && VEC_index (constructor_elt, CONSTRUCTOR_ELTS (expr), 0)->index
3826 == TYPE_FIELDS (etype))
3828 = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (expr), 0)->value;
3830 /* Otherwise, build an explicit component reference. */
3833 = build_component_ref (expr, NULL_TREE, TYPE_FIELDS (etype), false);
3835 return convert (type, unpadded);
3838 /* If the input is a biased type, adjust first. */
3839 if (ecode == INTEGER_TYPE && TYPE_BIASED_REPRESENTATION_P (etype))
3840 return convert (type, fold_build2 (PLUS_EXPR, TREE_TYPE (etype),
3841 fold_convert (TREE_TYPE (etype),
3843 TYPE_MIN_VALUE (etype)));
3845 /* If the input is a justified modular type, we need to extract the actual
3846 object before converting it to any other type with the exceptions of an
3847 unconstrained array or of a mere type variant. It is useful to avoid the
3848 extraction and conversion in the type variant case because it could end
3849 up replacing a VAR_DECL expr by a constructor and we might be about the
3850 take the address of the result. */
3851 if (ecode == RECORD_TYPE && TYPE_JUSTIFIED_MODULAR_P (etype)
3852 && code != UNCONSTRAINED_ARRAY_TYPE
3853 && TYPE_MAIN_VARIANT (type) != TYPE_MAIN_VARIANT (etype))
3854 return convert (type, build_component_ref (expr, NULL_TREE,
3855 TYPE_FIELDS (etype), false));
3857 /* If converting to a type that contains a template, convert to the data
3858 type and then build the template. */
3859 if (code == RECORD_TYPE && TYPE_CONTAINS_TEMPLATE_P (type))
3861 tree obj_type = TREE_TYPE (TREE_CHAIN (TYPE_FIELDS (type)));
3863 /* If the source already has a template, get a reference to the
3864 associated array only, as we are going to rebuild a template
3865 for the target type anyway. */
3866 expr = maybe_unconstrained_array (expr);
3869 gnat_build_constructor
3871 tree_cons (TYPE_FIELDS (type),
3872 build_template (TREE_TYPE (TYPE_FIELDS (type)),
3873 obj_type, NULL_TREE),
3874 tree_cons (TREE_CHAIN (TYPE_FIELDS (type)),
3875 convert (obj_type, expr), NULL_TREE)));
3878 /* There are some special cases of expressions that we process
3880 switch (TREE_CODE (expr))
3886 /* Just set its type here. For TRANSFORM_EXPR, we will do the actual
3887 conversion in gnat_expand_expr. NULL_EXPR does not represent
3888 and actual value, so no conversion is needed. */
3889 expr = copy_node (expr);
3890 TREE_TYPE (expr) = type;
3894 /* If we are converting a STRING_CST to another constrained array type,
3895 just make a new one in the proper type. */
3896 if (code == ecode && AGGREGATE_TYPE_P (etype)
3897 && !(TREE_CODE (TYPE_SIZE (etype)) == INTEGER_CST
3898 && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST))
3900 expr = copy_node (expr);
3901 TREE_TYPE (expr) = type;
3907 /* If we are converting a CONSTRUCTOR to a mere variant type, just make
3908 a new one in the proper type. */
3909 if (code == ecode && gnat_types_compatible_p (type, etype))
3911 expr = copy_node (expr);
3912 TREE_TYPE (expr) = type;
3916 /* Likewise for a conversion between original and packable version, but
3917 we have to work harder in order to preserve type consistency. */
3919 && code == RECORD_TYPE
3920 && TYPE_NAME (type) == TYPE_NAME (etype))
3922 VEC(constructor_elt,gc) *e = CONSTRUCTOR_ELTS (expr);
3923 unsigned HOST_WIDE_INT len = VEC_length (constructor_elt, e);
3924 VEC(constructor_elt,gc) *v = VEC_alloc (constructor_elt, gc, len);
3925 tree efield = TYPE_FIELDS (etype), field = TYPE_FIELDS (type);
3926 unsigned HOST_WIDE_INT idx;
3929 FOR_EACH_CONSTRUCTOR_ELT(e, idx, index, value)
3931 constructor_elt *elt = VEC_quick_push (constructor_elt, v, NULL);
3932 /* We expect only simple constructors. Otherwise, punt. */
3933 if (!(index == efield || index == DECL_ORIGINAL_FIELD (efield)))
3936 elt->value = convert (TREE_TYPE (field), value);
3937 efield = TREE_CHAIN (efield);
3938 field = TREE_CHAIN (field);
3943 expr = copy_node (expr);
3944 TREE_TYPE (expr) = type;
3945 CONSTRUCTOR_ELTS (expr) = v;
3951 case UNCONSTRAINED_ARRAY_REF:
3952 /* Convert this to the type of the inner array by getting the address of
3953 the array from the template. */
3954 expr = build_unary_op (INDIRECT_REF, NULL_TREE,
3955 build_component_ref (TREE_OPERAND (expr, 0),
3956 get_identifier ("P_ARRAY"),
3958 etype = TREE_TYPE (expr);
3959 ecode = TREE_CODE (etype);
3962 case VIEW_CONVERT_EXPR:
3964 /* GCC 4.x is very sensitive to type consistency overall, and view
3965 conversions thus are very frequent. Even though just "convert"ing
3966 the inner operand to the output type is fine in most cases, it
3967 might expose unexpected input/output type mismatches in special
3968 circumstances so we avoid such recursive calls when we can. */
3969 tree op0 = TREE_OPERAND (expr, 0);
3971 /* If we are converting back to the original type, we can just
3972 lift the input conversion. This is a common occurrence with
3973 switches back-and-forth amongst type variants. */
3974 if (type == TREE_TYPE (op0))
3977 /* Otherwise, if we're converting between two aggregate types, we
3978 might be allowed to substitute the VIEW_CONVERT_EXPR target type
3979 in place or to just convert the inner expression. */
3980 if (AGGREGATE_TYPE_P (type) && AGGREGATE_TYPE_P (etype))
3982 /* If we are converting between mere variants, we can just
3983 substitute the VIEW_CONVERT_EXPR in place. */
3984 if (gnat_types_compatible_p (type, etype))
3985 return build1 (VIEW_CONVERT_EXPR, type, op0);
3987 /* Otherwise, we may just bypass the input view conversion unless
3988 one of the types is a fat pointer, which is handled by
3989 specialized code below which relies on exact type matching. */
3990 else if (!TYPE_FAT_POINTER_P (type) && !TYPE_FAT_POINTER_P (etype))
3991 return convert (type, op0);
3997 /* If both types are record types, just convert the pointer and
3998 make a new INDIRECT_REF.
4000 ??? Disable this for now since it causes problems with the
4001 code in build_binary_op for MODIFY_EXPR which wants to
4002 strip off conversions. But that code really is a mess and
4003 we need to do this a much better way some time. */
4005 && (TREE_CODE (type) == RECORD_TYPE
4006 || TREE_CODE (type) == UNION_TYPE)
4007 && (TREE_CODE (etype) == RECORD_TYPE
4008 || TREE_CODE (etype) == UNION_TYPE)
4009 && !TYPE_FAT_POINTER_P (type) && !TYPE_FAT_POINTER_P (etype))
4010 return build_unary_op (INDIRECT_REF, NULL_TREE,
4011 convert (build_pointer_type (type),
4012 TREE_OPERAND (expr, 0)));
4019 /* Check for converting to a pointer to an unconstrained array. */
4020 if (TYPE_FAT_POINTER_P (type) && !TYPE_FAT_POINTER_P (etype))
4021 return convert_to_fat_pointer (type, expr);
4023 /* If we are converting between two aggregate types that are mere
4024 variants, just make a VIEW_CONVERT_EXPR. */
4025 else if (code == ecode
4026 && AGGREGATE_TYPE_P (type)
4027 && gnat_types_compatible_p (type, etype))
4028 return build1 (VIEW_CONVERT_EXPR, type, expr);
4030 /* In all other cases of related types, make a NOP_EXPR. */
4031 else if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (etype)
4032 || (code == INTEGER_CST && ecode == INTEGER_CST
4033 && (type == TREE_TYPE (etype) || etype == TREE_TYPE (type))))
4034 return fold_convert (type, expr);
4039 return fold_build1 (CONVERT_EXPR, type, expr);
4042 if (TYPE_HAS_ACTUAL_BOUNDS_P (type)
4043 && (ecode == ARRAY_TYPE || ecode == UNCONSTRAINED_ARRAY_TYPE
4044 || (ecode == RECORD_TYPE && TYPE_CONTAINS_TEMPLATE_P (etype))))
4045 return unchecked_convert (type, expr, false);
4046 else if (TYPE_BIASED_REPRESENTATION_P (type))
4047 return fold_convert (type,
4048 fold_build2 (MINUS_EXPR, TREE_TYPE (type),
4049 convert (TREE_TYPE (type), expr),
4050 TYPE_MIN_VALUE (type)));
4052 /* ... fall through ... */
4056 /* If we are converting an additive expression to an integer type
4057 with lower precision, be wary of the optimization that can be
4058 applied by convert_to_integer. There are 2 problematic cases:
4059 - if the first operand was originally of a biased type,
4060 because we could be recursively called to convert it
4061 to an intermediate type and thus rematerialize the
4062 additive operator endlessly,
4063 - if the expression contains a placeholder, because an
4064 intermediate conversion that changes the sign could
4065 be inserted and thus introduce an artificial overflow
4066 at compile time when the placeholder is substituted. */
4067 if (code == INTEGER_TYPE
4068 && ecode == INTEGER_TYPE
4069 && TYPE_PRECISION (type) < TYPE_PRECISION (etype)
4070 && (TREE_CODE (expr) == PLUS_EXPR || TREE_CODE (expr) == MINUS_EXPR))
4072 tree op0 = get_unwidened (TREE_OPERAND (expr, 0), type);
4074 if ((TREE_CODE (TREE_TYPE (op0)) == INTEGER_TYPE
4075 && TYPE_BIASED_REPRESENTATION_P (TREE_TYPE (op0)))
4076 || CONTAINS_PLACEHOLDER_P (expr))
4077 return build1 (NOP_EXPR, type, expr);
4080 return fold (convert_to_integer (type, expr));
4083 case REFERENCE_TYPE:
4084 /* If converting between two pointers to records denoting
4085 both a template and type, adjust if needed to account
4086 for any differing offsets, since one might be negative. */
4087 if (TYPE_THIN_POINTER_P (etype) && TYPE_THIN_POINTER_P (type))
4090 = size_diffop (bit_position (TYPE_FIELDS (TREE_TYPE (etype))),
4091 bit_position (TYPE_FIELDS (TREE_TYPE (type))));
4092 tree byte_diff = size_binop (CEIL_DIV_EXPR, bit_diff,
4093 sbitsize_int (BITS_PER_UNIT));
4095 expr = build1 (NOP_EXPR, type, expr);
4096 TREE_CONSTANT (expr) = TREE_CONSTANT (TREE_OPERAND (expr, 0));
4097 if (integer_zerop (byte_diff))
4100 return build_binary_op (POINTER_PLUS_EXPR, type, expr,
4101 fold (convert (sizetype, byte_diff)));
4104 /* If converting to a thin pointer, handle specially. */
4105 if (TYPE_THIN_POINTER_P (type)
4106 && TYPE_UNCONSTRAINED_ARRAY (TREE_TYPE (type)))
4107 return convert_to_thin_pointer (type, expr);
4109 /* If converting fat pointer to normal pointer, get the pointer to the
4110 array and then convert it. */
4111 else if (TYPE_FAT_POINTER_P (etype))
4112 expr = build_component_ref (expr, get_identifier ("P_ARRAY"),
4115 return fold (convert_to_pointer (type, expr));
4118 return fold (convert_to_real (type, expr));
4121 if (TYPE_JUSTIFIED_MODULAR_P (type) && !AGGREGATE_TYPE_P (etype))
4123 gnat_build_constructor
4124 (type, tree_cons (TYPE_FIELDS (type),
4125 convert (TREE_TYPE (TYPE_FIELDS (type)), expr),
4128 /* ... fall through ... */
4131 /* In these cases, assume the front-end has validated the conversion.
4132 If the conversion is valid, it will be a bit-wise conversion, so
4133 it can be viewed as an unchecked conversion. */
4134 return unchecked_convert (type, expr, false);
4137 /* This is a either a conversion between a tagged type and some
4138 subtype, which we have to mark as a UNION_TYPE because of
4139 overlapping fields or a conversion of an Unchecked_Union. */
4140 return unchecked_convert (type, expr, false);
4142 case UNCONSTRAINED_ARRAY_TYPE:
4143 /* If EXPR is a constrained array, take its address, convert it to a
4144 fat pointer, and then dereference it. Likewise if EXPR is a
4145 record containing both a template and a constrained array.
4146 Note that a record representing a justified modular type
4147 always represents a packed constrained array. */
4148 if (ecode == ARRAY_TYPE
4149 || (ecode == INTEGER_TYPE && TYPE_HAS_ACTUAL_BOUNDS_P (etype))
4150 || (ecode == RECORD_TYPE && TYPE_CONTAINS_TEMPLATE_P (etype))
4151 || (ecode == RECORD_TYPE && TYPE_JUSTIFIED_MODULAR_P (etype)))
4154 (INDIRECT_REF, NULL_TREE,
4155 convert_to_fat_pointer (TREE_TYPE (type),
4156 build_unary_op (ADDR_EXPR,
4159 /* Do something very similar for converting one unconstrained
4160 array to another. */
4161 else if (ecode == UNCONSTRAINED_ARRAY_TYPE)
4163 build_unary_op (INDIRECT_REF, NULL_TREE,
4164 convert (TREE_TYPE (type),
4165 build_unary_op (ADDR_EXPR,
4171 return fold (convert_to_complex (type, expr));
4178 /* Remove all conversions that are done in EXP. This includes converting
4179 from a padded type or to a justified modular type. If TRUE_ADDRESS
4180 is true, always return the address of the containing object even if
4181 the address is not bit-aligned. */
4184 remove_conversions (tree exp, bool true_address)
4186 switch (TREE_CODE (exp))
4190 && TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE
4191 && TYPE_JUSTIFIED_MODULAR_P (TREE_TYPE (exp)))
4193 remove_conversions (VEC_index (constructor_elt,
4194 CONSTRUCTOR_ELTS (exp), 0)->value,
4199 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == RECORD_TYPE
4200 && TYPE_IS_PADDING_P (TREE_TYPE (TREE_OPERAND (exp, 0))))
4201 return remove_conversions (TREE_OPERAND (exp, 0), true_address);
4204 case VIEW_CONVERT_EXPR: case NON_LVALUE_EXPR:
4206 return remove_conversions (TREE_OPERAND (exp, 0), true_address);
4215 /* If EXP's type is an UNCONSTRAINED_ARRAY_TYPE, return an expression that
4216 refers to the underlying array. If its type has TYPE_CONTAINS_TEMPLATE_P,
4217 likewise return an expression pointing to the underlying array. */
4220 maybe_unconstrained_array (tree exp)
4222 enum tree_code code = TREE_CODE (exp);
4225 switch (TREE_CODE (TREE_TYPE (exp)))
4227 case UNCONSTRAINED_ARRAY_TYPE:
4228 if (code == UNCONSTRAINED_ARRAY_REF)
4231 = build_unary_op (INDIRECT_REF, NULL_TREE,
4232 build_component_ref (TREE_OPERAND (exp, 0),
4233 get_identifier ("P_ARRAY"),
4235 TREE_READONLY (new) = TREE_STATIC (new) = TREE_READONLY (exp);
4239 else if (code == NULL_EXPR)
4240 return build1 (NULL_EXPR,
4241 TREE_TYPE (TREE_TYPE (TYPE_FIELDS
4242 (TREE_TYPE (TREE_TYPE (exp))))),
4243 TREE_OPERAND (exp, 0));
4246 /* If this is a padded type, convert to the unpadded type and see if
4247 it contains a template. */
4248 if (TYPE_IS_PADDING_P (TREE_TYPE (exp)))
4250 new = convert (TREE_TYPE (TYPE_FIELDS (TREE_TYPE (exp))), exp);
4251 if (TREE_CODE (TREE_TYPE (new)) == RECORD_TYPE
4252 && TYPE_CONTAINS_TEMPLATE_P (TREE_TYPE (new)))
4254 build_component_ref (new, NULL_TREE,
4255 TREE_CHAIN (TYPE_FIELDS (TREE_TYPE (new))),
4258 else if (TYPE_CONTAINS_TEMPLATE_P (TREE_TYPE (exp)))
4260 build_component_ref (exp, NULL_TREE,
4261 TREE_CHAIN (TYPE_FIELDS (TREE_TYPE (exp))), 0);
4271 /* Return true if EXPR is an expression that can be folded as an operand
4272 of a VIEW_CONVERT_EXPR. See the head comment of unchecked_convert for
4276 can_fold_for_view_convert_p (tree expr)
4280 /* The folder will fold NOP_EXPRs between integral types with the same
4281 precision (in the middle-end's sense). We cannot allow it if the
4282 types don't have the same precision in the Ada sense as well. */
4283 if (TREE_CODE (expr) != NOP_EXPR)
4286 t1 = TREE_TYPE (expr);
4287 t2 = TREE_TYPE (TREE_OPERAND (expr, 0));
4289 /* Defer to the folder for non-integral conversions. */
4290 if (!(INTEGRAL_TYPE_P (t1) && INTEGRAL_TYPE_P (t2)))
4293 /* Only fold conversions that preserve both precisions. */
4294 if (TYPE_PRECISION (t1) == TYPE_PRECISION (t2)
4295 && operand_equal_p (rm_size (t1), rm_size (t2), 0))
4301 /* Return an expression that does an unchecked conversion of EXPR to TYPE.
4302 If NOTRUNC_P is true, truncation operations should be suppressed.
4304 Special care is required with (source or target) integral types whose
4305 precision is not equal to their size, to make sure we fetch or assign
4306 the value bits whose location might depend on the endianness, e.g.
4308 Rmsize : constant := 8;
4309 subtype Int is Integer range 0 .. 2 ** Rmsize - 1;
4311 type Bit_Array is array (1 .. Rmsize) of Boolean;
4312 pragma Pack (Bit_Array);
4314 function To_Bit_Array is new Unchecked_Conversion (Int, Bit_Array);
4316 Value : Int := 2#1000_0001#;
4317 Vbits : Bit_Array := To_Bit_Array (Value);
4319 we expect the 8 bits at Vbits'Address to always contain Value, while
4320 their original location depends on the endianness, at Value'Address
4321 on a little-endian architecture but not on a big-endian one.
4323 ??? There is a problematic discrepancy between what is called precision
4324 here (and more generally throughout gigi) for integral types and what is
4325 called precision in the middle-end. In the former case it's the RM size
4326 as given by TYPE_RM_SIZE (or rm_size) whereas it's TYPE_PRECISION in the
4327 latter case, the hitch being that they are not equal when they matter,
4328 that is when the number of value bits is not equal to the type's size:
4329 TYPE_RM_SIZE does give the number of value bits but TYPE_PRECISION is set
4330 to the size. The sole exception are BOOLEAN_TYPEs for which both are 1.
4332 The consequence is that gigi must duplicate code bridging the gap between
4333 the type's size and its precision that exists for TYPE_PRECISION in the
4334 middle-end, because the latter knows nothing about TYPE_RM_SIZE, and be
4335 wary of transformations applied in the middle-end based on TYPE_PRECISION
4336 because this value doesn't reflect the actual precision for Ada. */
4339 unchecked_convert (tree type, tree expr, bool notrunc_p)
4341 tree etype = TREE_TYPE (expr);
4343 /* If the expression is already the right type, we are done. */
4347 /* If both types types are integral just do a normal conversion.
4348 Likewise for a conversion to an unconstrained array. */
4349 if ((((INTEGRAL_TYPE_P (type)
4350 && !(TREE_CODE (type) == INTEGER_TYPE
4351 && TYPE_VAX_FLOATING_POINT_P (type)))
4352 || (POINTER_TYPE_P (type) && ! TYPE_THIN_POINTER_P (type))
4353 || (TREE_CODE (type) == RECORD_TYPE
4354 && TYPE_JUSTIFIED_MODULAR_P (type)))
4355 && ((INTEGRAL_TYPE_P (etype)
4356 && !(TREE_CODE (etype) == INTEGER_TYPE
4357 && TYPE_VAX_FLOATING_POINT_P (etype)))
4358 || (POINTER_TYPE_P (etype) && !TYPE_THIN_POINTER_P (etype))
4359 || (TREE_CODE (etype) == RECORD_TYPE
4360 && TYPE_JUSTIFIED_MODULAR_P (etype))))
4361 || TREE_CODE (type) == UNCONSTRAINED_ARRAY_TYPE)
4363 if (TREE_CODE (etype) == INTEGER_TYPE
4364 && TYPE_BIASED_REPRESENTATION_P (etype))
4366 tree ntype = copy_type (etype);
4367 TYPE_BIASED_REPRESENTATION_P (ntype) = 0;
4368 TYPE_MAIN_VARIANT (ntype) = ntype;
4369 expr = build1 (NOP_EXPR, ntype, expr);
4372 if (TREE_CODE (type) == INTEGER_TYPE
4373 && TYPE_BIASED_REPRESENTATION_P (type))
4375 tree rtype = copy_type (type);
4376 TYPE_BIASED_REPRESENTATION_P (rtype) = 0;
4377 TYPE_MAIN_VARIANT (rtype) = rtype;
4378 expr = convert (rtype, expr);
4379 expr = build1 (NOP_EXPR, type, expr);
4382 /* We have another special case: if we are unchecked converting either
4383 a subtype or a type with limited range into a base type, we need to
4384 ensure that VRP doesn't propagate range information because this
4385 conversion may be done precisely to validate that the object is
4386 within the range it is supposed to have. */
4387 else if (TREE_CODE (expr) != INTEGER_CST
4388 && TREE_CODE (type) == INTEGER_TYPE && !TREE_TYPE (type)
4389 && ((TREE_CODE (etype) == INTEGER_TYPE && TREE_TYPE (etype))
4390 || TREE_CODE (etype) == ENUMERAL_TYPE
4391 || TREE_CODE (etype) == BOOLEAN_TYPE))
4393 /* The optimization barrier is a VIEW_CONVERT_EXPR node; moreover,
4394 in order not to be deemed an useless type conversion, it must
4395 be from subtype to base type.
4397 Therefore we first do the bulk of the conversion to a subtype of
4398 the final type. And this conversion must itself not be deemed
4399 useless if the source type is not a subtype because, otherwise,
4400 the final VIEW_CONVERT_EXPR will be deemed so as well. That's
4401 why we toggle the unsigned flag in this conversion, which is
4402 harmless since the final conversion is only a reinterpretation
4405 ??? This may raise addressability and/or aliasing issues because
4406 VIEW_CONVERT_EXPR gets gimplified as an lvalue, thus causing the
4407 address of its operand to be taken if it is deemed addressable
4408 and not already in GIMPLE form. */
4410 = gnat_type_for_mode (TYPE_MODE (type), !TYPE_UNSIGNED (etype));
4411 rtype = copy_type (rtype);
4412 TYPE_MAIN_VARIANT (rtype) = rtype;
4413 TREE_TYPE (rtype) = type;
4414 expr = convert (rtype, expr);
4415 expr = build1 (VIEW_CONVERT_EXPR, type, expr);
4419 expr = convert (type, expr);
4422 /* If we are converting to an integral type whose precision is not equal
4423 to its size, first unchecked convert to a record that contains an
4424 object of the output type. Then extract the field. */
4425 else if (INTEGRAL_TYPE_P (type) && TYPE_RM_SIZE (type)
4426 && 0 != compare_tree_int (TYPE_RM_SIZE (type),
4427 GET_MODE_BITSIZE (TYPE_MODE (type))))
4429 tree rec_type = make_node (RECORD_TYPE);
4430 tree field = create_field_decl (get_identifier ("OBJ"), type,
4431 rec_type, 1, 0, 0, 0);
4433 TYPE_FIELDS (rec_type) = field;
4434 layout_type (rec_type);
4436 expr = unchecked_convert (rec_type, expr, notrunc_p);
4437 expr = build_component_ref (expr, NULL_TREE, field, 0);
4440 /* Similarly if we are converting from an integral type whose precision
4441 is not equal to its size. */
4442 else if (INTEGRAL_TYPE_P (etype) && TYPE_RM_SIZE (etype)
4443 && 0 != compare_tree_int (TYPE_RM_SIZE (etype),
4444 GET_MODE_BITSIZE (TYPE_MODE (etype))))
4446 tree rec_type = make_node (RECORD_TYPE);
4448 = create_field_decl (get_identifier ("OBJ"), etype, rec_type,
4451 TYPE_FIELDS (rec_type) = field;
4452 layout_type (rec_type);
4454 expr = gnat_build_constructor (rec_type, build_tree_list (field, expr));
4455 expr = unchecked_convert (type, expr, notrunc_p);
4458 /* We have a special case when we are converting between two
4459 unconstrained array types. In that case, take the address,
4460 convert the fat pointer types, and dereference. */
4461 else if (TREE_CODE (etype) == UNCONSTRAINED_ARRAY_TYPE
4462 && TREE_CODE (type) == UNCONSTRAINED_ARRAY_TYPE)
4463 expr = build_unary_op (INDIRECT_REF, NULL_TREE,
4464 build1 (VIEW_CONVERT_EXPR, TREE_TYPE (type),
4465 build_unary_op (ADDR_EXPR, NULL_TREE,
4469 expr = maybe_unconstrained_array (expr);
4470 etype = TREE_TYPE (expr);
4471 if (can_fold_for_view_convert_p (expr))
4472 expr = fold_build1 (VIEW_CONVERT_EXPR, type, expr);
4474 expr = build1 (VIEW_CONVERT_EXPR, type, expr);
4477 /* If the result is an integral type whose precision is not equal to its
4478 size, sign- or zero-extend the result. We need not do this if the input
4479 is an integral type of the same precision and signedness or if the output
4480 is a biased type or if both the input and output are unsigned. */
4482 && INTEGRAL_TYPE_P (type) && TYPE_RM_SIZE (type)
4483 && !(TREE_CODE (type) == INTEGER_TYPE
4484 && TYPE_BIASED_REPRESENTATION_P (type))
4485 && 0 != compare_tree_int (TYPE_RM_SIZE (type),
4486 GET_MODE_BITSIZE (TYPE_MODE (type)))
4487 && !(INTEGRAL_TYPE_P (etype)
4488 && TYPE_UNSIGNED (type) == TYPE_UNSIGNED (etype)
4489 && operand_equal_p (TYPE_RM_SIZE (type),
4490 (TYPE_RM_SIZE (etype) != 0
4491 ? TYPE_RM_SIZE (etype) : TYPE_SIZE (etype)),
4493 && !(TYPE_UNSIGNED (type) && TYPE_UNSIGNED (etype)))
4495 tree base_type = gnat_type_for_mode (TYPE_MODE (type),
4496 TYPE_UNSIGNED (type));
4498 = convert (base_type,
4499 size_binop (MINUS_EXPR,
4501 (GET_MODE_BITSIZE (TYPE_MODE (type))),
4502 TYPE_RM_SIZE (type)));
4505 build_binary_op (RSHIFT_EXPR, base_type,
4506 build_binary_op (LSHIFT_EXPR, base_type,
4507 convert (base_type, expr),
4512 /* An unchecked conversion should never raise Constraint_Error. The code
4513 below assumes that GCC's conversion routines overflow the same way that
4514 the underlying hardware does. This is probably true. In the rare case
4515 when it is false, we can rely on the fact that such conversions are
4516 erroneous anyway. */
4517 if (TREE_CODE (expr) == INTEGER_CST)
4518 TREE_OVERFLOW (expr) = 0;
4520 /* If the sizes of the types differ and this is an VIEW_CONVERT_EXPR,
4521 show no longer constant. */
4522 if (TREE_CODE (expr) == VIEW_CONVERT_EXPR
4523 && !operand_equal_p (TYPE_SIZE_UNIT (type), TYPE_SIZE_UNIT (etype),
4525 TREE_CONSTANT (expr) = 0;
4530 /* Return the appropriate GCC tree code for the specified GNAT type,
4531 the latter being a record type as predicated by Is_Record_Type. */
4534 tree_code_for_record_type (Entity_Id gnat_type)
4536 Node_Id component_list
4537 = Component_List (Type_Definition
4539 (Implementation_Base_Type (gnat_type))));
4542 /* Make this a UNION_TYPE unless it's either not an Unchecked_Union or
4543 we have a non-discriminant field outside a variant. In either case,
4544 it's a RECORD_TYPE. */
4546 if (!Is_Unchecked_Union (gnat_type))
4549 for (component = First_Non_Pragma (Component_Items (component_list));
4550 Present (component);
4551 component = Next_Non_Pragma (component))
4552 if (Ekind (Defining_Entity (component)) == E_Component)
4558 /* Return true if GNU_TYPE is suitable as the type of a non-aliased
4559 component of an aggregate type. */
4562 type_for_nonaliased_component_p (tree gnu_type)
4564 /* If the type is passed by reference, we may have pointers to the
4565 component so it cannot be made non-aliased. */
4566 if (must_pass_by_ref (gnu_type) || default_pass_by_ref (gnu_type))
4569 /* We used to say that any component of aggregate type is aliased
4570 because the front-end may take 'Reference of it. The front-end
4571 has been enhanced in the meantime so as to use a renaming instead
4572 in most cases, but the back-end can probably take the address of
4573 such a component too so we go for the conservative stance.
4575 For instance, we might need the address of any array type, even
4576 if normally passed by copy, to construct a fat pointer if the
4577 component is used as an actual for an unconstrained formal.
4579 Likewise for record types: even if a specific record subtype is
4580 passed by copy, the parent type might be passed by ref (e.g. if
4581 it's of variable size) and we might take the address of a child
4582 component to pass to a parent formal. We have no way to check
4583 for such conditions here. */
4584 if (AGGREGATE_TYPE_P (gnu_type))
4590 /* Perform final processing on global variables. */
4593 gnat_write_global_declarations (void)
4595 /* Proceed to optimize and emit assembly.
4596 FIXME: shouldn't be the front end's responsibility to call this. */
4599 /* Emit debug info for all global declarations. */
4600 emit_debug_global_declarations (VEC_address (tree, global_decls),
4601 VEC_length (tree, global_decls));
4604 /* ************************************************************************
4605 * * GCC builtins support *
4606 * ************************************************************************ */
4608 /* The general scheme is fairly simple:
4610 For each builtin function/type to be declared, gnat_install_builtins calls
4611 internal facilities which eventually get to gnat_push_decl, which in turn
4612 tracks the so declared builtin function decls in the 'builtin_decls' global
4613 datastructure. When an Intrinsic subprogram declaration is processed, we
4614 search this global datastructure to retrieve the associated BUILT_IN DECL
4617 /* Search the chain of currently available builtin declarations for a node
4618 corresponding to function NAME (an IDENTIFIER_NODE). Return the first node
4619 found, if any, or NULL_TREE otherwise. */
4621 builtin_decl_for (tree name)
4626 for (i = 0; VEC_iterate(tree, builtin_decls, i, decl); i++)
4627 if (DECL_NAME (decl) == name)
4633 /* The code below eventually exposes gnat_install_builtins, which declares
4634 the builtin types and functions we might need, either internally or as
4635 user accessible facilities.
4637 ??? This is a first implementation shot, still in rough shape. It is
4638 heavily inspired from the "C" family implementation, with chunks copied
4639 verbatim from there.
4641 Two obvious TODO candidates are
4642 o Use a more efficient name/decl mapping scheme
4643 o Devise a middle-end infrastructure to avoid having to copy
4644 pieces between front-ends. */
4646 /* ----------------------------------------------------------------------- *
4647 * BUILTIN ELEMENTARY TYPES *
4648 * ----------------------------------------------------------------------- */
4650 /* Standard data types to be used in builtin argument declarations. */
4654 CTI_SIGNED_SIZE_TYPE, /* For format checking only. */
4656 CTI_CONST_STRING_TYPE,
4661 static tree c_global_trees[CTI_MAX];
4663 #define signed_size_type_node c_global_trees[CTI_SIGNED_SIZE_TYPE]
4664 #define string_type_node c_global_trees[CTI_STRING_TYPE]
4665 #define const_string_type_node c_global_trees[CTI_CONST_STRING_TYPE]
4667 /* ??? In addition some attribute handlers, we currently don't support a
4668 (small) number of builtin-types, which in turns inhibits support for a
4669 number of builtin functions. */
4670 #define wint_type_node void_type_node
4671 #define intmax_type_node void_type_node
4672 #define uintmax_type_node void_type_node
4674 /* Build the void_list_node (void_type_node having been created). */
4677 build_void_list_node (void)
4679 tree t = build_tree_list (NULL_TREE, void_type_node);
4683 /* Used to help initialize the builtin-types.def table. When a type of
4684 the correct size doesn't exist, use error_mark_node instead of NULL.
4685 The later results in segfaults even when a decl using the type doesn't
4689 builtin_type_for_size (int size, bool unsignedp)
4691 tree type = lang_hooks.types.type_for_size (size, unsignedp);
4692 return type ? type : error_mark_node;
4695 /* Build/push the elementary type decls that builtin functions/types
4699 install_builtin_elementary_types (void)
4701 signed_size_type_node = size_type_node;
4702 pid_type_node = integer_type_node;
4703 void_list_node = build_void_list_node ();
4705 string_type_node = build_pointer_type (char_type_node);
4706 const_string_type_node
4707 = build_pointer_type (build_qualified_type
4708 (char_type_node, TYPE_QUAL_CONST));
4711 /* ----------------------------------------------------------------------- *
4712 * BUILTIN FUNCTION TYPES *
4713 * ----------------------------------------------------------------------- */
4715 /* Now, builtin function types per se. */
4719 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
4720 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
4721 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
4722 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
4723 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4724 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4725 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
4726 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
4727 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
4728 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
4729 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
4730 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
4731 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4732 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4733 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
4735 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
4736 #include "builtin-types.def"
4737 #undef DEF_PRIMITIVE_TYPE
4738 #undef DEF_FUNCTION_TYPE_0
4739 #undef DEF_FUNCTION_TYPE_1
4740 #undef DEF_FUNCTION_TYPE_2
4741 #undef DEF_FUNCTION_TYPE_3
4742 #undef DEF_FUNCTION_TYPE_4
4743 #undef DEF_FUNCTION_TYPE_5
4744 #undef DEF_FUNCTION_TYPE_6
4745 #undef DEF_FUNCTION_TYPE_7
4746 #undef DEF_FUNCTION_TYPE_VAR_0
4747 #undef DEF_FUNCTION_TYPE_VAR_1
4748 #undef DEF_FUNCTION_TYPE_VAR_2
4749 #undef DEF_FUNCTION_TYPE_VAR_3
4750 #undef DEF_FUNCTION_TYPE_VAR_4
4751 #undef DEF_FUNCTION_TYPE_VAR_5
4752 #undef DEF_POINTER_TYPE
4756 typedef enum c_builtin_type builtin_type;
4758 /* A temporary array used in communication with def_fn_type. */
4759 static GTY(()) tree builtin_types[(int) BT_LAST + 1];
4761 /* A helper function for install_builtin_types. Build function type
4762 for DEF with return type RET and N arguments. If VAR is true, then the
4763 function should be variadic after those N arguments.
4765 Takes special care not to ICE if any of the types involved are
4766 error_mark_node, which indicates that said type is not in fact available
4767 (see builtin_type_for_size). In which case the function type as a whole
4768 should be error_mark_node. */
4771 def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
4773 tree args = NULL, t;
4778 for (i = 0; i < n; ++i)
4780 builtin_type a = va_arg (list, builtin_type);
4781 t = builtin_types[a];
4782 if (t == error_mark_node)
4784 args = tree_cons (NULL_TREE, t, args);
4788 args = nreverse (args);
4790 args = chainon (args, void_list_node);
4792 t = builtin_types[ret];
4793 if (t == error_mark_node)
4795 t = build_function_type (t, args);
4798 builtin_types[def] = t;
4801 /* Build the builtin function types and install them in the builtin_types
4802 array for later use in builtin function decls. */
4805 install_builtin_function_types (void)
4807 tree va_list_ref_type_node;
4808 tree va_list_arg_type_node;
4810 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
4812 va_list_arg_type_node = va_list_ref_type_node =
4813 build_pointer_type (TREE_TYPE (va_list_type_node));
4817 va_list_arg_type_node = va_list_type_node;
4818 va_list_ref_type_node = build_reference_type (va_list_type_node);
4821 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
4822 builtin_types[ENUM] = VALUE;
4823 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
4824 def_fn_type (ENUM, RETURN, 0, 0);
4825 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
4826 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
4827 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
4828 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
4829 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4830 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
4831 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4832 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
4833 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4834 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4835 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4837 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
4838 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4840 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
4841 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
4842 def_fn_type (ENUM, RETURN, 1, 0);
4843 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
4844 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
4845 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
4846 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
4847 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4848 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
4849 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4850 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
4851 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4852 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4853 #define DEF_POINTER_TYPE(ENUM, TYPE) \
4854 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
4856 #include "builtin-types.def"
4858 #undef DEF_PRIMITIVE_TYPE
4859 #undef DEF_FUNCTION_TYPE_1
4860 #undef DEF_FUNCTION_TYPE_2
4861 #undef DEF_FUNCTION_TYPE_3
4862 #undef DEF_FUNCTION_TYPE_4
4863 #undef DEF_FUNCTION_TYPE_5
4864 #undef DEF_FUNCTION_TYPE_6
4865 #undef DEF_FUNCTION_TYPE_VAR_0
4866 #undef DEF_FUNCTION_TYPE_VAR_1
4867 #undef DEF_FUNCTION_TYPE_VAR_2
4868 #undef DEF_FUNCTION_TYPE_VAR_3
4869 #undef DEF_FUNCTION_TYPE_VAR_4
4870 #undef DEF_FUNCTION_TYPE_VAR_5
4871 #undef DEF_POINTER_TYPE
4872 builtin_types[(int) BT_LAST] = NULL_TREE;
4875 /* ----------------------------------------------------------------------- *
4876 * BUILTIN ATTRIBUTES *
4877 * ----------------------------------------------------------------------- */
4879 enum built_in_attribute
4881 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
4882 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
4883 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
4884 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
4885 #include "builtin-attrs.def"
4886 #undef DEF_ATTR_NULL_TREE
4888 #undef DEF_ATTR_IDENT
4889 #undef DEF_ATTR_TREE_LIST
4893 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
4896 install_builtin_attributes (void)
4898 /* Fill in the built_in_attributes array. */
4899 #define DEF_ATTR_NULL_TREE(ENUM) \
4900 built_in_attributes[(int) ENUM] = NULL_TREE;
4901 #define DEF_ATTR_INT(ENUM, VALUE) \
4902 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
4903 #define DEF_ATTR_IDENT(ENUM, STRING) \
4904 built_in_attributes[(int) ENUM] = get_identifier (STRING);
4905 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4906 built_in_attributes[(int) ENUM] \
4907 = tree_cons (built_in_attributes[(int) PURPOSE], \
4908 built_in_attributes[(int) VALUE], \
4909 built_in_attributes[(int) CHAIN]);
4910 #include "builtin-attrs.def"
4911 #undef DEF_ATTR_NULL_TREE
4913 #undef DEF_ATTR_IDENT
4914 #undef DEF_ATTR_TREE_LIST
4917 /* Handle a "const" attribute; arguments as in
4918 struct attribute_spec.handler. */
4921 handle_const_attribute (tree *node, tree ARG_UNUSED (name),
4922 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
4925 if (TREE_CODE (*node) == FUNCTION_DECL)
4926 TREE_READONLY (*node) = 1;
4928 *no_add_attrs = true;
4933 /* Handle a "nothrow" attribute; arguments as in
4934 struct attribute_spec.handler. */
4937 handle_nothrow_attribute (tree *node, tree ARG_UNUSED (name),
4938 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
4941 if (TREE_CODE (*node) == FUNCTION_DECL)
4942 TREE_NOTHROW (*node) = 1;
4944 *no_add_attrs = true;
4949 /* Handle a "pure" attribute; arguments as in
4950 struct attribute_spec.handler. */
4953 handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4954 int ARG_UNUSED (flags), bool *no_add_attrs)
4956 if (TREE_CODE (*node) == FUNCTION_DECL)
4957 DECL_PURE_P (*node) = 1;
4958 /* ??? TODO: Support types. */
4961 warning (OPT_Wattributes, "%qE attribute ignored", name);
4962 *no_add_attrs = true;
4968 /* Handle a "no vops" attribute; arguments as in
4969 struct attribute_spec.handler. */
4972 handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
4973 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
4974 bool *ARG_UNUSED (no_add_attrs))
4976 gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
4977 DECL_IS_NOVOPS (*node) = 1;
4981 /* Helper for nonnull attribute handling; fetch the operand number
4982 from the attribute argument list. */
4985 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
4987 /* Verify the arg number is a constant. */
4988 if (TREE_CODE (arg_num_expr) != INTEGER_CST
4989 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
4992 *valp = TREE_INT_CST_LOW (arg_num_expr);
4996 /* Handle the "nonnull" attribute. */
4998 handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
4999 tree args, int ARG_UNUSED (flags),
5003 unsigned HOST_WIDE_INT attr_arg_num;
5005 /* If no arguments are specified, all pointer arguments should be
5006 non-null. Verify a full prototype is given so that the arguments
5007 will have the correct types when we actually check them later. */
5010 if (!TYPE_ARG_TYPES (type))
5012 error ("nonnull attribute without arguments on a non-prototype");
5013 *no_add_attrs = true;
5018 /* Argument list specified. Verify that each argument number references
5019 a pointer argument. */
5020 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
5023 unsigned HOST_WIDE_INT arg_num = 0, ck_num;
5025 if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
5027 error ("nonnull argument has invalid operand number (argument %lu)",
5028 (unsigned long) attr_arg_num);
5029 *no_add_attrs = true;
5033 argument = TYPE_ARG_TYPES (type);
5036 for (ck_num = 1; ; ck_num++)
5038 if (!argument || ck_num == arg_num)
5040 argument = TREE_CHAIN (argument);
5044 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
5046 error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
5047 (unsigned long) attr_arg_num, (unsigned long) arg_num);
5048 *no_add_attrs = true;
5052 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
5054 error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
5055 (unsigned long) attr_arg_num, (unsigned long) arg_num);
5056 *no_add_attrs = true;
5065 /* Handle a "sentinel" attribute. */
5068 handle_sentinel_attribute (tree *node, tree name, tree args,
5069 int ARG_UNUSED (flags), bool *no_add_attrs)
5071 tree params = TYPE_ARG_TYPES (*node);
5075 warning (OPT_Wattributes,
5076 "%qE attribute requires prototypes with named arguments", name);
5077 *no_add_attrs = true;
5081 while (TREE_CHAIN (params))
5082 params = TREE_CHAIN (params);
5084 if (VOID_TYPE_P (TREE_VALUE (params)))
5086 warning (OPT_Wattributes,
5087 "%qE attribute only applies to variadic functions", name);
5088 *no_add_attrs = true;
5094 tree position = TREE_VALUE (args);
5096 if (TREE_CODE (position) != INTEGER_CST)
5098 warning (0, "requested position is not an integer constant");
5099 *no_add_attrs = true;
5103 if (tree_int_cst_lt (position, integer_zero_node))
5105 warning (0, "requested position is less than zero");
5106 *no_add_attrs = true;
5114 /* Handle a "noreturn" attribute; arguments as in
5115 struct attribute_spec.handler. */
5118 handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5119 int ARG_UNUSED (flags), bool *no_add_attrs)
5121 tree type = TREE_TYPE (*node);
5123 /* See FIXME comment in c_common_attribute_table. */
5124 if (TREE_CODE (*node) == FUNCTION_DECL)
5125 TREE_THIS_VOLATILE (*node) = 1;
5126 else if (TREE_CODE (type) == POINTER_TYPE
5127 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5129 = build_pointer_type
5130 (build_type_variant (TREE_TYPE (type),
5131 TYPE_READONLY (TREE_TYPE (type)), 1));
5134 warning (OPT_Wattributes, "%qE attribute ignored", name);
5135 *no_add_attrs = true;
5141 /* Handle a "malloc" attribute; arguments as in
5142 struct attribute_spec.handler. */
5145 handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5146 int ARG_UNUSED (flags), bool *no_add_attrs)
5148 if (TREE_CODE (*node) == FUNCTION_DECL
5149 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
5150 DECL_IS_MALLOC (*node) = 1;
5153 warning (OPT_Wattributes, "%qE attribute ignored", name);
5154 *no_add_attrs = true;
5160 /* Fake handler for attributes we don't properly support. */
5163 fake_attribute_handler (tree * ARG_UNUSED (node),
5164 tree ARG_UNUSED (name),
5165 tree ARG_UNUSED (args),
5166 int ARG_UNUSED (flags),
5167 bool * ARG_UNUSED (no_add_attrs))
5172 /* Handle a "type_generic" attribute. */
5175 handle_type_generic_attribute (tree *node, tree ARG_UNUSED (name),
5176 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
5177 bool * ARG_UNUSED (no_add_attrs))
5181 /* Ensure we have a function type. */
5182 gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE);
5184 params = TYPE_ARG_TYPES (*node);
5185 while (params && ! VOID_TYPE_P (TREE_VALUE (params)))
5186 params = TREE_CHAIN (params);
5188 /* Ensure we have a variadic function. */
5189 gcc_assert (!params);
5194 /* ----------------------------------------------------------------------- *
5195 * BUILTIN FUNCTIONS *
5196 * ----------------------------------------------------------------------- */
5198 /* Worker for DEF_BUILTIN. Possibly define a builtin function with one or two
5199 names. Does not declare a non-__builtin_ function if flag_no_builtin, or
5200 if nonansi_p and flag_no_nonansi_builtin. */
5203 def_builtin_1 (enum built_in_function fncode,
5205 enum built_in_class fnclass,
5206 tree fntype, tree libtype,
5207 bool both_p, bool fallback_p,
5208 bool nonansi_p ATTRIBUTE_UNUSED,
5209 tree fnattrs, bool implicit_p)
5212 const char *libname;
5214 /* Preserve an already installed decl. It most likely was setup in advance
5215 (e.g. as part of the internal builtins) for specific reasons. */
5216 if (built_in_decls[(int) fncode] != NULL_TREE)
5219 gcc_assert ((!both_p && !fallback_p)
5220 || !strncmp (name, "__builtin_",
5221 strlen ("__builtin_")));
5223 libname = name + strlen ("__builtin_");
5224 decl = add_builtin_function (name, fntype, fncode, fnclass,
5225 (fallback_p ? libname : NULL),
5228 /* ??? This is normally further controlled by command-line options
5229 like -fno-builtin, but we don't have them for Ada. */
5230 add_builtin_function (libname, libtype, fncode, fnclass,
5233 built_in_decls[(int) fncode] = decl;
5235 implicit_built_in_decls[(int) fncode] = decl;
5238 static int flag_isoc94 = 0;
5239 static int flag_isoc99 = 0;
5241 /* Install what the common builtins.def offers. */
5244 install_builtin_functions (void)
5246 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
5247 NONANSI_P, ATTRS, IMPLICIT, COND) \
5249 def_builtin_1 (ENUM, NAME, CLASS, \
5250 builtin_types[(int) TYPE], \
5251 builtin_types[(int) LIBTYPE], \
5252 BOTH_P, FALLBACK_P, NONANSI_P, \
5253 built_in_attributes[(int) ATTRS], IMPLICIT);
5254 #include "builtins.def"
5258 /* ----------------------------------------------------------------------- *
5259 * BUILTIN FUNCTIONS *
5260 * ----------------------------------------------------------------------- */
5262 /* Install the builtin functions we might need. */
5265 gnat_install_builtins (void)
5267 install_builtin_elementary_types ();
5268 install_builtin_function_types ();
5269 install_builtin_attributes ();
5271 /* Install builtins used by generic middle-end pieces first. Some of these
5272 know about internal specificities and control attributes accordingly, for
5273 instance __builtin_alloca vs no-throw and -fstack-check. We will ignore
5274 the generic definition from builtins.def. */
5275 build_common_builtin_nodes ();
5277 /* Now, install the target specific builtins, such as the AltiVec family on
5278 ppc, and the common set as exposed by builtins.def. */
5279 targetm.init_builtins ();
5280 install_builtin_functions ();
5283 #include "gt-ada-utils.h"
5284 #include "gtype-ada.h"