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"
44 #include "langhooks.h"
45 #include "pointer-set.h"
47 #include "tree-dump.h"
48 #include "tree-inline.h"
49 #include "tree-iterator.h"
66 #ifndef MAX_FIXED_MODE_SIZE
67 #define MAX_FIXED_MODE_SIZE GET_MODE_BITSIZE (DImode)
70 #ifndef MAX_BITS_PER_WORD
71 #define MAX_BITS_PER_WORD BITS_PER_WORD
74 /* If nonzero, pretend we are allocating at global level. */
77 /* The default alignment of "double" floating-point types, i.e. floating
78 point types whose size is equal to 64 bits, or 0 if this alignment is
79 not specifically capped. */
80 int double_float_alignment
;
82 /* The default alignment of "double" or larger scalar types, i.e. scalar
83 types whose size is greater or equal to 64 bits, or 0 if this alignment
84 is not specifically capped. */
85 int double_scalar_alignment
;
87 /* Tree nodes for the various types and decls we create. */
88 tree gnat_std_decls
[(int) ADT_LAST
];
90 /* Functions to call for each of the possible raise reasons. */
91 tree gnat_raise_decls
[(int) LAST_REASON_CODE
+ 1];
93 /* Forward declarations for handlers of attributes. */
94 static tree
handle_const_attribute (tree
*, tree
, tree
, int, bool *);
95 static tree
handle_nothrow_attribute (tree
*, tree
, tree
, int, bool *);
96 static tree
handle_pure_attribute (tree
*, tree
, tree
, int, bool *);
97 static tree
handle_novops_attribute (tree
*, tree
, tree
, int, bool *);
98 static tree
handle_nonnull_attribute (tree
*, tree
, tree
, int, bool *);
99 static tree
handle_sentinel_attribute (tree
*, tree
, tree
, int, bool *);
100 static tree
handle_noreturn_attribute (tree
*, tree
, tree
, int, bool *);
101 static tree
handle_malloc_attribute (tree
*, tree
, tree
, int, bool *);
102 static tree
handle_type_generic_attribute (tree
*, tree
, tree
, int, bool *);
103 static tree
handle_vector_size_attribute (tree
*, tree
, tree
, int, bool *);
105 /* Fake handler for attributes we don't properly support, typically because
106 they'd require dragging a lot of the common-c front-end circuitry. */
107 static tree
fake_attribute_handler (tree
*, tree
, tree
, int, bool *);
109 /* Table of machine-independent internal attributes for Ada. We support
110 this minimal set of attributes to accommodate the needs of builtins. */
111 const struct attribute_spec gnat_internal_attribute_table
[] =
113 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
114 { "const", 0, 0, true, false, false, handle_const_attribute
},
115 { "nothrow", 0, 0, true, false, false, handle_nothrow_attribute
},
116 { "pure", 0, 0, true, false, false, handle_pure_attribute
},
117 { "no vops", 0, 0, true, false, false, handle_novops_attribute
},
118 { "nonnull", 0, -1, false, true, true, handle_nonnull_attribute
},
119 { "sentinel", 0, 1, false, true, true, handle_sentinel_attribute
},
120 { "noreturn", 0, 0, true, false, false, handle_noreturn_attribute
},
121 { "malloc", 0, 0, true, false, false, handle_malloc_attribute
},
122 { "type generic", 0, 0, false, true, true, handle_type_generic_attribute
},
124 { "vector_size", 1, 1, false, true, false, handle_vector_size_attribute
},
125 { "may_alias", 0, 0, false, true, false, NULL
},
127 /* ??? format and format_arg are heavy and not supported, which actually
128 prevents support for stdio builtins, which we however declare as part
129 of the common builtins.def contents. */
130 { "format", 3, 3, false, true, true, fake_attribute_handler
},
131 { "format_arg", 1, 1, false, true, true, fake_attribute_handler
},
133 { NULL
, 0, 0, false, false, false, NULL
}
136 /* Associates a GNAT tree node to a GCC tree node. It is used in
137 `save_gnu_tree', `get_gnu_tree' and `present_gnu_tree'. See documentation
138 of `save_gnu_tree' for more info. */
139 static GTY((length ("max_gnat_nodes"))) tree
*associate_gnat_to_gnu
;
141 #define GET_GNU_TREE(GNAT_ENTITY) \
142 associate_gnat_to_gnu[(GNAT_ENTITY) - First_Node_Id]
144 #define SET_GNU_TREE(GNAT_ENTITY,VAL) \
145 associate_gnat_to_gnu[(GNAT_ENTITY) - First_Node_Id] = (VAL)
147 #define PRESENT_GNU_TREE(GNAT_ENTITY) \
148 (associate_gnat_to_gnu[(GNAT_ENTITY) - First_Node_Id] != NULL_TREE)
150 /* Associates a GNAT entity to a GCC tree node used as a dummy, if any. */
151 static GTY((length ("max_gnat_nodes"))) tree
*dummy_node_table
;
153 #define GET_DUMMY_NODE(GNAT_ENTITY) \
154 dummy_node_table[(GNAT_ENTITY) - First_Node_Id]
156 #define SET_DUMMY_NODE(GNAT_ENTITY,VAL) \
157 dummy_node_table[(GNAT_ENTITY) - First_Node_Id] = (VAL)
159 #define PRESENT_DUMMY_NODE(GNAT_ENTITY) \
160 (dummy_node_table[(GNAT_ENTITY) - First_Node_Id] != NULL_TREE)
162 /* This variable keeps a table for types for each precision so that we only
163 allocate each of them once. Signed and unsigned types are kept separate.
165 Note that these types are only used when fold-const requests something
166 special. Perhaps we should NOT share these types; we'll see how it
168 static GTY(()) tree signed_and_unsigned_types
[2 * MAX_BITS_PER_WORD
+ 1][2];
170 /* Likewise for float types, but record these by mode. */
171 static GTY(()) tree float_types
[NUM_MACHINE_MODES
];
173 /* For each binding contour we allocate a binding_level structure to indicate
174 the binding depth. */
176 struct GTY((chain_next ("%h.chain"))) gnat_binding_level
{
177 /* The binding level containing this one (the enclosing binding level). */
178 struct gnat_binding_level
*chain
;
179 /* The BLOCK node for this level. */
181 /* If nonzero, the setjmp buffer that needs to be updated for any
182 variable-sized definition within this context. */
186 /* The binding level currently in effect. */
187 static GTY(()) struct gnat_binding_level
*current_binding_level
;
189 /* A chain of gnat_binding_level structures awaiting reuse. */
190 static GTY((deletable
)) struct gnat_binding_level
*free_binding_level
;
192 /* An array of global declarations. */
193 static GTY(()) VEC(tree
,gc
) *global_decls
;
195 /* An array of builtin function declarations. */
196 static GTY(()) VEC(tree
,gc
) *builtin_decls
;
198 /* An array of global renaming pointers. */
199 static GTY(()) VEC(tree
,gc
) *global_renaming_pointers
;
201 /* A chain of unused BLOCK nodes. */
202 static GTY((deletable
)) tree free_block_chain
;
204 static tree
merge_sizes (tree
, tree
, tree
, bool, bool);
205 static tree
compute_related_constant (tree
, tree
);
206 static tree
split_plus (tree
, tree
*);
207 static tree
float_type_for_precision (int, enum machine_mode
);
208 static tree
convert_to_fat_pointer (tree
, tree
);
209 static tree
convert_to_thin_pointer (tree
, tree
);
210 static tree
make_descriptor_field (const char *,tree
, tree
, tree
);
211 static bool potential_alignment_gap (tree
, tree
, tree
);
213 /* Initialize the association of GNAT nodes to GCC trees. */
216 init_gnat_to_gnu (void)
218 associate_gnat_to_gnu
219 = (tree
*) ggc_alloc_cleared (max_gnat_nodes
* sizeof (tree
));
222 /* GNAT_ENTITY is a GNAT tree node for an entity. GNU_DECL is the GCC tree
223 which is to be associated with GNAT_ENTITY. Such GCC tree node is always
224 a ..._DECL node. If NO_CHECK is true, the latter check is suppressed.
226 If GNU_DECL is zero, a previous association is to be reset. */
229 save_gnu_tree (Entity_Id gnat_entity
, tree gnu_decl
, bool no_check
)
231 /* Check that GNAT_ENTITY is not already defined and that it is being set
232 to something which is a decl. Raise gigi 401 if not. Usually, this
233 means GNAT_ENTITY is defined twice, but occasionally is due to some
235 gcc_assert (!(gnu_decl
236 && (PRESENT_GNU_TREE (gnat_entity
)
237 || (!no_check
&& !DECL_P (gnu_decl
)))));
239 SET_GNU_TREE (gnat_entity
, gnu_decl
);
242 /* GNAT_ENTITY is a GNAT tree node for a defining identifier.
243 Return the ..._DECL node that was associated with it. If there is no tree
244 node associated with GNAT_ENTITY, abort.
246 In some cases, such as delayed elaboration or expressions that need to
247 be elaborated only once, GNAT_ENTITY is really not an entity. */
250 get_gnu_tree (Entity_Id gnat_entity
)
252 gcc_assert (PRESENT_GNU_TREE (gnat_entity
));
253 return GET_GNU_TREE (gnat_entity
);
256 /* Return nonzero if a GCC tree has been associated with GNAT_ENTITY. */
259 present_gnu_tree (Entity_Id gnat_entity
)
261 return PRESENT_GNU_TREE (gnat_entity
);
264 /* Initialize the association of GNAT nodes to GCC trees as dummies. */
267 init_dummy_type (void)
270 = (tree
*) ggc_alloc_cleared (max_gnat_nodes
* sizeof (tree
));
273 /* Make a dummy type corresponding to GNAT_TYPE. */
276 make_dummy_type (Entity_Id gnat_type
)
278 Entity_Id gnat_underlying
= Gigi_Equivalent_Type (gnat_type
);
281 /* If there is an equivalent type, get its underlying type. */
282 if (Present (gnat_underlying
))
283 gnat_underlying
= Underlying_Type (gnat_underlying
);
285 /* If there was no equivalent type (can only happen when just annotating
286 types) or underlying type, go back to the original type. */
287 if (No (gnat_underlying
))
288 gnat_underlying
= gnat_type
;
290 /* If it there already a dummy type, use that one. Else make one. */
291 if (PRESENT_DUMMY_NODE (gnat_underlying
))
292 return GET_DUMMY_NODE (gnat_underlying
);
294 /* If this is a record, make a RECORD_TYPE or UNION_TYPE; else make
296 gnu_type
= make_node (Is_Record_Type (gnat_underlying
)
297 ? tree_code_for_record_type (gnat_underlying
)
299 TYPE_NAME (gnu_type
) = get_entity_name (gnat_type
);
300 TYPE_DUMMY_P (gnu_type
) = 1;
301 TYPE_STUB_DECL (gnu_type
)
302 = create_type_stub_decl (TYPE_NAME (gnu_type
), gnu_type
);
303 if (AGGREGATE_TYPE_P (gnu_type
))
304 TYPE_BY_REFERENCE_P (gnu_type
) = Is_By_Reference_Type (gnat_type
);
306 SET_DUMMY_NODE (gnat_underlying
, gnu_type
);
311 /* Return nonzero if we are currently in the global binding level. */
314 global_bindings_p (void)
316 return ((force_global
|| !current_function_decl
) ? -1 : 0);
319 /* Enter a new binding level. */
322 gnat_pushlevel (void)
324 struct gnat_binding_level
*newlevel
= NULL
;
326 /* Reuse a struct for this binding level, if there is one. */
327 if (free_binding_level
)
329 newlevel
= free_binding_level
;
330 free_binding_level
= free_binding_level
->chain
;
334 = (struct gnat_binding_level
*)
335 ggc_alloc (sizeof (struct gnat_binding_level
));
337 /* Use a free BLOCK, if any; otherwise, allocate one. */
338 if (free_block_chain
)
340 newlevel
->block
= free_block_chain
;
341 free_block_chain
= BLOCK_CHAIN (free_block_chain
);
342 BLOCK_CHAIN (newlevel
->block
) = NULL_TREE
;
345 newlevel
->block
= make_node (BLOCK
);
347 /* Point the BLOCK we just made to its parent. */
348 if (current_binding_level
)
349 BLOCK_SUPERCONTEXT (newlevel
->block
) = current_binding_level
->block
;
351 BLOCK_VARS (newlevel
->block
) = BLOCK_SUBBLOCKS (newlevel
->block
) = NULL_TREE
;
352 TREE_USED (newlevel
->block
) = 1;
354 /* Add this level to the front of the chain (stack) of levels that are
356 newlevel
->chain
= current_binding_level
;
357 newlevel
->jmpbuf_decl
= NULL_TREE
;
358 current_binding_level
= newlevel
;
361 /* Set SUPERCONTEXT of the BLOCK for the current binding level to FNDECL
362 and point FNDECL to this BLOCK. */
365 set_current_block_context (tree fndecl
)
367 BLOCK_SUPERCONTEXT (current_binding_level
->block
) = fndecl
;
368 DECL_INITIAL (fndecl
) = current_binding_level
->block
;
371 /* Set the jmpbuf_decl for the current binding level to DECL. */
374 set_block_jmpbuf_decl (tree decl
)
376 current_binding_level
->jmpbuf_decl
= decl
;
379 /* Get the jmpbuf_decl, if any, for the current binding level. */
382 get_block_jmpbuf_decl (void)
384 return current_binding_level
->jmpbuf_decl
;
387 /* Exit a binding level. Set any BLOCK into the current code group. */
392 struct gnat_binding_level
*level
= current_binding_level
;
393 tree block
= level
->block
;
395 BLOCK_VARS (block
) = nreverse (BLOCK_VARS (block
));
396 BLOCK_SUBBLOCKS (block
) = nreverse (BLOCK_SUBBLOCKS (block
));
398 /* If this is a function-level BLOCK don't do anything. Otherwise, if there
399 are no variables free the block and merge its subblocks into those of its
400 parent block. Otherwise, add it to the list of its parent. */
401 if (TREE_CODE (BLOCK_SUPERCONTEXT (block
)) == FUNCTION_DECL
)
403 else if (BLOCK_VARS (block
) == NULL_TREE
)
405 BLOCK_SUBBLOCKS (level
->chain
->block
)
406 = chainon (BLOCK_SUBBLOCKS (block
),
407 BLOCK_SUBBLOCKS (level
->chain
->block
));
408 BLOCK_CHAIN (block
) = free_block_chain
;
409 free_block_chain
= block
;
413 BLOCK_CHAIN (block
) = BLOCK_SUBBLOCKS (level
->chain
->block
);
414 BLOCK_SUBBLOCKS (level
->chain
->block
) = block
;
415 TREE_USED (block
) = 1;
416 set_block_for_group (block
);
419 /* Free this binding structure. */
420 current_binding_level
= level
->chain
;
421 level
->chain
= free_binding_level
;
422 free_binding_level
= level
;
426 /* Records a ..._DECL node DECL as belonging to the current lexical scope
427 and uses GNAT_NODE for location information and propagating flags. */
430 gnat_pushdecl (tree decl
, Node_Id gnat_node
)
432 /* If this decl is public external or at toplevel, there is no context.
433 But PARM_DECLs always go in the level of its function. */
434 if (TREE_CODE (decl
) != PARM_DECL
435 && ((DECL_EXTERNAL (decl
) && TREE_PUBLIC (decl
))
436 || global_bindings_p ()))
437 DECL_CONTEXT (decl
) = 0;
440 DECL_CONTEXT (decl
) = current_function_decl
;
442 /* Functions imported in another function are not really nested. */
443 if (TREE_CODE (decl
) == FUNCTION_DECL
&& TREE_PUBLIC (decl
))
444 DECL_NO_STATIC_CHAIN (decl
) = 1;
447 TREE_NO_WARNING (decl
) = (gnat_node
== Empty
|| Warnings_Off (gnat_node
));
449 /* Set the location of DECL and emit a declaration for it. */
450 if (Present (gnat_node
))
451 Sloc_to_locus (Sloc (gnat_node
), &DECL_SOURCE_LOCATION (decl
));
452 add_decl_expr (decl
, gnat_node
);
454 /* Put the declaration on the list. The list of declarations is in reverse
455 order. The list will be reversed later. Put global variables in the
456 globals list and builtin functions in a dedicated list to speed up
457 further lookups. Don't put TYPE_DECLs for UNCONSTRAINED_ARRAY_TYPE into
458 the list, as they will cause trouble with the debugger and aren't needed
460 if (TREE_CODE (decl
) != TYPE_DECL
461 || TREE_CODE (TREE_TYPE (decl
)) != UNCONSTRAINED_ARRAY_TYPE
)
463 if (global_bindings_p ())
465 VEC_safe_push (tree
, gc
, global_decls
, decl
);
467 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_BUILT_IN (decl
))
468 VEC_safe_push (tree
, gc
, builtin_decls
, decl
);
472 TREE_CHAIN (decl
) = BLOCK_VARS (current_binding_level
->block
);
473 BLOCK_VARS (current_binding_level
->block
) = decl
;
477 /* For the declaration of a type, set its name if it either is not already
478 set or if the previous type name was not derived from a source name.
479 We'd rather have the type named with a real name and all the pointer
480 types to the same object have the same POINTER_TYPE node. Code in the
481 equivalent function of c-decl.c makes a copy of the type node here, but
482 that may cause us trouble with incomplete types. We make an exception
483 for fat pointer types because the compiler automatically builds them
484 for unconstrained array types and the debugger uses them to represent
485 both these and pointers to these. */
486 if (TREE_CODE (decl
) == TYPE_DECL
&& DECL_NAME (decl
))
488 tree t
= TREE_TYPE (decl
);
490 if (!(TYPE_NAME (t
) && TREE_CODE (TYPE_NAME (t
)) == TYPE_DECL
))
492 else if (TYPE_FAT_POINTER_P (t
))
494 tree tt
= build_variant_type_copy (t
);
495 TYPE_NAME (tt
) = decl
;
496 TREE_USED (tt
) = TREE_USED (t
);
497 TREE_TYPE (decl
) = tt
;
498 DECL_ORIGINAL_TYPE (decl
) = t
;
501 else if (DECL_ARTIFICIAL (TYPE_NAME (t
)) && !DECL_ARTIFICIAL (decl
))
506 /* Propagate the name to all the variants. This is needed for
507 the type qualifiers machinery to work properly. */
509 for (t
= TYPE_MAIN_VARIANT (t
); t
; t
= TYPE_NEXT_VARIANT (t
))
510 TYPE_NAME (t
) = decl
;
514 /* Do little here. Set up the standard declarations later after the
515 front end has been run. */
518 gnat_init_decl_processing (void)
520 /* Make the binding_level structure for global names. */
521 current_function_decl
= 0;
522 current_binding_level
= 0;
523 free_binding_level
= 0;
526 build_common_tree_nodes (true, true);
528 /* In Ada, we use a signed type for SIZETYPE. Use the signed type
529 corresponding to the width of Pmode. In most cases when ptr_mode
530 and Pmode differ, C will use the width of ptr_mode for SIZETYPE.
531 But we get far better code using the width of Pmode. */
532 size_type_node
= gnat_type_for_mode (Pmode
, 0);
533 set_sizetype (size_type_node
);
535 /* In Ada, we use an unsigned 8-bit type for the default boolean type. */
536 boolean_type_node
= make_unsigned_type (8);
537 TREE_SET_CODE (boolean_type_node
, BOOLEAN_TYPE
);
538 SET_TYPE_RM_MAX_VALUE (boolean_type_node
,
539 build_int_cst (boolean_type_node
, 1));
540 SET_TYPE_RM_SIZE (boolean_type_node
, bitsize_int (1));
542 build_common_tree_nodes_2 (0);
543 boolean_true_node
= TYPE_MAX_VALUE (boolean_type_node
);
545 ptr_void_type_node
= build_pointer_type (void_type_node
);
548 /* Record TYPE as a builtin type for Ada. NAME is the name of the type. */
551 record_builtin_type (const char *name
, tree type
)
553 tree type_decl
= build_decl (input_location
,
554 TYPE_DECL
, get_identifier (name
), type
);
556 gnat_pushdecl (type_decl
, Empty
);
558 if (debug_hooks
->type_decl
)
559 debug_hooks
->type_decl (type_decl
, false);
562 /* Given a record type RECORD_TYPE and a chain of FIELD_DECL nodes FIELDLIST,
563 finish constructing the record or union type. If REP_LEVEL is zero, this
564 record has no representation clause and so will be entirely laid out here.
565 If REP_LEVEL is one, this record has a representation clause and has been
566 laid out already; only set the sizes and alignment. If REP_LEVEL is two,
567 this record is derived from a parent record and thus inherits its layout;
568 only make a pass on the fields to finalize them. If DO_NOT_FINALIZE is
569 true, the record type is expected to be modified afterwards so it will
570 not be sent to the back-end for finalization. */
573 finish_record_type (tree record_type
, tree fieldlist
, int rep_level
,
574 bool do_not_finalize
)
576 enum tree_code code
= TREE_CODE (record_type
);
577 tree name
= TYPE_NAME (record_type
);
578 tree ada_size
= bitsize_zero_node
;
579 tree size
= bitsize_zero_node
;
580 bool had_size
= TYPE_SIZE (record_type
) != 0;
581 bool had_size_unit
= TYPE_SIZE_UNIT (record_type
) != 0;
582 bool had_align
= TYPE_ALIGN (record_type
) != 0;
585 TYPE_FIELDS (record_type
) = fieldlist
;
587 /* Always attach the TYPE_STUB_DECL for a record type. It is required to
588 generate debug info and have a parallel type. */
589 if (name
&& TREE_CODE (name
) == TYPE_DECL
)
590 name
= DECL_NAME (name
);
591 TYPE_STUB_DECL (record_type
) = create_type_stub_decl (name
, record_type
);
593 /* Globally initialize the record first. If this is a rep'ed record,
594 that just means some initializations; otherwise, layout the record. */
597 TYPE_ALIGN (record_type
) = MAX (BITS_PER_UNIT
, TYPE_ALIGN (record_type
));
598 SET_TYPE_MODE (record_type
, BLKmode
);
601 TYPE_SIZE_UNIT (record_type
) = size_zero_node
;
603 TYPE_SIZE (record_type
) = bitsize_zero_node
;
605 /* For all-repped records with a size specified, lay the QUAL_UNION_TYPE
606 out just like a UNION_TYPE, since the size will be fixed. */
607 else if (code
== QUAL_UNION_TYPE
)
612 /* Ensure there isn't a size already set. There can be in an error
613 case where there is a rep clause but all fields have errors and
614 no longer have a position. */
615 TYPE_SIZE (record_type
) = 0;
616 layout_type (record_type
);
619 /* At this point, the position and size of each field is known. It was
620 either set before entry by a rep clause, or by laying out the type above.
622 We now run a pass over the fields (in reverse order for QUAL_UNION_TYPEs)
623 to compute the Ada size; the GCC size and alignment (for rep'ed records
624 that are not padding types); and the mode (for rep'ed records). We also
625 clear the DECL_BIT_FIELD indication for the cases we know have not been
626 handled yet, and adjust DECL_NONADDRESSABLE_P accordingly. */
628 if (code
== QUAL_UNION_TYPE
)
629 fieldlist
= nreverse (fieldlist
);
631 for (field
= fieldlist
; field
; field
= TREE_CHAIN (field
))
633 tree type
= TREE_TYPE (field
);
634 tree pos
= bit_position (field
);
635 tree this_size
= DECL_SIZE (field
);
638 if ((TREE_CODE (type
) == RECORD_TYPE
639 || TREE_CODE (type
) == UNION_TYPE
640 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
641 && !TYPE_IS_FAT_POINTER_P (type
)
642 && !TYPE_CONTAINS_TEMPLATE_P (type
)
643 && TYPE_ADA_SIZE (type
))
644 this_ada_size
= TYPE_ADA_SIZE (type
);
646 this_ada_size
= this_size
;
648 /* Clear DECL_BIT_FIELD for the cases layout_decl does not handle. */
649 if (DECL_BIT_FIELD (field
)
650 && operand_equal_p (this_size
, TYPE_SIZE (type
), 0))
652 unsigned int align
= TYPE_ALIGN (type
);
654 /* In the general case, type alignment is required. */
655 if (value_factor_p (pos
, align
))
657 /* The enclosing record type must be sufficiently aligned.
658 Otherwise, if no alignment was specified for it and it
659 has been laid out already, bump its alignment to the
660 desired one if this is compatible with its size. */
661 if (TYPE_ALIGN (record_type
) >= align
)
663 DECL_ALIGN (field
) = MAX (DECL_ALIGN (field
), align
);
664 DECL_BIT_FIELD (field
) = 0;
668 && value_factor_p (TYPE_SIZE (record_type
), align
))
670 TYPE_ALIGN (record_type
) = align
;
671 DECL_ALIGN (field
) = MAX (DECL_ALIGN (field
), align
);
672 DECL_BIT_FIELD (field
) = 0;
676 /* In the non-strict alignment case, only byte alignment is. */
677 if (!STRICT_ALIGNMENT
678 && DECL_BIT_FIELD (field
)
679 && value_factor_p (pos
, BITS_PER_UNIT
))
680 DECL_BIT_FIELD (field
) = 0;
683 /* If we still have DECL_BIT_FIELD set at this point, we know that the
684 field is technically not addressable. Except that it can actually
685 be addressed if it is BLKmode and happens to be properly aligned. */
686 if (DECL_BIT_FIELD (field
)
687 && !(DECL_MODE (field
) == BLKmode
688 && value_factor_p (pos
, BITS_PER_UNIT
)))
689 DECL_NONADDRESSABLE_P (field
) = 1;
691 /* A type must be as aligned as its most aligned field that is not
692 a bit-field. But this is already enforced by layout_type. */
693 if (rep_level
> 0 && !DECL_BIT_FIELD (field
))
694 TYPE_ALIGN (record_type
)
695 = MAX (TYPE_ALIGN (record_type
), DECL_ALIGN (field
));
700 ada_size
= size_binop (MAX_EXPR
, ada_size
, this_ada_size
);
701 size
= size_binop (MAX_EXPR
, size
, this_size
);
704 case QUAL_UNION_TYPE
:
706 = fold_build3 (COND_EXPR
, bitsizetype
, DECL_QUALIFIER (field
),
707 this_ada_size
, ada_size
);
708 size
= fold_build3 (COND_EXPR
, bitsizetype
, DECL_QUALIFIER (field
),
713 /* Since we know here that all fields are sorted in order of
714 increasing bit position, the size of the record is one
715 higher than the ending bit of the last field processed
716 unless we have a rep clause, since in that case we might
717 have a field outside a QUAL_UNION_TYPE that has a higher ending
718 position. So use a MAX in that case. Also, if this field is a
719 QUAL_UNION_TYPE, we need to take into account the previous size in
720 the case of empty variants. */
722 = merge_sizes (ada_size
, pos
, this_ada_size
,
723 TREE_CODE (type
) == QUAL_UNION_TYPE
, rep_level
> 0);
725 = merge_sizes (size
, pos
, this_size
,
726 TREE_CODE (type
) == QUAL_UNION_TYPE
, rep_level
> 0);
734 if (code
== QUAL_UNION_TYPE
)
735 nreverse (fieldlist
);
737 /* If the type is discriminated, it can be used to access all its
738 constrained subtypes, so force structural equality checks. */
739 if (CONTAINS_PLACEHOLDER_P (size
))
740 SET_TYPE_STRUCTURAL_EQUALITY (record_type
);
744 /* If this is a padding record, we never want to make the size smaller
745 than what was specified in it, if any. */
746 if (TREE_CODE (record_type
) == RECORD_TYPE
747 && TYPE_IS_PADDING_P (record_type
) && TYPE_SIZE (record_type
))
748 size
= TYPE_SIZE (record_type
);
750 /* Now set any of the values we've just computed that apply. */
751 if (!TYPE_IS_FAT_POINTER_P (record_type
)
752 && !TYPE_CONTAINS_TEMPLATE_P (record_type
))
753 SET_TYPE_ADA_SIZE (record_type
, ada_size
);
757 tree size_unit
= had_size_unit
758 ? TYPE_SIZE_UNIT (record_type
)
760 size_binop (CEIL_DIV_EXPR
, size
,
762 unsigned int align
= TYPE_ALIGN (record_type
);
764 TYPE_SIZE (record_type
) = variable_size (round_up (size
, align
));
765 TYPE_SIZE_UNIT (record_type
)
766 = variable_size (round_up (size_unit
, align
/ BITS_PER_UNIT
));
768 compute_record_mode (record_type
);
772 if (!do_not_finalize
)
773 rest_of_record_type_compilation (record_type
);
776 /* Wrap up compilation of RECORD_TYPE, i.e. most notably output all
777 the debug information associated with it. It need not be invoked
778 directly in most cases since finish_record_type takes care of doing
779 so, unless explicitly requested not to through DO_NOT_FINALIZE. */
782 rest_of_record_type_compilation (tree record_type
)
784 tree fieldlist
= TYPE_FIELDS (record_type
);
786 enum tree_code code
= TREE_CODE (record_type
);
787 bool var_size
= false;
789 for (field
= fieldlist
; field
; field
= TREE_CHAIN (field
))
791 /* We need to make an XVE/XVU record if any field has variable size,
792 whether or not the record does. For example, if we have a union,
793 it may be that all fields, rounded up to the alignment, have the
794 same size, in which case we'll use that size. But the debug
795 output routines (except Dwarf2) won't be able to output the fields,
796 so we need to make the special record. */
797 if (TREE_CODE (DECL_SIZE (field
)) != INTEGER_CST
798 /* If a field has a non-constant qualifier, the record will have
799 variable size too. */
800 || (code
== QUAL_UNION_TYPE
801 && TREE_CODE (DECL_QUALIFIER (field
)) != INTEGER_CST
))
808 /* If this record is of variable size, rename it so that the
809 debugger knows it is and make a new, parallel, record
810 that tells the debugger how the record is laid out. See
811 exp_dbug.ads. But don't do this for records that are padding
812 since they confuse GDB. */
814 && !(TREE_CODE (record_type
) == RECORD_TYPE
815 && TYPE_IS_PADDING_P (record_type
)))
818 = make_node (TREE_CODE (record_type
) == QUAL_UNION_TYPE
819 ? UNION_TYPE
: TREE_CODE (record_type
));
820 tree orig_name
= TYPE_NAME (record_type
), new_name
;
821 tree last_pos
= bitsize_zero_node
;
822 tree old_field
, prev_old_field
= NULL_TREE
;
824 if (TREE_CODE (orig_name
) == TYPE_DECL
)
825 orig_name
= DECL_NAME (orig_name
);
828 = concat_name (orig_name
, TREE_CODE (record_type
) == QUAL_UNION_TYPE
830 TYPE_NAME (new_record_type
) = new_name
;
831 TYPE_ALIGN (new_record_type
) = BIGGEST_ALIGNMENT
;
832 TYPE_STUB_DECL (new_record_type
)
833 = create_type_stub_decl (new_name
, new_record_type
);
834 DECL_IGNORED_P (TYPE_STUB_DECL (new_record_type
))
835 = DECL_IGNORED_P (TYPE_STUB_DECL (record_type
));
836 TYPE_SIZE (new_record_type
) = size_int (TYPE_ALIGN (record_type
));
837 TYPE_SIZE_UNIT (new_record_type
)
838 = size_int (TYPE_ALIGN (record_type
) / BITS_PER_UNIT
);
840 add_parallel_type (TYPE_STUB_DECL (record_type
), new_record_type
);
842 /* Now scan all the fields, replacing each field with a new
843 field corresponding to the new encoding. */
844 for (old_field
= TYPE_FIELDS (record_type
); old_field
;
845 old_field
= TREE_CHAIN (old_field
))
847 tree field_type
= TREE_TYPE (old_field
);
848 tree field_name
= DECL_NAME (old_field
);
850 tree curpos
= bit_position (old_field
);
852 unsigned int align
= 0;
855 /* See how the position was modified from the last position.
857 There are two basic cases we support: a value was added
858 to the last position or the last position was rounded to
859 a boundary and they something was added. Check for the
860 first case first. If not, see if there is any evidence
861 of rounding. If so, round the last position and try
864 If this is a union, the position can be taken as zero. */
866 /* Some computations depend on the shape of the position expression,
867 so strip conversions to make sure it's exposed. */
868 curpos
= remove_conversions (curpos
, true);
870 if (TREE_CODE (new_record_type
) == UNION_TYPE
)
871 pos
= bitsize_zero_node
, align
= 0;
873 pos
= compute_related_constant (curpos
, last_pos
);
875 if (!pos
&& TREE_CODE (curpos
) == MULT_EXPR
876 && host_integerp (TREE_OPERAND (curpos
, 1), 1))
878 tree offset
= TREE_OPERAND (curpos
, 0);
879 align
= tree_low_cst (TREE_OPERAND (curpos
, 1), 1);
881 /* An offset which is a bitwise AND with a negative power of 2
882 means an alignment corresponding to this power of 2. */
883 offset
= remove_conversions (offset
, true);
884 if (TREE_CODE (offset
) == BIT_AND_EXPR
885 && host_integerp (TREE_OPERAND (offset
, 1), 0)
886 && tree_int_cst_sgn (TREE_OPERAND (offset
, 1)) < 0)
889 = - tree_low_cst (TREE_OPERAND (offset
, 1), 0);
890 if (exact_log2 (pow
) > 0)
894 pos
= compute_related_constant (curpos
,
895 round_up (last_pos
, align
));
897 else if (!pos
&& TREE_CODE (curpos
) == PLUS_EXPR
898 && TREE_CODE (TREE_OPERAND (curpos
, 1)) == INTEGER_CST
899 && TREE_CODE (TREE_OPERAND (curpos
, 0)) == MULT_EXPR
900 && host_integerp (TREE_OPERAND
901 (TREE_OPERAND (curpos
, 0), 1),
906 (TREE_OPERAND (TREE_OPERAND (curpos
, 0), 1), 1);
907 pos
= compute_related_constant (curpos
,
908 round_up (last_pos
, align
));
910 else if (potential_alignment_gap (prev_old_field
, old_field
,
913 align
= TYPE_ALIGN (field_type
);
914 pos
= compute_related_constant (curpos
,
915 round_up (last_pos
, align
));
918 /* If we can't compute a position, set it to zero.
920 ??? We really should abort here, but it's too much work
921 to get this correct for all cases. */
924 pos
= bitsize_zero_node
;
926 /* See if this type is variable-sized and make a pointer type
927 and indicate the indirection if so. Beware that the debug
928 back-end may adjust the position computed above according
929 to the alignment of the field type, i.e. the pointer type
930 in this case, if we don't preventively counter that. */
931 if (TREE_CODE (DECL_SIZE (old_field
)) != INTEGER_CST
)
933 field_type
= build_pointer_type (field_type
);
934 if (align
!= 0 && TYPE_ALIGN (field_type
) > align
)
936 field_type
= copy_node (field_type
);
937 TYPE_ALIGN (field_type
) = align
;
942 /* Make a new field name, if necessary. */
943 if (var
|| align
!= 0)
948 sprintf (suffix
, "XV%c%u", var
? 'L' : 'A',
949 align
/ BITS_PER_UNIT
);
951 strcpy (suffix
, "XVL");
953 field_name
= concat_name (field_name
, suffix
);
956 new_field
= create_field_decl (field_name
, field_type
,
958 DECL_SIZE (old_field
), pos
, 0);
959 TREE_CHAIN (new_field
) = TYPE_FIELDS (new_record_type
);
960 TYPE_FIELDS (new_record_type
) = new_field
;
962 /* If old_field is a QUAL_UNION_TYPE, take its size as being
963 zero. The only time it's not the last field of the record
964 is when there are other components at fixed positions after
965 it (meaning there was a rep clause for every field) and we
966 want to be able to encode them. */
967 last_pos
= size_binop (PLUS_EXPR
, bit_position (old_field
),
968 (TREE_CODE (TREE_TYPE (old_field
))
971 : DECL_SIZE (old_field
));
972 prev_old_field
= old_field
;
975 TYPE_FIELDS (new_record_type
)
976 = nreverse (TYPE_FIELDS (new_record_type
));
978 rest_of_type_decl_compilation (TYPE_STUB_DECL (new_record_type
));
981 rest_of_type_decl_compilation (TYPE_STUB_DECL (record_type
));
984 /* Append PARALLEL_TYPE on the chain of parallel types for decl. */
987 add_parallel_type (tree decl
, tree parallel_type
)
991 while (DECL_PARALLEL_TYPE (d
))
992 d
= TYPE_STUB_DECL (DECL_PARALLEL_TYPE (d
));
994 SET_DECL_PARALLEL_TYPE (d
, parallel_type
);
997 /* Return the parallel type associated to a type, if any. */
1000 get_parallel_type (tree type
)
1002 if (TYPE_STUB_DECL (type
))
1003 return DECL_PARALLEL_TYPE (TYPE_STUB_DECL (type
));
1008 /* Utility function of above to merge LAST_SIZE, the previous size of a record
1009 with FIRST_BIT and SIZE that describe a field. SPECIAL is true if this
1010 represents a QUAL_UNION_TYPE in which case we must look for COND_EXPRs and
1011 replace a value of zero with the old size. If HAS_REP is true, we take the
1012 MAX of the end position of this field with LAST_SIZE. In all other cases,
1013 we use FIRST_BIT plus SIZE. Return an expression for the size. */
1016 merge_sizes (tree last_size
, tree first_bit
, tree size
, bool special
,
1019 tree type
= TREE_TYPE (last_size
);
1022 if (!special
|| TREE_CODE (size
) != COND_EXPR
)
1024 new_size
= size_binop (PLUS_EXPR
, first_bit
, size
);
1026 new_size
= size_binop (MAX_EXPR
, last_size
, new_size
);
1030 new_size
= fold_build3 (COND_EXPR
, type
, TREE_OPERAND (size
, 0),
1031 integer_zerop (TREE_OPERAND (size
, 1))
1032 ? last_size
: merge_sizes (last_size
, first_bit
,
1033 TREE_OPERAND (size
, 1),
1035 integer_zerop (TREE_OPERAND (size
, 2))
1036 ? last_size
: merge_sizes (last_size
, first_bit
,
1037 TREE_OPERAND (size
, 2),
1040 /* We don't need any NON_VALUE_EXPRs and they can confuse us (especially
1041 when fed through substitute_in_expr) into thinking that a constant
1042 size is not constant. */
1043 while (TREE_CODE (new_size
) == NON_LVALUE_EXPR
)
1044 new_size
= TREE_OPERAND (new_size
, 0);
1049 /* Utility function of above to see if OP0 and OP1, both of SIZETYPE, are
1050 related by the addition of a constant. Return that constant if so. */
1053 compute_related_constant (tree op0
, tree op1
)
1055 tree op0_var
, op1_var
;
1056 tree op0_con
= split_plus (op0
, &op0_var
);
1057 tree op1_con
= split_plus (op1
, &op1_var
);
1058 tree result
= size_binop (MINUS_EXPR
, op0_con
, op1_con
);
1060 if (operand_equal_p (op0_var
, op1_var
, 0))
1062 else if (operand_equal_p (op0
, size_binop (PLUS_EXPR
, op1_var
, result
), 0))
1068 /* Utility function of above to split a tree OP which may be a sum, into a
1069 constant part, which is returned, and a variable part, which is stored
1070 in *PVAR. *PVAR may be bitsize_zero_node. All operations must be of
1074 split_plus (tree in
, tree
*pvar
)
1076 /* Strip NOPS in order to ease the tree traversal and maximize the
1077 potential for constant or plus/minus discovery. We need to be careful
1078 to always return and set *pvar to bitsizetype trees, but it's worth
1082 *pvar
= convert (bitsizetype
, in
);
1084 if (TREE_CODE (in
) == INTEGER_CST
)
1086 *pvar
= bitsize_zero_node
;
1087 return convert (bitsizetype
, in
);
1089 else if (TREE_CODE (in
) == PLUS_EXPR
|| TREE_CODE (in
) == MINUS_EXPR
)
1091 tree lhs_var
, rhs_var
;
1092 tree lhs_con
= split_plus (TREE_OPERAND (in
, 0), &lhs_var
);
1093 tree rhs_con
= split_plus (TREE_OPERAND (in
, 1), &rhs_var
);
1095 if (lhs_var
== TREE_OPERAND (in
, 0)
1096 && rhs_var
== TREE_OPERAND (in
, 1))
1097 return bitsize_zero_node
;
1099 *pvar
= size_binop (TREE_CODE (in
), lhs_var
, rhs_var
);
1100 return size_binop (TREE_CODE (in
), lhs_con
, rhs_con
);
1103 return bitsize_zero_node
;
1106 /* Return a FUNCTION_TYPE node. RETURN_TYPE is the type returned by the
1107 subprogram. If it is void_type_node, then we are dealing with a procedure,
1108 otherwise we are dealing with a function. PARAM_DECL_LIST is a list of
1109 PARM_DECL nodes that are the subprogram arguments. CICO_LIST is the
1110 copy-in/copy-out list to be stored into TYPE_CICO_LIST.
1111 RETURNS_UNCONSTRAINED is true if the function returns an unconstrained
1112 object. RETURNS_BY_REF is true if the function returns by reference.
1113 RETURNS_BY_TARGET_PTR is true if the function is to be passed (as its
1114 first parameter) the address of the place to copy its result. */
1117 create_subprog_type (tree return_type
, tree param_decl_list
, tree cico_list
,
1118 bool returns_unconstrained
, bool returns_by_ref
,
1119 bool returns_by_target_ptr
)
1121 /* A chain of TREE_LIST nodes whose TREE_VALUEs are the data type nodes of
1122 the subprogram formal parameters. This list is generated by traversing the
1123 input list of PARM_DECL nodes. */
1124 tree param_type_list
= NULL
;
1128 for (param_decl
= param_decl_list
; param_decl
;
1129 param_decl
= TREE_CHAIN (param_decl
))
1130 param_type_list
= tree_cons (NULL_TREE
, TREE_TYPE (param_decl
),
1133 /* The list of the function parameter types has to be terminated by the void
1134 type to signal to the back-end that we are not dealing with a variable
1135 parameter subprogram, but that the subprogram has a fixed number of
1137 param_type_list
= tree_cons (NULL_TREE
, void_type_node
, param_type_list
);
1139 /* The list of argument types has been created in reverse
1141 param_type_list
= nreverse (param_type_list
);
1143 type
= build_function_type (return_type
, param_type_list
);
1145 /* TYPE may have been shared since GCC hashes types. If it has a CICO_LIST
1146 or the new type should, make a copy of TYPE. Likewise for
1147 RETURNS_UNCONSTRAINED and RETURNS_BY_REF. */
1148 if (TYPE_CI_CO_LIST (type
) || cico_list
1149 || TYPE_RETURNS_UNCONSTRAINED_P (type
) != returns_unconstrained
1150 || TYPE_RETURNS_BY_REF_P (type
) != returns_by_ref
1151 || TYPE_RETURNS_BY_TARGET_PTR_P (type
) != returns_by_target_ptr
)
1152 type
= copy_type (type
);
1154 TYPE_CI_CO_LIST (type
) = cico_list
;
1155 TYPE_RETURNS_UNCONSTRAINED_P (type
) = returns_unconstrained
;
1156 TYPE_RETURNS_BY_REF_P (type
) = returns_by_ref
;
1157 TYPE_RETURNS_BY_TARGET_PTR_P (type
) = returns_by_target_ptr
;
1161 /* Return a copy of TYPE but safe to modify in any way. */
1164 copy_type (tree type
)
1166 tree new_type
= copy_node (type
);
1168 /* copy_node clears this field instead of copying it, because it is
1169 aliased with TREE_CHAIN. */
1170 TYPE_STUB_DECL (new_type
) = TYPE_STUB_DECL (type
);
1172 TYPE_POINTER_TO (new_type
) = 0;
1173 TYPE_REFERENCE_TO (new_type
) = 0;
1174 TYPE_MAIN_VARIANT (new_type
) = new_type
;
1175 TYPE_NEXT_VARIANT (new_type
) = 0;
1180 /* Return a subtype of sizetype with range MIN to MAX and whose
1181 TYPE_INDEX_TYPE is INDEX. GNAT_NODE is used for the position
1182 of the associated TYPE_DECL. */
1185 create_index_type (tree min
, tree max
, tree index
, Node_Id gnat_node
)
1187 /* First build a type for the desired range. */
1188 tree type
= build_index_2_type (min
, max
);
1190 /* If this type has the TYPE_INDEX_TYPE we want, return it. */
1191 if (TYPE_INDEX_TYPE (type
) == index
)
1194 /* Otherwise, if TYPE_INDEX_TYPE is set, make a copy. Note that we have
1195 no way of sharing these types, but that's only a small hole. */
1196 if (TYPE_INDEX_TYPE (type
))
1197 type
= copy_type (type
);
1199 SET_TYPE_INDEX_TYPE (type
, index
);
1200 create_type_decl (NULL_TREE
, type
, NULL
, true, false, gnat_node
);
1205 /* Return a subtype of TYPE with range MIN to MAX. If TYPE is NULL,
1206 sizetype is used. */
1209 create_range_type (tree type
, tree min
, tree max
)
1213 if (type
== NULL_TREE
)
1216 /* First build a type with the base range. */
1218 = build_range_type (type
, TYPE_MIN_VALUE (type
), TYPE_MAX_VALUE (type
));
1220 min
= convert (type
, min
);
1221 max
= convert (type
, max
);
1223 /* If this type has the TYPE_RM_{MIN,MAX}_VALUE we want, return it. */
1224 if (TYPE_RM_MIN_VALUE (range_type
)
1225 && TYPE_RM_MAX_VALUE (range_type
)
1226 && operand_equal_p (TYPE_RM_MIN_VALUE (range_type
), min
, 0)
1227 && operand_equal_p (TYPE_RM_MAX_VALUE (range_type
), max
, 0))
1230 /* Otherwise, if TYPE_RM_{MIN,MAX}_VALUE is set, make a copy. */
1231 if (TYPE_RM_MIN_VALUE (range_type
) || TYPE_RM_MAX_VALUE (range_type
))
1232 range_type
= copy_type (range_type
);
1234 /* Then set the actual range. */
1235 SET_TYPE_RM_MIN_VALUE (range_type
, min
);
1236 SET_TYPE_RM_MAX_VALUE (range_type
, max
);
1241 /* Return a TYPE_DECL node suitable for the TYPE_STUB_DECL field of a type.
1242 TYPE_NAME gives the name of the type and TYPE is a ..._TYPE node giving
1246 create_type_stub_decl (tree type_name
, tree type
)
1248 /* Using a named TYPE_DECL ensures that a type name marker is emitted in
1249 STABS while setting DECL_ARTIFICIAL ensures that no DW_TAG_typedef is
1250 emitted in DWARF. */
1251 tree type_decl
= build_decl (input_location
,
1252 TYPE_DECL
, type_name
, type
);
1253 DECL_ARTIFICIAL (type_decl
) = 1;
1257 /* Return a TYPE_DECL node. TYPE_NAME gives the name of the type and TYPE
1258 is a ..._TYPE node giving its data type. ARTIFICIAL_P is true if this
1259 is a declaration that was generated by the compiler. DEBUG_INFO_P is
1260 true if we need to write debug information about this type. GNAT_NODE
1261 is used for the position of the decl. */
1264 create_type_decl (tree type_name
, tree type
, struct attrib
*attr_list
,
1265 bool artificial_p
, bool debug_info_p
, Node_Id gnat_node
)
1267 enum tree_code code
= TREE_CODE (type
);
1268 bool named
= TYPE_NAME (type
) && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
;
1271 /* Only the builtin TYPE_STUB_DECL should be used for dummy types. */
1272 gcc_assert (!TYPE_IS_DUMMY_P (type
));
1274 /* If the type hasn't been named yet, we're naming it; preserve an existing
1275 TYPE_STUB_DECL that has been attached to it for some purpose. */
1276 if (!named
&& TYPE_STUB_DECL (type
))
1278 type_decl
= TYPE_STUB_DECL (type
);
1279 DECL_NAME (type_decl
) = type_name
;
1282 type_decl
= build_decl (input_location
,
1283 TYPE_DECL
, type_name
, type
);
1285 DECL_ARTIFICIAL (type_decl
) = artificial_p
;
1286 gnat_pushdecl (type_decl
, gnat_node
);
1287 process_attributes (type_decl
, attr_list
);
1289 /* If we're naming the type, equate the TYPE_STUB_DECL to the name.
1290 This causes the name to be also viewed as a "tag" by the debug
1291 back-end, with the advantage that no DW_TAG_typedef is emitted
1292 for artificial "tagged" types in DWARF. */
1294 TYPE_STUB_DECL (type
) = type_decl
;
1296 /* Pass the type declaration to the debug back-end unless this is an
1297 UNCONSTRAINED_ARRAY_TYPE that the back-end does not support, or a
1298 type for which debugging information was not requested, or else an
1299 ENUMERAL_TYPE or RECORD_TYPE (except for fat pointers) which are
1300 handled separately. And do not pass dummy types either. */
1301 if (code
== UNCONSTRAINED_ARRAY_TYPE
|| !debug_info_p
)
1302 DECL_IGNORED_P (type_decl
) = 1;
1303 else if (code
!= ENUMERAL_TYPE
1304 && (code
!= RECORD_TYPE
|| TYPE_IS_FAT_POINTER_P (type
))
1305 && !((code
== POINTER_TYPE
|| code
== REFERENCE_TYPE
)
1306 && TYPE_IS_DUMMY_P (TREE_TYPE (type
)))
1307 && !(code
== RECORD_TYPE
1309 (TREE_TYPE (TREE_TYPE (TYPE_FIELDS (type
))))))
1310 rest_of_type_decl_compilation (type_decl
);
1315 /* Return a VAR_DECL or CONST_DECL node.
1317 VAR_NAME gives the name of the variable. ASM_NAME is its assembler name
1318 (if provided). TYPE is its data type (a GCC ..._TYPE node). VAR_INIT is
1319 the GCC tree for an optional initial expression; NULL_TREE if none.
1321 CONST_FLAG is true if this variable is constant, in which case we might
1322 return a CONST_DECL node unless CONST_DECL_ALLOWED_P is false.
1324 PUBLIC_FLAG is true if this is for a reference to a public entity or for a
1325 definition to be made visible outside of the current compilation unit, for
1326 instance variable definitions in a package specification.
1328 EXTERN_FLAG is true when processing an external variable declaration (as
1329 opposed to a definition: no storage is to be allocated for the variable).
1331 STATIC_FLAG is only relevant when not at top level. In that case
1332 it indicates whether to always allocate storage to the variable.
1334 GNAT_NODE is used for the position of the decl. */
1337 create_var_decl_1 (tree var_name
, tree asm_name
, tree type
, tree var_init
,
1338 bool const_flag
, bool public_flag
, bool extern_flag
,
1339 bool static_flag
, bool const_decl_allowed_p
,
1340 struct attrib
*attr_list
, Node_Id gnat_node
)
1344 && gnat_types_compatible_p (type
, TREE_TYPE (var_init
))
1345 && (global_bindings_p () || static_flag
1346 ? initializer_constant_valid_p (var_init
, TREE_TYPE (var_init
)) != 0
1347 : TREE_CONSTANT (var_init
)));
1349 /* Whether we will make TREE_CONSTANT the DECL we produce here, in which
1350 case the initializer may be used in-lieu of the DECL node (as done in
1351 Identifier_to_gnu). This is useful to prevent the need of elaboration
1352 code when an identifier for which such a decl is made is in turn used as
1353 an initializer. We used to rely on CONST vs VAR_DECL for this purpose,
1354 but extra constraints apply to this choice (see below) and are not
1355 relevant to the distinction we wish to make. */
1356 bool constant_p
= const_flag
&& init_const
;
1358 /* The actual DECL node. CONST_DECL was initially intended for enumerals
1359 and may be used for scalars in general but not for aggregates. */
1361 = build_decl (input_location
,
1362 (constant_p
&& const_decl_allowed_p
1363 && !AGGREGATE_TYPE_P (type
)) ? CONST_DECL
: VAR_DECL
,
1366 /* If this is external, throw away any initializations (they will be done
1367 elsewhere) unless this is a constant for which we would like to remain
1368 able to get the initializer. If we are defining a global here, leave a
1369 constant initialization and save any variable elaborations for the
1370 elaboration routine. If we are just annotating types, throw away the
1371 initialization if it isn't a constant. */
1372 if ((extern_flag
&& !constant_p
)
1373 || (type_annotate_only
&& var_init
&& !TREE_CONSTANT (var_init
)))
1374 var_init
= NULL_TREE
;
1376 /* At the global level, an initializer requiring code to be generated
1377 produces elaboration statements. Check that such statements are allowed,
1378 that is, not violating a No_Elaboration_Code restriction. */
1379 if (global_bindings_p () && var_init
!= 0 && ! init_const
)
1380 Check_Elaboration_Code_Allowed (gnat_node
);
1382 /* Ada doesn't feature Fortran-like COMMON variables so we shouldn't
1383 try to fiddle with DECL_COMMON. However, on platforms that don't
1384 support global BSS sections, uninitialized global variables would
1385 go in DATA instead, thus increasing the size of the executable. */
1387 && TREE_CODE (var_decl
) == VAR_DECL
1388 && !have_global_bss_p ())
1389 DECL_COMMON (var_decl
) = 1;
1390 DECL_INITIAL (var_decl
) = var_init
;
1391 TREE_READONLY (var_decl
) = const_flag
;
1392 DECL_EXTERNAL (var_decl
) = extern_flag
;
1393 TREE_PUBLIC (var_decl
) = public_flag
|| extern_flag
;
1394 TREE_CONSTANT (var_decl
) = constant_p
;
1395 TREE_THIS_VOLATILE (var_decl
) = TREE_SIDE_EFFECTS (var_decl
)
1396 = TYPE_VOLATILE (type
);
1398 /* If it's public and not external, always allocate storage for it.
1399 At the global binding level we need to allocate static storage for the
1400 variable if and only if it's not external. If we are not at the top level
1401 we allocate automatic storage unless requested not to. */
1402 TREE_STATIC (var_decl
)
1403 = !extern_flag
&& (public_flag
|| static_flag
|| global_bindings_p ());
1405 /* For an external constant whose initializer is not absolute, do not emit
1406 debug info. In DWARF this would mean a global relocation in a read-only
1407 section which runs afoul of the PE-COFF runtime relocation mechanism. */
1410 && initializer_constant_valid_p (var_init
, TREE_TYPE (var_init
))
1411 != null_pointer_node
)
1412 DECL_IGNORED_P (var_decl
) = 1;
1414 if (asm_name
&& VAR_OR_FUNCTION_DECL_P (var_decl
))
1415 SET_DECL_ASSEMBLER_NAME (var_decl
, asm_name
);
1417 process_attributes (var_decl
, attr_list
);
1419 /* Add this decl to the current binding level. */
1420 gnat_pushdecl (var_decl
, gnat_node
);
1422 if (TREE_SIDE_EFFECTS (var_decl
))
1423 TREE_ADDRESSABLE (var_decl
) = 1;
1425 if (TREE_CODE (var_decl
) != CONST_DECL
)
1427 if (global_bindings_p ())
1428 rest_of_decl_compilation (var_decl
, true, 0);
1431 expand_decl (var_decl
);
1436 /* Return true if TYPE, an aggregate type, contains (or is) an array. */
1439 aggregate_type_contains_array_p (tree type
)
1441 switch (TREE_CODE (type
))
1445 case QUAL_UNION_TYPE
:
1448 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
1449 if (AGGREGATE_TYPE_P (TREE_TYPE (field
))
1450 && aggregate_type_contains_array_p (TREE_TYPE (field
)))
1463 /* Return a FIELD_DECL node. FIELD_NAME the field name, FIELD_TYPE is its
1464 type, and RECORD_TYPE is the type of the parent. PACKED is nonzero if
1465 this field is in a record type with a "pragma pack". If SIZE is nonzero
1466 it is the specified size for this field. If POS is nonzero, it is the bit
1467 position. If ADDRESSABLE is nonzero, it means we are allowed to take
1468 the address of this field for aliasing purposes. If it is negative, we
1469 should not make a bitfield, which is used by make_aligning_type. */
1472 create_field_decl (tree field_name
, tree field_type
, tree record_type
,
1473 int packed
, tree size
, tree pos
, int addressable
)
1475 tree field_decl
= build_decl (input_location
,
1476 FIELD_DECL
, field_name
, field_type
);
1478 DECL_CONTEXT (field_decl
) = record_type
;
1479 TREE_READONLY (field_decl
) = TYPE_READONLY (field_type
);
1481 /* If FIELD_TYPE is BLKmode, we must ensure this is aligned to at least a
1482 byte boundary since GCC cannot handle less-aligned BLKmode bitfields.
1483 Likewise for an aggregate without specified position that contains an
1484 array, because in this case slices of variable length of this array
1485 must be handled by GCC and variable-sized objects need to be aligned
1486 to at least a byte boundary. */
1487 if (packed
&& (TYPE_MODE (field_type
) == BLKmode
1489 && AGGREGATE_TYPE_P (field_type
)
1490 && aggregate_type_contains_array_p (field_type
))))
1491 DECL_ALIGN (field_decl
) = BITS_PER_UNIT
;
1493 /* If a size is specified, use it. Otherwise, if the record type is packed
1494 compute a size to use, which may differ from the object's natural size.
1495 We always set a size in this case to trigger the checks for bitfield
1496 creation below, which is typically required when no position has been
1499 size
= convert (bitsizetype
, size
);
1500 else if (packed
== 1)
1502 size
= rm_size (field_type
);
1504 /* For a constant size larger than MAX_FIXED_MODE_SIZE, round up to
1506 if (TREE_CODE (size
) == INTEGER_CST
1507 && compare_tree_int (size
, MAX_FIXED_MODE_SIZE
) > 0)
1508 size
= round_up (size
, BITS_PER_UNIT
);
1511 /* If we may, according to ADDRESSABLE, make a bitfield if a size is
1512 specified for two reasons: first if the size differs from the natural
1513 size. Second, if the alignment is insufficient. There are a number of
1514 ways the latter can be true.
1516 We never make a bitfield if the type of the field has a nonconstant size,
1517 because no such entity requiring bitfield operations should reach here.
1519 We do *preventively* make a bitfield when there might be the need for it
1520 but we don't have all the necessary information to decide, as is the case
1521 of a field with no specified position in a packed record.
1523 We also don't look at STRICT_ALIGNMENT here, and rely on later processing
1524 in layout_decl or finish_record_type to clear the bit_field indication if
1525 it is in fact not needed. */
1526 if (addressable
>= 0
1528 && TREE_CODE (size
) == INTEGER_CST
1529 && TREE_CODE (TYPE_SIZE (field_type
)) == INTEGER_CST
1530 && (!tree_int_cst_equal (size
, TYPE_SIZE (field_type
))
1531 || (pos
&& !value_factor_p (pos
, TYPE_ALIGN (field_type
)))
1533 || (TYPE_ALIGN (record_type
) != 0
1534 && TYPE_ALIGN (record_type
) < TYPE_ALIGN (field_type
))))
1536 DECL_BIT_FIELD (field_decl
) = 1;
1537 DECL_SIZE (field_decl
) = size
;
1538 if (!packed
&& !pos
)
1540 if (TYPE_ALIGN (record_type
) != 0
1541 && TYPE_ALIGN (record_type
) < TYPE_ALIGN (field_type
))
1542 DECL_ALIGN (field_decl
) = TYPE_ALIGN (record_type
);
1544 DECL_ALIGN (field_decl
) = TYPE_ALIGN (field_type
);
1548 DECL_PACKED (field_decl
) = pos
? DECL_BIT_FIELD (field_decl
) : packed
;
1550 /* Bump the alignment if need be, either for bitfield/packing purposes or
1551 to satisfy the type requirements if no such consideration applies. When
1552 we get the alignment from the type, indicate if this is from an explicit
1553 user request, which prevents stor-layout from lowering it later on. */
1555 unsigned int bit_align
1556 = (DECL_BIT_FIELD (field_decl
) ? 1
1557 : packed
&& TYPE_MODE (field_type
) != BLKmode
? BITS_PER_UNIT
: 0);
1559 if (bit_align
> DECL_ALIGN (field_decl
))
1560 DECL_ALIGN (field_decl
) = bit_align
;
1561 else if (!bit_align
&& TYPE_ALIGN (field_type
) > DECL_ALIGN (field_decl
))
1563 DECL_ALIGN (field_decl
) = TYPE_ALIGN (field_type
);
1564 DECL_USER_ALIGN (field_decl
) = TYPE_USER_ALIGN (field_type
);
1570 /* We need to pass in the alignment the DECL is known to have.
1571 This is the lowest-order bit set in POS, but no more than
1572 the alignment of the record, if one is specified. Note
1573 that an alignment of 0 is taken as infinite. */
1574 unsigned int known_align
;
1576 if (host_integerp (pos
, 1))
1577 known_align
= tree_low_cst (pos
, 1) & - tree_low_cst (pos
, 1);
1579 known_align
= BITS_PER_UNIT
;
1581 if (TYPE_ALIGN (record_type
)
1582 && (known_align
== 0 || known_align
> TYPE_ALIGN (record_type
)))
1583 known_align
= TYPE_ALIGN (record_type
);
1585 layout_decl (field_decl
, known_align
);
1586 SET_DECL_OFFSET_ALIGN (field_decl
,
1587 host_integerp (pos
, 1) ? BIGGEST_ALIGNMENT
1589 pos_from_bit (&DECL_FIELD_OFFSET (field_decl
),
1590 &DECL_FIELD_BIT_OFFSET (field_decl
),
1591 DECL_OFFSET_ALIGN (field_decl
), pos
);
1594 /* In addition to what our caller says, claim the field is addressable if we
1595 know that its type is not suitable.
1597 The field may also be "technically" nonaddressable, meaning that even if
1598 we attempt to take the field's address we will actually get the address
1599 of a copy. This is the case for true bitfields, but the DECL_BIT_FIELD
1600 value we have at this point is not accurate enough, so we don't account
1601 for this here and let finish_record_type decide. */
1602 if (!addressable
&& !type_for_nonaliased_component_p (field_type
))
1605 DECL_NONADDRESSABLE_P (field_decl
) = !addressable
;
1610 /* Return a PARM_DECL node. PARAM_NAME is the name of the parameter and
1611 PARAM_TYPE is its type. READONLY is true if the parameter is readonly
1612 (either an In parameter or an address of a pass-by-ref parameter). */
1615 create_param_decl (tree param_name
, tree param_type
, bool readonly
)
1617 tree param_decl
= build_decl (input_location
,
1618 PARM_DECL
, param_name
, param_type
);
1620 /* Honor TARGET_PROMOTE_PROTOTYPES like the C compiler, as not doing so
1621 can lead to various ABI violations. */
1622 if (targetm
.calls
.promote_prototypes (NULL_TREE
)
1623 && INTEGRAL_TYPE_P (param_type
)
1624 && TYPE_PRECISION (param_type
) < TYPE_PRECISION (integer_type_node
))
1626 /* We have to be careful about biased types here. Make a subtype
1627 of integer_type_node with the proper biasing. */
1628 if (TREE_CODE (param_type
) == INTEGER_TYPE
1629 && TYPE_BIASED_REPRESENTATION_P (param_type
))
1632 = make_unsigned_type (TYPE_PRECISION (integer_type_node
));
1633 TREE_TYPE (subtype
) = integer_type_node
;
1634 TYPE_BIASED_REPRESENTATION_P (subtype
) = 1;
1635 SET_TYPE_RM_MIN_VALUE (subtype
, TYPE_MIN_VALUE (param_type
));
1636 SET_TYPE_RM_MAX_VALUE (subtype
, TYPE_MAX_VALUE (param_type
));
1637 param_type
= subtype
;
1640 param_type
= integer_type_node
;
1643 DECL_ARG_TYPE (param_decl
) = param_type
;
1644 TREE_READONLY (param_decl
) = readonly
;
1648 /* Given a DECL and ATTR_LIST, process the listed attributes. */
1651 process_attributes (tree decl
, struct attrib
*attr_list
)
1653 for (; attr_list
; attr_list
= attr_list
->next
)
1654 switch (attr_list
->type
)
1656 case ATTR_MACHINE_ATTRIBUTE
:
1657 decl_attributes (&decl
, tree_cons (attr_list
->name
, attr_list
->args
,
1659 ATTR_FLAG_TYPE_IN_PLACE
);
1662 case ATTR_LINK_ALIAS
:
1663 if (! DECL_EXTERNAL (decl
))
1665 TREE_STATIC (decl
) = 1;
1666 assemble_alias (decl
, attr_list
->name
);
1670 case ATTR_WEAK_EXTERNAL
:
1672 declare_weak (decl
);
1674 post_error ("?weak declarations not supported on this target",
1675 attr_list
->error_point
);
1678 case ATTR_LINK_SECTION
:
1679 if (targetm
.have_named_sections
)
1681 DECL_SECTION_NAME (decl
)
1682 = build_string (IDENTIFIER_LENGTH (attr_list
->name
),
1683 IDENTIFIER_POINTER (attr_list
->name
));
1684 DECL_COMMON (decl
) = 0;
1687 post_error ("?section attributes are not supported for this target",
1688 attr_list
->error_point
);
1691 case ATTR_LINK_CONSTRUCTOR
:
1692 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
1693 TREE_USED (decl
) = 1;
1696 case ATTR_LINK_DESTRUCTOR
:
1697 DECL_STATIC_DESTRUCTOR (decl
) = 1;
1698 TREE_USED (decl
) = 1;
1701 case ATTR_THREAD_LOCAL_STORAGE
:
1702 DECL_TLS_MODEL (decl
) = decl_default_tls_model (decl
);
1703 DECL_COMMON (decl
) = 0;
1708 /* Record DECL as a global renaming pointer. */
1711 record_global_renaming_pointer (tree decl
)
1713 gcc_assert (DECL_RENAMED_OBJECT (decl
));
1714 VEC_safe_push (tree
, gc
, global_renaming_pointers
, decl
);
1717 /* Invalidate the global renaming pointers. */
1720 invalidate_global_renaming_pointers (void)
1725 for (i
= 0; VEC_iterate(tree
, global_renaming_pointers
, i
, iter
); i
++)
1726 SET_DECL_RENAMED_OBJECT (iter
, NULL_TREE
);
1728 VEC_free (tree
, gc
, global_renaming_pointers
);
1731 /* Return true if VALUE is a known to be a multiple of FACTOR, which must be
1735 value_factor_p (tree value
, HOST_WIDE_INT factor
)
1737 if (host_integerp (value
, 1))
1738 return tree_low_cst (value
, 1) % factor
== 0;
1740 if (TREE_CODE (value
) == MULT_EXPR
)
1741 return (value_factor_p (TREE_OPERAND (value
, 0), factor
)
1742 || value_factor_p (TREE_OPERAND (value
, 1), factor
));
1747 /* Given 2 consecutive field decls PREV_FIELD and CURR_FIELD, return true
1748 unless we can prove these 2 fields are laid out in such a way that no gap
1749 exist between the end of PREV_FIELD and the beginning of CURR_FIELD. OFFSET
1750 is the distance in bits between the end of PREV_FIELD and the starting
1751 position of CURR_FIELD. It is ignored if null. */
1754 potential_alignment_gap (tree prev_field
, tree curr_field
, tree offset
)
1756 /* If this is the first field of the record, there cannot be any gap */
1760 /* If the previous field is a union type, then return False: The only
1761 time when such a field is not the last field of the record is when
1762 there are other components at fixed positions after it (meaning there
1763 was a rep clause for every field), in which case we don't want the
1764 alignment constraint to override them. */
1765 if (TREE_CODE (TREE_TYPE (prev_field
)) == QUAL_UNION_TYPE
)
1768 /* If the distance between the end of prev_field and the beginning of
1769 curr_field is constant, then there is a gap if the value of this
1770 constant is not null. */
1771 if (offset
&& host_integerp (offset
, 1))
1772 return !integer_zerop (offset
);
1774 /* If the size and position of the previous field are constant,
1775 then check the sum of this size and position. There will be a gap
1776 iff it is not multiple of the current field alignment. */
1777 if (host_integerp (DECL_SIZE (prev_field
), 1)
1778 && host_integerp (bit_position (prev_field
), 1))
1779 return ((tree_low_cst (bit_position (prev_field
), 1)
1780 + tree_low_cst (DECL_SIZE (prev_field
), 1))
1781 % DECL_ALIGN (curr_field
) != 0);
1783 /* If both the position and size of the previous field are multiples
1784 of the current field alignment, there cannot be any gap. */
1785 if (value_factor_p (bit_position (prev_field
), DECL_ALIGN (curr_field
))
1786 && value_factor_p (DECL_SIZE (prev_field
), DECL_ALIGN (curr_field
)))
1789 /* Fallback, return that there may be a potential gap */
1793 /* Returns a LABEL_DECL node for LABEL_NAME. */
1796 create_label_decl (tree label_name
)
1798 tree label_decl
= build_decl (input_location
,
1799 LABEL_DECL
, label_name
, void_type_node
);
1801 DECL_CONTEXT (label_decl
) = current_function_decl
;
1802 DECL_MODE (label_decl
) = VOIDmode
;
1803 DECL_SOURCE_LOCATION (label_decl
) = input_location
;
1808 /* Returns a FUNCTION_DECL node. SUBPROG_NAME is the name of the subprogram,
1809 ASM_NAME is its assembler name, SUBPROG_TYPE is its type (a FUNCTION_TYPE
1810 node), PARAM_DECL_LIST is the list of the subprogram arguments (a list of
1811 PARM_DECL nodes chained through the TREE_CHAIN field).
1813 INLINE_FLAG, PUBLIC_FLAG, EXTERN_FLAG, and ATTR_LIST are used to set the
1814 appropriate fields in the FUNCTION_DECL. GNAT_NODE gives the location. */
1817 create_subprog_decl (tree subprog_name
, tree asm_name
,
1818 tree subprog_type
, tree param_decl_list
, bool inline_flag
,
1819 bool public_flag
, bool extern_flag
,
1820 struct attrib
*attr_list
, Node_Id gnat_node
)
1822 tree return_type
= TREE_TYPE (subprog_type
);
1823 tree subprog_decl
= build_decl (input_location
,
1824 FUNCTION_DECL
, subprog_name
, subprog_type
);
1826 /* If this is a non-inline function nested inside an inlined external
1827 function, we cannot honor both requests without cloning the nested
1828 function in the current unit since it is private to the other unit.
1829 We could inline the nested function as well but it's probably better
1830 to err on the side of too little inlining. */
1832 && current_function_decl
1833 && DECL_DECLARED_INLINE_P (current_function_decl
)
1834 && DECL_EXTERNAL (current_function_decl
))
1835 DECL_DECLARED_INLINE_P (current_function_decl
) = 0;
1837 DECL_EXTERNAL (subprog_decl
) = extern_flag
;
1838 TREE_PUBLIC (subprog_decl
) = public_flag
;
1839 TREE_STATIC (subprog_decl
) = 1;
1840 TREE_READONLY (subprog_decl
) = TYPE_READONLY (subprog_type
);
1841 TREE_THIS_VOLATILE (subprog_decl
) = TYPE_VOLATILE (subprog_type
);
1842 TREE_SIDE_EFFECTS (subprog_decl
) = TYPE_VOLATILE (subprog_type
);
1843 DECL_DECLARED_INLINE_P (subprog_decl
) = inline_flag
;
1844 DECL_ARGUMENTS (subprog_decl
) = param_decl_list
;
1845 DECL_RESULT (subprog_decl
) = build_decl (input_location
,
1846 RESULT_DECL
, 0, return_type
);
1847 DECL_ARTIFICIAL (DECL_RESULT (subprog_decl
)) = 1;
1848 DECL_IGNORED_P (DECL_RESULT (subprog_decl
)) = 1;
1850 /* TREE_ADDRESSABLE is set on the result type to request the use of the
1851 target by-reference return mechanism. This is not supported all the
1852 way down to RTL expansion with GCC 4, which ICEs on temporary creation
1853 attempts with such a type and expects DECL_BY_REFERENCE to be set on
1854 the RESULT_DECL instead - see gnat_genericize for more details. */
1855 if (TREE_ADDRESSABLE (TREE_TYPE (DECL_RESULT (subprog_decl
))))
1857 tree result_decl
= DECL_RESULT (subprog_decl
);
1859 TREE_ADDRESSABLE (TREE_TYPE (result_decl
)) = 0;
1860 DECL_BY_REFERENCE (result_decl
) = 1;
1865 SET_DECL_ASSEMBLER_NAME (subprog_decl
, asm_name
);
1867 /* The expand_main_function circuitry expects "main_identifier_node" to
1868 designate the DECL_NAME of the 'main' entry point, in turn expected
1869 to be declared as the "main" function literally by default. Ada
1870 program entry points are typically declared with a different name
1871 within the binder generated file, exported as 'main' to satisfy the
1872 system expectations. Redirect main_identifier_node in this case. */
1873 if (asm_name
== main_identifier_node
)
1874 main_identifier_node
= DECL_NAME (subprog_decl
);
1877 process_attributes (subprog_decl
, attr_list
);
1879 /* Add this decl to the current binding level. */
1880 gnat_pushdecl (subprog_decl
, gnat_node
);
1882 /* Output the assembler code and/or RTL for the declaration. */
1883 rest_of_decl_compilation (subprog_decl
, global_bindings_p (), 0);
1885 return subprog_decl
;
1888 /* Set up the framework for generating code for SUBPROG_DECL, a subprogram
1889 body. This routine needs to be invoked before processing the declarations
1890 appearing in the subprogram. */
1893 begin_subprog_body (tree subprog_decl
)
1897 current_function_decl
= subprog_decl
;
1898 announce_function (subprog_decl
);
1900 /* Enter a new binding level and show that all the parameters belong to
1903 for (param_decl
= DECL_ARGUMENTS (subprog_decl
); param_decl
;
1904 param_decl
= TREE_CHAIN (param_decl
))
1905 DECL_CONTEXT (param_decl
) = subprog_decl
;
1907 make_decl_rtl (subprog_decl
);
1909 /* We handle pending sizes via the elaboration of types, so we don't need to
1910 save them. This causes them to be marked as part of the outer function
1911 and then discarded. */
1912 get_pending_sizes ();
1916 /* Helper for the genericization callback. Return a dereference of VAL
1917 if it is of a reference type. */
1920 convert_from_reference (tree val
)
1922 tree value_type
, ref
;
1924 if (TREE_CODE (TREE_TYPE (val
)) != REFERENCE_TYPE
)
1927 value_type
= TREE_TYPE (TREE_TYPE (val
));
1928 ref
= build1 (INDIRECT_REF
, value_type
, val
);
1930 /* See if what we reference is CONST or VOLATILE, which requires
1931 looking into array types to get to the component type. */
1933 while (TREE_CODE (value_type
) == ARRAY_TYPE
)
1934 value_type
= TREE_TYPE (value_type
);
1937 = (TYPE_QUALS (value_type
) & TYPE_QUAL_CONST
);
1938 TREE_THIS_VOLATILE (ref
)
1939 = (TYPE_QUALS (value_type
) & TYPE_QUAL_VOLATILE
);
1941 TREE_SIDE_EFFECTS (ref
)
1942 = (TREE_THIS_VOLATILE (ref
) || TREE_SIDE_EFFECTS (val
));
1947 /* Helper for the genericization callback. Returns true if T denotes
1948 a RESULT_DECL with DECL_BY_REFERENCE set. */
1951 is_byref_result (tree t
)
1953 return (TREE_CODE (t
) == RESULT_DECL
&& DECL_BY_REFERENCE (t
));
1957 /* Tree walking callback for gnat_genericize. Currently ...
1959 o Adjust references to the function's DECL_RESULT if it is marked
1960 DECL_BY_REFERENCE and so has had its type turned into a reference
1961 type at the end of the function compilation. */
1964 gnat_genericize_r (tree
*stmt_p
, int *walk_subtrees
, void *data
)
1966 /* This implementation is modeled after what the C++ front-end is
1967 doing, basis of the downstream passes behavior. */
1969 tree stmt
= *stmt_p
;
1970 struct pointer_set_t
*p_set
= (struct pointer_set_t
*) data
;
1972 /* If we have a direct mention of the result decl, dereference. */
1973 if (is_byref_result (stmt
))
1975 *stmt_p
= convert_from_reference (stmt
);
1980 /* Otherwise, no need to walk the same tree twice. */
1981 if (pointer_set_contains (p_set
, stmt
))
1987 /* If we are taking the address of what now is a reference, just get the
1989 if (TREE_CODE (stmt
) == ADDR_EXPR
1990 && is_byref_result (TREE_OPERAND (stmt
, 0)))
1992 *stmt_p
= convert (TREE_TYPE (stmt
), TREE_OPERAND (stmt
, 0));
1996 /* Don't dereference an by-reference RESULT_DECL inside a RETURN_EXPR. */
1997 else if (TREE_CODE (stmt
) == RETURN_EXPR
1998 && TREE_OPERAND (stmt
, 0)
1999 && is_byref_result (TREE_OPERAND (stmt
, 0)))
2002 /* Don't look inside trees that cannot embed references of interest. */
2003 else if (IS_TYPE_OR_DECL_P (stmt
))
2006 pointer_set_insert (p_set
, *stmt_p
);
2011 /* Perform lowering of Ada trees to GENERIC. In particular:
2013 o Turn a DECL_BY_REFERENCE RESULT_DECL into a real by-reference decl
2014 and adjust all the references to this decl accordingly. */
2017 gnat_genericize (tree fndecl
)
2019 /* Prior to GCC 4, an explicit By_Reference result mechanism for a function
2020 was handled by simply setting TREE_ADDRESSABLE on the result type.
2021 Everything required to actually pass by invisible ref using the target
2022 mechanism (e.g. extra parameter) was handled at RTL expansion time.
2024 This doesn't work with GCC 4 any more for several reasons. First, the
2025 gimplification process might need the creation of temporaries of this
2026 type, and the gimplifier ICEs on such attempts. Second, the middle-end
2027 now relies on a different attribute for such cases (DECL_BY_REFERENCE on
2028 RESULT/PARM_DECLs), and expects the user invisible by-reference-ness to
2029 be explicitly accounted for by the front-end in the function body.
2031 We achieve the complete transformation in two steps:
2033 1/ create_subprog_decl performs early attribute tweaks: it clears
2034 TREE_ADDRESSABLE from the result type and sets DECL_BY_REFERENCE on
2035 the result decl. The former ensures that the bit isn't set in the GCC
2036 tree saved for the function, so prevents ICEs on temporary creation.
2037 The latter we use here to trigger the rest of the processing.
2039 2/ This function performs the type transformation on the result decl
2040 and adjusts all the references to this decl from the function body
2043 Clearing TREE_ADDRESSABLE from the type differs from the C++ front-end
2044 strategy, which escapes the gimplifier temporary creation issues by
2045 creating it's own temporaries using TARGET_EXPR nodes. Our way relies
2046 on simple specific support code in aggregate_value_p to look at the
2047 target function result decl explicitly. */
2049 struct pointer_set_t
*p_set
;
2050 tree decl_result
= DECL_RESULT (fndecl
);
2052 if (!DECL_BY_REFERENCE (decl_result
))
2055 /* Make the DECL_RESULT explicitly by-reference and adjust all the
2056 occurrences in the function body using the common tree-walking facility.
2057 We want to see every occurrence of the result decl to adjust the
2058 referencing tree, so need to use our own pointer set to control which
2059 trees should be visited again or not. */
2061 p_set
= pointer_set_create ();
2063 TREE_TYPE (decl_result
) = build_reference_type (TREE_TYPE (decl_result
));
2064 TREE_ADDRESSABLE (decl_result
) = 0;
2065 relayout_decl (decl_result
);
2067 walk_tree (&DECL_SAVED_TREE (fndecl
), gnat_genericize_r
, p_set
, NULL
);
2069 pointer_set_destroy (p_set
);
2072 /* Finish the definition of the current subprogram BODY and finalize it. */
2075 end_subprog_body (tree body
)
2077 tree fndecl
= current_function_decl
;
2079 /* Mark the BLOCK for this level as being for this function and pop the
2080 level. Since the vars in it are the parameters, clear them. */
2081 BLOCK_VARS (current_binding_level
->block
) = 0;
2082 BLOCK_SUPERCONTEXT (current_binding_level
->block
) = fndecl
;
2083 DECL_INITIAL (fndecl
) = current_binding_level
->block
;
2086 /* We handle pending sizes via the elaboration of types, so we don't
2087 need to save them. */
2088 get_pending_sizes ();
2090 /* Mark the RESULT_DECL as being in this subprogram. */
2091 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
2093 DECL_SAVED_TREE (fndecl
) = body
;
2095 current_function_decl
= DECL_CONTEXT (fndecl
);
2098 /* We cannot track the location of errors past this point. */
2099 error_gnat_node
= Empty
;
2101 /* If we're only annotating types, don't actually compile this function. */
2102 if (type_annotate_only
)
2105 /* Perform the required pre-gimplification transformations on the tree. */
2106 gnat_genericize (fndecl
);
2108 /* Dump functions before gimplification. */
2109 dump_function (TDI_original
, fndecl
);
2111 /* ??? This special handling of nested functions is probably obsolete. */
2112 if (!DECL_CONTEXT (fndecl
))
2113 cgraph_finalize_function (fndecl
, false);
2115 /* Register this function with cgraph just far enough to get it
2116 added to our parent's nested function list. */
2117 (void) cgraph_node (fndecl
);
2121 gnat_builtin_function (tree decl
)
2123 gnat_pushdecl (decl
, Empty
);
2127 /* Return an integer type with the number of bits of precision given by
2128 PRECISION. UNSIGNEDP is nonzero if the type is unsigned; otherwise
2129 it is a signed type. */
2132 gnat_type_for_size (unsigned precision
, int unsignedp
)
2137 if (precision
<= 2 * MAX_BITS_PER_WORD
2138 && signed_and_unsigned_types
[precision
][unsignedp
])
2139 return signed_and_unsigned_types
[precision
][unsignedp
];
2142 t
= make_unsigned_type (precision
);
2144 t
= make_signed_type (precision
);
2146 if (precision
<= 2 * MAX_BITS_PER_WORD
)
2147 signed_and_unsigned_types
[precision
][unsignedp
] = t
;
2151 sprintf (type_name
, "%sSIGNED_%d", unsignedp
? "UN" : "", precision
);
2152 TYPE_NAME (t
) = get_identifier (type_name
);
2158 /* Likewise for floating-point types. */
2161 float_type_for_precision (int precision
, enum machine_mode mode
)
2166 if (float_types
[(int) mode
])
2167 return float_types
[(int) mode
];
2169 float_types
[(int) mode
] = t
= make_node (REAL_TYPE
);
2170 TYPE_PRECISION (t
) = precision
;
2173 gcc_assert (TYPE_MODE (t
) == mode
);
2176 sprintf (type_name
, "FLOAT_%d", precision
);
2177 TYPE_NAME (t
) = get_identifier (type_name
);
2183 /* Return a data type that has machine mode MODE. UNSIGNEDP selects
2184 an unsigned type; otherwise a signed type is returned. */
2187 gnat_type_for_mode (enum machine_mode mode
, int unsignedp
)
2189 if (mode
== BLKmode
)
2191 else if (mode
== VOIDmode
)
2192 return void_type_node
;
2193 else if (COMPLEX_MODE_P (mode
))
2195 else if (SCALAR_FLOAT_MODE_P (mode
))
2196 return float_type_for_precision (GET_MODE_PRECISION (mode
), mode
);
2197 else if (SCALAR_INT_MODE_P (mode
))
2198 return gnat_type_for_size (GET_MODE_BITSIZE (mode
), unsignedp
);
2203 /* Return the unsigned version of a TYPE_NODE, a scalar type. */
2206 gnat_unsigned_type (tree type_node
)
2208 tree type
= gnat_type_for_size (TYPE_PRECISION (type_node
), 1);
2210 if (TREE_CODE (type_node
) == INTEGER_TYPE
&& TYPE_MODULAR_P (type_node
))
2212 type
= copy_node (type
);
2213 TREE_TYPE (type
) = type_node
;
2215 else if (TREE_TYPE (type_node
)
2216 && TREE_CODE (TREE_TYPE (type_node
)) == INTEGER_TYPE
2217 && TYPE_MODULAR_P (TREE_TYPE (type_node
)))
2219 type
= copy_node (type
);
2220 TREE_TYPE (type
) = TREE_TYPE (type_node
);
2226 /* Return the signed version of a TYPE_NODE, a scalar type. */
2229 gnat_signed_type (tree type_node
)
2231 tree type
= gnat_type_for_size (TYPE_PRECISION (type_node
), 0);
2233 if (TREE_CODE (type_node
) == INTEGER_TYPE
&& TYPE_MODULAR_P (type_node
))
2235 type
= copy_node (type
);
2236 TREE_TYPE (type
) = type_node
;
2238 else if (TREE_TYPE (type_node
)
2239 && TREE_CODE (TREE_TYPE (type_node
)) == INTEGER_TYPE
2240 && TYPE_MODULAR_P (TREE_TYPE (type_node
)))
2242 type
= copy_node (type
);
2243 TREE_TYPE (type
) = TREE_TYPE (type_node
);
2249 /* Return 1 if the types T1 and T2 are compatible, i.e. if they can be
2250 transparently converted to each other. */
2253 gnat_types_compatible_p (tree t1
, tree t2
)
2255 enum tree_code code
;
2257 /* This is the default criterion. */
2258 if (TYPE_MAIN_VARIANT (t1
) == TYPE_MAIN_VARIANT (t2
))
2261 /* We only check structural equivalence here. */
2262 if ((code
= TREE_CODE (t1
)) != TREE_CODE (t2
))
2265 /* Array types are also compatible if they are constrained and have
2266 the same component type and the same domain. */
2267 if (code
== ARRAY_TYPE
2268 && TREE_TYPE (t1
) == TREE_TYPE (t2
)
2269 && (TYPE_DOMAIN (t1
) == TYPE_DOMAIN (t2
)
2270 || (TYPE_DOMAIN (t1
)
2272 && tree_int_cst_equal (TYPE_MIN_VALUE (TYPE_DOMAIN (t1
)),
2273 TYPE_MIN_VALUE (TYPE_DOMAIN (t2
)))
2274 && tree_int_cst_equal (TYPE_MAX_VALUE (TYPE_DOMAIN (t1
)),
2275 TYPE_MAX_VALUE (TYPE_DOMAIN (t2
))))))
2278 /* Padding record types are also compatible if they pad the same
2279 type and have the same constant size. */
2280 if (code
== RECORD_TYPE
2281 && TYPE_IS_PADDING_P (t1
) && TYPE_IS_PADDING_P (t2
)
2282 && TREE_TYPE (TYPE_FIELDS (t1
)) == TREE_TYPE (TYPE_FIELDS (t2
))
2283 && tree_int_cst_equal (TYPE_SIZE (t1
), TYPE_SIZE (t2
)))
2289 /* EXP is an expression for the size of an object. If this size contains
2290 discriminant references, replace them with the maximum (if MAX_P) or
2291 minimum (if !MAX_P) possible value of the discriminant. */
2294 max_size (tree exp
, bool max_p
)
2296 enum tree_code code
= TREE_CODE (exp
);
2297 tree type
= TREE_TYPE (exp
);
2299 switch (TREE_CODE_CLASS (code
))
2301 case tcc_declaration
:
2306 if (code
== CALL_EXPR
)
2311 t
= maybe_inline_call_in_expr (exp
);
2313 return max_size (t
, max_p
);
2315 n
= call_expr_nargs (exp
);
2317 argarray
= (tree
*) alloca (n
* sizeof (tree
));
2318 for (i
= 0; i
< n
; i
++)
2319 argarray
[i
] = max_size (CALL_EXPR_ARG (exp
, i
), max_p
);
2320 return build_call_array (type
, CALL_EXPR_FN (exp
), n
, argarray
);
2325 /* If this contains a PLACEHOLDER_EXPR, it is the thing we want to
2326 modify. Otherwise, we treat it like a variable. */
2327 if (!CONTAINS_PLACEHOLDER_P (exp
))
2330 type
= TREE_TYPE (TREE_OPERAND (exp
, 1));
2332 max_size (max_p
? TYPE_MAX_VALUE (type
) : TYPE_MIN_VALUE (type
), true);
2334 case tcc_comparison
:
2335 return max_p
? size_one_node
: size_zero_node
;
2339 case tcc_expression
:
2340 switch (TREE_CODE_LENGTH (code
))
2343 if (code
== NON_LVALUE_EXPR
)
2344 return max_size (TREE_OPERAND (exp
, 0), max_p
);
2347 fold_build1 (code
, type
,
2348 max_size (TREE_OPERAND (exp
, 0),
2349 code
== NEGATE_EXPR
? !max_p
: max_p
));
2352 if (code
== COMPOUND_EXPR
)
2353 return max_size (TREE_OPERAND (exp
, 1), max_p
);
2355 /* Calculate "(A ? B : C) - D" as "A ? B - D : C - D" which
2356 may provide a tighter bound on max_size. */
2357 if (code
== MINUS_EXPR
2358 && TREE_CODE (TREE_OPERAND (exp
, 0)) == COND_EXPR
)
2360 tree lhs
= fold_build2 (MINUS_EXPR
, type
,
2361 TREE_OPERAND (TREE_OPERAND (exp
, 0), 1),
2362 TREE_OPERAND (exp
, 1));
2363 tree rhs
= fold_build2 (MINUS_EXPR
, type
,
2364 TREE_OPERAND (TREE_OPERAND (exp
, 0), 2),
2365 TREE_OPERAND (exp
, 1));
2366 return fold_build2 (max_p
? MAX_EXPR
: MIN_EXPR
, type
,
2367 max_size (lhs
, max_p
),
2368 max_size (rhs
, max_p
));
2372 tree lhs
= max_size (TREE_OPERAND (exp
, 0), max_p
);
2373 tree rhs
= max_size (TREE_OPERAND (exp
, 1),
2374 code
== MINUS_EXPR
? !max_p
: max_p
);
2376 /* Special-case wanting the maximum value of a MIN_EXPR.
2377 In that case, if one side overflows, return the other.
2378 sizetype is signed, but we know sizes are non-negative.
2379 Likewise, handle a MINUS_EXPR or PLUS_EXPR with the LHS
2380 overflowing or the maximum possible value and the RHS
2384 && TREE_CODE (rhs
) == INTEGER_CST
2385 && TREE_OVERFLOW (rhs
))
2389 && TREE_CODE (lhs
) == INTEGER_CST
2390 && TREE_OVERFLOW (lhs
))
2392 else if ((code
== MINUS_EXPR
|| code
== PLUS_EXPR
)
2393 && ((TREE_CODE (lhs
) == INTEGER_CST
2394 && TREE_OVERFLOW (lhs
))
2395 || operand_equal_p (lhs
, TYPE_MAX_VALUE (type
), 0))
2396 && !TREE_CONSTANT (rhs
))
2399 return fold_build2 (code
, type
, lhs
, rhs
);
2403 if (code
== SAVE_EXPR
)
2405 else if (code
== COND_EXPR
)
2406 return fold_build2 (max_p
? MAX_EXPR
: MIN_EXPR
, type
,
2407 max_size (TREE_OPERAND (exp
, 1), max_p
),
2408 max_size (TREE_OPERAND (exp
, 2), max_p
));
2411 /* Other tree classes cannot happen. */
2419 /* Build a template of type TEMPLATE_TYPE from the array bounds of ARRAY_TYPE.
2420 EXPR is an expression that we can use to locate any PLACEHOLDER_EXPRs.
2421 Return a constructor for the template. */
2424 build_template (tree template_type
, tree array_type
, tree expr
)
2426 tree template_elts
= NULL_TREE
;
2427 tree bound_list
= NULL_TREE
;
2430 while (TREE_CODE (array_type
) == RECORD_TYPE
2431 && (TYPE_IS_PADDING_P (array_type
)
2432 || TYPE_JUSTIFIED_MODULAR_P (array_type
)))
2433 array_type
= TREE_TYPE (TYPE_FIELDS (array_type
));
2435 if (TREE_CODE (array_type
) == ARRAY_TYPE
2436 || (TREE_CODE (array_type
) == INTEGER_TYPE
2437 && TYPE_HAS_ACTUAL_BOUNDS_P (array_type
)))
2438 bound_list
= TYPE_ACTUAL_BOUNDS (array_type
);
2440 /* First make the list for a CONSTRUCTOR for the template. Go down the
2441 field list of the template instead of the type chain because this
2442 array might be an Ada array of arrays and we can't tell where the
2443 nested arrays stop being the underlying object. */
2445 for (field
= TYPE_FIELDS (template_type
); field
;
2447 ? (bound_list
= TREE_CHAIN (bound_list
))
2448 : (array_type
= TREE_TYPE (array_type
))),
2449 field
= TREE_CHAIN (TREE_CHAIN (field
)))
2451 tree bounds
, min
, max
;
2453 /* If we have a bound list, get the bounds from there. Likewise
2454 for an ARRAY_TYPE. Otherwise, if expr is a PARM_DECL with
2455 DECL_BY_COMPONENT_PTR_P, use the bounds of the field in the template.
2456 This will give us a maximum range. */
2458 bounds
= TREE_VALUE (bound_list
);
2459 else if (TREE_CODE (array_type
) == ARRAY_TYPE
)
2460 bounds
= TYPE_INDEX_TYPE (TYPE_DOMAIN (array_type
));
2461 else if (expr
&& TREE_CODE (expr
) == PARM_DECL
2462 && DECL_BY_COMPONENT_PTR_P (expr
))
2463 bounds
= TREE_TYPE (field
);
2467 min
= convert (TREE_TYPE (field
), TYPE_MIN_VALUE (bounds
));
2468 max
= convert (TREE_TYPE (TREE_CHAIN (field
)), TYPE_MAX_VALUE (bounds
));
2470 /* If either MIN or MAX involve a PLACEHOLDER_EXPR, we must
2471 substitute it from OBJECT. */
2472 min
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (min
, expr
);
2473 max
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (max
, expr
);
2475 template_elts
= tree_cons (TREE_CHAIN (field
), max
,
2476 tree_cons (field
, min
, template_elts
));
2479 return gnat_build_constructor (template_type
, nreverse (template_elts
));
2482 /* Build a 32bit VMS descriptor from a Mechanism_Type, which must specify
2483 a descriptor type, and the GCC type of an object. Each FIELD_DECL
2484 in the type contains in its DECL_INITIAL the expression to use when
2485 a constructor is made for the type. GNAT_ENTITY is an entity used
2486 to print out an error message if the mechanism cannot be applied to
2487 an object of that type and also for the name. */
2490 build_vms_descriptor32 (tree type
, Mechanism_Type mech
, Entity_Id gnat_entity
)
2492 tree record_type
= make_node (RECORD_TYPE
);
2493 tree pointer32_type
;
2494 tree field_list
= 0;
2503 /* If TYPE is an unconstrained array, use the underlying array type. */
2504 if (TREE_CODE (type
) == UNCONSTRAINED_ARRAY_TYPE
)
2505 type
= TREE_TYPE (TREE_TYPE (TYPE_FIELDS (TREE_TYPE (type
))));
2507 /* If this is an array, compute the number of dimensions in the array,
2508 get the index types, and point to the inner type. */
2509 if (TREE_CODE (type
) != ARRAY_TYPE
)
2512 for (ndim
= 1, inner_type
= type
;
2513 TREE_CODE (TREE_TYPE (inner_type
)) == ARRAY_TYPE
2514 && TYPE_MULTI_ARRAY_P (TREE_TYPE (inner_type
));
2515 ndim
++, inner_type
= TREE_TYPE (inner_type
))
2518 idx_arr
= (tree
*) alloca (ndim
* sizeof (tree
));
2520 if (mech
!= By_Descriptor_NCA
&& mech
!= By_Short_Descriptor_NCA
2521 && TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_CONVENTION_FORTRAN_P (type
))
2522 for (i
= ndim
- 1, inner_type
= type
;
2524 i
--, inner_type
= TREE_TYPE (inner_type
))
2525 idx_arr
[i
] = TYPE_DOMAIN (inner_type
);
2527 for (i
= 0, inner_type
= type
;
2529 i
++, inner_type
= TREE_TYPE (inner_type
))
2530 idx_arr
[i
] = TYPE_DOMAIN (inner_type
);
2532 /* Now get the DTYPE value. */
2533 switch (TREE_CODE (type
))
2538 if (TYPE_VAX_FLOATING_POINT_P (type
))
2539 switch (tree_low_cst (TYPE_DIGITS_VALUE (type
), 1))
2552 switch (GET_MODE_BITSIZE (TYPE_MODE (type
)))
2555 dtype
= TYPE_UNSIGNED (type
) ? 2 : 6;
2558 dtype
= TYPE_UNSIGNED (type
) ? 3 : 7;
2561 dtype
= TYPE_UNSIGNED (type
) ? 4 : 8;
2564 dtype
= TYPE_UNSIGNED (type
) ? 5 : 9;
2567 dtype
= TYPE_UNSIGNED (type
) ? 25 : 26;
2573 dtype
= GET_MODE_BITSIZE (TYPE_MODE (type
)) == 32 ? 52 : 53;
2577 if (TREE_CODE (TREE_TYPE (type
)) == INTEGER_TYPE
2578 && TYPE_VAX_FLOATING_POINT_P (type
))
2579 switch (tree_low_cst (TYPE_DIGITS_VALUE (type
), 1))
2591 dtype
= GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (type
))) == 32 ? 54: 55;
2602 /* Get the CLASS value. */
2605 case By_Descriptor_A
:
2606 case By_Short_Descriptor_A
:
2609 case By_Descriptor_NCA
:
2610 case By_Short_Descriptor_NCA
:
2613 case By_Descriptor_SB
:
2614 case By_Short_Descriptor_SB
:
2618 case By_Short_Descriptor
:
2619 case By_Descriptor_S
:
2620 case By_Short_Descriptor_S
:
2626 /* Make the type for a descriptor for VMS. The first four fields
2627 are the same for all types. */
2630 = chainon (field_list
,
2631 make_descriptor_field
2632 ("LENGTH", gnat_type_for_size (16, 1), record_type
,
2633 size_in_bytes ((mech
== By_Descriptor_A
||
2634 mech
== By_Short_Descriptor_A
)
2635 ? inner_type
: type
)));
2637 field_list
= chainon (field_list
,
2638 make_descriptor_field ("DTYPE",
2639 gnat_type_for_size (8, 1),
2640 record_type
, size_int (dtype
)));
2641 field_list
= chainon (field_list
,
2642 make_descriptor_field ("CLASS",
2643 gnat_type_for_size (8, 1),
2644 record_type
, size_int (klass
)));
2646 /* Of course this will crash at run-time if the address space is not
2647 within the low 32 bits, but there is nothing else we can do. */
2648 pointer32_type
= build_pointer_type_for_mode (type
, SImode
, false);
2651 = chainon (field_list
,
2652 make_descriptor_field
2653 ("POINTER", pointer32_type
, record_type
,
2654 build_unary_op (ADDR_EXPR
,
2656 build0 (PLACEHOLDER_EXPR
, type
))));
2661 case By_Short_Descriptor
:
2662 case By_Descriptor_S
:
2663 case By_Short_Descriptor_S
:
2666 case By_Descriptor_SB
:
2667 case By_Short_Descriptor_SB
:
2669 = chainon (field_list
,
2670 make_descriptor_field
2671 ("SB_L1", gnat_type_for_size (32, 1), record_type
,
2672 TREE_CODE (type
) == ARRAY_TYPE
2673 ? TYPE_MIN_VALUE (TYPE_DOMAIN (type
)) : size_zero_node
));
2675 = chainon (field_list
,
2676 make_descriptor_field
2677 ("SB_U1", gnat_type_for_size (32, 1), record_type
,
2678 TREE_CODE (type
) == ARRAY_TYPE
2679 ? TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) : size_zero_node
));
2682 case By_Descriptor_A
:
2683 case By_Short_Descriptor_A
:
2684 case By_Descriptor_NCA
:
2685 case By_Short_Descriptor_NCA
:
2686 field_list
= chainon (field_list
,
2687 make_descriptor_field ("SCALE",
2688 gnat_type_for_size (8, 1),
2692 field_list
= chainon (field_list
,
2693 make_descriptor_field ("DIGITS",
2694 gnat_type_for_size (8, 1),
2699 = chainon (field_list
,
2700 make_descriptor_field
2701 ("AFLAGS", gnat_type_for_size (8, 1), record_type
,
2702 size_int ((mech
== By_Descriptor_NCA
||
2703 mech
== By_Short_Descriptor_NCA
)
2705 /* Set FL_COLUMN, FL_COEFF, and FL_BOUNDS. */
2706 : (TREE_CODE (type
) == ARRAY_TYPE
2707 && TYPE_CONVENTION_FORTRAN_P (type
)
2710 field_list
= chainon (field_list
,
2711 make_descriptor_field ("DIMCT",
2712 gnat_type_for_size (8, 1),
2716 field_list
= chainon (field_list
,
2717 make_descriptor_field ("ARSIZE",
2718 gnat_type_for_size (32, 1),
2720 size_in_bytes (type
)));
2722 /* Now build a pointer to the 0,0,0... element. */
2723 tem
= build0 (PLACEHOLDER_EXPR
, type
);
2724 for (i
= 0, inner_type
= type
; i
< ndim
;
2725 i
++, inner_type
= TREE_TYPE (inner_type
))
2726 tem
= build4 (ARRAY_REF
, TREE_TYPE (inner_type
), tem
,
2727 convert (TYPE_DOMAIN (inner_type
), size_zero_node
),
2728 NULL_TREE
, NULL_TREE
);
2731 = chainon (field_list
,
2732 make_descriptor_field
2734 build_pointer_type_for_mode (inner_type
, SImode
, false),
2737 build_pointer_type_for_mode (inner_type
, SImode
,
2741 /* Next come the addressing coefficients. */
2742 tem
= size_one_node
;
2743 for (i
= 0; i
< ndim
; i
++)
2747 = size_binop (MULT_EXPR
, tem
,
2748 size_binop (PLUS_EXPR
,
2749 size_binop (MINUS_EXPR
,
2750 TYPE_MAX_VALUE (idx_arr
[i
]),
2751 TYPE_MIN_VALUE (idx_arr
[i
])),
2754 fname
[0] = ((mech
== By_Descriptor_NCA
||
2755 mech
== By_Short_Descriptor_NCA
) ? 'S' : 'M');
2756 fname
[1] = '0' + i
, fname
[2] = 0;
2758 = chainon (field_list
,
2759 make_descriptor_field (fname
,
2760 gnat_type_for_size (32, 1),
2761 record_type
, idx_length
));
2763 if (mech
== By_Descriptor_NCA
|| mech
== By_Short_Descriptor_NCA
)
2767 /* Finally here are the bounds. */
2768 for (i
= 0; i
< ndim
; i
++)
2772 fname
[0] = 'L', fname
[1] = '0' + i
, fname
[2] = 0;
2774 = chainon (field_list
,
2775 make_descriptor_field
2776 (fname
, gnat_type_for_size (32, 1), record_type
,
2777 TYPE_MIN_VALUE (idx_arr
[i
])));
2781 = chainon (field_list
,
2782 make_descriptor_field
2783 (fname
, gnat_type_for_size (32, 1), record_type
,
2784 TYPE_MAX_VALUE (idx_arr
[i
])));
2789 post_error ("unsupported descriptor type for &", gnat_entity
);
2792 TYPE_NAME (record_type
) = create_concat_name (gnat_entity
, "DESC");
2793 finish_record_type (record_type
, field_list
, 0, true);
2797 /* Build a 64bit VMS descriptor from a Mechanism_Type, which must specify
2798 a descriptor type, and the GCC type of an object. Each FIELD_DECL
2799 in the type contains in its DECL_INITIAL the expression to use when
2800 a constructor is made for the type. GNAT_ENTITY is an entity used
2801 to print out an error message if the mechanism cannot be applied to
2802 an object of that type and also for the name. */
2805 build_vms_descriptor (tree type
, Mechanism_Type mech
, Entity_Id gnat_entity
)
2807 tree record64_type
= make_node (RECORD_TYPE
);
2808 tree pointer64_type
;
2809 tree field_list64
= 0;
2818 /* If TYPE is an unconstrained array, use the underlying array type. */
2819 if (TREE_CODE (type
) == UNCONSTRAINED_ARRAY_TYPE
)
2820 type
= TREE_TYPE (TREE_TYPE (TYPE_FIELDS (TREE_TYPE (type
))));
2822 /* If this is an array, compute the number of dimensions in the array,
2823 get the index types, and point to the inner type. */
2824 if (TREE_CODE (type
) != ARRAY_TYPE
)
2827 for (ndim
= 1, inner_type
= type
;
2828 TREE_CODE (TREE_TYPE (inner_type
)) == ARRAY_TYPE
2829 && TYPE_MULTI_ARRAY_P (TREE_TYPE (inner_type
));
2830 ndim
++, inner_type
= TREE_TYPE (inner_type
))
2833 idx_arr
= (tree
*) alloca (ndim
* sizeof (tree
));
2835 if (mech
!= By_Descriptor_NCA
2836 && TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_CONVENTION_FORTRAN_P (type
))
2837 for (i
= ndim
- 1, inner_type
= type
;
2839 i
--, inner_type
= TREE_TYPE (inner_type
))
2840 idx_arr
[i
] = TYPE_DOMAIN (inner_type
);
2842 for (i
= 0, inner_type
= type
;
2844 i
++, inner_type
= TREE_TYPE (inner_type
))
2845 idx_arr
[i
] = TYPE_DOMAIN (inner_type
);
2847 /* Now get the DTYPE value. */
2848 switch (TREE_CODE (type
))
2853 if (TYPE_VAX_FLOATING_POINT_P (type
))
2854 switch (tree_low_cst (TYPE_DIGITS_VALUE (type
), 1))
2867 switch (GET_MODE_BITSIZE (TYPE_MODE (type
)))
2870 dtype
= TYPE_UNSIGNED (type
) ? 2 : 6;
2873 dtype
= TYPE_UNSIGNED (type
) ? 3 : 7;
2876 dtype
= TYPE_UNSIGNED (type
) ? 4 : 8;
2879 dtype
= TYPE_UNSIGNED (type
) ? 5 : 9;
2882 dtype
= TYPE_UNSIGNED (type
) ? 25 : 26;
2888 dtype
= GET_MODE_BITSIZE (TYPE_MODE (type
)) == 32 ? 52 : 53;
2892 if (TREE_CODE (TREE_TYPE (type
)) == INTEGER_TYPE
2893 && TYPE_VAX_FLOATING_POINT_P (type
))
2894 switch (tree_low_cst (TYPE_DIGITS_VALUE (type
), 1))
2906 dtype
= GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (type
))) == 32 ? 54: 55;
2917 /* Get the CLASS value. */
2920 case By_Descriptor_A
:
2923 case By_Descriptor_NCA
:
2926 case By_Descriptor_SB
:
2930 case By_Descriptor_S
:
2936 /* Make the type for a 64bit descriptor for VMS. The first six fields
2937 are the same for all types. */
2939 field_list64
= chainon (field_list64
,
2940 make_descriptor_field ("MBO",
2941 gnat_type_for_size (16, 1),
2942 record64_type
, size_int (1)));
2944 field_list64
= chainon (field_list64
,
2945 make_descriptor_field ("DTYPE",
2946 gnat_type_for_size (8, 1),
2947 record64_type
, size_int (dtype
)));
2948 field_list64
= chainon (field_list64
,
2949 make_descriptor_field ("CLASS",
2950 gnat_type_for_size (8, 1),
2951 record64_type
, size_int (klass
)));
2953 field_list64
= chainon (field_list64
,
2954 make_descriptor_field ("MBMO",
2955 gnat_type_for_size (32, 1),
2956 record64_type
, ssize_int (-1)));
2959 = chainon (field_list64
,
2960 make_descriptor_field
2961 ("LENGTH", gnat_type_for_size (64, 1), record64_type
,
2962 size_in_bytes (mech
== By_Descriptor_A
? inner_type
: type
)));
2964 pointer64_type
= build_pointer_type_for_mode (type
, DImode
, false);
2967 = chainon (field_list64
,
2968 make_descriptor_field
2969 ("POINTER", pointer64_type
, record64_type
,
2970 build_unary_op (ADDR_EXPR
,
2972 build0 (PLACEHOLDER_EXPR
, type
))));
2977 case By_Descriptor_S
:
2980 case By_Descriptor_SB
:
2982 = chainon (field_list64
,
2983 make_descriptor_field
2984 ("SB_L1", gnat_type_for_size (64, 1), record64_type
,
2985 TREE_CODE (type
) == ARRAY_TYPE
2986 ? TYPE_MIN_VALUE (TYPE_DOMAIN (type
)) : size_zero_node
));
2988 = chainon (field_list64
,
2989 make_descriptor_field
2990 ("SB_U1", gnat_type_for_size (64, 1), record64_type
,
2991 TREE_CODE (type
) == ARRAY_TYPE
2992 ? TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) : size_zero_node
));
2995 case By_Descriptor_A
:
2996 case By_Descriptor_NCA
:
2997 field_list64
= chainon (field_list64
,
2998 make_descriptor_field ("SCALE",
2999 gnat_type_for_size (8, 1),
3003 field_list64
= chainon (field_list64
,
3004 make_descriptor_field ("DIGITS",
3005 gnat_type_for_size (8, 1),
3010 = chainon (field_list64
,
3011 make_descriptor_field
3012 ("AFLAGS", gnat_type_for_size (8, 1), record64_type
,
3013 size_int (mech
== By_Descriptor_NCA
3015 /* Set FL_COLUMN, FL_COEFF, and FL_BOUNDS. */
3016 : (TREE_CODE (type
) == ARRAY_TYPE
3017 && TYPE_CONVENTION_FORTRAN_P (type
)
3020 field_list64
= chainon (field_list64
,
3021 make_descriptor_field ("DIMCT",
3022 gnat_type_for_size (8, 1),
3026 field_list64
= chainon (field_list64
,
3027 make_descriptor_field ("MBZ",
3028 gnat_type_for_size (32, 1),
3031 field_list64
= chainon (field_list64
,
3032 make_descriptor_field ("ARSIZE",
3033 gnat_type_for_size (64, 1),
3035 size_in_bytes (type
)));
3037 /* Now build a pointer to the 0,0,0... element. */
3038 tem
= build0 (PLACEHOLDER_EXPR
, type
);
3039 for (i
= 0, inner_type
= type
; i
< ndim
;
3040 i
++, inner_type
= TREE_TYPE (inner_type
))
3041 tem
= build4 (ARRAY_REF
, TREE_TYPE (inner_type
), tem
,
3042 convert (TYPE_DOMAIN (inner_type
), size_zero_node
),
3043 NULL_TREE
, NULL_TREE
);
3046 = chainon (field_list64
,
3047 make_descriptor_field
3049 build_pointer_type_for_mode (inner_type
, DImode
, false),
3052 build_pointer_type_for_mode (inner_type
, DImode
,
3056 /* Next come the addressing coefficients. */
3057 tem
= size_one_node
;
3058 for (i
= 0; i
< ndim
; i
++)
3062 = size_binop (MULT_EXPR
, tem
,
3063 size_binop (PLUS_EXPR
,
3064 size_binop (MINUS_EXPR
,
3065 TYPE_MAX_VALUE (idx_arr
[i
]),
3066 TYPE_MIN_VALUE (idx_arr
[i
])),
3069 fname
[0] = (mech
== By_Descriptor_NCA
? 'S' : 'M');
3070 fname
[1] = '0' + i
, fname
[2] = 0;
3072 = chainon (field_list64
,
3073 make_descriptor_field (fname
,
3074 gnat_type_for_size (64, 1),
3075 record64_type
, idx_length
));
3077 if (mech
== By_Descriptor_NCA
)
3081 /* Finally here are the bounds. */
3082 for (i
= 0; i
< ndim
; i
++)
3086 fname
[0] = 'L', fname
[1] = '0' + i
, fname
[2] = 0;
3088 = chainon (field_list64
,
3089 make_descriptor_field
3090 (fname
, gnat_type_for_size (64, 1), record64_type
,
3091 TYPE_MIN_VALUE (idx_arr
[i
])));
3095 = chainon (field_list64
,
3096 make_descriptor_field
3097 (fname
, gnat_type_for_size (64, 1), record64_type
,
3098 TYPE_MAX_VALUE (idx_arr
[i
])));
3103 post_error ("unsupported descriptor type for &", gnat_entity
);
3106 TYPE_NAME (record64_type
) = create_concat_name (gnat_entity
, "DESC64");
3107 finish_record_type (record64_type
, field_list64
, 0, true);
3108 return record64_type
;
3111 /* Utility routine for above code to make a field. */
3114 make_descriptor_field (const char *name
, tree type
,
3115 tree rec_type
, tree initial
)
3118 = create_field_decl (get_identifier (name
), type
, rec_type
, 0, 0, 0, 0);
3120 DECL_INITIAL (field
) = initial
;
3124 /* Convert GNU_EXPR, a pointer to a 64bit VMS descriptor, to GNU_TYPE, a
3125 regular pointer or fat pointer type. GNAT_SUBPROG is the subprogram to
3126 which the VMS descriptor is passed. */
3129 convert_vms_descriptor64 (tree gnu_type
, tree gnu_expr
, Entity_Id gnat_subprog
)
3131 tree desc_type
= TREE_TYPE (TREE_TYPE (gnu_expr
));
3132 tree desc
= build1 (INDIRECT_REF
, desc_type
, gnu_expr
);
3133 /* The CLASS field is the 3rd field in the descriptor. */
3134 tree klass
= TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (desc_type
)));
3135 /* The POINTER field is the 6th field in the descriptor. */
3136 tree pointer64
= TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (klass
)));
3138 /* Retrieve the value of the POINTER field. */
3140 = build3 (COMPONENT_REF
, TREE_TYPE (pointer64
), desc
, pointer64
, NULL_TREE
);
3142 if (POINTER_TYPE_P (gnu_type
))
3143 return convert (gnu_type
, gnu_expr64
);
3145 else if (TYPE_FAT_POINTER_P (gnu_type
))
3147 tree p_array_type
= TREE_TYPE (TYPE_FIELDS (gnu_type
));
3148 tree p_bounds_type
= TREE_TYPE (TREE_CHAIN (TYPE_FIELDS (gnu_type
)));
3149 tree template_type
= TREE_TYPE (p_bounds_type
);
3150 tree min_field
= TYPE_FIELDS (template_type
);
3151 tree max_field
= TREE_CHAIN (TYPE_FIELDS (template_type
));
3152 tree template_tree
, template_addr
, aflags
, dimct
, t
, u
;
3153 /* See the head comment of build_vms_descriptor. */
3154 int iklass
= TREE_INT_CST_LOW (DECL_INITIAL (klass
));
3155 tree lfield
, ufield
;
3157 /* Convert POINTER to the type of the P_ARRAY field. */
3158 gnu_expr64
= convert (p_array_type
, gnu_expr64
);
3162 case 1: /* Class S */
3163 case 15: /* Class SB */
3164 /* Build {1, LENGTH} template; LENGTH64 is the 5th field. */
3165 t
= TREE_CHAIN (TREE_CHAIN (klass
));
3166 t
= build3 (COMPONENT_REF
, TREE_TYPE (t
), desc
, t
, NULL_TREE
);
3167 t
= tree_cons (min_field
,
3168 convert (TREE_TYPE (min_field
), integer_one_node
),
3169 tree_cons (max_field
,
3170 convert (TREE_TYPE (max_field
), t
),
3172 template_tree
= gnat_build_constructor (template_type
, t
);
3173 template_addr
= build_unary_op (ADDR_EXPR
, NULL_TREE
, template_tree
);
3175 /* For class S, we are done. */
3179 /* Test that we really have a SB descriptor, like DEC Ada. */
3180 t
= build3 (COMPONENT_REF
, TREE_TYPE (klass
), desc
, klass
, NULL
);
3181 u
= convert (TREE_TYPE (klass
), DECL_INITIAL (klass
));
3182 u
= build_binary_op (EQ_EXPR
, integer_type_node
, t
, u
);
3183 /* If so, there is already a template in the descriptor and
3184 it is located right after the POINTER field. The fields are
3185 64bits so they must be repacked. */
3186 t
= TREE_CHAIN (pointer64
);
3187 lfield
= build3 (COMPONENT_REF
, TREE_TYPE (t
), desc
, t
, NULL_TREE
);
3188 lfield
= convert (TREE_TYPE (TYPE_FIELDS (template_type
)), lfield
);
3191 ufield
= build3 (COMPONENT_REF
, TREE_TYPE (t
), desc
, t
, NULL_TREE
);
3193 (TREE_TYPE (TREE_CHAIN (TYPE_FIELDS (template_type
))), ufield
);
3195 /* Build the template in the form of a constructor. */
3196 t
= tree_cons (TYPE_FIELDS (template_type
), lfield
,
3197 tree_cons (TREE_CHAIN (TYPE_FIELDS (template_type
)),
3198 ufield
, NULL_TREE
));
3199 template_tree
= gnat_build_constructor (template_type
, t
);
3201 /* Otherwise use the {1, LENGTH} template we build above. */
3202 template_addr
= build3 (COND_EXPR
, p_bounds_type
, u
,
3203 build_unary_op (ADDR_EXPR
, p_bounds_type
,
3208 case 4: /* Class A */
3209 /* The AFLAGS field is the 3rd field after the pointer in the
3211 t
= TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (pointer64
)));
3212 aflags
= build3 (COMPONENT_REF
, TREE_TYPE (t
), desc
, t
, NULL_TREE
);
3213 /* The DIMCT field is the next field in the descriptor after
3216 dimct
= build3 (COMPONENT_REF
, TREE_TYPE (t
), desc
, t
, NULL_TREE
);
3217 /* Raise CONSTRAINT_ERROR if either more than 1 dimension
3218 or FL_COEFF or FL_BOUNDS not set. */
3219 u
= build_int_cst (TREE_TYPE (aflags
), 192);
3220 u
= build_binary_op (TRUTH_OR_EXPR
, integer_type_node
,
3221 build_binary_op (NE_EXPR
, integer_type_node
,
3223 convert (TREE_TYPE (dimct
),
3225 build_binary_op (NE_EXPR
, integer_type_node
,
3226 build2 (BIT_AND_EXPR
,
3230 /* There is already a template in the descriptor and it is located
3231 in block 3. The fields are 64bits so they must be repacked. */
3232 t
= TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (TREE_CHAIN
3234 lfield
= build3 (COMPONENT_REF
, TREE_TYPE (t
), desc
, t
, NULL_TREE
);
3235 lfield
= convert (TREE_TYPE (TYPE_FIELDS (template_type
)), lfield
);
3238 ufield
= build3 (COMPONENT_REF
, TREE_TYPE (t
), desc
, t
, NULL_TREE
);
3240 (TREE_TYPE (TREE_CHAIN (TYPE_FIELDS (template_type
))), ufield
);
3242 /* Build the template in the form of a constructor. */
3243 t
= tree_cons (TYPE_FIELDS (template_type
), lfield
,
3244 tree_cons (TREE_CHAIN (TYPE_FIELDS (template_type
)),
3245 ufield
, NULL_TREE
));
3246 template_tree
= gnat_build_constructor (template_type
, t
);
3247 template_tree
= build3 (COND_EXPR
, template_type
, u
,
3248 build_call_raise (CE_Length_Check_Failed
, Empty
,
3249 N_Raise_Constraint_Error
),
3252 = build_unary_op (ADDR_EXPR
, p_bounds_type
, template_tree
);
3255 case 10: /* Class NCA */
3257 post_error ("unsupported descriptor type for &", gnat_subprog
);
3258 template_addr
= integer_zero_node
;
3262 /* Build the fat pointer in the form of a constructor. */
3263 t
= tree_cons (TYPE_FIELDS (gnu_type
), gnu_expr64
,
3264 tree_cons (TREE_CHAIN (TYPE_FIELDS (gnu_type
)),
3265 template_addr
, NULL_TREE
));
3266 return gnat_build_constructor (gnu_type
, t
);
3273 /* Convert GNU_EXPR, a pointer to a 32bit VMS descriptor, to GNU_TYPE, a
3274 regular pointer or fat pointer type. GNAT_SUBPROG is the subprogram to
3275 which the VMS descriptor is passed. */
3278 convert_vms_descriptor32 (tree gnu_type
, tree gnu_expr
, Entity_Id gnat_subprog
)
3280 tree desc_type
= TREE_TYPE (TREE_TYPE (gnu_expr
));
3281 tree desc
= build1 (INDIRECT_REF
, desc_type
, gnu_expr
);
3282 /* The CLASS field is the 3rd field in the descriptor. */
3283 tree klass
= TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (desc_type
)));
3284 /* The POINTER field is the 4th field in the descriptor. */
3285 tree pointer
= TREE_CHAIN (klass
);
3287 /* Retrieve the value of the POINTER field. */
3289 = build3 (COMPONENT_REF
, TREE_TYPE (pointer
), desc
, pointer
, NULL_TREE
);
3291 if (POINTER_TYPE_P (gnu_type
))
3292 return convert (gnu_type
, gnu_expr32
);
3294 else if (TYPE_FAT_POINTER_P (gnu_type
))
3296 tree p_array_type
= TREE_TYPE (TYPE_FIELDS (gnu_type
));
3297 tree p_bounds_type
= TREE_TYPE (TREE_CHAIN (TYPE_FIELDS (gnu_type
)));
3298 tree template_type
= TREE_TYPE (p_bounds_type
);
3299 tree min_field
= TYPE_FIELDS (template_type
);
3300 tree max_field
= TREE_CHAIN (TYPE_FIELDS (template_type
));
3301 tree template_tree
, template_addr
, aflags
, dimct
, t
, u
;
3302 /* See the head comment of build_vms_descriptor. */
3303 int iklass
= TREE_INT_CST_LOW (DECL_INITIAL (klass
));
3305 /* Convert POINTER to the type of the P_ARRAY field. */
3306 gnu_expr32
= convert (p_array_type
, gnu_expr32
);
3310 case 1: /* Class S */
3311 case 15: /* Class SB */
3312 /* Build {1, LENGTH} template; LENGTH is the 1st field. */
3313 t
= TYPE_FIELDS (desc_type
);
3314 t
= build3 (COMPONENT_REF
, TREE_TYPE (t
), desc
, t
, NULL_TREE
);
3315 t
= tree_cons (min_field
,
3316 convert (TREE_TYPE (min_field
), integer_one_node
),
3317 tree_cons (max_field
,
3318 convert (TREE_TYPE (max_field
), t
),
3320 template_tree
= gnat_build_constructor (template_type
, t
);
3321 template_addr
= build_unary_op (ADDR_EXPR
, NULL_TREE
, template_tree
);
3323 /* For class S, we are done. */
3327 /* Test that we really have a SB descriptor, like DEC Ada. */
3328 t
= build3 (COMPONENT_REF
, TREE_TYPE (klass
), desc
, klass
, NULL
);
3329 u
= convert (TREE_TYPE (klass
), DECL_INITIAL (klass
));
3330 u
= build_binary_op (EQ_EXPR
, integer_type_node
, t
, u
);
3331 /* If so, there is already a template in the descriptor and
3332 it is located right after the POINTER field. */
3333 t
= TREE_CHAIN (pointer
);
3335 = build3 (COMPONENT_REF
, TREE_TYPE (t
), desc
, t
, NULL_TREE
);
3336 /* Otherwise use the {1, LENGTH} template we build above. */
3337 template_addr
= build3 (COND_EXPR
, p_bounds_type
, u
,
3338 build_unary_op (ADDR_EXPR
, p_bounds_type
,
3343 case 4: /* Class A */
3344 /* The AFLAGS field is the 7th field in the descriptor. */
3345 t
= TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (pointer
)));
3346 aflags
= build3 (COMPONENT_REF
, TREE_TYPE (t
), desc
, t
, NULL_TREE
);
3347 /* The DIMCT field is the 8th field in the descriptor. */
3349 dimct
= build3 (COMPONENT_REF
, TREE_TYPE (t
), desc
, t
, NULL_TREE
);
3350 /* Raise CONSTRAINT_ERROR if either more than 1 dimension
3351 or FL_COEFF or FL_BOUNDS not set. */
3352 u
= build_int_cst (TREE_TYPE (aflags
), 192);
3353 u
= build_binary_op (TRUTH_OR_EXPR
, integer_type_node
,
3354 build_binary_op (NE_EXPR
, integer_type_node
,
3356 convert (TREE_TYPE (dimct
),
3358 build_binary_op (NE_EXPR
, integer_type_node
,
3359 build2 (BIT_AND_EXPR
,
3363 /* There is already a template in the descriptor and it is
3364 located at the start of block 3 (12th field). */
3365 t
= TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (t
))));
3367 = build3 (COMPONENT_REF
, TREE_TYPE (t
), desc
, t
, NULL_TREE
);
3368 template_tree
= build3 (COND_EXPR
, TREE_TYPE (t
), u
,
3369 build_call_raise (CE_Length_Check_Failed
, Empty
,
3370 N_Raise_Constraint_Error
),
3373 = build_unary_op (ADDR_EXPR
, p_bounds_type
, template_tree
);
3376 case 10: /* Class NCA */
3378 post_error ("unsupported descriptor type for &", gnat_subprog
);
3379 template_addr
= integer_zero_node
;
3383 /* Build the fat pointer in the form of a constructor. */
3384 t
= tree_cons (TYPE_FIELDS (gnu_type
), gnu_expr32
,
3385 tree_cons (TREE_CHAIN (TYPE_FIELDS (gnu_type
)),
3386 template_addr
, NULL_TREE
));
3388 return gnat_build_constructor (gnu_type
, t
);
3395 /* Convert GNU_EXPR, a pointer to a VMS descriptor, to GNU_TYPE, a regular
3396 pointer or fat pointer type. GNU_EXPR_ALT_TYPE is the alternate (32-bit)
3397 pointer type of GNU_EXPR. GNAT_SUBPROG is the subprogram to which the
3398 VMS descriptor is passed. */
3401 convert_vms_descriptor (tree gnu_type
, tree gnu_expr
, tree gnu_expr_alt_type
,
3402 Entity_Id gnat_subprog
)
3404 tree desc_type
= TREE_TYPE (TREE_TYPE (gnu_expr
));
3405 tree desc
= build1 (INDIRECT_REF
, desc_type
, gnu_expr
);
3406 tree mbo
= TYPE_FIELDS (desc_type
);
3407 const char *mbostr
= IDENTIFIER_POINTER (DECL_NAME (mbo
));
3408 tree mbmo
= TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (mbo
)));
3409 tree is64bit
, gnu_expr32
, gnu_expr64
;
3411 /* If the field name is not MBO, it must be 32-bit and no alternate.
3412 Otherwise primary must be 64-bit and alternate 32-bit. */
3413 if (strcmp (mbostr
, "MBO") != 0)
3414 return convert_vms_descriptor32 (gnu_type
, gnu_expr
, gnat_subprog
);
3416 /* Build the test for 64-bit descriptor. */
3417 mbo
= build3 (COMPONENT_REF
, TREE_TYPE (mbo
), desc
, mbo
, NULL_TREE
);
3418 mbmo
= build3 (COMPONENT_REF
, TREE_TYPE (mbmo
), desc
, mbmo
, NULL_TREE
);
3420 = build_binary_op (TRUTH_ANDIF_EXPR
, integer_type_node
,
3421 build_binary_op (EQ_EXPR
, integer_type_node
,
3422 convert (integer_type_node
, mbo
),
3424 build_binary_op (EQ_EXPR
, integer_type_node
,
3425 convert (integer_type_node
, mbmo
),
3426 integer_minus_one_node
));
3428 /* Build the 2 possible end results. */
3429 gnu_expr64
= convert_vms_descriptor64 (gnu_type
, gnu_expr
, gnat_subprog
);
3430 gnu_expr
= fold_convert (gnu_expr_alt_type
, gnu_expr
);
3431 gnu_expr32
= convert_vms_descriptor32 (gnu_type
, gnu_expr
, gnat_subprog
);
3433 return build3 (COND_EXPR
, gnu_type
, is64bit
, gnu_expr64
, gnu_expr32
);
3436 /* Build a stub for the subprogram specified by the GCC tree GNU_SUBPROG
3437 and the GNAT node GNAT_SUBPROG. */
3440 build_function_stub (tree gnu_subprog
, Entity_Id gnat_subprog
)
3442 tree gnu_subprog_type
, gnu_subprog_addr
, gnu_subprog_call
;
3443 tree gnu_stub_param
, gnu_param_list
, gnu_arg_types
, gnu_param
;
3444 tree gnu_stub_decl
= DECL_FUNCTION_STUB (gnu_subprog
);
3447 gnu_subprog_type
= TREE_TYPE (gnu_subprog
);
3448 gnu_param_list
= NULL_TREE
;
3450 begin_subprog_body (gnu_stub_decl
);
3453 start_stmt_group ();
3455 /* Loop over the parameters of the stub and translate any of them
3456 passed by descriptor into a by reference one. */
3457 for (gnu_stub_param
= DECL_ARGUMENTS (gnu_stub_decl
),
3458 gnu_arg_types
= TYPE_ARG_TYPES (gnu_subprog_type
);
3460 gnu_stub_param
= TREE_CHAIN (gnu_stub_param
),
3461 gnu_arg_types
= TREE_CHAIN (gnu_arg_types
))
3463 if (DECL_BY_DESCRIPTOR_P (gnu_stub_param
))
3465 = convert_vms_descriptor (TREE_VALUE (gnu_arg_types
),
3467 DECL_PARM_ALT_TYPE (gnu_stub_param
),
3470 gnu_param
= gnu_stub_param
;
3472 gnu_param_list
= tree_cons (NULL_TREE
, gnu_param
, gnu_param_list
);
3475 gnu_body
= end_stmt_group ();
3477 /* Invoke the internal subprogram. */
3478 gnu_subprog_addr
= build1 (ADDR_EXPR
, build_pointer_type (gnu_subprog_type
),
3480 gnu_subprog_call
= build_call_list (TREE_TYPE (gnu_subprog_type
),
3482 nreverse (gnu_param_list
));
3484 /* Propagate the return value, if any. */
3485 if (VOID_TYPE_P (TREE_TYPE (gnu_subprog_type
)))
3486 append_to_statement_list (gnu_subprog_call
, &gnu_body
);
3488 append_to_statement_list (build_return_expr (DECL_RESULT (gnu_stub_decl
),
3494 allocate_struct_function (gnu_stub_decl
, false);
3495 end_subprog_body (gnu_body
);
3498 /* Build a type to be used to represent an aliased object whose nominal
3499 type is an unconstrained array. This consists of a RECORD_TYPE containing
3500 a field of TEMPLATE_TYPE and a field of OBJECT_TYPE, which is an
3501 ARRAY_TYPE. If ARRAY_TYPE is that of the unconstrained array, this
3502 is used to represent an arbitrary unconstrained object. Use NAME
3503 as the name of the record. */
3506 build_unc_object_type (tree template_type
, tree object_type
, tree name
)
3508 tree type
= make_node (RECORD_TYPE
);
3509 tree template_field
= create_field_decl (get_identifier ("BOUNDS"),
3510 template_type
, type
, 0, 0, 0, 1);
3511 tree array_field
= create_field_decl (get_identifier ("ARRAY"), object_type
,
3514 TYPE_NAME (type
) = name
;
3515 TYPE_CONTAINS_TEMPLATE_P (type
) = 1;
3516 finish_record_type (type
,
3517 chainon (chainon (NULL_TREE
, template_field
),
3524 /* Same, taking a thin or fat pointer type instead of a template type. */
3527 build_unc_object_type_from_ptr (tree thin_fat_ptr_type
, tree object_type
,
3532 gcc_assert (TYPE_FAT_OR_THIN_POINTER_P (thin_fat_ptr_type
));
3535 = (TYPE_FAT_POINTER_P (thin_fat_ptr_type
)
3536 ? TREE_TYPE (TREE_TYPE (TREE_CHAIN (TYPE_FIELDS (thin_fat_ptr_type
))))
3537 : TREE_TYPE (TYPE_FIELDS (TREE_TYPE (thin_fat_ptr_type
))));
3538 return build_unc_object_type (template_type
, object_type
, name
);
3541 /* Shift the component offsets within an unconstrained object TYPE to make it
3542 suitable for use as a designated type for thin pointers. */
3545 shift_unc_components_for_thin_pointers (tree type
)
3547 /* Thin pointer values designate the ARRAY data of an unconstrained object,
3548 allocated past the BOUNDS template. The designated type is adjusted to
3549 have ARRAY at position zero and the template at a negative offset, so
3550 that COMPONENT_REFs on (*thin_ptr) designate the proper location. */
3552 tree bounds_field
= TYPE_FIELDS (type
);
3553 tree array_field
= TREE_CHAIN (TYPE_FIELDS (type
));
3555 DECL_FIELD_OFFSET (bounds_field
)
3556 = size_binop (MINUS_EXPR
, size_zero_node
, byte_position (array_field
));
3558 DECL_FIELD_OFFSET (array_field
) = size_zero_node
;
3559 DECL_FIELD_BIT_OFFSET (array_field
) = bitsize_zero_node
;
3562 /* Update anything previously pointing to OLD_TYPE to point to NEW_TYPE.
3563 In the normal case this is just two adjustments, but we have more to
3564 do if NEW_TYPE is an UNCONSTRAINED_ARRAY_TYPE. */
3567 update_pointer_to (tree old_type
, tree new_type
)
3569 tree ptr
= TYPE_POINTER_TO (old_type
);
3570 tree ref
= TYPE_REFERENCE_TO (old_type
);
3574 /* If this is the main variant, process all the other variants first. */
3575 if (TYPE_MAIN_VARIANT (old_type
) == old_type
)
3576 for (type
= TYPE_NEXT_VARIANT (old_type
); type
;
3577 type
= TYPE_NEXT_VARIANT (type
))
3578 update_pointer_to (type
, new_type
);
3580 /* If no pointers and no references, we are done. */
3584 /* Merge the old type qualifiers in the new type.
3586 Each old variant has qualifiers for specific reasons, and the new
3587 designated type as well. Each set of qualifiers represents useful
3588 information grabbed at some point, and merging the two simply unifies
3589 these inputs into the final type description.
3591 Consider for instance a volatile type frozen after an access to constant
3592 type designating it; after the designated type's freeze, we get here with
3593 a volatile NEW_TYPE and a dummy OLD_TYPE with a readonly variant, created
3594 when the access type was processed. We will make a volatile and readonly
3595 designated type, because that's what it really is.
3597 We might also get here for a non-dummy OLD_TYPE variant with different
3598 qualifiers than those of NEW_TYPE, for instance in some cases of pointers
3599 to private record type elaboration (see the comments around the call to
3600 this routine in gnat_to_gnu_entity <E_Access_Type>). We have to merge
3601 the qualifiers in those cases too, to avoid accidentally discarding the
3602 initial set, and will often end up with OLD_TYPE == NEW_TYPE then. */
3604 = build_qualified_type (new_type
,
3605 TYPE_QUALS (old_type
) | TYPE_QUALS (new_type
));
3607 /* If old type and new type are identical, there is nothing to do. */
3608 if (old_type
== new_type
)
3611 /* Otherwise, first handle the simple case. */
3612 if (TREE_CODE (new_type
) != UNCONSTRAINED_ARRAY_TYPE
)
3614 TYPE_POINTER_TO (new_type
) = ptr
;
3615 TYPE_REFERENCE_TO (new_type
) = ref
;
3617 for (; ptr
; ptr
= TYPE_NEXT_PTR_TO (ptr
))
3618 for (ptr1
= TYPE_MAIN_VARIANT (ptr
); ptr1
;
3619 ptr1
= TYPE_NEXT_VARIANT (ptr1
))
3620 TREE_TYPE (ptr1
) = new_type
;
3622 for (; ref
; ref
= TYPE_NEXT_REF_TO (ref
))
3623 for (ref1
= TYPE_MAIN_VARIANT (ref
); ref1
;
3624 ref1
= TYPE_NEXT_VARIANT (ref1
))
3625 TREE_TYPE (ref1
) = new_type
;
3628 /* Now deal with the unconstrained array case. In this case the "pointer"
3629 is actually a RECORD_TYPE where both fields are pointers to dummy nodes.
3630 Turn them into pointers to the correct types using update_pointer_to. */
3631 else if (!TYPE_FAT_POINTER_P (ptr
))
3636 tree new_obj_rec
= TYPE_OBJECT_RECORD_TYPE (new_type
);
3637 tree array_field
= TYPE_FIELDS (ptr
);
3638 tree bounds_field
= TREE_CHAIN (TYPE_FIELDS (ptr
));
3639 tree new_ptr
= TYPE_POINTER_TO (new_type
);
3643 /* Make pointers to the dummy template point to the real template. */
3645 (TREE_TYPE (TREE_TYPE (bounds_field
)),
3646 TREE_TYPE (TREE_TYPE (TREE_CHAIN (TYPE_FIELDS (new_ptr
)))));
3648 /* The references to the template bounds present in the array type
3649 are made through a PLACEHOLDER_EXPR of type NEW_PTR. Since we
3650 are updating PTR to make it a full replacement for NEW_PTR as
3651 pointer to NEW_TYPE, we must rework the PLACEHOLDER_EXPR so as
3652 to make it of type PTR. */
3653 new_ref
= build3 (COMPONENT_REF
, TREE_TYPE (bounds_field
),
3654 build0 (PLACEHOLDER_EXPR
, ptr
),
3655 bounds_field
, NULL_TREE
);
3657 /* Create the new array for the new PLACEHOLDER_EXPR and make pointers
3658 to the dummy array point to it. */
3660 (TREE_TYPE (TREE_TYPE (array_field
)),
3661 substitute_in_type (TREE_TYPE (TREE_TYPE (TYPE_FIELDS (new_ptr
))),
3662 TREE_CHAIN (TYPE_FIELDS (new_ptr
)), new_ref
));
3664 /* Make PTR the pointer to NEW_TYPE. */
3665 TYPE_POINTER_TO (new_type
) = TYPE_REFERENCE_TO (new_type
)
3666 = TREE_TYPE (new_type
) = ptr
;
3668 for (var
= TYPE_MAIN_VARIANT (ptr
); var
; var
= TYPE_NEXT_VARIANT (var
))
3669 SET_TYPE_UNCONSTRAINED_ARRAY (var
, new_type
);
3671 /* Now handle updating the allocation record, what the thin pointer
3672 points to. Update all pointers from the old record into the new
3673 one, update the type of the array field, and recompute the size. */
3674 update_pointer_to (TYPE_OBJECT_RECORD_TYPE (old_type
), new_obj_rec
);
3676 TREE_TYPE (TREE_CHAIN (TYPE_FIELDS (new_obj_rec
)))
3677 = TREE_TYPE (TREE_TYPE (array_field
));
3679 /* The size recomputation needs to account for alignment constraints, so
3680 we let layout_type work it out. This will reset the field offsets to
3681 what they would be in a regular record, so we shift them back to what
3682 we want them to be for a thin pointer designated type afterwards. */
3683 DECL_SIZE (TYPE_FIELDS (new_obj_rec
)) = 0;
3684 DECL_SIZE (TREE_CHAIN (TYPE_FIELDS (new_obj_rec
))) = 0;
3685 TYPE_SIZE (new_obj_rec
) = 0;
3686 layout_type (new_obj_rec
);
3688 shift_unc_components_for_thin_pointers (new_obj_rec
);
3690 /* We are done, at last. */
3691 rest_of_record_type_compilation (ptr
);
3695 /* Convert EXPR, a pointer to a constrained array, into a pointer to an
3696 unconstrained one. This involves making or finding a template. */
3699 convert_to_fat_pointer (tree type
, tree expr
)
3701 tree template_type
= TREE_TYPE (TREE_TYPE (TREE_CHAIN (TYPE_FIELDS (type
))));
3702 tree p_array_type
= TREE_TYPE (TYPE_FIELDS (type
));
3703 tree etype
= TREE_TYPE (expr
);
3706 /* If EXPR is null, make a fat pointer that contains null pointers to the
3707 template and array. */
3708 if (integer_zerop (expr
))
3710 gnat_build_constructor
3712 tree_cons (TYPE_FIELDS (type
),
3713 convert (p_array_type
, expr
),
3714 tree_cons (TREE_CHAIN (TYPE_FIELDS (type
)),
3715 convert (build_pointer_type (template_type
),
3719 /* If EXPR is a thin pointer, make template and data from the record.. */
3720 else if (TYPE_THIN_POINTER_P (etype
))
3722 tree fields
= TYPE_FIELDS (TREE_TYPE (etype
));
3724 expr
= save_expr (expr
);
3725 if (TREE_CODE (expr
) == ADDR_EXPR
)
3726 expr
= TREE_OPERAND (expr
, 0);
3728 expr
= build1 (INDIRECT_REF
, TREE_TYPE (etype
), expr
);
3730 template_tree
= build_component_ref (expr
, NULL_TREE
, fields
, false);
3731 expr
= build_unary_op (ADDR_EXPR
, NULL_TREE
,
3732 build_component_ref (expr
, NULL_TREE
,
3733 TREE_CHAIN (fields
), false));
3736 /* Otherwise, build the constructor for the template. */
3738 template_tree
= build_template (template_type
, TREE_TYPE (etype
), expr
);
3740 /* The final result is a constructor for the fat pointer.
3742 If EXPR is an argument of a foreign convention subprogram, the type it
3743 points to is directly the component type. In this case, the expression
3744 type may not match the corresponding FIELD_DECL type at this point, so we
3745 call "convert" here to fix that up if necessary. This type consistency is
3746 required, for instance because it ensures that possible later folding of
3747 COMPONENT_REFs against this constructor always yields something of the
3748 same type as the initial reference.
3750 Note that the call to "build_template" above is still fine because it
3751 will only refer to the provided TEMPLATE_TYPE in this case. */
3753 gnat_build_constructor
3755 tree_cons (TYPE_FIELDS (type
),
3756 convert (p_array_type
, expr
),
3757 tree_cons (TREE_CHAIN (TYPE_FIELDS (type
)),
3758 build_unary_op (ADDR_EXPR
, NULL_TREE
,
3763 /* Convert to a thin pointer type, TYPE. The only thing we know how to convert
3764 is something that is a fat pointer, so convert to it first if it EXPR
3765 is not already a fat pointer. */
3768 convert_to_thin_pointer (tree type
, tree expr
)
3770 if (!TYPE_FAT_POINTER_P (TREE_TYPE (expr
)))
3772 = convert_to_fat_pointer
3773 (TREE_TYPE (TYPE_UNCONSTRAINED_ARRAY (TREE_TYPE (type
))), expr
);
3775 /* We get the pointer to the data and use a NOP_EXPR to make it the
3777 expr
= build_component_ref (expr
, NULL_TREE
, TYPE_FIELDS (TREE_TYPE (expr
)),
3779 expr
= build1 (NOP_EXPR
, type
, expr
);
3784 /* Create an expression whose value is that of EXPR,
3785 converted to type TYPE. The TREE_TYPE of the value
3786 is always TYPE. This function implements all reasonable
3787 conversions; callers should filter out those that are
3788 not permitted by the language being compiled. */
3791 convert (tree type
, tree expr
)
3793 enum tree_code code
= TREE_CODE (type
);
3794 tree etype
= TREE_TYPE (expr
);
3795 enum tree_code ecode
= TREE_CODE (etype
);
3797 /* If EXPR is already the right type, we are done. */
3801 /* If both input and output have padding and are of variable size, do this
3802 as an unchecked conversion. Likewise if one is a mere variant of the
3803 other, so we avoid a pointless unpad/repad sequence. */
3804 else if (code
== RECORD_TYPE
&& ecode
== RECORD_TYPE
3805 && TYPE_IS_PADDING_P (type
) && TYPE_IS_PADDING_P (etype
)
3806 && (!TREE_CONSTANT (TYPE_SIZE (type
))
3807 || !TREE_CONSTANT (TYPE_SIZE (etype
))
3808 || gnat_types_compatible_p (type
, etype
)
3809 || TYPE_NAME (TREE_TYPE (TYPE_FIELDS (type
)))
3810 == TYPE_NAME (TREE_TYPE (TYPE_FIELDS (etype
)))))
3813 /* If the output type has padding, convert to the inner type and make a
3814 constructor to build the record, unless a variable size is involved. */
3815 else if (code
== RECORD_TYPE
&& TYPE_IS_PADDING_P (type
))
3817 /* If we previously converted from another type and our type is
3818 of variable size, remove the conversion to avoid the need for
3819 variable-sized temporaries. Likewise for a conversion between
3820 original and packable version. */
3821 if (TREE_CODE (expr
) == VIEW_CONVERT_EXPR
3822 && (!TREE_CONSTANT (TYPE_SIZE (type
))
3823 || (ecode
== RECORD_TYPE
3824 && TYPE_NAME (etype
)
3825 == TYPE_NAME (TREE_TYPE (TREE_OPERAND (expr
, 0))))))
3826 expr
= TREE_OPERAND (expr
, 0);
3828 /* If we are just removing the padding from expr, convert the original
3829 object if we have variable size in order to avoid the need for some
3830 variable-sized temporaries. Likewise if the padding is a variant
3831 of the other, so we avoid a pointless unpad/repad sequence. */
3832 if (TREE_CODE (expr
) == COMPONENT_REF
3833 && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == RECORD_TYPE
3834 && TYPE_IS_PADDING_P (TREE_TYPE (TREE_OPERAND (expr
, 0)))
3835 && (!TREE_CONSTANT (TYPE_SIZE (type
))
3836 || gnat_types_compatible_p (type
,
3837 TREE_TYPE (TREE_OPERAND (expr
, 0)))
3838 || (ecode
== RECORD_TYPE
3839 && TYPE_NAME (etype
)
3840 == TYPE_NAME (TREE_TYPE (TYPE_FIELDS (type
))))))
3841 return convert (type
, TREE_OPERAND (expr
, 0));
3843 /* If the result type is a padded type with a self-referentially-sized
3844 field and the expression type is a record, do this as an unchecked
3846 if (TREE_CODE (etype
) == RECORD_TYPE
3847 && CONTAINS_PLACEHOLDER_P (DECL_SIZE (TYPE_FIELDS (type
))))
3848 return unchecked_convert (type
, expr
, false);
3850 /* If we are converting between array types with variable size, do the
3851 final conversion as an unchecked conversion, again to avoid the need
3852 for some variable-sized temporaries. If valid, this conversion is
3853 very likely purely technical and without real effects. */
3854 if (TREE_CODE (etype
) == ARRAY_TYPE
3855 && TREE_CODE (TREE_TYPE (TYPE_FIELDS (type
))) == ARRAY_TYPE
3856 && !TREE_CONSTANT (TYPE_SIZE (etype
))
3857 && !TREE_CONSTANT (TYPE_SIZE (type
)))
3858 return unchecked_convert (type
,
3859 convert (TREE_TYPE (TYPE_FIELDS (type
)),
3864 gnat_build_constructor (type
,
3865 tree_cons (TYPE_FIELDS (type
),
3867 (TYPE_FIELDS (type
)),
3872 /* If the input type has padding, remove it and convert to the output type.
3873 The conditions ordering is arranged to ensure that the output type is not
3874 a padding type here, as it is not clear whether the conversion would
3875 always be correct if this was to happen. */
3876 else if (ecode
== RECORD_TYPE
&& TYPE_IS_PADDING_P (etype
))
3880 /* If we have just converted to this padded type, just get the
3881 inner expression. */
3882 if (TREE_CODE (expr
) == CONSTRUCTOR
3883 && !VEC_empty (constructor_elt
, CONSTRUCTOR_ELTS (expr
))
3884 && VEC_index (constructor_elt
, CONSTRUCTOR_ELTS (expr
), 0)->index
3885 == TYPE_FIELDS (etype
))
3887 = VEC_index (constructor_elt
, CONSTRUCTOR_ELTS (expr
), 0)->value
;
3889 /* Otherwise, build an explicit component reference. */
3892 = build_component_ref (expr
, NULL_TREE
, TYPE_FIELDS (etype
), false);
3894 return convert (type
, unpadded
);
3897 /* If the input is a biased type, adjust first. */
3898 if (ecode
== INTEGER_TYPE
&& TYPE_BIASED_REPRESENTATION_P (etype
))
3899 return convert (type
, fold_build2 (PLUS_EXPR
, TREE_TYPE (etype
),
3900 fold_convert (TREE_TYPE (etype
),
3902 TYPE_MIN_VALUE (etype
)));
3904 /* If the input is a justified modular type, we need to extract the actual
3905 object before converting it to any other type with the exceptions of an
3906 unconstrained array or of a mere type variant. It is useful to avoid the
3907 extraction and conversion in the type variant case because it could end
3908 up replacing a VAR_DECL expr by a constructor and we might be about the
3909 take the address of the result. */
3910 if (ecode
== RECORD_TYPE
&& TYPE_JUSTIFIED_MODULAR_P (etype
)
3911 && code
!= UNCONSTRAINED_ARRAY_TYPE
3912 && TYPE_MAIN_VARIANT (type
) != TYPE_MAIN_VARIANT (etype
))
3913 return convert (type
, build_component_ref (expr
, NULL_TREE
,
3914 TYPE_FIELDS (etype
), false));
3916 /* If converting to a type that contains a template, convert to the data
3917 type and then build the template. */
3918 if (code
== RECORD_TYPE
&& TYPE_CONTAINS_TEMPLATE_P (type
))
3920 tree obj_type
= TREE_TYPE (TREE_CHAIN (TYPE_FIELDS (type
)));
3922 /* If the source already has a template, get a reference to the
3923 associated array only, as we are going to rebuild a template
3924 for the target type anyway. */
3925 expr
= maybe_unconstrained_array (expr
);
3928 gnat_build_constructor
3930 tree_cons (TYPE_FIELDS (type
),
3931 build_template (TREE_TYPE (TYPE_FIELDS (type
)),
3932 obj_type
, NULL_TREE
),
3933 tree_cons (TREE_CHAIN (TYPE_FIELDS (type
)),
3934 convert (obj_type
, expr
), NULL_TREE
)));
3937 /* There are some special cases of expressions that we process
3939 switch (TREE_CODE (expr
))
3945 /* Just set its type here. For TRANSFORM_EXPR, we will do the actual
3946 conversion in gnat_expand_expr. NULL_EXPR does not represent
3947 and actual value, so no conversion is needed. */
3948 expr
= copy_node (expr
);
3949 TREE_TYPE (expr
) = type
;
3953 /* If we are converting a STRING_CST to another constrained array type,
3954 just make a new one in the proper type. */
3955 if (code
== ecode
&& AGGREGATE_TYPE_P (etype
)
3956 && !(TREE_CODE (TYPE_SIZE (etype
)) == INTEGER_CST
3957 && TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
))
3959 expr
= copy_node (expr
);
3960 TREE_TYPE (expr
) = type
;
3966 /* If we are converting a CONSTRUCTOR to a mere variant type, just make
3967 a new one in the proper type. */
3968 if (code
== ecode
&& gnat_types_compatible_p (type
, etype
))
3970 expr
= copy_node (expr
);
3971 TREE_TYPE (expr
) = type
;
3975 /* Likewise for a conversion between original and packable version, but
3976 we have to work harder in order to preserve type consistency. */
3978 && code
== RECORD_TYPE
3979 && TYPE_NAME (type
) == TYPE_NAME (etype
))
3981 VEC(constructor_elt
,gc
) *e
= CONSTRUCTOR_ELTS (expr
);
3982 unsigned HOST_WIDE_INT len
= VEC_length (constructor_elt
, e
);
3983 VEC(constructor_elt
,gc
) *v
= VEC_alloc (constructor_elt
, gc
, len
);
3984 tree efield
= TYPE_FIELDS (etype
), field
= TYPE_FIELDS (type
);
3985 unsigned HOST_WIDE_INT idx
;
3988 /* Whether we need to clear TREE_CONSTANT et al. on the output
3989 constructor when we convert in place. */
3990 bool clear_constant
= false;
3992 FOR_EACH_CONSTRUCTOR_ELT(e
, idx
, index
, value
)
3994 constructor_elt
*elt
= VEC_quick_push (constructor_elt
, v
, NULL
);
3995 /* We expect only simple constructors. Otherwise, punt. */
3996 if (!(index
== efield
|| index
== DECL_ORIGINAL_FIELD (efield
)))
3999 elt
->value
= convert (TREE_TYPE (field
), value
);
4001 /* If packing has made this field a bitfield and the input
4002 value couldn't be emitted statically any more, we need to
4003 clear TREE_CONSTANT on our output. */
4004 if (!clear_constant
&& TREE_CONSTANT (expr
)
4005 && !CONSTRUCTOR_BITFIELD_P (efield
)
4006 && CONSTRUCTOR_BITFIELD_P (field
)
4007 && !initializer_constant_valid_for_bitfield_p (value
))
4008 clear_constant
= true;
4010 efield
= TREE_CHAIN (efield
);
4011 field
= TREE_CHAIN (field
);
4014 /* If we have been able to match and convert all the input fields
4015 to their output type, convert in place now. We'll fallback to a
4016 view conversion downstream otherwise. */
4019 expr
= copy_node (expr
);
4020 TREE_TYPE (expr
) = type
;
4021 CONSTRUCTOR_ELTS (expr
) = v
;
4023 TREE_CONSTANT (expr
) = TREE_STATIC (expr
) = false;
4029 case UNCONSTRAINED_ARRAY_REF
:
4030 /* Convert this to the type of the inner array by getting the address of
4031 the array from the template. */
4032 expr
= build_unary_op (INDIRECT_REF
, NULL_TREE
,
4033 build_component_ref (TREE_OPERAND (expr
, 0),
4034 get_identifier ("P_ARRAY"),
4036 etype
= TREE_TYPE (expr
);
4037 ecode
= TREE_CODE (etype
);
4040 case VIEW_CONVERT_EXPR
:
4042 /* GCC 4.x is very sensitive to type consistency overall, and view
4043 conversions thus are very frequent. Even though just "convert"ing
4044 the inner operand to the output type is fine in most cases, it
4045 might expose unexpected input/output type mismatches in special
4046 circumstances so we avoid such recursive calls when we can. */
4047 tree op0
= TREE_OPERAND (expr
, 0);
4049 /* If we are converting back to the original type, we can just
4050 lift the input conversion. This is a common occurrence with
4051 switches back-and-forth amongst type variants. */
4052 if (type
== TREE_TYPE (op0
))
4055 /* Otherwise, if we're converting between two aggregate types, we
4056 might be allowed to substitute the VIEW_CONVERT_EXPR target type
4057 in place or to just convert the inner expression. */
4058 if (AGGREGATE_TYPE_P (type
) && AGGREGATE_TYPE_P (etype
))
4060 /* If we are converting between mere variants, we can just
4061 substitute the VIEW_CONVERT_EXPR in place. */
4062 if (gnat_types_compatible_p (type
, etype
))
4063 return build1 (VIEW_CONVERT_EXPR
, type
, op0
);
4065 /* Otherwise, we may just bypass the input view conversion unless
4066 one of the types is a fat pointer, which is handled by
4067 specialized code below which relies on exact type matching. */
4068 else if (!TYPE_FAT_POINTER_P (type
) && !TYPE_FAT_POINTER_P (etype
))
4069 return convert (type
, op0
);
4075 /* If both types are record types, just convert the pointer and
4076 make a new INDIRECT_REF.
4078 ??? Disable this for now since it causes problems with the
4079 code in build_binary_op for MODIFY_EXPR which wants to
4080 strip off conversions. But that code really is a mess and
4081 we need to do this a much better way some time. */
4083 && (TREE_CODE (type
) == RECORD_TYPE
4084 || TREE_CODE (type
) == UNION_TYPE
)
4085 && (TREE_CODE (etype
) == RECORD_TYPE
4086 || TREE_CODE (etype
) == UNION_TYPE
)
4087 && !TYPE_FAT_POINTER_P (type
) && !TYPE_FAT_POINTER_P (etype
))
4088 return build_unary_op (INDIRECT_REF
, NULL_TREE
,
4089 convert (build_pointer_type (type
),
4090 TREE_OPERAND (expr
, 0)));
4097 /* Check for converting to a pointer to an unconstrained array. */
4098 if (TYPE_FAT_POINTER_P (type
) && !TYPE_FAT_POINTER_P (etype
))
4099 return convert_to_fat_pointer (type
, expr
);
4101 /* If we are converting between two aggregate types that are mere
4102 variants, just make a VIEW_CONVERT_EXPR. */
4103 else if (code
== ecode
4104 && AGGREGATE_TYPE_P (type
)
4105 && gnat_types_compatible_p (type
, etype
))
4106 return build1 (VIEW_CONVERT_EXPR
, type
, expr
);
4108 /* In all other cases of related types, make a NOP_EXPR. */
4109 else if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (etype
)
4110 || (code
== INTEGER_CST
&& ecode
== INTEGER_CST
4111 && (type
== TREE_TYPE (etype
) || etype
== TREE_TYPE (type
))))
4112 return fold_convert (type
, expr
);
4117 return fold_build1 (CONVERT_EXPR
, type
, expr
);
4120 if (TYPE_HAS_ACTUAL_BOUNDS_P (type
)
4121 && (ecode
== ARRAY_TYPE
|| ecode
== UNCONSTRAINED_ARRAY_TYPE
4122 || (ecode
== RECORD_TYPE
&& TYPE_CONTAINS_TEMPLATE_P (etype
))))
4123 return unchecked_convert (type
, expr
, false);
4124 else if (TYPE_BIASED_REPRESENTATION_P (type
))
4125 return fold_convert (type
,
4126 fold_build2 (MINUS_EXPR
, TREE_TYPE (type
),
4127 convert (TREE_TYPE (type
), expr
),
4128 TYPE_MIN_VALUE (type
)));
4130 /* ... fall through ... */
4134 /* If we are converting an additive expression to an integer type
4135 with lower precision, be wary of the optimization that can be
4136 applied by convert_to_integer. There are 2 problematic cases:
4137 - if the first operand was originally of a biased type,
4138 because we could be recursively called to convert it
4139 to an intermediate type and thus rematerialize the
4140 additive operator endlessly,
4141 - if the expression contains a placeholder, because an
4142 intermediate conversion that changes the sign could
4143 be inserted and thus introduce an artificial overflow
4144 at compile time when the placeholder is substituted. */
4145 if (code
== INTEGER_TYPE
4146 && ecode
== INTEGER_TYPE
4147 && TYPE_PRECISION (type
) < TYPE_PRECISION (etype
)
4148 && (TREE_CODE (expr
) == PLUS_EXPR
|| TREE_CODE (expr
) == MINUS_EXPR
))
4150 tree op0
= get_unwidened (TREE_OPERAND (expr
, 0), type
);
4152 if ((TREE_CODE (TREE_TYPE (op0
)) == INTEGER_TYPE
4153 && TYPE_BIASED_REPRESENTATION_P (TREE_TYPE (op0
)))
4154 || CONTAINS_PLACEHOLDER_P (expr
))
4155 return build1 (NOP_EXPR
, type
, expr
);
4158 return fold (convert_to_integer (type
, expr
));
4161 case REFERENCE_TYPE
:
4162 /* If converting between two pointers to records denoting
4163 both a template and type, adjust if needed to account
4164 for any differing offsets, since one might be negative. */
4165 if (TYPE_THIN_POINTER_P (etype
) && TYPE_THIN_POINTER_P (type
))
4168 = size_diffop (bit_position (TYPE_FIELDS (TREE_TYPE (etype
))),
4169 bit_position (TYPE_FIELDS (TREE_TYPE (type
))));
4170 tree byte_diff
= size_binop (CEIL_DIV_EXPR
, bit_diff
,
4171 sbitsize_int (BITS_PER_UNIT
));
4173 expr
= build1 (NOP_EXPR
, type
, expr
);
4174 TREE_CONSTANT (expr
) = TREE_CONSTANT (TREE_OPERAND (expr
, 0));
4175 if (integer_zerop (byte_diff
))
4178 return build_binary_op (POINTER_PLUS_EXPR
, type
, expr
,
4179 fold (convert (sizetype
, byte_diff
)));
4182 /* If converting to a thin pointer, handle specially. */
4183 if (TYPE_THIN_POINTER_P (type
)
4184 && TYPE_UNCONSTRAINED_ARRAY (TREE_TYPE (type
)))
4185 return convert_to_thin_pointer (type
, expr
);
4187 /* If converting fat pointer to normal pointer, get the pointer to the
4188 array and then convert it. */
4189 else if (TYPE_FAT_POINTER_P (etype
))
4190 expr
= build_component_ref (expr
, get_identifier ("P_ARRAY"),
4193 return fold (convert_to_pointer (type
, expr
));
4196 return fold (convert_to_real (type
, expr
));
4199 if (TYPE_JUSTIFIED_MODULAR_P (type
) && !AGGREGATE_TYPE_P (etype
))
4201 gnat_build_constructor
4202 (type
, tree_cons (TYPE_FIELDS (type
),
4203 convert (TREE_TYPE (TYPE_FIELDS (type
)), expr
),
4206 /* ... fall through ... */
4209 /* In these cases, assume the front-end has validated the conversion.
4210 If the conversion is valid, it will be a bit-wise conversion, so
4211 it can be viewed as an unchecked conversion. */
4212 return unchecked_convert (type
, expr
, false);
4215 /* This is a either a conversion between a tagged type and some
4216 subtype, which we have to mark as a UNION_TYPE because of
4217 overlapping fields or a conversion of an Unchecked_Union. */
4218 return unchecked_convert (type
, expr
, false);
4220 case UNCONSTRAINED_ARRAY_TYPE
:
4221 /* If EXPR is a constrained array, take its address, convert it to a
4222 fat pointer, and then dereference it. Likewise if EXPR is a
4223 record containing both a template and a constrained array.
4224 Note that a record representing a justified modular type
4225 always represents a packed constrained array. */
4226 if (ecode
== ARRAY_TYPE
4227 || (ecode
== INTEGER_TYPE
&& TYPE_HAS_ACTUAL_BOUNDS_P (etype
))
4228 || (ecode
== RECORD_TYPE
&& TYPE_CONTAINS_TEMPLATE_P (etype
))
4229 || (ecode
== RECORD_TYPE
&& TYPE_JUSTIFIED_MODULAR_P (etype
)))
4232 (INDIRECT_REF
, NULL_TREE
,
4233 convert_to_fat_pointer (TREE_TYPE (type
),
4234 build_unary_op (ADDR_EXPR
,
4237 /* Do something very similar for converting one unconstrained
4238 array to another. */
4239 else if (ecode
== UNCONSTRAINED_ARRAY_TYPE
)
4241 build_unary_op (INDIRECT_REF
, NULL_TREE
,
4242 convert (TREE_TYPE (type
),
4243 build_unary_op (ADDR_EXPR
,
4249 return fold (convert_to_complex (type
, expr
));
4256 /* Remove all conversions that are done in EXP. This includes converting
4257 from a padded type or to a justified modular type. If TRUE_ADDRESS
4258 is true, always return the address of the containing object even if
4259 the address is not bit-aligned. */
4262 remove_conversions (tree exp
, bool true_address
)
4264 switch (TREE_CODE (exp
))
4268 && TREE_CODE (TREE_TYPE (exp
)) == RECORD_TYPE
4269 && TYPE_JUSTIFIED_MODULAR_P (TREE_TYPE (exp
)))
4271 remove_conversions (VEC_index (constructor_elt
,
4272 CONSTRUCTOR_ELTS (exp
), 0)->value
,
4277 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (exp
, 0))) == RECORD_TYPE
4278 && TYPE_IS_PADDING_P (TREE_TYPE (TREE_OPERAND (exp
, 0))))
4279 return remove_conversions (TREE_OPERAND (exp
, 0), true_address
);
4282 case VIEW_CONVERT_EXPR
: case NON_LVALUE_EXPR
:
4284 return remove_conversions (TREE_OPERAND (exp
, 0), true_address
);
4293 /* If EXP's type is an UNCONSTRAINED_ARRAY_TYPE, return an expression that
4294 refers to the underlying array. If its type has TYPE_CONTAINS_TEMPLATE_P,
4295 likewise return an expression pointing to the underlying array. */
4298 maybe_unconstrained_array (tree exp
)
4300 enum tree_code code
= TREE_CODE (exp
);
4303 switch (TREE_CODE (TREE_TYPE (exp
)))
4305 case UNCONSTRAINED_ARRAY_TYPE
:
4306 if (code
== UNCONSTRAINED_ARRAY_REF
)
4309 = build_unary_op (INDIRECT_REF
, NULL_TREE
,
4310 build_component_ref (TREE_OPERAND (exp
, 0),
4311 get_identifier ("P_ARRAY"),
4313 TREE_READONLY (new_exp
) = TREE_STATIC (new_exp
)
4314 = TREE_READONLY (exp
);
4318 else if (code
== NULL_EXPR
)
4319 return build1 (NULL_EXPR
,
4320 TREE_TYPE (TREE_TYPE (TYPE_FIELDS
4321 (TREE_TYPE (TREE_TYPE (exp
))))),
4322 TREE_OPERAND (exp
, 0));
4325 /* If this is a padded type, convert to the unpadded type and see if
4326 it contains a template. */
4327 if (TYPE_IS_PADDING_P (TREE_TYPE (exp
)))
4329 new_exp
= convert (TREE_TYPE (TYPE_FIELDS (TREE_TYPE (exp
))), exp
);
4330 if (TREE_CODE (TREE_TYPE (new_exp
)) == RECORD_TYPE
4331 && TYPE_CONTAINS_TEMPLATE_P (TREE_TYPE (new_exp
)))
4333 build_component_ref (new_exp
, NULL_TREE
,
4335 (TYPE_FIELDS (TREE_TYPE (new_exp
))),
4338 else if (TYPE_CONTAINS_TEMPLATE_P (TREE_TYPE (exp
)))
4340 build_component_ref (exp
, NULL_TREE
,
4341 TREE_CHAIN (TYPE_FIELDS (TREE_TYPE (exp
))), 0);
4351 /* Return true if EXPR is an expression that can be folded as an operand
4352 of a VIEW_CONVERT_EXPR. See ada-tree.h for a complete rationale. */
4355 can_fold_for_view_convert_p (tree expr
)
4359 /* The folder will fold NOP_EXPRs between integral types with the same
4360 precision (in the middle-end's sense). We cannot allow it if the
4361 types don't have the same precision in the Ada sense as well. */
4362 if (TREE_CODE (expr
) != NOP_EXPR
)
4365 t1
= TREE_TYPE (expr
);
4366 t2
= TREE_TYPE (TREE_OPERAND (expr
, 0));
4368 /* Defer to the folder for non-integral conversions. */
4369 if (!(INTEGRAL_TYPE_P (t1
) && INTEGRAL_TYPE_P (t2
)))
4372 /* Only fold conversions that preserve both precisions. */
4373 if (TYPE_PRECISION (t1
) == TYPE_PRECISION (t2
)
4374 && operand_equal_p (rm_size (t1
), rm_size (t2
), 0))
4380 /* Return an expression that does an unchecked conversion of EXPR to TYPE.
4381 If NOTRUNC_P is true, truncation operations should be suppressed.
4383 Special care is required with (source or target) integral types whose
4384 precision is not equal to their size, to make sure we fetch or assign
4385 the value bits whose location might depend on the endianness, e.g.
4387 Rmsize : constant := 8;
4388 subtype Int is Integer range 0 .. 2 ** Rmsize - 1;
4390 type Bit_Array is array (1 .. Rmsize) of Boolean;
4391 pragma Pack (Bit_Array);
4393 function To_Bit_Array is new Unchecked_Conversion (Int, Bit_Array);
4395 Value : Int := 2#1000_0001#;
4396 Vbits : Bit_Array := To_Bit_Array (Value);
4398 we expect the 8 bits at Vbits'Address to always contain Value, while
4399 their original location depends on the endianness, at Value'Address
4400 on a little-endian architecture but not on a big-endian one. */
4403 unchecked_convert (tree type
, tree expr
, bool notrunc_p
)
4405 tree etype
= TREE_TYPE (expr
);
4407 /* If the expression is already the right type, we are done. */
4411 /* If both types types are integral just do a normal conversion.
4412 Likewise for a conversion to an unconstrained array. */
4413 if ((((INTEGRAL_TYPE_P (type
)
4414 && !(TREE_CODE (type
) == INTEGER_TYPE
4415 && TYPE_VAX_FLOATING_POINT_P (type
)))
4416 || (POINTER_TYPE_P (type
) && ! TYPE_THIN_POINTER_P (type
))
4417 || (TREE_CODE (type
) == RECORD_TYPE
4418 && TYPE_JUSTIFIED_MODULAR_P (type
)))
4419 && ((INTEGRAL_TYPE_P (etype
)
4420 && !(TREE_CODE (etype
) == INTEGER_TYPE
4421 && TYPE_VAX_FLOATING_POINT_P (etype
)))
4422 || (POINTER_TYPE_P (etype
) && !TYPE_THIN_POINTER_P (etype
))
4423 || (TREE_CODE (etype
) == RECORD_TYPE
4424 && TYPE_JUSTIFIED_MODULAR_P (etype
))))
4425 || TREE_CODE (type
) == UNCONSTRAINED_ARRAY_TYPE
)
4427 if (TREE_CODE (etype
) == INTEGER_TYPE
4428 && TYPE_BIASED_REPRESENTATION_P (etype
))
4430 tree ntype
= copy_type (etype
);
4431 TYPE_BIASED_REPRESENTATION_P (ntype
) = 0;
4432 TYPE_MAIN_VARIANT (ntype
) = ntype
;
4433 expr
= build1 (NOP_EXPR
, ntype
, expr
);
4436 if (TREE_CODE (type
) == INTEGER_TYPE
4437 && TYPE_BIASED_REPRESENTATION_P (type
))
4439 tree rtype
= copy_type (type
);
4440 TYPE_BIASED_REPRESENTATION_P (rtype
) = 0;
4441 TYPE_MAIN_VARIANT (rtype
) = rtype
;
4442 expr
= convert (rtype
, expr
);
4443 expr
= build1 (NOP_EXPR
, type
, expr
);
4446 expr
= convert (type
, expr
);
4449 /* If we are converting to an integral type whose precision is not equal
4450 to its size, first unchecked convert to a record that contains an
4451 object of the output type. Then extract the field. */
4452 else if (INTEGRAL_TYPE_P (type
) && TYPE_RM_SIZE (type
)
4453 && 0 != compare_tree_int (TYPE_RM_SIZE (type
),
4454 GET_MODE_BITSIZE (TYPE_MODE (type
))))
4456 tree rec_type
= make_node (RECORD_TYPE
);
4457 tree field
= create_field_decl (get_identifier ("OBJ"), type
,
4458 rec_type
, 1, 0, 0, 0);
4460 TYPE_FIELDS (rec_type
) = field
;
4461 layout_type (rec_type
);
4463 expr
= unchecked_convert (rec_type
, expr
, notrunc_p
);
4464 expr
= build_component_ref (expr
, NULL_TREE
, field
, 0);
4467 /* Similarly if we are converting from an integral type whose precision
4468 is not equal to its size. */
4469 else if (INTEGRAL_TYPE_P (etype
) && TYPE_RM_SIZE (etype
)
4470 && 0 != compare_tree_int (TYPE_RM_SIZE (etype
),
4471 GET_MODE_BITSIZE (TYPE_MODE (etype
))))
4473 tree rec_type
= make_node (RECORD_TYPE
);
4475 = create_field_decl (get_identifier ("OBJ"), etype
, rec_type
,
4478 TYPE_FIELDS (rec_type
) = field
;
4479 layout_type (rec_type
);
4481 expr
= gnat_build_constructor (rec_type
, build_tree_list (field
, expr
));
4482 expr
= unchecked_convert (type
, expr
, notrunc_p
);
4485 /* We have a special case when we are converting between two
4486 unconstrained array types. In that case, take the address,
4487 convert the fat pointer types, and dereference. */
4488 else if (TREE_CODE (etype
) == UNCONSTRAINED_ARRAY_TYPE
4489 && TREE_CODE (type
) == UNCONSTRAINED_ARRAY_TYPE
)
4490 expr
= build_unary_op (INDIRECT_REF
, NULL_TREE
,
4491 build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (type
),
4492 build_unary_op (ADDR_EXPR
, NULL_TREE
,
4496 expr
= maybe_unconstrained_array (expr
);
4497 etype
= TREE_TYPE (expr
);
4498 if (can_fold_for_view_convert_p (expr
))
4499 expr
= fold_build1 (VIEW_CONVERT_EXPR
, type
, expr
);
4501 expr
= build1 (VIEW_CONVERT_EXPR
, type
, expr
);
4504 /* If the result is an integral type whose precision is not equal to its
4505 size, sign- or zero-extend the result. We need not do this if the input
4506 is an integral type of the same precision and signedness or if the output
4507 is a biased type or if both the input and output are unsigned. */
4509 && INTEGRAL_TYPE_P (type
) && TYPE_RM_SIZE (type
)
4510 && !(TREE_CODE (type
) == INTEGER_TYPE
4511 && TYPE_BIASED_REPRESENTATION_P (type
))
4512 && 0 != compare_tree_int (TYPE_RM_SIZE (type
),
4513 GET_MODE_BITSIZE (TYPE_MODE (type
)))
4514 && !(INTEGRAL_TYPE_P (etype
)
4515 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (etype
)
4516 && operand_equal_p (TYPE_RM_SIZE (type
),
4517 (TYPE_RM_SIZE (etype
) != 0
4518 ? TYPE_RM_SIZE (etype
) : TYPE_SIZE (etype
)),
4520 && !(TYPE_UNSIGNED (type
) && TYPE_UNSIGNED (etype
)))
4522 tree base_type
= gnat_type_for_mode (TYPE_MODE (type
),
4523 TYPE_UNSIGNED (type
));
4525 = convert (base_type
,
4526 size_binop (MINUS_EXPR
,
4528 (GET_MODE_BITSIZE (TYPE_MODE (type
))),
4529 TYPE_RM_SIZE (type
)));
4532 build_binary_op (RSHIFT_EXPR
, base_type
,
4533 build_binary_op (LSHIFT_EXPR
, base_type
,
4534 convert (base_type
, expr
),
4539 /* An unchecked conversion should never raise Constraint_Error. The code
4540 below assumes that GCC's conversion routines overflow the same way that
4541 the underlying hardware does. This is probably true. In the rare case
4542 when it is false, we can rely on the fact that such conversions are
4543 erroneous anyway. */
4544 if (TREE_CODE (expr
) == INTEGER_CST
)
4545 TREE_OVERFLOW (expr
) = 0;
4547 /* If the sizes of the types differ and this is an VIEW_CONVERT_EXPR,
4548 show no longer constant. */
4549 if (TREE_CODE (expr
) == VIEW_CONVERT_EXPR
4550 && !operand_equal_p (TYPE_SIZE_UNIT (type
), TYPE_SIZE_UNIT (etype
),
4552 TREE_CONSTANT (expr
) = 0;
4557 /* Return the appropriate GCC tree code for the specified GNAT_TYPE,
4558 the latter being a record type as predicated by Is_Record_Type. */
4561 tree_code_for_record_type (Entity_Id gnat_type
)
4563 Node_Id component_list
4564 = Component_List (Type_Definition
4566 (Implementation_Base_Type (gnat_type
))));
4569 /* Make this a UNION_TYPE unless it's either not an Unchecked_Union or
4570 we have a non-discriminant field outside a variant. In either case,
4571 it's a RECORD_TYPE. */
4573 if (!Is_Unchecked_Union (gnat_type
))
4576 for (component
= First_Non_Pragma (Component_Items (component_list
));
4577 Present (component
);
4578 component
= Next_Non_Pragma (component
))
4579 if (Ekind (Defining_Entity (component
)) == E_Component
)
4585 /* Return true if GNAT_TYPE is a "double" floating-point type, i.e. whose
4586 size is equal to 64 bits, or an array of such a type. Set ALIGN_CLAUSE
4587 according to the presence of an alignment clause on the type or, if it
4588 is an array, on the component type. */
4591 is_double_float_or_array (Entity_Id gnat_type
, bool *align_clause
)
4593 gnat_type
= Underlying_Type (gnat_type
);
4595 *align_clause
= Present (Alignment_Clause (gnat_type
));
4597 if (Is_Array_Type (gnat_type
))
4599 gnat_type
= Underlying_Type (Component_Type (gnat_type
));
4600 if (Present (Alignment_Clause (gnat_type
)))
4601 *align_clause
= true;
4604 if (!Is_Floating_Point_Type (gnat_type
))
4607 if (UI_To_Int (Esize (gnat_type
)) != 64)
4613 /* Return true if GNAT_TYPE is a "double" or larger scalar type, i.e. whose
4614 size is greater or equal to 64 bits, or an array of such a type. Set
4615 ALIGN_CLAUSE according to the presence of an alignment clause on the
4616 type or, if it is an array, on the component type. */
4619 is_double_scalar_or_array (Entity_Id gnat_type
, bool *align_clause
)
4621 gnat_type
= Underlying_Type (gnat_type
);
4623 *align_clause
= Present (Alignment_Clause (gnat_type
));
4625 if (Is_Array_Type (gnat_type
))
4627 gnat_type
= Underlying_Type (Component_Type (gnat_type
));
4628 if (Present (Alignment_Clause (gnat_type
)))
4629 *align_clause
= true;
4632 if (!Is_Scalar_Type (gnat_type
))
4635 if (UI_To_Int (Esize (gnat_type
)) < 64)
4641 /* Return true if GNU_TYPE is suitable as the type of a non-aliased
4642 component of an aggregate type. */
4645 type_for_nonaliased_component_p (tree gnu_type
)
4647 /* If the type is passed by reference, we may have pointers to the
4648 component so it cannot be made non-aliased. */
4649 if (must_pass_by_ref (gnu_type
) || default_pass_by_ref (gnu_type
))
4652 /* We used to say that any component of aggregate type is aliased
4653 because the front-end may take 'Reference of it. The front-end
4654 has been enhanced in the meantime so as to use a renaming instead
4655 in most cases, but the back-end can probably take the address of
4656 such a component too so we go for the conservative stance.
4658 For instance, we might need the address of any array type, even
4659 if normally passed by copy, to construct a fat pointer if the
4660 component is used as an actual for an unconstrained formal.
4662 Likewise for record types: even if a specific record subtype is
4663 passed by copy, the parent type might be passed by ref (e.g. if
4664 it's of variable size) and we might take the address of a child
4665 component to pass to a parent formal. We have no way to check
4666 for such conditions here. */
4667 if (AGGREGATE_TYPE_P (gnu_type
))
4673 /* Perform final processing on global variables. */
4676 gnat_write_global_declarations (void)
4678 /* Proceed to optimize and emit assembly.
4679 FIXME: shouldn't be the front end's responsibility to call this. */
4680 cgraph_finalize_compilation_unit ();
4682 /* Emit debug info for all global declarations. */
4683 emit_debug_global_declarations (VEC_address (tree
, global_decls
),
4684 VEC_length (tree
, global_decls
));
4687 /* ************************************************************************
4688 * * GCC builtins support *
4689 * ************************************************************************ */
4691 /* The general scheme is fairly simple:
4693 For each builtin function/type to be declared, gnat_install_builtins calls
4694 internal facilities which eventually get to gnat_push_decl, which in turn
4695 tracks the so declared builtin function decls in the 'builtin_decls' global
4696 datastructure. When an Intrinsic subprogram declaration is processed, we
4697 search this global datastructure to retrieve the associated BUILT_IN DECL
4700 /* Search the chain of currently available builtin declarations for a node
4701 corresponding to function NAME (an IDENTIFIER_NODE). Return the first node
4702 found, if any, or NULL_TREE otherwise. */
4704 builtin_decl_for (tree name
)
4709 for (i
= 0; VEC_iterate(tree
, builtin_decls
, i
, decl
); i
++)
4710 if (DECL_NAME (decl
) == name
)
4716 /* The code below eventually exposes gnat_install_builtins, which declares
4717 the builtin types and functions we might need, either internally or as
4718 user accessible facilities.
4720 ??? This is a first implementation shot, still in rough shape. It is
4721 heavily inspired from the "C" family implementation, with chunks copied
4722 verbatim from there.
4724 Two obvious TODO candidates are
4725 o Use a more efficient name/decl mapping scheme
4726 o Devise a middle-end infrastructure to avoid having to copy
4727 pieces between front-ends. */
4729 /* ----------------------------------------------------------------------- *
4730 * BUILTIN ELEMENTARY TYPES *
4731 * ----------------------------------------------------------------------- */
4733 /* Standard data types to be used in builtin argument declarations. */
4737 CTI_SIGNED_SIZE_TYPE
, /* For format checking only. */
4739 CTI_CONST_STRING_TYPE
,
4744 static tree c_global_trees
[CTI_MAX
];
4746 #define signed_size_type_node c_global_trees[CTI_SIGNED_SIZE_TYPE]
4747 #define string_type_node c_global_trees[CTI_STRING_TYPE]
4748 #define const_string_type_node c_global_trees[CTI_CONST_STRING_TYPE]
4750 /* ??? In addition some attribute handlers, we currently don't support a
4751 (small) number of builtin-types, which in turns inhibits support for a
4752 number of builtin functions. */
4753 #define wint_type_node void_type_node
4754 #define intmax_type_node void_type_node
4755 #define uintmax_type_node void_type_node
4757 /* Build the void_list_node (void_type_node having been created). */
4760 build_void_list_node (void)
4762 tree t
= build_tree_list (NULL_TREE
, void_type_node
);
4766 /* Used to help initialize the builtin-types.def table. When a type of
4767 the correct size doesn't exist, use error_mark_node instead of NULL.
4768 The later results in segfaults even when a decl using the type doesn't
4772 builtin_type_for_size (int size
, bool unsignedp
)
4774 tree type
= lang_hooks
.types
.type_for_size (size
, unsignedp
);
4775 return type
? type
: error_mark_node
;
4778 /* Build/push the elementary type decls that builtin functions/types
4782 install_builtin_elementary_types (void)
4784 signed_size_type_node
= size_type_node
;
4785 pid_type_node
= integer_type_node
;
4786 void_list_node
= build_void_list_node ();
4788 string_type_node
= build_pointer_type (char_type_node
);
4789 const_string_type_node
4790 = build_pointer_type (build_qualified_type
4791 (char_type_node
, TYPE_QUAL_CONST
));
4794 /* ----------------------------------------------------------------------- *
4795 * BUILTIN FUNCTION TYPES *
4796 * ----------------------------------------------------------------------- */
4798 /* Now, builtin function types per se. */
4802 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
4803 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
4804 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
4805 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
4806 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4807 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4808 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
4809 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
4810 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
4811 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
4812 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
4813 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
4814 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4815 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4816 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
4818 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
4819 #include "builtin-types.def"
4820 #undef DEF_PRIMITIVE_TYPE
4821 #undef DEF_FUNCTION_TYPE_0
4822 #undef DEF_FUNCTION_TYPE_1
4823 #undef DEF_FUNCTION_TYPE_2
4824 #undef DEF_FUNCTION_TYPE_3
4825 #undef DEF_FUNCTION_TYPE_4
4826 #undef DEF_FUNCTION_TYPE_5
4827 #undef DEF_FUNCTION_TYPE_6
4828 #undef DEF_FUNCTION_TYPE_7
4829 #undef DEF_FUNCTION_TYPE_VAR_0
4830 #undef DEF_FUNCTION_TYPE_VAR_1
4831 #undef DEF_FUNCTION_TYPE_VAR_2
4832 #undef DEF_FUNCTION_TYPE_VAR_3
4833 #undef DEF_FUNCTION_TYPE_VAR_4
4834 #undef DEF_FUNCTION_TYPE_VAR_5
4835 #undef DEF_POINTER_TYPE
4839 typedef enum c_builtin_type builtin_type
;
4841 /* A temporary array used in communication with def_fn_type. */
4842 static GTY(()) tree builtin_types
[(int) BT_LAST
+ 1];
4844 /* A helper function for install_builtin_types. Build function type
4845 for DEF with return type RET and N arguments. If VAR is true, then the
4846 function should be variadic after those N arguments.
4848 Takes special care not to ICE if any of the types involved are
4849 error_mark_node, which indicates that said type is not in fact available
4850 (see builtin_type_for_size). In which case the function type as a whole
4851 should be error_mark_node. */
4854 def_fn_type (builtin_type def
, builtin_type ret
, bool var
, int n
, ...)
4856 tree args
= NULL
, t
;
4861 for (i
= 0; i
< n
; ++i
)
4863 builtin_type a
= (builtin_type
) va_arg (list
, int);
4864 t
= builtin_types
[a
];
4865 if (t
== error_mark_node
)
4867 args
= tree_cons (NULL_TREE
, t
, args
);
4871 args
= nreverse (args
);
4873 args
= chainon (args
, void_list_node
);
4875 t
= builtin_types
[ret
];
4876 if (t
== error_mark_node
)
4878 t
= build_function_type (t
, args
);
4881 builtin_types
[def
] = t
;
4884 /* Build the builtin function types and install them in the builtin_types
4885 array for later use in builtin function decls. */
4888 install_builtin_function_types (void)
4890 tree va_list_ref_type_node
;
4891 tree va_list_arg_type_node
;
4893 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
4895 va_list_arg_type_node
= va_list_ref_type_node
=
4896 build_pointer_type (TREE_TYPE (va_list_type_node
));
4900 va_list_arg_type_node
= va_list_type_node
;
4901 va_list_ref_type_node
= build_reference_type (va_list_type_node
);
4904 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
4905 builtin_types[ENUM] = VALUE;
4906 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
4907 def_fn_type (ENUM, RETURN, 0, 0);
4908 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
4909 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
4910 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
4911 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
4912 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4913 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
4914 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4915 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
4916 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4917 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4918 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4920 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
4921 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4923 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
4924 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
4925 def_fn_type (ENUM, RETURN, 1, 0);
4926 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
4927 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
4928 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
4929 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
4930 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4931 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
4932 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4933 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
4934 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4935 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4936 #define DEF_POINTER_TYPE(ENUM, TYPE) \
4937 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
4939 #include "builtin-types.def"
4941 #undef DEF_PRIMITIVE_TYPE
4942 #undef DEF_FUNCTION_TYPE_1
4943 #undef DEF_FUNCTION_TYPE_2
4944 #undef DEF_FUNCTION_TYPE_3
4945 #undef DEF_FUNCTION_TYPE_4
4946 #undef DEF_FUNCTION_TYPE_5
4947 #undef DEF_FUNCTION_TYPE_6
4948 #undef DEF_FUNCTION_TYPE_VAR_0
4949 #undef DEF_FUNCTION_TYPE_VAR_1
4950 #undef DEF_FUNCTION_TYPE_VAR_2
4951 #undef DEF_FUNCTION_TYPE_VAR_3
4952 #undef DEF_FUNCTION_TYPE_VAR_4
4953 #undef DEF_FUNCTION_TYPE_VAR_5
4954 #undef DEF_POINTER_TYPE
4955 builtin_types
[(int) BT_LAST
] = NULL_TREE
;
4958 /* ----------------------------------------------------------------------- *
4959 * BUILTIN ATTRIBUTES *
4960 * ----------------------------------------------------------------------- */
4962 enum built_in_attribute
4964 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
4965 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
4966 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
4967 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
4968 #include "builtin-attrs.def"
4969 #undef DEF_ATTR_NULL_TREE
4971 #undef DEF_ATTR_IDENT
4972 #undef DEF_ATTR_TREE_LIST
4976 static GTY(()) tree built_in_attributes
[(int) ATTR_LAST
];
4979 install_builtin_attributes (void)
4981 /* Fill in the built_in_attributes array. */
4982 #define DEF_ATTR_NULL_TREE(ENUM) \
4983 built_in_attributes[(int) ENUM] = NULL_TREE;
4984 #define DEF_ATTR_INT(ENUM, VALUE) \
4985 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
4986 #define DEF_ATTR_IDENT(ENUM, STRING) \
4987 built_in_attributes[(int) ENUM] = get_identifier (STRING);
4988 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4989 built_in_attributes[(int) ENUM] \
4990 = tree_cons (built_in_attributes[(int) PURPOSE], \
4991 built_in_attributes[(int) VALUE], \
4992 built_in_attributes[(int) CHAIN]);
4993 #include "builtin-attrs.def"
4994 #undef DEF_ATTR_NULL_TREE
4996 #undef DEF_ATTR_IDENT
4997 #undef DEF_ATTR_TREE_LIST
5000 /* Handle a "const" attribute; arguments as in
5001 struct attribute_spec.handler. */
5004 handle_const_attribute (tree
*node
, tree
ARG_UNUSED (name
),
5005 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
5008 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5009 TREE_READONLY (*node
) = 1;
5011 *no_add_attrs
= true;
5016 /* Handle a "nothrow" attribute; arguments as in
5017 struct attribute_spec.handler. */
5020 handle_nothrow_attribute (tree
*node
, tree
ARG_UNUSED (name
),
5021 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
5024 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5025 TREE_NOTHROW (*node
) = 1;
5027 *no_add_attrs
= true;
5032 /* Handle a "pure" attribute; arguments as in
5033 struct attribute_spec.handler. */
5036 handle_pure_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5037 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5039 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5040 DECL_PURE_P (*node
) = 1;
5041 /* ??? TODO: Support types. */
5044 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5045 *no_add_attrs
= true;
5051 /* Handle a "no vops" attribute; arguments as in
5052 struct attribute_spec.handler. */
5055 handle_novops_attribute (tree
*node
, tree
ARG_UNUSED (name
),
5056 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
5057 bool *ARG_UNUSED (no_add_attrs
))
5059 gcc_assert (TREE_CODE (*node
) == FUNCTION_DECL
);
5060 DECL_IS_NOVOPS (*node
) = 1;
5064 /* Helper for nonnull attribute handling; fetch the operand number
5065 from the attribute argument list. */
5068 get_nonnull_operand (tree arg_num_expr
, unsigned HOST_WIDE_INT
*valp
)
5070 /* Verify the arg number is a constant. */
5071 if (TREE_CODE (arg_num_expr
) != INTEGER_CST
5072 || TREE_INT_CST_HIGH (arg_num_expr
) != 0)
5075 *valp
= TREE_INT_CST_LOW (arg_num_expr
);
5079 /* Handle the "nonnull" attribute. */
5081 handle_nonnull_attribute (tree
*node
, tree
ARG_UNUSED (name
),
5082 tree args
, int ARG_UNUSED (flags
),
5086 unsigned HOST_WIDE_INT attr_arg_num
;
5088 /* If no arguments are specified, all pointer arguments should be
5089 non-null. Verify a full prototype is given so that the arguments
5090 will have the correct types when we actually check them later. */
5093 if (!TYPE_ARG_TYPES (type
))
5095 error ("nonnull attribute without arguments on a non-prototype");
5096 *no_add_attrs
= true;
5101 /* Argument list specified. Verify that each argument number references
5102 a pointer argument. */
5103 for (attr_arg_num
= 1; args
; args
= TREE_CHAIN (args
))
5106 unsigned HOST_WIDE_INT arg_num
= 0, ck_num
;
5108 if (!get_nonnull_operand (TREE_VALUE (args
), &arg_num
))
5110 error ("nonnull argument has invalid operand number (argument %lu)",
5111 (unsigned long) attr_arg_num
);
5112 *no_add_attrs
= true;
5116 argument
= TYPE_ARG_TYPES (type
);
5119 for (ck_num
= 1; ; ck_num
++)
5121 if (!argument
|| ck_num
== arg_num
)
5123 argument
= TREE_CHAIN (argument
);
5127 || TREE_CODE (TREE_VALUE (argument
)) == VOID_TYPE
)
5129 error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
5130 (unsigned long) attr_arg_num
, (unsigned long) arg_num
);
5131 *no_add_attrs
= true;
5135 if (TREE_CODE (TREE_VALUE (argument
)) != POINTER_TYPE
)
5137 error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
5138 (unsigned long) attr_arg_num
, (unsigned long) arg_num
);
5139 *no_add_attrs
= true;
5148 /* Handle a "sentinel" attribute. */
5151 handle_sentinel_attribute (tree
*node
, tree name
, tree args
,
5152 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5154 tree params
= TYPE_ARG_TYPES (*node
);
5158 warning (OPT_Wattributes
,
5159 "%qE attribute requires prototypes with named arguments", name
);
5160 *no_add_attrs
= true;
5164 while (TREE_CHAIN (params
))
5165 params
= TREE_CHAIN (params
);
5167 if (VOID_TYPE_P (TREE_VALUE (params
)))
5169 warning (OPT_Wattributes
,
5170 "%qE attribute only applies to variadic functions", name
);
5171 *no_add_attrs
= true;
5177 tree position
= TREE_VALUE (args
);
5179 if (TREE_CODE (position
) != INTEGER_CST
)
5181 warning (0, "requested position is not an integer constant");
5182 *no_add_attrs
= true;
5186 if (tree_int_cst_lt (position
, integer_zero_node
))
5188 warning (0, "requested position is less than zero");
5189 *no_add_attrs
= true;
5197 /* Handle a "noreturn" attribute; arguments as in
5198 struct attribute_spec.handler. */
5201 handle_noreturn_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5202 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5204 tree type
= TREE_TYPE (*node
);
5206 /* See FIXME comment in c_common_attribute_table. */
5207 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5208 TREE_THIS_VOLATILE (*node
) = 1;
5209 else if (TREE_CODE (type
) == POINTER_TYPE
5210 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
5212 = build_pointer_type
5213 (build_type_variant (TREE_TYPE (type
),
5214 TYPE_READONLY (TREE_TYPE (type
)), 1));
5217 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5218 *no_add_attrs
= true;
5224 /* Handle a "malloc" attribute; arguments as in
5225 struct attribute_spec.handler. */
5228 handle_malloc_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5229 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5231 if (TREE_CODE (*node
) == FUNCTION_DECL
5232 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node
))))
5233 DECL_IS_MALLOC (*node
) = 1;
5236 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5237 *no_add_attrs
= true;
5243 /* Fake handler for attributes we don't properly support. */
5246 fake_attribute_handler (tree
* ARG_UNUSED (node
),
5247 tree
ARG_UNUSED (name
),
5248 tree
ARG_UNUSED (args
),
5249 int ARG_UNUSED (flags
),
5250 bool * ARG_UNUSED (no_add_attrs
))
5255 /* Handle a "type_generic" attribute. */
5258 handle_type_generic_attribute (tree
*node
, tree
ARG_UNUSED (name
),
5259 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
5260 bool * ARG_UNUSED (no_add_attrs
))
5264 /* Ensure we have a function type. */
5265 gcc_assert (TREE_CODE (*node
) == FUNCTION_TYPE
);
5267 params
= TYPE_ARG_TYPES (*node
);
5268 while (params
&& ! VOID_TYPE_P (TREE_VALUE (params
)))
5269 params
= TREE_CHAIN (params
);
5271 /* Ensure we have a variadic function. */
5272 gcc_assert (!params
);
5277 /* Handle a "vector_size" attribute; arguments as in
5278 struct attribute_spec.handler. */
5281 handle_vector_size_attribute (tree
*node
, tree name
, tree args
,
5282 int ARG_UNUSED (flags
),
5285 unsigned HOST_WIDE_INT vecsize
, nunits
;
5286 enum machine_mode orig_mode
;
5287 tree type
= *node
, new_type
, size
;
5289 *no_add_attrs
= true;
5291 size
= TREE_VALUE (args
);
5293 if (!host_integerp (size
, 1))
5295 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5299 /* Get the vector size (in bytes). */
5300 vecsize
= tree_low_cst (size
, 1);
5302 /* We need to provide for vector pointers, vector arrays, and
5303 functions returning vectors. For example:
5305 __attribute__((vector_size(16))) short *foo;
5307 In this case, the mode is SI, but the type being modified is
5308 HI, so we need to look further. */
5310 while (POINTER_TYPE_P (type
)
5311 || TREE_CODE (type
) == FUNCTION_TYPE
5312 || TREE_CODE (type
) == METHOD_TYPE
5313 || TREE_CODE (type
) == ARRAY_TYPE
5314 || TREE_CODE (type
) == OFFSET_TYPE
)
5315 type
= TREE_TYPE (type
);
5317 /* Get the mode of the type being modified. */
5318 orig_mode
= TYPE_MODE (type
);
5320 if ((!INTEGRAL_TYPE_P (type
)
5321 && !SCALAR_FLOAT_TYPE_P (type
)
5322 && !FIXED_POINT_TYPE_P (type
))
5323 || (!SCALAR_FLOAT_MODE_P (orig_mode
)
5324 && GET_MODE_CLASS (orig_mode
) != MODE_INT
5325 && !ALL_SCALAR_FIXED_POINT_MODE_P (orig_mode
))
5326 || !host_integerp (TYPE_SIZE_UNIT (type
), 1)
5327 || TREE_CODE (type
) == BOOLEAN_TYPE
)
5329 error ("invalid vector type for attribute %qE", name
);
5333 if (vecsize
% tree_low_cst (TYPE_SIZE_UNIT (type
), 1))
5335 error ("vector size not an integral multiple of component size");
5341 error ("zero vector size");
5345 /* Calculate how many units fit in the vector. */
5346 nunits
= vecsize
/ tree_low_cst (TYPE_SIZE_UNIT (type
), 1);
5347 if (nunits
& (nunits
- 1))
5349 error ("number of components of the vector not a power of two");
5353 new_type
= build_vector_type (type
, nunits
);
5355 /* Build back pointers if needed. */
5356 *node
= lang_hooks
.types
.reconstruct_complex_type (*node
, new_type
);
5361 /* ----------------------------------------------------------------------- *
5362 * BUILTIN FUNCTIONS *
5363 * ----------------------------------------------------------------------- */
5365 /* Worker for DEF_BUILTIN. Possibly define a builtin function with one or two
5366 names. Does not declare a non-__builtin_ function if flag_no_builtin, or
5367 if nonansi_p and flag_no_nonansi_builtin. */
5370 def_builtin_1 (enum built_in_function fncode
,
5372 enum built_in_class fnclass
,
5373 tree fntype
, tree libtype
,
5374 bool both_p
, bool fallback_p
,
5375 bool nonansi_p ATTRIBUTE_UNUSED
,
5376 tree fnattrs
, bool implicit_p
)
5379 const char *libname
;
5381 /* Preserve an already installed decl. It most likely was setup in advance
5382 (e.g. as part of the internal builtins) for specific reasons. */
5383 if (built_in_decls
[(int) fncode
] != NULL_TREE
)
5386 gcc_assert ((!both_p
&& !fallback_p
)
5387 || !strncmp (name
, "__builtin_",
5388 strlen ("__builtin_")));
5390 libname
= name
+ strlen ("__builtin_");
5391 decl
= add_builtin_function (name
, fntype
, fncode
, fnclass
,
5392 (fallback_p
? libname
: NULL
),
5395 /* ??? This is normally further controlled by command-line options
5396 like -fno-builtin, but we don't have them for Ada. */
5397 add_builtin_function (libname
, libtype
, fncode
, fnclass
,
5400 built_in_decls
[(int) fncode
] = decl
;
5402 implicit_built_in_decls
[(int) fncode
] = decl
;
5405 static int flag_isoc94
= 0;
5406 static int flag_isoc99
= 0;
5408 /* Install what the common builtins.def offers. */
5411 install_builtin_functions (void)
5413 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
5414 NONANSI_P, ATTRS, IMPLICIT, COND) \
5416 def_builtin_1 (ENUM, NAME, CLASS, \
5417 builtin_types[(int) TYPE], \
5418 builtin_types[(int) LIBTYPE], \
5419 BOTH_P, FALLBACK_P, NONANSI_P, \
5420 built_in_attributes[(int) ATTRS], IMPLICIT);
5421 #include "builtins.def"
5425 /* ----------------------------------------------------------------------- *
5426 * BUILTIN FUNCTIONS *
5427 * ----------------------------------------------------------------------- */
5429 /* Install the builtin functions we might need. */
5432 gnat_install_builtins (void)
5434 install_builtin_elementary_types ();
5435 install_builtin_function_types ();
5436 install_builtin_attributes ();
5438 /* Install builtins used by generic middle-end pieces first. Some of these
5439 know about internal specificities and control attributes accordingly, for
5440 instance __builtin_alloca vs no-throw and -fstack-check. We will ignore
5441 the generic definition from builtins.def. */
5442 build_common_builtin_nodes ();
5444 /* Now, install the target specific builtins, such as the AltiVec family on
5445 ppc, and the common set as exposed by builtins.def. */
5446 targetm
.init_builtins ();
5447 install_builtin_functions ();
5450 #include "gt-ada-utils.h"
5451 #include "gtype-ada.h"