| blob | 42e07b5d17024c63f420d9c489e9c078b3aaa67f |
1 /****************************************************************************
2 * *
3 * GNAT COMPILER COMPONENTS *
4 * *
5 * T R A N S *
6 * *
7 * C Implementation File *
8 * *
9 * Copyright (C) 1992-2010, Free Software Foundation, Inc. *
10 * *
11 * GNAT is free software; you can redistribute it and/or modify it under *
12 * terms of the GNU General Public License as published by the Free Soft- *
13 * ware Foundation; either version 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 distributed with GNAT; see file COPYING3. If not see *
19 * <http://www.gnu.org/licenses/>. *
20 * *
21 * GNAT was originally developed by the GNAT team at New York University. *
22 * Extensive contributions were provided by Ada Core Technologies Inc. *
23 * *
24 ****************************************************************************/
55 /* We should avoid allocating more than ALLOCA_THRESHOLD bytes via alloca,
56 for fear of running out of stack space. If we need more, we use xmalloc
57 instead. */
58 #define ALLOCA_THRESHOLD 1000
60 /* Let code below know whether we are targetting VMS without need of
61 intrusive preprocessor directives. */
62 #ifndef TARGET_ABI_OPEN_VMS
63 #define TARGET_ABI_OPEN_VMS 0
64 #endif
66 /* For efficient float-to-int rounding, it is necessary to know whether
67 floating-point arithmetic may use wider intermediate results. When
68 FP_ARITH_MAY_WIDEN is not defined, be conservative and only assume
69 that arithmetic does not widen if double precision is emulated. */
70 #ifndef FP_ARITH_MAY_WIDEN
71 #if defined(HAVE_extendsfdf2)
72 #define FP_ARITH_MAY_WIDEN HAVE_extendsfdf2
73 #else
74 #define FP_ARITH_MAY_WIDEN 0
75 #endif
76 #endif
92 /* Current filename without path. */
95 /* True when gigi is being called on an analyzed but unexpanded
96 tree, and the only purpose of the call is to properly annotate
97 types with representation information. */
100 /* When not optimizing, we cache the 'First, 'Last and 'Length attributes
101 of unconstrained array IN parameters to avoid emitting a great deal of
102 redundant instructions to recompute them each time. */
106 tree first;
107 tree last;
108 tree length;
109 };
118 };
120 #define f_parm_attr_cache \
121 DECL_STRUCT_FUNCTION (current_function_decl)->language->parm_attr_cache
123 /* A structure used to gather together information about a statement group.
124 We use this to gather related statements, for example the "then" part
125 of a IF. In the case where it represents a lexical scope, we may also
126 have a BLOCK node corresponding to it and/or cleanups. */
133 };
137 /* List of unused struct stmt_group nodes. */
140 /* A structure used to record information on elaboration procedures
141 we've made and need to process.
143 ??? gnat_node should be Node_Id, but gengtype gets confused. */
149 };
153 /* Free list of TREE_LIST nodes used for stacks. */
156 /* List of TREE_LIST nodes representing a stack of exception pointer
157 variables. TREE_VALUE is the VAR_DECL that stores the address of
158 the raised exception. Nonzero means we are in an exception
159 handler. Not used in the zero-cost case. */
162 /* List of TREE_LIST nodes used to store the current elaboration procedure
163 decl. TREE_VALUE is the decl. */
166 /* Variable that stores a list of labels to be used as a goto target instead of
167 a return in some functions. See processing for N_Subprogram_Body. */
170 /* List of TREE_LIST nodes representing a stack of LOOP_STMT nodes.
171 TREE_VALUE of each entry is the label of the corresponding LOOP_STMT. */
174 /* List of TREE_LIST nodes representing labels for switch statements.
175 TREE_VALUE of each entry is the label at the end of the switch. */
178 /* List of TREE_LIST nodes containing the stacks for N_{Push,Pop}_*_Label. */
183 /* Map GNAT tree codes to GCC tree codes for simple expressions. */
186 /* Current node being treated, in case abort called. */
187 Node_Id error_gnat_node;
220 /* Hooks for debug info back-ends, only supported and used in a restricted set
221 of configurations. */
224 \f
225 /* This is the main program of the back-end. It sets up all the table
226 structures and then generates code. */
228 void
237 {
238 Entity_Id gnat_literal;
260 /* Declare the name of the compilation unit as the first global
261 name in order to make the middle-end fully deterministic. */
266 {
267 /* Use the identifier table to make a permanent copy of the filename as
268 the name table gets reallocated after Gigi returns but before all the
269 debugging information is output. The __gnat_to_canonical_file_spec
270 call translates filenames from pragmas Source_Reference that contain
271 host style syntax not understood by gdb. */
273 = IDENTIFIER_POINTER
274 (get_identifier
275 (__gnat_to_canonical_file_spec
278 /* We rely on the order isomorphism between files and line maps. */
281 /* We create the line map for a source file at once, with a fixed number
282 of columns chosen to avoid jumping over the next power of 2. */
287 }
289 /* Initialize ourselves. */
294 /* If we are just annotating types, give VOID_TYPE zero sizes to avoid
295 errors. */
297 {
300 }
302 /* If the GNU type extensions to DWARF are available, setup the hooks. */
303 #if defined (DWARF2_DEBUGGING_INFO) && defined (DWARF2_GNU_TYPE_EXTENSIONS)
304 /* We condition the name demangling and the generation of type encoding
305 strings on -gdwarf+ and always set descriptive types on. */
307 {
310 }
312 #endif
314 /* Enable GNAT stack checking method if needed */
318 /* Retrieve alignment settings. */
322 /* Record the builtin types. Define `integer' and `unsigned char' first so
323 that dbx will output them first. */
333 /* Save the type we made for integer as the type for Standard.Integer. */
337 /* Save the type we made for boolean as the type for Standard.Boolean. */
360 /* Now declare runtime functions. */
363 /* malloc is a function declaration tree for a function to allocate
364 memory. */
365 malloc_decl
373 /* malloc32 is a function declaration tree for a function to allocate
374 32-bit memory on a 64-bit system. Needed only on 64-bit VMS. */
375 malloc32_decl
383 /* free is a function declaration tree for a function to free memory. */
384 free_decl
388 ptr_void_type_node,
389 t)),
392 /* This is used for 64-bit multiplication with overflow checking. */
393 mulv64_decl
399 /* Make the types and functions used for exception processing. */
400 jmpbuf_type
406 /* Functions to get and set the jumpbuf pointer for the current thread. */
407 get_jmpbuf_decl
408 = create_subprog_decl
412 /* Avoid creating superfluous edges to __builtin_setjmp receivers. */
415 set_jmpbuf_decl
416 = create_subprog_decl
418 NULL_TREE,
423 /* setjmp returns an integer and has one operand, which is a pointer to
424 a jmpbuf. */
425 setjmp_decl
426 = create_subprog_decl
435 /* update_setjmp_buf updates a setjmp buffer from the current stack pointer
436 address. */
437 update_setjmp_buf_decl
438 = create_subprog_decl
447 /* Hooks to call when entering/leaving an exception handler. */
448 begin_handler_decl
452 ptr_void_type_node,
453 t)),
456 end_handler_decl
460 ptr_void_type_node,
461 t)),
464 /* If in no exception handlers mode, all raise statements are redirected to
465 __gnat_last_chance_handler. No need to redefine raise_nodefer_decl since
466 this procedure will never be called in this mode. */
468 {
469 tree decl
470 = create_subprog_decl
476 integer_type_node,
477 t))),
482 }
483 else
484 /* Otherwise, make one decl for each exception reason. */
486 {
491 = create_subprog_decl
495 build_pointer_type
498 integer_type_node,
499 t))),
501 }
504 {
509 TYPE_QUAL_VOLATILE);
510 }
512 /* Set the types that GCC and Gigi use from the front end. We would
513 like to do this for char_type_node, but it needs to correspond to
514 the C char type. */
515 exception_type
519 /* Make other functions used for exception processing. */
520 get_excptr_decl
521 = create_subprog_decl
523 NULL_TREE,
526 /* Avoid creating superfluous edges to __builtin_setjmp receivers. */
529 raise_nodefer_decl
530 = create_subprog_decl
535 t)),
538 /* Indicate that these never return. */
543 TYPE_QUAL_VOLATILE);
545 /* Build the special descriptor type and its null node if needed. */
547 {
555 {
561 }
566 }
568 long_long_float_type
572 {
573 /* In this case, the builtin floating point types are VAX float,
574 so make up a type for use. */
579 }
580 else
583 /* Dummy objects to materialize "others" and "all others" in the exception
584 tables. These are exported by a-exexpr.adb, so see this unit for the
585 types to use. */
586 others_decl
591 all_others_decl
598 /* Install the builtins we might need, either internally or as
599 user available facilities for Intrinsic imports. */
603 gnu_constraint_error_label_stack
608 /* Process any Pragma Ident for the main unit. */
609 #ifdef ASM_OUTPUT_IDENT
611 ASM_OUTPUT_IDENT
614 #endif
616 /* If we are using the GCC exception mechanism, let GCC know. */
620 /* Now translate the compilation unit proper. */
624 /* Finally see if we have any elaboration procedures to deal with. */
626 {
629 /* Unshare SAVE_EXPRs between subprograms. These are not unshared by
630 the gimplifier for obvious reasons, but it turns out that we need to
631 unshare them for the global level because of SAVE_EXPRs made around
632 checks for global objects and around allocators for global objects
633 of variable size, in order to prevent node sharing in the underlying
634 expression. Note that this implicitly assumes that the SAVE_EXPR
635 nodes themselves are not shared between subprograms, which would be
636 an upstream bug for which we would not change the outcome. */
639 /* We should have a BIND_EXPR but it may not have any statements in it.
640 If it doesn't have any, we have nothing to do except for setting the
641 flag on the GNAT node. Otherwise, process the function as others. */
647 else
648 {
651 }
652 }
654 /* We cannot track the location of errors past this point. */
656 }
657 \f
658 /* Return a positive value if an lvalue is required for GNAT_NODE, which is
659 an N_Attribute_Reference. */
661 static int
663 {
665 {
700 }
701 }
703 /* Return a positive value if an lvalue is required for GNAT_NODE. GNU_TYPE
704 is the type that will be used for GNAT_NODE in the translated GNU tree.
705 CONSTANT indicates whether the underlying object represented by GNAT_NODE
706 is constant in the Ada sense, ALIASED whether it is aliased (but the latter
707 doesn't affect the outcome if CONSTANT is not true).
709 The function climbs up the GNAT tree starting from the node and returns 1
710 upon encountering a node that effectively requires an lvalue downstream.
711 It returns int instead of bool to facilitate usage in non-purely binary
712 logic contexts. */
714 static int
717 {
721 {
734 /* Only the array expression can require an lvalue. */
738 /* ??? Consider that referencing an indexed component with a
739 non-constant index forces the whole aggregate to memory.
740 Note that N_Integer_Literal is conservative, any static
741 expression in the RM sense could probably be accepted. */
748 /* ... fall through ... */
751 /* Only the array expression can require an lvalue. */
763 /* We need to make a real renaming only if the constant object is
764 aliased or if we may use a renaming pointer; otherwise we can
765 optimize and return the rvalue. We make an exception if the object
766 is an identifier since in this case the rvalue can be propagated
767 attached to the CONST_DECL. */
769 || aliased
770 /* This should match the constant case of the renaming code. */
771 || Is_Composite_Type
776 /* We cannot use a constructor if this is an atomic object because
777 the actual assignment might end up being done component-wise. */
782 /* We cannot use a constructor if the LHS is an atomic object because
783 the actual assignment might end up being done component-wise. */
789 /* Returning 0 is very likely correct but we get better code if we
790 go through the conversion. */
797 }
800 }
802 /* Subroutine of gnat_to_gnu to translate gnat_node, an N_Identifier,
803 to a GCC tree, which is returned. GNU_RESULT_TYPE_P is a pointer
804 to where we should place the result type. */
806 static tree
808 {
812 /* Whether we should require an lvalue for GNAT_NODE. Needed in
813 specific circumstances only, so evaluated lazily. < 0 means
814 unknown, > 0 means known true, 0 means known false. */
817 /* If GNAT_NODE is a constant, whether we should use the initialization
818 value instead of the constant entity, typically for scalars with an
819 address clause when the parent doesn't require an lvalue. */
822 /* If the Etype of this node does not equal the Etype of the Entity,
823 something is wrong with the entity map, probably in generic
824 instantiation. However, this does not apply to types. Since we sometime
825 have strange Ekind's, just do this test for objects. Also, if the Etype of
826 the Entity is private, the Etype of the N_Identifier is allowed to be the
827 full type and also we consider a packed array type to be the same as the
828 original type. Similarly, a class-wide type is equivalent to a subtype of
829 itself. Finally, if the types are Itypes, one may be a copy of the other,
830 which is also legal. */
853 /* If this is a reference to a deferred constant whose partial view is an
854 unconstrained private type, the proper type is on the full view of the
855 constant, not on the full view of the type, which may be unconstrained.
857 This may be a reference to a type, for example in the prefix of the
858 attribute Position, generated for dispatching code (see Make_DT in
859 exp_disp,adb). In that case we need the type itself, not is parent,
860 in particular if it is a derived type */
865 {
868 }
869 else
870 {
871 /* We want to use the Actual_Subtype if it has already been elaborated,
872 otherwise the Etype. Avoid using Actual_Subtype for packed arrays to
873 simplify things. */
881 else
883 }
885 /* Expand the type of this identifier first, in case it is an enumeral
886 literal, which only get made when the type is expanded. There is no
887 order-of-elaboration issue here. */
890 /* If this is a non-imported scalar constant with an address clause,
891 retrieve the value instead of a pointer to be dereferenced unless
892 an lvalue is required. This is generally more efficient and actually
893 required if this is a static expression because it might be used
894 in a context where a dereference is inappropriate, such as a case
895 statement alternative or a record discriminant. There is no possible
896 volatile-ness short-circuit here since Volatile constants must bei
897 imported per C.6. */
901 {
905 }
908 {
909 /* If this is a deferred constant, the initializer is attached to
910 the full view. */
915 }
916 else
919 /* If we are in an exception handler, force this variable into memory to
920 ensure optimization does not remove stores that appear redundant but are
921 actually needed in case an exception occurs.
923 ??? Note that we need not do this if the variable is declared within the
924 handler, only if it is referenced in the handler and declared in an
925 enclosing block, but we have no way of testing that right now.
927 ??? We used to essentially set the TREE_ADDRESSABLE flag on the variable
928 here, but it can now be removed by the Tree aliasing machinery if the
929 address of the variable is never taken. All we can do is to make the
930 variable volatile, which might incur the generation of temporaries just
931 to access the memory in some circumstances. This can be avoided for
932 variables of non-constant size because they are automatically allocated
933 to memory. There might be no way of allocating a proper temporary for
934 them in any case. We only do this for SJLJ though. */
940 /* Some objects (such as parameters passed by reference, globals of
941 variable size, and renamed objects) actually represent the address
942 of the object. In that case, we must do the dereference. Likewise,
943 deal with parameters to foreign convention subprograms. */
948 {
950 tree renamed_obj;
954 gnu_result
957 gnu_result));
959 /* If it's a renaming pointer and we are at the right binding level,
960 we can reference the renamed object directly, since the renamed
961 expression has been protected against multiple evaluations. */
968 /* Return the underlying CST for a CONST_DECL like a few lines below,
969 after dereferencing in this case. */
974 else
979 }
981 /* The GNAT tree has the type of a function as the type of its result. Also
982 use the type of the result if the Etype is a subtype which is nominally
983 unconstrained. But remove any padding from the resulting type. */
986 {
990 }
992 /* If we have a constant declaration and its initializer at hand,
993 try to return the latter to avoid the need to call fold in lots
994 of places and the need of elaboration code if this Id is used as
995 an initializer itself. */
999 {
1003 /* If there is a (corresponding) variable, we only want to return
1004 the constant value if an lvalue is not required. Evaluate this
1005 now if we have not already done so. */
1012 }
1016 }
1017 \f
1018 /* Subroutine of gnat_to_gnu to process gnat_node, an N_Pragma. Return
1019 any statements we generate. */
1021 static tree
1023 {
1024 Node_Id gnat_temp;
1027 /* Check for (and ignore) unrecognized pragma and do nothing if we are just
1028 annotating types. */
1034 {
1036 /* Do nothing at top level: all such variables are already viewable. */
1043 {
1049 #ifdef ASM_COMMENT_START
1051 #endif
1056 /* Use the value only if it fits into a normal register,
1057 otherwise use the address. */
1066 #ifdef ASM_COMMENT_START
1072 NULL);
1075 #endif
1077 asm_constraint,
1078 NULL_TREE,
1079 tree_cons
1087 }
1093 {
1106 }
1113 }
1116 }
1117 \f
1118 /* Subroutine of gnat_to_gnu to translate GNAT_NODE, an N_Attribute node,
1119 to a GCC tree, which is returned. GNU_RESULT_TYPE_P is a pointer to
1120 where we should place the result type. ATTRIBUTE is the attribute ID. */
1122 static tree
1124 {
1130 /* If the input is a NULL_EXPR, make a new one. */
1132 {
1136 }
1139 {
1142 /* These are just conversions since representation clauses for
1143 enumeration types are handled in the front-end. */
1144 {
1150 }
1155 /* These just add or subtract the constant 1 since representation
1156 clauses for enumeration types are handled in the front-end. */
1161 {
1163 gnu_expr
1164 = emit_check
1166 gnu_expr,
1167 attribute == Attr_Pred
1171 }
1173 gnu_result
1181 /* Conversions don't change addresses but can cause us to miss the
1182 COMPONENT_REF case below, so strip them off. */
1186 /* If we are taking 'Address of an unconstrained object, this is the
1187 pointer to the underlying array. */
1191 /* If we are building a static dispatch table, we have to honor
1192 TARGET_VTABLE_USES_DESCRIPTORS if we want to be compatible
1193 with the C++ ABI. We do it in the non-static case as well,
1194 see gnat_to_gnu_entity, case E_Access_Subprogram_Type. */
1197 {
1199 /* Descriptors can only be built here for top-level functions. */
1205 /* If we're not going to build the descriptor, we have to retrieve
1206 the one which will be built by the linker (or by the compiler
1207 later if a static chain is requested). */
1209 {
1212 gnu_result);
1214 }
1219 {
1221 {
1225 }
1226 else
1231 }
1235 }
1237 /* ... fall through ... */
1243 gnu_result
1250 /* For 'Code_Address, find an inner ADDR_EXPR and mark it so that we
1251 don't try to build a trampoline. */
1253 {
1261 }
1263 /* For other address attributes applied to a nested function,
1264 find an inner ADDR_EXPR and annotate it so that we can issue
1265 a useful warning with -Wtrampolines. */
1267 {
1271 ;
1275 {
1278 /* Check that we're not violating the No_Implicit_Dynamic_Code
1279 restriction. Be conservative if we don't know anything
1280 about the trampoline strategy for the target. */
1282 }
1283 }
1287 {
1288 tree gnu_obj_type;
1293 /* If this is an unconstrained array, we know the object has been
1294 allocated with the template in front of the object. So compute
1295 the template address. */
1297 gnu_ptr
1299 (TYPE_OBJECT_RECORD_TYPE
1301 gnu_ptr);
1306 {
1309 tree gnu_byte_offset
1317 }
1320 }
1329 /* Remove NOPs and conversions between original and packable version
1330 from GNU_EXPR, and conversions from GNU_PREFIX. We use GNU_EXPR
1331 to see if a COMPONENT_REF was involved. */
1336 == RECORD_TYPE
1345 /* Replace an unconstrained array type with the type of the underlying
1346 array. We can't do this with a call to maybe_unconstrained_array
1347 since we may have a TYPE_DECL. For 'Max_Size_In_Storage_Elements,
1348 use the record type that will be used to allocate the object and its
1349 template. */
1351 {
1355 }
1357 /* If we're looking for the size of a field, return the field size.
1358 Otherwise, if the prefix is an object, or if we're looking for
1359 'Object_Size or 'Max_Size_In_Storage_Elements, the result is the
1360 GCC size of the type. Otherwise, it is the RM size of the type. */
1366 {
1367 /* If the prefix is an object of a padded type, the GCC size isn't
1368 relevant to the programmer. Normally what we want is the RM size,
1369 which was set from the specified size, but if it was not set, we
1370 want the size of the field. Using the MAX of those two produces
1371 the right result in all cases. Don't use the size of the field
1372 if it's self-referential, since that's never what's wanted. */
1376 {
1380 gnu_result
1383 }
1385 {
1387 Node_Id gnat_actual_subtype
1389 tree gnu_ptr_type
1394 {
1395 tree gnu_actual_obj_type
1397 gnu_type
1399 gnu_actual_obj_type,
1401 }
1404 }
1405 else
1407 }
1408 else
1413 /* Deal with a self-referential size by returning the maximum size for
1414 a type and by qualifying the size with the object for 'Size of an
1415 object. */
1417 {
1420 else
1422 }
1424 /* If the type contains a template, subtract its size. */
1438 {
1451 else
1452 {
1458 /* If the default alignment of "double" or larger scalar types is
1459 specifically capped and there is an alignment clause neither
1460 on the type nor on the prefix itself, return the cap. */
1462 is_capped_double
1465 is_capped_double
1467 else
1477 else
1479 }
1482 }
1491 {
1498 else
1499 gnu_result
1500 = build_binary_op
1502 build_binary_op
1514 }
1516 /* ... fall through ... */
1519 {
1526 /* Make sure any implicit dereference gets done. */
1529 /* We treat unconstrained array In parameters specially. */
1539 {
1541 tree gnu_type_temp;
1547 ;
1550 }
1557 /* When not optimizing, look up the slot associated with the parameter
1558 and the dimension in the cache and create a new one on failure. */
1560 {
1566 {
1571 }
1572 }
1574 /* Return the cached expression or build a new one. */
1576 {
1578 {
1581 }
1583 gnu_result
1585 }
1588 {
1590 {
1593 }
1595 gnu_result
1597 }
1600 {
1602 {
1605 }
1606 else
1607 {
1608 /* We used to compute the length as max (hb - lb + 1, 0),
1609 which could overflow for some cases of empty arrays, e.g.
1610 when lb == index_type'first. We now compute the length as
1611 (hb >= lb) ? hb - lb + 1 : 0, which would only overflow in
1612 much rarer cases, for extremely large arrays we expect
1613 never to encounter in practice. In addition, the former
1614 computation required the use of potentially constraining
1615 signed arithmetic while the latter doesn't. Note that
1616 the comparison must be done in the original index type,
1617 to avoid any overflow during the conversion. */
1622 gnu_result
1625 comp_type,
1629 gnu_result
1632 integer_type_node,
1634 gnu_result,
1636 }
1637 }
1639 /* If this has a PLACEHOLDER_EXPR, qualify it by the object we are
1640 handling. Note that these attributes could not have been used on
1641 an unconstrained array type. */
1644 /* Cache the expression we have just computed. Since we want to do it
1645 at runtime, we force the use of a SAVE_EXPR and let the gimplifier
1646 create the temporary. */
1648 {
1649 gnu_result
1656 else
1658 }
1660 /* Set the source location onto the predicate of the condition in the
1661 'Length case but do not do it if the expression is cached to avoid
1662 messing up the debug info. */
1667 gnat_node);
1670 }
1677 {
1678 HOST_WIDE_INT bitsize;
1679 HOST_WIDE_INT bitpos;
1680 tree gnu_offset;
1681 tree gnu_field_bitpos;
1682 tree gnu_field_offset;
1683 tree gnu_inner;
1691 /* We can have 'Bit on any object, but if it isn't a COMPONENT_REF,
1692 the result is 0. Don't allow 'Bit on a bare component, though. */
1696 {
1699 }
1701 else
1710 {
1718 {
1719 gnu_field_bitpos
1722 gnu_field_offset
1725 }
1726 }
1728 {
1731 }
1732 else
1733 {
1736 }
1739 {
1754 bitsize_one_node);
1760 }
1762 /* If this has a PLACEHOLDER_EXPR, qualify it by the object we are
1763 handling. */
1766 }
1770 {
1778 }
1804 /* Note this size cannot be self-referential. */
1811 /* This is just a zero cast to the pointer type for our prefix and
1812 dereferenced. */
1814 gnu_result
1817 integer_zero_node));
1822 {
1829 {
1834 ;
1835 }
1843 && (DECL_BY_COMPONENT_PTR_P
1847 }
1851 /* Say we have an unimplemented attribute. Then set the value to be
1852 returned to be a zero and hope that's something we can convert to
1853 the type of this attribute. */
1858 }
1860 /* If this is an attribute where the prefix was unused, force a use of it if
1861 it has a side-effect. But don't do it if the prefix is just an entity
1862 name. However, if an access check is needed, we must do it. See second
1863 example in AARM 11.6(5.e). */
1871 }
1872 \f
1873 /* Subroutine of gnat_to_gnu to translate gnat_node, an N_Case_Statement,
1874 to a GCC tree, which is returned. */
1876 static tree
1878 {
1879 tree gnu_result;
1880 tree gnu_expr;
1881 Node_Id gnat_when;
1886 /* The range of values in a case statement is determined by the rules in
1887 RM 5.4(7-9). In almost all cases, this range is represented by the Etype
1888 of the expression. One exception arises in the case of a simple name that
1889 is parenthesized. This still has the Etype of the name, but since it is
1890 not a name, para 7 does not apply, and we need to go to the base type.
1891 This is the only case where parenthesization affects the dynamic
1892 semantics (i.e. the range of possible values at runtime that is covered
1893 by the others alternative.
1895 Another exception is if the subtype of the expression is non-static. In
1896 that case, we also have to use the base type. */
1902 /* We build a SWITCH_EXPR that contains the code with interspersed
1903 CASE_LABEL_EXPRs for each label. */
1911 {
1913 Node_Id gnat_choice;
1915 /* First compile all the different case choices for the current WHEN
1916 alternative. */
1919 {
1923 {
1938 /* This represents either a subtype range or a static value of
1939 some kind; Ekind says which. */
1941 {
1947 }
1949 /* ... fall through ... */
1961 }
1963 /* If the case value is a subtype that raises Constraint_Error at
1964 run-time because of a wrong bound, then gnu_low or gnu_high is
1965 not translated into an INTEGER_CST. In such a case, we need
1966 to ensure that the when statement is not added in the tree,
1967 otherwise it will crash the gimplifier. */
1970 {
1975 gnat_choice);
1977 }
1978 }
1980 /* Push a binding level here in case variables are declared as we want
1981 them to be local to this set of statements instead of to the block
1982 containing the Case statement. */
1984 {
1988 }
1989 }
1991 /* Now emit a definition of the label all the cases branched to. */
1999 }
2000 \f
2001 /* Subroutine of gnat_to_gnu to translate gnat_node, an N_Loop_Statement,
2002 to a GCC tree, which is returned. */
2004 static tree
2006 {
2007 /* ??? It would be nice to use "build" here, but there's no build5. */
2013 tree gnu_result;
2022 /* Save the end label of this LOOP_STMT in a stack so that the corresponding
2023 N_Exit_Statement can find it. */
2027 /* Set the condition under which the loop must keep going.
2028 For the case "LOOP .... END LOOP;" the condition is always true. */
2030 ;
2032 /* For the case "WHILE condition LOOP ..... END LOOP;" it's immediate. */
2037 /* Otherwise we have an iteration scheme and the condition is given by
2038 the bounds of the subtype of the iteration variable. */
2039 else
2040 {
2051 /* We must disable modulo reduction for the loop variable, if any,
2052 in order for the loop comparison to be effective. */
2054 {
2060 }
2061 else
2062 {
2068 }
2070 /* We know the loop variable will not overflow if GNU_LAST is a constant
2071 and is not equal to GNU_LIMIT. If it might overflow, we have to move
2072 the limit test to the end of the loop. In that case, we have to test
2073 for an empty loop outside the loop. */
2077 {
2078 gnu_cond_expr
2084 }
2086 /* Open a new nesting level that will surround the loop to declare the
2087 loop index variable. */
2091 /* Declare the loop index and set it to its initial value. */
2096 /* The loop variable might be a padded type, so use `convert' to get a
2097 reference to the inner variable if so. */
2100 /* Set either the top or bottom exit condition as appropriate depending
2101 on whether or not we know an overflow cannot occur. */
2106 else
2113 gnu_loop_var,
2116 gnu_loop_var,
2118 integer_one_node)));
2120 gnat_iter_scheme);
2121 }
2123 /* If the loop was named, have the name point to this loop. In this case,
2124 the association is not a ..._DECL node, but the end label from this
2125 LOOP_STMT. */
2130 /* Make the loop body into its own block, so any allocated storage will be
2131 released every iteration. This is needed for stack allocation. */
2135 /* If we declared a variable, then we are in a statement group for that
2136 declaration. Add the LOOP_STMT to it and make that the "loop". */
2138 {
2142 }
2144 /* If we have an outer COND_EXPR, that's our result and this loop is its
2145 "true" statement. Otherwise, the result is the LOOP_STMT. */
2147 {
2151 }
2152 else
2158 }
2159 \f
2160 /* Emit statements to establish __gnat_handle_vms_condition as a VMS condition
2161 handler for the current function. */
2163 /* This is implemented by issuing a call to the appropriate VMS specific
2164 builtin. To avoid having VMS specific sections in the global gigi decls
2165 array, we maintain the decls of interest here. We can't declare them
2166 inside the function because we must mark them never to be GC'd, which we
2167 can only do at the global level. */
2172 static void
2174 {
2175 tree establish_stmt;
2177 /* Elaborate the required decls on the first call. Check on the decl for
2178 the gnat condition handler to decide, as this is one we create so we are
2179 sure that it will be non null on subsequent calls. The builtin decl is
2180 looked up so remains null on targets where it is not implemented yet. */
2182 {
2183 vms_builtin_establish_handler_decl
2184 = builtin_decl_for
2187 gnat_vms_condition_handler_decl
2189 NULL_TREE,
2191 ptr_void_type_node,
2192 ptr_void_type_node,
2193 NULL_TREE),
2196 /* ??? DECL_CONTEXT shouldn't have been set because of DECL_EXTERNAL. */
2198 }
2200 /* Do nothing if the establish builtin is not available, which might happen
2201 on targets where the facility is not implemented. */
2205 establish_stmt
2207 build_unary_op
2209 gnat_vms_condition_handler_decl));
2212 }
2213 \f
2214 /* Subroutine of gnat_to_gnu to process gnat_node, an N_Subprogram_Body. We
2215 don't return anything. */
2217 static void
2219 {
2220 /* Defining identifier of a parameter to the subprogram. */
2221 Entity_Id gnat_param;
2222 /* The defining identifier for the subprogram body. Note that if a
2223 specification has appeared before for this body, then the identifier
2224 occurring in that specification will also be a defining identifier and all
2225 the calls to this subprogram will point to that specification. */
2226 Entity_Id gnat_subprog_id
2229 /* The FUNCTION_DECL node corresponding to the subprogram spec. */
2230 tree gnu_subprog_decl;
2231 /* Its RESULT_DECL node. */
2232 tree gnu_result_decl;
2233 /* The FUNCTION_TYPE node corresponding to the subprogram spec. */
2234 tree gnu_subprog_type;
2235 tree gnu_cico_list;
2236 tree gnu_result;
2239 /* If this is a generic object or if it has been eliminated,
2240 ignore it. */
2246 /* If this subprogram acts as its own spec, define it. Otherwise, just get
2247 the already-elaborated tree node. However, if this subprogram had its
2248 elaboration deferred, we will already have made a tree node for it. So
2249 treat it as not being defined in that case. Such a subprogram cannot
2250 have an address clause or a freeze node, so this test is safe, though it
2251 does disable some otherwise-useful error checking. */
2252 gnu_subprog_decl
2259 /* If the function returns by invisible reference, make it explicit in the
2260 function body. See gnat_to_gnu_entity, E_Subprogram_Type case. */
2262 {
2266 }
2268 /* Propagate the debug mode. */
2272 /* Set the line number in the decl to correspond to that of the body so that
2273 the line number notes are written correctly. */
2276 /* Initialize the information structure for the function. */
2284 /* If there are Out parameters, we need to ensure that the return statement
2285 properly copies them out. We do this by making a new block and converting
2286 any inner return into a goto to a label at the end of the block. */
2291 /* Get a tree corresponding to the code for the subprogram. */
2295 /* See if there are any parameters for which we don't yet have GCC entities.
2296 These must be for Out parameters for which we will be making VAR_DECL
2297 nodes here. Fill them in to TYPE_CI_CO_LIST, which must contain the empty
2298 entry as well. We can match up the entries because TYPE_CI_CO_LIST is in
2299 the order of the parameters. */
2304 {
2305 /* Skip any entries that have been already filled in; they must
2306 correspond to In Out parameters. */
2309 ;
2311 /* Do any needed references for padded types. */
2315 }
2317 /* On VMS, establish our condition handler to possibly turn a condition into
2318 the corresponding exception if the subprogram has a foreign convention or
2319 is exported.
2321 To ensure proper execution of local finalizations on condition instances,
2322 we must turn a condition into the corresponding exception even if there
2323 is no applicable Ada handler, and need at least one condition handler per
2324 possible call chain involving GNAT code. OTOH, establishing the handler
2325 has a cost so we want to minimize the number of subprograms into which
2326 this happens. The foreign or exported condition is expected to satisfy
2327 all the constraints. */
2335 /* Generate the code of the subprogram itself. A return statement will be
2336 present and any Out parameters will be handled there. */
2341 /* If we populated the parameter attributes cache, we need to make sure
2342 that the cached expressions are evaluated on all possible paths. */
2345 {
2352 {
2359 }
2363 }
2365 /* If we are dealing with a return from an Ada procedure with parameters
2366 passed by copy-in/copy-out, we need to return a record containing the
2367 final values of these parameters. If the list contains only one entry,
2368 return just that entry though.
2370 For a full description of the copy-in/copy-out parameter mechanism, see
2371 the part of the gnat_to_gnu_entity routine dealing with the translation
2372 of subprograms.
2374 We need to make a block that contains the definition of that label and
2375 the copying of the return value. It first contains the function, then
2376 the label and copy statement. */
2378 {
2379 tree gnu_retval;
2390 else
2392 gnu_cico_list);
2398 }
2402 /* Set the end location. */
2403 Sloc_to_locus
2411 /* Finally annotate the parameters and disconnect the trees for parameters
2412 that we have turned into variables since they are now unusable. */
2416 {
2422 }
2428 }
2429 \f
2430 /* Subroutine of gnat_to_gnu to translate gnat_node, either an N_Function_Call
2431 or an N_Procedure_Call_Statement, to a GCC tree, which is returned.
2432 GNU_RESULT_TYPE_P is a pointer to where we should place the result type.
2433 If GNU_TARGET is non-null, this must be a function call and the result
2434 of the call is to be placed into that object. */
2436 static tree
2438 {
2439 /* The GCC node corresponding to the GNAT subprogram name. This can either
2440 be a FUNCTION_DECL node if we are dealing with a standard subprogram call,
2441 or an indirect reference expression (an INDIRECT_REF node) pointing to a
2442 subprogram. */
2444 /* The FUNCTION_TYPE node giving the GCC type of the subprogram. */
2447 Entity_Id gnat_formal;
2448 Node_Id gnat_actual;
2453 tree gnu_call;
2457 /* If we are calling a stubbed function, raise Program_Error, but Elaborate
2458 all our args first. */
2460 {
2470 {
2473 }
2476 }
2478 /* The only way we can be making a call via an access type is if Name is an
2479 explicit dereference. In that case, get the list of formal args from the
2480 type the access type is pointing to. Otherwise, get the formals from the
2481 entity being called. */
2485 /* Assume here that this must be 'Elab_Body or 'Elab_Spec. */
2487 else
2490 /* Create the list of the actual parameters as GCC expects it, namely a
2491 chain of TREE_LIST nodes in which the TREE_VALUE field of each node
2492 is an expression and the TREE_PURPOSE field is null. But skip Out
2493 parameters not passed by reference and that need not be copied in. */
2498 {
2502 /* In the Out or In Out case, we must suppress conversions that yield
2503 an lvalue but can nevertheless cause the creation of a temporary,
2504 because we need the real object in this case, either to pass its
2505 address if it's passed by reference or as target of the back copy
2506 done after the call if it uses the copy-in copy-out mechanism.
2507 We do it in the In case too, except for an unchecked conversion
2508 because it alone can cause the actual to be misaligned and the
2509 addressability test is applied to the real object. */
2510 bool suppress_type_conversion
2515 Node_Id gnat_name = suppress_type_conversion
2518 tree gnu_actual;
2520 /* If it's possible we may need to use this expression twice, make sure
2521 that any side-effects are handled via SAVE_EXPRs; likewise if we need
2522 to force side-effects before the call.
2523 ??? This is more conservative than we need since we don't need to do
2524 this for pass-by-ref with no conversion. */
2528 /* If we are passing a non-addressable parameter by reference, pass the
2529 address of a copy. In the Out or In Out case, set up to copy back
2530 out after the call. */
2538 {
2541 /* If the type is passed by reference, a copy is not allowed. */
2544 post_error
2547 /* For users of Starlet we issue a warning because the interface
2548 apparently assumes that by-ref parameters outlive the procedure
2549 invocation. The code still will not work as intended, but we
2550 cannot do much better since low-level parts of the back-end
2551 would allocate temporaries at will because of the misalignment
2552 if we did not do so here. */
2554 {
2555 post_error
2557 post_error_ne
2561 gnat_formal);
2562 }
2564 /* If the actual type of the object is already the nominal type,
2565 we have nothing to do, except if the size is self-referential
2566 in which case we'll remove the unpadding below. */
2569 ;
2571 /* Otherwise remove unpadding from the object and reset the copy. */
2573 && TYPE_IS_PADDING_P
2577 /* Otherwise convert to the nominal type of the object if it's
2578 a record type. There are several cases in which we need to
2579 make the temporary using this type instead of the actual type
2580 of the object if they are distinct, because the expectations
2581 of the callee would otherwise not be met:
2582 - if it's a justified modular type,
2583 - if the actual type is a smaller packable version of it. */
2587 gnu_name_type)))
2590 /* Make a SAVE_EXPR to force the creation of a temporary. Special
2591 code in gnat_gimplify_expr ensures that the same temporary is
2592 used as the object and copied back after the call if needed. */
2596 /* Set up to move the copy back to the original if needed. */
2598 {
2600 gnu_name);
2603 }
2604 }
2606 /* Start from the real object and build the actual. */
2609 /* If this was a procedure call, we may not have removed any padding.
2610 So do it here for the part we will use as an input, if any. */
2613 gnu_actual
2616 /* Put back the conversion we suppressed above in the computation of the
2617 real object. And even if we didn't suppress any conversion there, we
2618 may have suppressed a conversion to the Etype of the actual earlier,
2619 since the parent is a procedure call, so put it back here. */
2622 gnu_actual
2625 else
2626 gnu_actual
2629 /* Make sure that the actual is in range of the formal's type. */
2632 gnu_actual
2635 /* And convert it to this type. */
2639 /* Unless this is an In parameter, we must remove any justified modular
2640 building from GNU_NAME to get an lvalue. */
2645 gnu_name
2648 /* If we have not saved a GCC object for the formal, it means it is an
2649 Out parameter not passed by reference and that need not be copied in.
2650 Otherwise, first see if the PARM_DECL is passed by reference. */
2654 {
2656 {
2657 /* In Out or Out parameters passed by reference don't use the
2658 copy-in copy-out mechanism so the address of the real object
2659 must be passed to the function. */
2662 /* If we have a padded type, be sure we've removed padding. */
2666 gnu_actual);
2668 /* If we have the constructed subtype of an aliased object
2669 with an unconstrained nominal subtype, the type of the
2670 actual includes the template, although it is formally
2671 constrained. So we need to convert it back to the real
2672 constructed subtype to retrieve the constrained part
2673 and takes its address. */
2680 gnu_actual);
2681 }
2683 /* The symmetry of the paths to the type of an entity is broken here
2684 since arguments don't know that they will be passed by ref. */
2687 }
2691 {
2697 {
2700 }
2702 /* Take the address of the object and convert to the proper pointer
2703 type. We'd like to actually compute the address of the beginning
2704 of the array using an ADDR_EXPR of an ARRAY_REF, but there's a
2705 possibility that the ARRAY_REF might return a constant and we'd be
2706 getting the wrong address. Neither approach is exactly correct,
2707 but this is the most likely to work in all cases. */
2710 gnu_actual));
2711 }
2715 {
2716 /* If this is 'Null_Parameter, pass a zero descriptor. */
2720 gnu_actual
2722 else
2725 gnat_formal,
2726 gnat_actual));
2727 }
2728 else
2729 {
2730 tree gnu_size;
2738 /* If this is 'Null_Parameter, pass a zero even though we are
2739 dereferencing it. */
2745 gnu_actual
2749 integer_zero_node),
2751 else
2753 }
2756 }
2762 /* If it's a function call, the result is the call expression unless a target
2763 is specified, in which case we copy the result into the target and return
2764 the assignment statement. */
2766 {
2770 /* If the function returns an unconstrained array or by direct reference,
2771 we have to dereference the pointer. */
2777 {
2778 /* ??? If the return type has non-constant size, then force the
2779 return slot optimization as we would not be able to generate
2780 a temporary. That's what has been done historically. */
2783 else
2786 gnu_result
2788 }
2789 else
2793 }
2795 /* If this is the case where the GNAT tree contains a procedure call but the
2796 Ada procedure has copy-in/copy-out parameters, then the special parameter
2797 passing mechanism must be used. */
2799 {
2800 /* List of FIELD_DECLs associated with the PARM_DECLs of the copy
2801 in copy out parameters. */
2806 {
2807 tree gnu_name;
2809 /* The call sequence must contain one and only one call, even though
2810 the function is const or pure. So force a SAVE_EXPR. */
2815 /* If any of the names had side-effects, ensure they are all
2816 evaluated before the call. */
2818 gnu_name;
2823 }
2827 else
2834 /* If we are dealing with a copy in copy out parameter, we must
2835 retrieve its value from the record returned in the call. */
2841 || (DECL_BY_DESCRIPTOR_P
2844 {
2845 /* Get the value to assign to this Out or In Out parameter. It is
2846 either the result of the function if there is only a single such
2847 parameter or the appropriate field from the record returned. */
2848 tree gnu_result
2850 ? gnu_call
2855 /* If the actual is a conversion, get the inner expression, which
2856 will be the real destination, and convert the result to the
2857 type of the actual parameter. */
2858 tree gnu_actual
2861 /* If the result is a padded type, remove the padding. */
2863 gnu_result
2865 gnu_result);
2867 /* If the actual is a type conversion, the real target object is
2868 denoted by the inner Expression and we need to convert the
2869 result to the associated type.
2870 We also need to convert our gnu assignment target to this type
2871 if the corresponding GNU_NAME was constructed from the GNAT
2872 conversion node and not from the inner Expression. */
2874 {
2875 gnu_result
2876 = convert_with_check
2884 }
2886 /* Unchecked conversions as actuals for Out parameters are not
2887 allowed in user code because they are not variables, but do
2888 occur in front-end expansions. The associated GNU_NAME is
2889 always obtained from the inner expression in such cases. */
2892 gnu_result,
2894 else
2895 {
2897 gnu_result
2899 gnat_actual);
2904 }
2906 /* Undo wrapping of boolean rvalues. */
2909 == BOOLEAN_TYPE
2918 }
2919 }
2920 else
2926 }
2927 \f
2928 /* Subroutine of gnat_to_gnu to translate gnat_node, an
2929 N_Handled_Sequence_Of_Statements, to a GCC tree, which is returned. */
2931 static tree
2933 {
2936 /* If just annotating, ignore all EH and cleanups. */
2940 bool setjmp_longjmp
2946 tree gnu_result;
2947 tree gnu_expr;
2948 Node_Id gnat_temp;
2950 /* The GCC exception handling mechanism can handle both ZCX and SJLJ schemes
2951 and we have our own SJLJ mechanism. To call the GCC mechanism, we call
2952 add_cleanup, and when we leave the binding, end_stmt_group will create
2953 the TRY_FINALLY_EXPR.
2955 ??? The region level calls down there have been specifically put in place
2956 for a ZCX context and currently the order in which things are emitted
2957 (region/handlers) is different from the SJLJ case. Instead of putting
2958 other calls with different conditions at other places for the SJLJ case,
2959 it seems cleaner to reorder things for the SJLJ case and generalize the
2960 condition to make it not ZCX specific.
2962 If there are any exceptions or cleanup processing involved, we need an
2963 outer statement group (for Setjmp_Longjmp) and binding level. */
2965 {
2968 }
2970 /* If using setjmp_longjmp, make the variables for the setjmp buffer and save
2971 area for address of previous buffer. Do this first since we need to have
2972 the setjmp buf known for any decls in this block. */
2974 {
2979 gnat_node);
2982 /* The __builtin_setjmp receivers will immediately reinstall it. Now
2983 because of the unstructured form of EH used by setjmp_longjmp, there
2984 might be forward edges going to __builtin_setjmp receivers on which
2985 it is uninitialized, although they will never be actually taken. */
2995 /* When we exit this block, restore the saved value. */
2998 }
3000 /* If we are to call a function when exiting this block, add a cleanup
3001 to the binding level we made above. Note that add_cleanup is FIFO
3002 so we must register this cleanup after the EH cleanup just above. */
3007 /* Now build the tree for the declarations and statements inside this block.
3008 If this is SJLJ, set our jmp_buf as the current buffer. */
3014 gnu_jmpbuf_decl)));
3020 /* Generate code for each statement in the block. */
3028 /* Now generate code for the two exception models, if either is relevant for
3029 this block. */
3031 {
3033 tree gnu_handler;
3035 /* Make a binding level for the exception handling declarations and code
3036 and set up gnu_except_ptr_stack for the handlers to use. */
3042 NULL_TREE,
3047 /* Generate code for each handler. The N_Exception_Handler case does the
3048 real work and returns a COND_EXPR for each handler, which we chain
3049 together here. */
3052 {
3055 /* If this is the first one, set it as the outer one. Otherwise,
3056 point the "else" part of the previous handler to us. Then point
3057 to our "else" part. */
3060 else
3064 }
3066 /* If none of the exception handlers did anything, re-raise but do not
3067 defer abortion. */
3070 set_expr_location_from_node
3076 else
3079 /* End the binding level dedicated to the exception handlers and get the
3080 whole statement group. */
3085 /* If the setjmp returns 1, we restore our incoming longjmp value and
3086 then check the handlers. */
3089 gnu_jmpsave_decl),
3090 gnat_node);
3094 /* This block is now "if (setjmp) ... <handlers> else <block>". */
3096 (build_call_1_expr
3099 gnu_jmpbuf_decl))),
3101 }
3103 {
3104 tree gnu_handlers;
3106 /* First make a block containing the handlers. */
3114 /* Now make the TRY_CATCH_EXPR for the block. */
3117 }
3118 else
3121 /* Now close our outer block, if we had to make one. */
3123 {
3127 }
3130 }
3131 \f
3132 /* Subroutine of gnat_to_gnu to translate gnat_node, an N_Exception_Handler,
3133 to a GCC tree, which is returned. This is the variant for Setjmp_Longjmp
3134 exception handling. */
3136 static tree
3138 {
3139 /* Unless this is "Others" or the special "Non-Ada" exception for Ada, make
3140 an "if" statement to select the proper exceptions. For "Others", exclude
3141 exceptions where Handled_By_Others is nonzero unless the All_Others flag
3142 is set. For "Non-ada", accept an exception if "Lang" is 'V'. */
3145 Node_Id gnat_temp;
3149 {
3150 tree this_choice;
3153 {
3156 else
3157 this_choice
3158 = build_binary_op
3160 convert
3162 build_component_ref
3163 (build_unary_op
3168 integer_zero_node);
3169 }
3173 {
3175 tree gnu_expr;
3177 /* Exception may be a renaming. Recover original exception which is
3178 the one elaborated and registered. */
3184 this_choice
3185 = build_binary_op
3190 /* If this is the distinguished exception "Non_Ada_Error" (and we are
3191 in VMS mode), also allow a non-Ada exception (a VMS condition) t
3192 match. */
3194 {
3195 tree gnu_comp
3196 = build_component_ref
3201 this_choice
3202 = build_binary_op
3206 this_choice);
3207 }
3208 }
3209 else
3214 }
3217 }
3218 \f
3219 /* Subroutine of gnat_to_gnu to translate gnat_node, an N_Exception_Handler,
3220 to a GCC tree, which is returned. This is the variant for ZCX. */
3222 static tree
3224 {
3226 tree gnu_expr;
3227 tree gnu_etype;
3228 tree gnu_current_exc_ptr;
3229 tree gnu_incoming_exc_ptr;
3230 Node_Id gnat_temp;
3232 /* We build a TREE_LIST of nodes representing what exception types this
3233 handler can catch, with special cases for others and all others cases.
3235 Each exception type is actually identified by a pointer to the exception
3236 id, or to a dummy object for "others" and "all others".
3238 Care should be taken to ensure that the control flow impact of "others"
3239 and "all others" is known to GCC. lang_eh_type_covers is doing the trick
3240 currently. */
3243 {
3245 {
3246 tree gnu_expr
3249 gnu_etype
3251 }
3254 {
3257 /* Exception may be a renaming. Recover original exception which is
3258 the one elaborated and registered. */
3265 /* The Non_Ada_Error case for VMS exceptions is handled
3266 by the personality routine. */
3267 }
3268 else
3271 /* The GCC interface expects NULL to be passed for catch all handlers, so
3272 it would be quite tempting to set gnu_etypes_list to NULL if gnu_etype
3273 is integer_zero_node. It would not work, however, because GCC's
3274 notion of "catch all" is stronger than our notion of "others". Until
3275 we correctly use the cleanup interface as well, doing that would
3276 prevent the "all others" handlers from being seen, because nothing
3277 can be caught beyond a catch all from GCC's point of view. */
3279 }
3284 /* Expand a call to the begin_handler hook at the beginning of the handler,
3285 and arrange for a call to the end_handler hook to occur on every possible
3286 exit path.
3288 The hooks expect a pointer to the low level occurrence. This is required
3289 for our stack management scheme because a raise inside the handler pushes
3290 a new occurrence on top of the stack, which means that this top does not
3291 necessarily match the occurrence this handler was dealing with.
3293 __builtin_eh_pointer references the exception occurrence being
3294 propagated. Upon handler entry, this is the exception for which the
3295 handler is triggered. This might not be the case upon handler exit,
3296 however, as we might have a new occurrence propagated by the handler's
3297 body, and the end_handler hook called as a cleanup in this context.
3299 We use a local variable to retrieve the incoming value at handler entry
3300 time, and reuse it to feed the end_handler hook's argument at exit. */
3302 gnu_current_exc_ptr
3308 gnat_node);
3311 gnu_incoming_exc_ptr),
3312 gnat_node);
3313 /* ??? We don't seem to have an End_Label at hand to set the location. */
3315 Empty);
3321 }
3322 \f
3323 /* Subroutine of gnat_to_gnu to generate code for an N_Compilation unit. */
3325 static void
3327 {
3328 /* Make the decl for the elaboration procedure. */
3333 tree gnu_elab_proc_decl
3334 = create_subprog_decl
3338 gnat_unit_entity);
3348 /* For a body, first process the spec if there is one. */
3352 {
3355 }
3360 {
3367 }
3373 /* Process any pragmas and actions following the unit. */
3378 /* Save away what we've made so far and record this potential elaboration
3379 procedure. */
3389 /* Generate elaboration code for this unit, if necessary, and say whether
3390 we did or not. */
3393 /* Invalidate the global renaming pointers. This is necessary because
3394 stabilization of the renamed entities may create SAVE_EXPRs which
3395 have been tied to a specific elaboration routine just above. */
3397 }
3398 \f
3399 /* Return true if GNAT_NODE, an unchecked type conversion, is a no-op as far
3400 as gigi is concerned. This is used to avoid conversions on the LHS. */
3402 static bool
3404 {
3407 /* The conversion must be on the LHS of an assignment or an actual parameter
3408 of a call. Otherwise, even if the conversion was essentially a no-op, it
3409 could de facto ensure type consistency and this should be preserved. */
3418 /* We're interested in artificial conversions generated by the front-end
3419 to make private types explicit, e.g. in Expand_Assign_Array. */
3426 /* The direct conversion to the underlying type is a no-op. */
3430 /* For an array type, the conversion to the PAT is a no-op. */
3436 }
3438 /* This function is the driver of the GNAT to GCC tree transformation process.
3439 It is the entry point of the tree transformer. GNAT_NODE is the root of
3440 some GNAT tree. Return the root of the corresponding GCC tree. If this
3441 is an expression, return the GCC equivalent of the expression. If this
3442 is a statement, return the statement or add it to the current statement
3443 group, in which case anything returned is to be interpreted as occurring
3444 after anything added. */
3446 tree
3448 {
3454 Node_Id gnat_temp;
3456 /* Save node number for error message and set location information. */
3460 /* If this node is a statement and we are only annotating types, return an
3461 empty statement list. */
3465 /* If this node is a non-static subexpression and we are only annotating
3466 types, make this into a NULL_EXPR. */
3473 N_Raise_Constraint_Error));
3483 {
3484 /* If this is a statement and we are at top level, it must be part of
3485 the elaboration procedure, so mark us as being in that procedure
3486 and push our context. */
3488 {
3493 }
3495 /* If we are in the elaboration procedure, check if we are violating a
3496 No_Elaboration_Code restriction by having a statement there. Don't
3497 check for a possible No_Elaboration_Code restriction violation on
3498 N_Handled_Sequence_Of_Statements, as we want to signal an error on
3499 every nested real statement instead. This also avoids triggering
3500 spurious errors on dummy (empty) sequences created by the front-end
3501 for package bodies in some cases. */
3505 }
3508 {
3509 /********************************/
3510 /* Chapter 2: Lexical Elements */
3511 /********************************/
3521 {
3522 tree gnu_type;
3524 /* Get the type of the result, looking inside any padding and
3525 justified modular types. Then get the value in that type. */
3534 /* If the result overflows (meaning it doesn't fit in its base type),
3535 abort. We would like to check that the value is within the range
3536 of the subtype, but that causes problems with subtypes whose usage
3537 will raise Constraint_Error and with biased representation, so
3538 we don't. */
3540 }
3544 /* If a Entity is present, it means that this was one of the
3545 literals in a user-defined character type. In that case,
3546 just return the value in the CONST_DECL. Otherwise, use the
3547 character code. In that case, the base type should be an
3548 INTEGER_TYPE, but we won't bother checking for that. */
3552 else
3553 gnu_result
3554 = build_int_cst_type
3559 /* If this is of a fixed-point type, the value we want is the
3560 value of the corresponding integer. */
3562 {
3565 gnu_result_type);
3567 }
3569 /* We should never see a Vax_Float type literal, since the front end
3570 is supposed to transform these using appropriate conversions. */
3574 else
3575 {
3580 /* If the real value is zero, so is the result. Otherwise,
3581 convert it to a machine number if it isn't already. That
3582 forces BASE to 0 or 2 and simplifies the rest of our logic. */
3585 else
3586 {
3588 ur_realval
3592 gnu_result
3595 /* If we have a base of zero, divide by the denominator.
3596 Otherwise, the base must be 2 and we scale the value, which
3597 we know can fit in the mantissa of the type (hence the use
3598 of that type above). */
3600 gnu_result
3603 gnu_result,
3605 gnu_result_type));
3606 else
3607 {
3608 REAL_VALUE_TYPE tmp;
3614 }
3615 }
3617 /* Now see if we need to negate the result. Do it this way to
3618 properly handle -0. */
3620 gnu_result
3622 gnu_result);
3623 }
3630 {
3637 else
3640 /* Build the string with the characters in the literal. Note
3641 that Ada strings are 1-origin. */
3645 /* Put a null at the end of the string in case it's in a context
3646 where GCC will want to treat it as a C string. */
3651 /* Strings in GCC don't normally have types, but we want
3652 this to not be converted to the array type. */
3657 }
3658 else
3659 {
3660 /* Build a list consisting of each character, then make
3661 the aggregate. */
3669 {
3670 gnu_list
3675 gnu_list);
3679 }
3681 gnu_result
3683 }
3690 /**************************************/
3691 /* Chapter 3: Declarations and Types */
3692 /**************************************/
3709 /* If we are just annotating types and this object has an unconstrained
3710 or task type, don't elaborate it. */
3720 && (!type_annotate_only
3722 {
3725 gnu_expr
3728 /* If this object has its elaboration delayed, we must force
3729 evaluation of GNU_EXPR right now and save it for when the object
3730 is frozen. */
3732 {
3735 gnu_expr
3740 else
3744 }
3745 }
3746 else
3752 /* If this is a deferred constant with an address clause, we ignore the
3753 full view since the clause is on the partial view and we cannot have
3754 2 different GCC trees for the object. The only bits of the full view
3755 we will use is the initializer, but it will be directly fetched. */
3768 /* Don't do anything if this renaming is handled by the front end or if
3769 we are just annotating types and this object has a composite or task
3770 type, don't elaborate it. We return the result in case it has any
3771 SAVE_EXPRs in it that need to be evaluated here. */
3773 && ! (type_annotate_only
3777 gnu_result
3780 else
3793 /* These are fully handled in the front end. */
3797 /*************************************/
3798 /* Chapter 4: Names and Expressions */
3799 /*************************************/
3808 {
3810 tree gnu_type;
3817 /* Convert vector inputs to their representative array type, to fit
3818 what the code below expects. */
3823 /* If we got a padded type, remove it too. */
3825 gnu_array_object
3827 gnu_array_object);
3831 /* First compute the number of dimensions of the array, then
3832 fill the expression array, the order depending on whether
3833 this is a Convention_Fortran array or not. */
3838 ;
3847 else
3855 {
3861 gnu_expr
3862 = emit_index_check
3866 gnat_temp);
3870 }
3871 }
3877 {
3879 tree gnu_type;
3884 /* Do any implicit dereferences of the prefix and do any needed
3885 range check. */
3890 {
3891 /* Get the bounds of the slice. */
3892 tree gnu_index_type
3896 /* Get the permitted bounds. */
3897 tree gnu_base_index_type
3899 tree gnu_base_min_expr = SUBSTITUTE_PLACEHOLDER_IN_EXPR
3901 tree gnu_base_max_expr = SUBSTITUTE_PLACEHOLDER_IN_EXPR
3908 /* Derive a good type to convert everything to. */
3911 /* Test whether the minimum slice value is too small. */
3914 gnu_min_expr),
3916 gnu_base_min_expr));
3918 /* Test whether the maximum slice value is too large. */
3921 gnu_max_expr),
3923 gnu_base_max_expr));
3925 /* Build a slice index check that returns the low bound,
3926 assuming the slice is not empty. */
3927 gnu_expr = emit_check
3932 /* Build a conditional expression that does the index checks and
3933 returns the low bound if the slice is not empty (max >= min),
3934 and returns the naked low bound otherwise (max < min), unless
3935 it is non-constant and the high bound is; this prevents VRP
3936 from inferring bogus ranges on the unlikely path. */
3940 gnu_max_expr),
3942 gnu_min_expr)),
3943 gnu_expr,
3947 }
3948 else
3949 /* Simply return the naked low bound. */
3952 /* If this is a slice with non-constant size of an array with constant
3953 size, set the maximum size for the allocation of temporaries. */
3960 }
3964 {
3968 tree gnu_field;
3972 {
3977 }
3981 /* For discriminant references in tagged types always substitute the
3982 corresponding discriminant as the actual selected component. */
3987 /* For discriminant references of untagged types always substitute the
3988 corresponding stored discriminant. */
3992 /* Handle extracting the real or imaginary part of a complex.
3993 The real part is the first field and the imaginary the last. */
3998 else
3999 {
4002 /* If there are discriminants, the prefix might be evaluated more
4003 than once, which is a problem if it has side-effects. */
4010 gnu_result
4014 && lvalue_required_for_attribute_p
4016 }
4020 }
4024 {
4025 /* The attribute designator (like an enumeration value). */
4028 /* The Elab_Spec and Elab_Body attributes are special in that
4029 Prefix is a unit, not an object with a GCC equivalent. Similarly
4030 for Elaborated, since that variable isn't otherwise known. */
4034 attribute == Attr_Elab_Body
4037 gnat_node));
4040 }
4044 /* Like 'Access as far as we are concerned. */
4052 {
4053 tree gnu_aggr_type;
4055 /* ??? It is wrong to evaluate the type now, but there doesn't
4056 seem to be any other practical way of doing it. */
4060 gnu_aggr_type = gnu_result_type
4065 gnu_aggr_type
4075 gnu_result
4078 gnu_aggr_type);
4081 gnu_aggr_type,
4084 gnu_result
4085 = build_binary_op
4090 (Next
4092 else
4096 }
4104 else
4111 /* Get the operand expression. */
4115 gnu_result
4119 kind == N_Type_Conversion
4126 /* Skip further processing if the conversion is deemed a no-op. */
4128 {
4131 }
4135 /* If the result is a pointer type, see if we are improperly
4136 converting to a stricter alignment. */
4139 {
4145 post_error_ne_tree_2
4149 }
4151 /* If we are converting a descriptor to a function pointer, first
4152 build the pointer. */
4164 {
4169 /* GNAT_RANGE is either an N_Range node or an identifier denoting a
4170 subtype. */
4172 {
4175 }
4178 {
4183 }
4184 else
4189 /* If LOW and HIGH are identical, perform an equality test. Otherwise,
4190 ensure that GNU_OBJ is evaluated only once and perform a full range
4191 test. */
4193 gnu_result
4195 else
4196 {
4205 gnu_result
4207 }
4211 }
4219 ? RDIV_EXPR
4226 /* These can either be operations on booleans or on modular types.
4227 Fall through for boolean types since that's the way GNU_CODES is
4228 set up. */
4230 Modular_Integer_Kind))
4231 {
4232 enum tree_code code
4243 }
4245 /* ... fall through ... */
4257 {
4260 tree gnu_type;
4266 /* Pending generic support for efficient vector logical operations in
4267 GCC, convert vectors to their representative array type view and
4268 fallthrough. */
4272 /* If this is a comparison operator, convert any references to
4273 an unconstrained array value into a reference to the
4274 actual array. */
4276 {
4279 }
4281 /* If the result type is a private type, its full view may be a
4282 numeric subtype. The representation we need is that of its base
4283 type, given that it is the result of an arithmetic operation. */
4285 gnu_type = gnu_result_type
4288 /* If this is a shift whose count is not guaranteed to be correct,
4289 we need to adjust the shift count. */
4291 {
4293 tree gnu_max_shift
4300 gnu_rhs
4301 = build_binary_op
4304 gnu_count_type,
4305 gnu_max_shift,
4307 integer_one_node)),
4308 gnu_rhs);
4309 }
4311 /* For right shifts, the type says what kind of shift to do,
4312 so we may need to choose a different type. In this case,
4313 we have to ignore integer overflow lest it propagates all
4314 the way down and causes a CE to be explicitly raised. */
4316 {
4319 }
4322 {
4325 }
4328 {
4334 }
4336 /* Instead of expanding overflow checks for addition, subtraction
4337 and multiplication itself, the front end will leave this to
4338 the back end when Backend_Overflow_Checks_On_Target is set.
4339 As the GCC back end itself does not know yet how to properly
4340 do overflow checking, do it here. The goal is to push
4341 the expansions further into the back end over time. */
4350 else
4353 /* If this is a logical shift with the shift count not verified,
4354 we must return zero if it is too large. We cannot compensate
4355 above in this case. */
4358 gnu_result
4359 = build_cond_expr
4362 gnu_rhs,
4366 gnu_result);
4367 }
4371 {
4374 tree gnu_false
4378 gnu_result
4380 }
4389 /* This case can apply to a boolean or a modular type.
4390 Fall through for a boolean operand since GNU_CODES is set
4391 up to handle this. */
4395 {
4399 gnu_expr);
4401 }
4403 /* ... fall through ... */
4410 else
4417 gnu_result
4420 else
4426 {
4428 tree gnu_type;
4433 /* The Expression operand can either be an N_Identifier or
4434 Expanded_Name, which must represent a type, or a
4435 N_Qualified_Expression, which contains both the object type and an
4436 initial value for the object. */
4441 {
4442 Entity_Id gnat_desig_type
4450 gnu_init
4455 {
4458 }
4459 else
4460 {
4466 }
4467 }
4468 else
4475 ignore_init_type);
4476 }
4479 /**************************/
4480 /* Chapter 5: Statements */
4481 /**************************/
4489 /* When not optimizing, turn null statements from source into gotos to
4490 the next statement that the middle-end knows how to preserve. */
4492 {
4502 }
4503 else
4508 /* Get the LHS and RHS of the statement and convert any reference to an
4509 unconstrained array into a reference to the underlying array.
4510 If we are not to do range checking and the RHS is an N_Function_Call,
4511 pass the LHS to the call function. */
4514 /* If the type has a size that overflows, convert this into raise of
4515 Storage_Error: execution shouldn't have gotten here anyway. */
4519 N_Raise_Storage_Error);
4524 else
4525 {
4526 gnu_rhs
4529 /* If range check is needed, emit code to generate it. */
4532 gnat_node);
4534 gnu_result
4537 /* If the type being assigned is an array type and the two sides
4538 are not completely disjoint, play safe and use memmove. */
4542 {
4556 }
4557 }
4561 {
4564 /* Make the outer COND_EXPR. Avoid non-determinism. */
4573 /* Now make a COND_EXPR for each of the "else if" parts. Put each
4574 into the previous "else" part and point to where to put any
4575 outer "else". Also avoid non-determinism. */
4579 {
4589 }
4592 }
4616 gnu_result
4626 {
4629 /* If we have a return label defined, convert this into a branch to
4630 that label. The return proper will be handled elsewhere. */
4632 {
4636 }
4638 /* If the subprogram is a function, we must return the expression. */
4640 {
4645 /* Do not remove the padding from GNU_RET_VAL if the inner type is
4646 self-referential since we want to allocate the fixed size. */
4648 && TYPE_IS_PADDING_P
4650 && CONTAINS_PLACEHOLDER_P
4654 /* If the subprogram returns by direct reference, return a pointer
4655 to the return value. */
4660 /* Otherwise, if it returns an unconstrained array, we have to
4661 allocate a new version of the result and return it. */
4663 {
4666 gnu_ret_val,
4671 }
4673 /* If the subprogram returns by invisible reference, dereference
4674 the pointer it is passed using the type of the return value
4675 and build the copy operation manually. This ensures that we
4676 don't copy too much data, for example if the return type is
4677 unconstrained with a maximum size. */
4679 {
4680 gnu_ret_obj
4682 gnu_result_decl);
4688 }
4690 /* Otherwise, build a regular return. */
4691 else
4693 }
4694 else
4695 {
4698 }
4701 }
4709 /***************************/
4710 /* Chapter 6: Subprograms */
4711 /***************************/
4714 /* Unless there is a freeze node, declare the subprogram. We consider
4715 this a "definition" even though we're not generating code for
4716 the subprogram because we will be making the corresponding GCC
4717 node here. */
4726 /* This subprogram doesn't exist for code generation purposes, but we
4727 have to elaborate the types of any parameters and result, unless
4728 they are imported types (nothing to generate in this case). */
4730 /* Process the parameter types first. */
4733 = First_Formal_With_Extras
4742 /* Then the result type, set to Standard_Void_Type for procedures. */
4744 {
4745 Entity_Id gnat_temp_type
4750 }
4756 /* For a child unit identifier go up a level to get the specification.
4757 We get this when we try to find the spec of a child unit package
4758 that is the compilation unit being compiled. */
4772 /************************/
4773 /* Chapter 7: Packages */
4774 /************************/
4790 /* If this is the body of a generic package - do nothing. */
4792 {
4795 }
4806 /********************************/
4807 /* Chapter 8: Visibility Rules */
4808 /********************************/
4812 /* Nothing to do here - but these may appear in list of declarations. */
4816 /*********************/
4817 /* Chapter 9: Tasks */
4818 /*********************/
4829 /*********************************************************/
4830 /* Chapter 10: Program Structure and Compilation Issues */
4831 /*********************************************************/
4835 /* This is not called for the main unit, which is handled in function
4836 gigi above. */
4848 /* Simply process whatever unit is being inserted. */
4856 /***************************/
4857 /* Chapter 11: Exceptions */
4858 /***************************/
4861 /* If there is an At_End procedure attached to this node, and the EH
4862 mechanism is SJLJ, we must have at least a corresponding At_End
4863 handler, unless the No_Exception_Handlers restriction is set. */
4878 else
4899 gnu_constraint_error_label_stack
4904 gnu_storage_error_label_stack
4909 gnu_program_error_label_stack
4913 /******************************/
4914 /* Chapter 12: Generic Units */
4915 /******************************/
4925 /* These nodes can appear on a declaration list but there is nothing to
4926 to be done with them. */
4930 /**************************************************/
4931 /* Chapter 13: Representation Clauses and */
4932 /* Implementation-Dependent Features */
4933 /**************************************************/
4938 /* The only one we need to deal with is 'Address since, for the others,
4939 the front-end puts the information elsewhere. */
4943 /* And we only deal with 'Address if the object has a Freeze node. */
4948 /* Get the value to use as the address and save it as the equivalent
4949 for the object. When it is frozen, gnat_to_gnu_entity will do the
4950 right thing. */
4957 /* We do nothing with these. SEM puts the information elsewhere. */
4963 {
4973 /* First retrieve the 3 operand lists built by the front-end. */
4976 {
4983 }
4987 {
4994 }
4998 gnu_clobbers
5001 gnu_clobbers);
5003 /* Then perform some standard checking and processing on the
5004 operands. In particular, mark them addressable if needed. */
5009 oconstraints
5013 {
5015 constraint
5021 {
5022 /* If the operand is going to end up in memory,
5023 mark it addressable. Note that we don't test
5024 allows_mem like in the input case below; this
5025 is modelled on the C front-end. */
5029 }
5030 else
5034 }
5037 {
5039 constraint
5045 {
5046 /* If the operand is going to end up in memory,
5047 mark it addressable. */
5051 }
5052 else
5056 }
5062 }
5063 else
5068 /****************/
5069 /* Added Nodes */
5070 /****************/
5088 {
5091 tree gnu_obj_type;
5093 tree gnu_obj_size;
5095 /* If this is a thin pointer, we must dereference it to create
5096 a fat pointer, then go back below to a thin pointer. The
5097 reason for this is that we need a fat pointer someplace in
5098 order to properly compute the size. */
5102 gnu_ptr));
5104 /* If this is an unconstrained array, we know the object must
5105 have been allocated with the template in front of the object.
5106 So pass the template address, but get the total size. Do this
5107 by converting to a thin pointer. */
5109 gnu_ptr
5111 (TYPE_OBJECT_RECORD_TYPE
5113 gnu_ptr);
5118 {
5119 gnu_actual_obj_type
5123 gnu_actual_obj_type
5125 gnu_actual_obj_type,
5127 }
5128 else
5135 {
5138 tree gnu_byte_offset
5146 }
5148 gnu_result
5152 gnat_node);
5153 }
5160 {
5163 }
5166 gnu_result
5169 /* If the type is VOID, this is a statement, so we need to
5170 generate the code for the call. Handle a Condition, if there
5171 is one. */
5173 {
5180 }
5181 else
5186 {
5191 /* No need for any warning in this case. */
5193 ;
5195 /* If the result is a pointer type, see if we are either converting
5196 from a non-pointer or from a pointer to a type with a different
5197 alias set and warn if so. If the result is defined in the same
5198 unit as this unchecked conversion, we can allow this because we
5199 can know to make the pointer type behave properly. */
5203 {
5216 || !alias_sets_conflict_p
5219 {
5220 post_error_ne
5223 post_error
5225 gnat_node);
5226 post_error_ne
5229 }
5230 }
5232 /* But if the result is a fat pointer type, we have no mechanism to
5233 do that, so we unconditionally warn in problematic cases. */
5235 {
5236 tree gnu_source_array_type
5240 tree gnu_target_array_type
5250 || !alias_sets_conflict_p
5253 {
5254 post_error_ne
5257 post_error
5259 gnat_node);
5260 }
5261 }
5262 }
5271 /* SCIL nodes require no processing for GCC. */
5284 }
5286 /* If we pushed our level as part of processing the elaboration routine,
5287 pop it back now. */
5289 {
5294 }
5296 /* Set the location information on the result if it is a real expression.
5297 References can be reused for multiple GNAT nodes and they would get
5298 the location information of their last use. Note that we may have
5299 no result if we tried to build a CALL_EXPR node to a procedure with
5300 no side-effects and optimization is enabled. */
5308 /* If we're supposed to return something of void_type, it means we have
5309 something we're elaborating for effect, so just return. */
5313 /* If the result is a constant that overflowed, raise Constraint_Error. */
5315 {
5317 gnu_result
5320 N_Raise_Constraint_Error));
5321 }
5323 /* If our result has side-effects and is of an unconstrained type,
5324 make a SAVE_EXPR so that we can be sure it will only be referenced
5325 once. Note we must do this before any conversions. */
5331 /* Now convert the result to the result type, unless we are in one of the
5332 following cases:
5334 1. If this is the Name of an assignment statement or a parameter of
5335 a procedure call, return the result almost unmodified since the
5336 RHS will have to be converted to our type in that case, unless
5337 the result type has a simpler size. Likewise if there is just
5338 a no-op unchecked conversion in-between. Similarly, don't convert
5339 integral types that are the operands of an unchecked conversion
5340 since we need to ignore those conversions (for 'Valid).
5342 2. If we have a label (which doesn't have any well-defined type), a
5343 field or an error, return the result almost unmodified. Also don't
5344 do the conversion if the result type involves a PLACEHOLDER_EXPR in
5345 its size since those are the cases where the front end may have the
5346 type wrong due to "instantiating" the unconstrained record with
5347 discriminant values. Similarly, if the two types are record types
5348 with the same name don't convert. This will be the case when we are
5349 converting from a packable version of a type to its original type and
5350 we need those conversions to be NOPs in order for assignments into
5351 these types to work properly.
5353 3. If the type is void or if we have no result, return error_mark_node
5354 to show we have no result.
5356 4. Finally, if the type of the result is already correct. */
5378 && (CONTAINS_PLACEHOLDER_P
5382 {
5383 /* Remove padding only if the inner object is of self-referential
5384 size: in that case it must be an object of unconstrained type
5385 with a default discriminant and we want to avoid copying too
5386 much data. */
5391 gnu_result);
5392 }
5405 {
5406 /* Remove any padding. */
5409 gnu_result);
5410 }
5418 /* We don't need any NOP_EXPR or NON_LVALUE_EXPR on the result. */
5425 }
5426 \f
5427 /* Subroutine of above to push the exception label stack. GNU_STACK is
5428 a pointer to the stack to update and GNAT_LABEL, if present, is the
5429 label to push onto the stack. */
5431 static void
5433 {
5439 }
5440 \f
5441 /* Record the current code position in GNAT_NODE. */
5443 static void
5445 {
5450 }
5452 /* Insert the code for GNAT_NODE at the position saved for that node. */
5454 static void
5456 {
5459 }
5460 \f
5461 /* Start a new statement group chained to the previous group. */
5463 void
5465 {
5468 /* First see if we can get one from the free list. */
5471 else
5477 }
5479 /* Add GNU_STMT to the current statement group. */
5481 void
5483 {
5485 }
5487 /* Similar, but set the location of GNU_STMT to that of GNAT_NODE. */
5489 void
5491 {
5495 }
5497 /* Add a declaration statement for GNU_DECL to the current statement group.
5498 Get SLOC from Entity_Id. */
5500 void
5502 {
5506 /* If this is a variable that Gigi is to ignore, we may have been given
5507 an ERROR_MARK. So test for it. We also might have been given a
5508 reference for a renaming. So only do something for a decl. Also
5509 ignore a TYPE_DECL for an UNCONSTRAINED_ARRAY_TYPE. */
5517 /* If we are global, we don't want to actually output the DECL_EXPR for
5518 this decl since we already have evaluated the expressions in the
5519 sizes and positions as globals and doing it again would be wrong. */
5521 {
5522 /* Mark everything as used to prevent node sharing with subprograms.
5523 Note that walk_tree knows how to deal with TYPE_DECL, but neither
5524 VAR_DECL nor CONST_DECL. This appears to be somewhat arbitrary. */
5528 {
5532 }
5533 /* In any case, we have to deal with our own TYPE_ADA_SIZE field. */
5540 }
5541 else
5544 /* If this is a variable and an initializer is attached to it, it must be
5545 valid for the context. Similar to init_const in create_var_decl_1. */
5552 {
5553 /* If GNU_DECL has a padded type, convert it to the unpadded
5554 type so the assignment is done properly. */
5557 else
5564 {
5567 }
5570 }
5571 }
5573 /* Callback for walk_tree to mark the visited trees rooted at *TP. */
5575 static tree
5577 {
5583 /* Don't mark a dummy type as visited because we want to mark its sizes
5584 and fields once it's filled in. */
5592 }
5594 /* Mark nodes rooted at T with TREE_VISITED and types as having their
5595 sized gimplified. We use this to indicate all variable sizes and
5596 positions in global types may not be shared by any subprogram. */
5598 void
5600 {
5602 }
5604 /* Utility function to unshare expressions wrapped up in a SAVE_EXPR. */
5606 static tree
5609 {
5616 }
5618 /* Add GNU_CLEANUP, a cleanup action, to the current code group and
5619 set its location to that of GNAT_NODE if present. */
5621 static void
5623 {
5627 }
5629 /* Set the BLOCK node corresponding to the current code group to GNU_BLOCK. */
5631 void
5633 {
5636 }
5638 /* Return code corresponding to the current code group. It is normally
5639 a STATEMENT_LIST, but may also be a BIND_EXPR or TRY_FINALLY_EXPR if
5640 BLOCK or cleanups were set. */
5642 tree
5644 {
5648 /* If this is a null list, allocate a new STATEMENT_LIST. Then, if there
5649 are cleanups, make a TRY_FINALLY_EXPR. Last, if there is a BLOCK,
5650 make a BIND_EXPR. Note that we nest in that because the cleanup may
5651 reference variables in the block. */
5663 /* Remove this group from the stack and add it to the free list. */
5669 }
5671 /* Add a list of statements from GNAT_LIST, a possibly-empty list of
5672 statements.*/
5674 static void
5676 {
5677 Node_Id gnat_node;
5683 }
5685 /* Build a tree from GNAT_LIST, a possibly-empty list of statements.
5686 If BINDING_P is true, push and pop a binding level around the list. */
5688 static tree
5690 {
5700 }
5701 \f
5702 /* Push and pop routines for stacks. We keep a free list around so we
5703 don't waste tree nodes. */
5705 static void
5707 {
5711 {
5716 }
5717 else
5721 }
5723 static void
5725 {
5731 }
5732 \f
5733 /* Generate GIMPLE in place for the expression at *EXPR_P. */
5735 int
5738 {
5740 tree op;
5746 {
5748 /* If this is for a scalar, just make a VAR_DECL for it. If for
5749 an aggregate, get a null pointer of the appropriate type and
5750 dereference it. */
5754 integer_zero_node));
5755 else
5756 {
5759 }
5765 /* We should only do this if we are just elaborating for side-effects,
5766 but we can't know that yet. */
5773 /* If we are taking the address of a constant CONSTRUCTOR, force it to
5774 be put into static memory. We know it's going to be readonly given
5775 the semantics we have and it's required to be in static memory when
5776 the reference is in an elaboration procedure. */
5778 {
5789 }
5791 /* If we are taking the address of a SAVE_EXPR, we are typically dealing
5792 with a misaligned argument to be passed by reference in a subprogram
5793 call. We cannot let the common gimplifier code perform the creation
5794 of the temporary and its initialization because, in order to ensure
5795 that the final copy operation is a store and since the temporary made
5796 for a SAVE_EXPR is not addressable, it may create another temporary,
5797 addressable this time, which would break the back copy mechanism for
5798 an IN OUT parameter. */
5800 {
5817 }
5824 /* The expressions for the RM bounds must be gimplified to ensure that
5825 they are properly elaborated. See gimplify_decl_expr. */
5829 {
5834 {
5839 {
5843 }
5847 {
5851 }
5853 }
5858 }
5860 /* ... fall through ... */
5864 }
5865 }
5867 /* Generate GIMPLE in place for the statement at *STMT_P. */
5869 static enum gimplify_status
5871 {
5875 {
5881 {
5884 tree t;
5886 /* Set to emit the statements of the loop. */
5889 /* We first emit the start label and then a conditional jump to
5890 the end label if there's a top condition, then the body of the
5891 loop, then a conditional branch to the end label, then the update,
5892 if any, and finally a jump to the start label and the definition
5893 of the end label. */
5895 gnu_start_label),
5896 stmt_p);
5903 void_type_node,
5904 gnu_end_label)),
5905 stmt_p);
5914 void_type_node,
5915 gnu_end_label)),
5916 stmt_p);
5926 gnu_end_label),
5927 stmt_p);
5929 }
5932 /* Build a statement to jump to the corresponding end label, then
5933 see if it needs to be conditional. */
5942 }
5943 }
5944 \f
5945 /* Force references to each of the entities in packages withed by GNAT_NODE.
5946 Operate recursively but check that we aren't elaborating something more
5947 than once.
5949 This routine is exclusively called in type_annotate mode, to compute DDA
5950 information for types in withed units, for ASIS use. */
5952 static void
5954 {
5957 /* Process each unit only once. As we trace the context of all relevant
5958 units transitively, including generic bodies, we may encounter the
5959 same generic unit repeatedly. */
5963 /* Save entities in all context units. A body may have an implicit_with
5964 on its own spec, if the context includes a child unit, so don't save
5965 the spec twice. */
5972 {
5976 {
5993 }
5995 {
5996 Node_Id gnat_body
5999 /* Retrieve compilation unit node of generic body. */
6004 /* If body is available, elaborate its context. */
6007 }
6008 }
6012 }
6013 \f
6014 /* Do the processing of N_Freeze_Entity, GNAT_NODE. */
6016 static void
6018 {
6020 tree gnu_old;
6021 tree gnu_new;
6022 tree gnu_init
6027 /* If this is a package, need to generate code for the package. */
6029 {
6030 insert_code_for
6034 }
6036 /* Check for old definition after the above call. This Freeze_Node
6037 might be for one its Itypes. */
6038 gnu_old
6041 /* If this entity has an Address representation clause, GNU_OLD is the
6042 address, so discard it here. */
6046 /* Don't do anything for class-wide types as they are always transformed
6047 into their root type. */
6051 /* Don't do anything for subprograms that may have been elaborated before
6052 their freeze nodes. This can happen, for example because of an inner call
6053 in an instance body, or a previous compilation of a spec for inlining
6054 purposes. */
6059 || (gnu_old
6064 /* If we have a non-dummy type old tree, we have nothing to do, except
6065 aborting if this is the public view of a private type whose full view was
6066 not delayed, as this node was never delayed as it should have been. We
6067 let this happen for concurrent types and their Corresponding_Record_Type,
6068 however, because each might legitimately be elaborated before it's own
6069 freeze node, e.g. while processing the other. */
6073 {
6081 }
6083 /* Reset the saved tree, if any, and elaborate the object or type for real.
6084 If there is a full declaration, elaborate it and copy the type to
6085 GNAT_ENTITY. Likewise if this is the record subtype corresponding to
6086 a class wide type or subtype. */
6088 {
6097 }
6101 {
6104 /* Propagate back-annotations from full view to partial view. */
6114 /* The above call may have defined this entity (the simplest example
6115 of this is when we have a private enumeral type since the bounds
6116 will have the public view. */
6122 }
6123 else
6126 /* If we've made any pointers to the old version of this type, we
6127 have to update them. */
6131 }
6132 \f
6133 /* Process the list of inlined subprograms of GNAT_NODE, which is an
6134 N_Compilation_Unit. */
6136 static void
6138 {
6139 Entity_Id gnat_entity;
6140 Node_Id gnat_body;
6142 /* If we can inline, generate Gimple for all the inlined subprograms.
6143 Define the entity first so we set DECL_EXTERNAL. */
6148 {
6152 {
6153 /* ??? This really should always be Present. */
6157 gnat_body
6159 }
6162 {
6165 }
6166 }
6167 }
6168 \f
6169 /* Elaborate decls in the lists GNAT_DECLS and GNAT_DECLS2, if present.
6170 We make two passes, one to elaborate anything other than bodies (but
6171 we declare a function if there was no spec). The second pass
6172 elaborates the bodies.
6174 GNAT_END_LIST gives the element in the list past the end. Normally,
6175 this is Empty, but can be First_Real_Statement for a
6176 Handled_Sequence_Of_Statements.
6178 We make a complete pass through both lists if PASS1P is true, then make
6179 the second pass over both lists if PASS2P is true. The lists usually
6180 correspond to the public and private parts of a package. */
6182 static void
6185 {
6187 Node_Id gnat_decl;
6197 {
6198 /* For package specs, we recurse inside the declarations,
6199 thus taking the two pass approach inside the boundary. */
6207 /* Similarly for any declarations in the actions of a
6208 freeze node. */
6210 {
6213 }
6215 /* Package bodies with freeze nodes get their elaboration deferred
6216 until the freeze node, but the code must be placed in the right
6217 place, so record the code position now. */
6225 (Corresponding_Spec
6228 record_code_position
6231 /* We defer most subprogram bodies to the second pass. */
6233 {
6235 {
6241 }
6242 }
6244 /* For bodies and stubs that act as their own specs, the entity
6245 itself must be elaborated in the first pass, because it may
6246 be used in other declarations. */
6248 {
6249 Node_Id gnat_subprog_id
6256 }
6258 /* Concurrent stubs stand for the corresponding subprogram bodies,
6259 which are deferred like other bodies. */
6262 ;
6264 else
6266 }
6268 /* Here we elaborate everything we deferred above except for package bodies,
6269 which are elaborated at their freeze nodes. Note that we must also
6270 go inside things (package specs and freeze nodes) the first pass did. */
6276 {
6292 }
6293 }
6294 \f
6295 /* Make a unary operation of kind CODE using build_unary_op, but guard
6296 the operation by an overflow check. CODE can be one of NEGATE_EXPR
6297 or ABS_EXPR. GNU_TYPE is the type desired for the result. Usually
6298 the operation is to be performed in that type. GNAT_NODE is the gnat
6299 node conveying the source location for which the error should be
6300 signaled. */
6302 static tree
6304 Node_Id gnat_node)
6305 {
6314 }
6316 /* Make a binary operation of kind CODE using build_binary_op, but guard
6317 the operation by an overflow check. CODE can be one of PLUS_EXPR,
6318 MINUS_EXPR or MULT_EXPR. GNU_TYPE is the type desired for the result.
6319 Usually the operation is to be performed in that type. GNAT_NODE is
6320 the GNAT node conveying the source location for which the error should
6321 be signaled. */
6323 static tree
6326 {
6331 tree gnu_expr;
6334 tree rhs_lt_zero;
6335 tree check_pos;
6336 tree check_neg;
6337 tree check;
6342 /* Prefer a constant or known-positive rhs to simplify checks. */
6347 {
6351 }
6354 ? integer_zero_node
6357 /* ??? Should use more efficient check for operand_equal_p (lhs, rhs, 0) */
6359 /* Try a few strategies that may be cheaper than the general
6360 code at the end of the function, if the rhs is not known.
6361 The strategies are:
6362 - Call library function for 64-bit multiplication (complex)
6363 - Widen, if input arguments are sufficiently small
6364 - Determine overflow using wrapped result for addition/subtraction. */
6367 {
6368 /* Even for add/subtract double size to get another base type. */
6372 {
6378 }
6383 {
6390 tree check = build_binary_op
6399 return
6401 }
6404 {
6406 tree wrapped_expr = convert
6411 tree result = convert
6414 /* Overflow when (rhs < 0) ^ (wrapped_expr < lhs)), for addition
6415 or when (rhs < 0) ^ (wrapped_expr > lhs) for subtraction. */
6416 tree check = build_binary_op
6421 return
6423 }
6424 }
6427 {
6429 /* When rhs >= 0, overflow when lhs > type_max - rhs. */
6434 /* When rhs < 0, overflow when lhs < type_min - rhs. */
6441 /* When rhs >= 0, overflow when lhs < type_min + rhs. */
6446 /* When rhs < 0, overflow when lhs > type_max + rhs. */
6453 /* The check here is designed to be efficient if the rhs is constant,
6454 but it will work for any rhs by using integer division.
6455 Four different check expressions determine wether X * C overflows,
6456 depending on C.
6457 C == 0 => false
6458 C > 0 => X > type_max / C || X < type_min / C
6459 C == -1 => X == type_min
6460 C < -1 => X > type_min / C || X < type_max / C */
6482 }
6486 /* If we can fold the expression to a constant, just return it.
6487 The caller will deal with overflow, no need to generate a check. */
6495 }
6497 /* Emit code for a range check. GNU_EXPR is the expression to be checked,
6498 GNAT_RANGE_TYPE the gnat type or subtype containing the bounds against
6499 which we have to check. GNAT_NODE is the GNAT node conveying the source
6500 location for which the error should be signaled. */
6502 static tree
6504 {
6510 /* If GNU_EXPR has GNAT_RANGE_TYPE as its base type, no check is needed.
6511 This can for example happen when translating 'Val or 'Value. */
6515 /* If GNU_EXPR has an integral type that is narrower than GNU_RANGE_TYPE,
6516 we can't do anything since we might be truncating the bounds. No
6517 check is needed in this case. */
6523 /* Checked expressions must be evaluated only once. */
6526 /* There's no good type to use here, so we might as well use
6527 integer_type_node. Note that the form of the check is
6528 (not (expr >= lo)) or (not (expr <= hi))
6529 the reason for this slightly convoluted form is that NaNs
6530 are not considered to be in range in the float case. */
6531 return emit_check
6533 invert_truthvalue
6537 invert_truthvalue
6541 gnu_high)))),
6543 }
6544 \f
6545 /* Emit code for an index check. GNU_ARRAY_OBJECT is the array object which
6546 we are about to index, GNU_EXPR is the index expression to be checked,
6547 GNU_LOW and GNU_HIGH are the lower and upper bounds against which GNU_EXPR
6548 has to be checked. Note that for index checking we cannot simply use the
6549 emit_range_check function (although very similar code needs to be generated
6550 in both cases) since for index checking the array type against which we are
6551 checking the indices may be unconstrained and consequently we need to get
6552 the actual index bounds from the array object itself (GNU_ARRAY_OBJECT).
6553 The place where we need to do that is in subprograms having unconstrained
6554 array formal parameters. GNAT_NODE is the GNAT node conveying the source
6555 location for which the error should be signaled. */
6557 static tree
6560 {
6561 tree gnu_expr_check;
6563 /* Checked expressions must be evaluated only once. */
6566 /* Must do this computation in the base type in case the expression's
6567 type is an unsigned subtypes. */
6570 /* If GNU_LOW or GNU_HIGH are a PLACEHOLDER_EXPR, qualify them by
6571 the object we are handling. */
6575 /* There's no good type to use here, so we might as well use
6576 integer_type_node. */
6577 return emit_check
6580 gnu_expr_check,
6582 gnu_low)),
6584 gnu_expr_check,
6586 gnu_high))),
6588 }
6589 \f
6590 /* GNU_COND contains the condition corresponding to an access, discriminant or
6591 range check of value GNU_EXPR. Build a COND_EXPR that returns GNU_EXPR if
6592 GNU_COND is false and raises a CONSTRAINT_ERROR if GNU_COND is true.
6593 REASON is the code that says why the exception was raised. GNAT_NODE is
6594 the GNAT node conveying the source location for which the error should be
6595 signaled. */
6597 static tree
6599 {
6600 tree gnu_call
6602 tree gnu_result
6606 gnu_expr);
6608 /* GNU_RESULT has side effects if and only if GNU_EXPR has:
6609 we don't need to evaluate it just for the check. */
6613 }
6614 \f
6615 /* Return an expression that converts GNU_EXPR to GNAT_TYPE, doing overflow
6616 checks if OVERFLOW_P is true and range checks if RANGE_P is true.
6617 GNAT_TYPE is known to be an integral type. If TRUNCATE_P true, do a
6618 float to integer conversion with truncation; otherwise round.
6619 GNAT_NODE is the GNAT node conveying the source location for which the
6620 error should be signaled. */
6622 static tree
6625 {
6632 /* If we are not doing any checks, the output is an integral type, and
6633 the input is not a floating type, just do the conversion. This
6634 shortcut is required to avoid problems with packed array types
6635 and simplifies code in all cases anyway. */
6640 /* First convert the expression to its base type. This
6641 will never generate code, but makes the tests below much simpler.
6642 But don't do this if converting from an integer type to an unconstrained
6643 array type since then we need to get the bounds from the original
6644 (unpacked) type. */
6648 /* If overflow checks are requested, we need to be sure the result will
6649 fit in the output base type. But don't do this if the input
6650 is integer and the output floating-point. */
6653 {
6654 /* Ensure GNU_EXPR only gets evaluated once. */
6662 /* Convert the lower bounds to signed types, so we're sure we're
6663 comparing them properly. Likewise, convert the upper bounds
6664 to unsigned types. */
6678 /* Check each bound separately and only if the result bound
6679 is tighter than the bound on the input type. Note that all the
6680 types are base types, so the bounds must be constant. Also,
6681 the comparison is done in the base type of the input, which
6682 always has the proper signedness. First check for input
6683 integer (which means output integer), output float (which means
6684 both float), or mixed, in which case we always compare.
6685 Note that we have to do the comparison which would *fail* in the
6686 case of an error since if it's an FP comparison and one of the
6687 values is a NaN or Inf, the comparison will fail. */
6694 gnu_cond
6695 = invert_truthvalue
6698 gnu_out_lb)));
6706 gnu_cond
6708 invert_truthvalue
6710 gnu_input,
6712 gnu_out_ub))));
6717 }
6719 /* Now convert to the result base type. If this is a non-truncating
6720 float-to-integer conversion, round. */
6723 {
6729 /* The following calculations depend on proper rounding to even
6730 of each arithmetic operation. In order to prevent excess
6731 precision from spoiling this property, use the widest hardware
6732 floating-point type if FP_ARITH_MAY_WIDEN is true. */
6733 calc_type
6736 /* FIXME: Should not have padding in the first place. */
6740 /* Compute the exact value calc_type'Pred (0.5) at compile time. */
6744 half_minus_pred_half);
6747 /* If the input is strictly negative, subtract this value
6748 and otherwise add it from the input. For 0.5, the result
6749 is exactly between 1.0 and the machine number preceding 1.0
6750 (for calc_type). Since the last bit of 1.0 is even, this 0.5
6751 will round to 1.0, while all other number with an absolute
6752 value less than 0.5 round to 0.0. For larger numbers exactly
6753 halfway between integers, rounding will always be correct as
6754 the true mathematical result will be closer to the higher
6755 integer compared to the lower one. So, this constant works
6756 for all floating-point numbers.
6758 The reason to use the same constant with subtract/add instead
6759 of a positive and negative constant is to allow the comparison
6760 to be scheduled in parallel with retrieval of the constant and
6761 conversion of the input to the calc_type (if necessary). */
6766 gnu_comp
6768 gnu_add_pred_half
6770 gnu_subtract_pred_half
6774 }
6780 else
6783 /* Finally, do the range check if requested. Note that if the result type
6784 is a modular type, the range check is actually an overflow check. */
6791 }
6792 \f
6793 /* Return true if TYPE is a smaller packable version of RECORD_TYPE. */
6795 static bool
6797 {
6800 /* We're not interested in variants here. */
6804 /* Like a variant, a packable version keeps the original TYPE_NAME. */
6815 }
6817 /* Return true if GNU_EXPR can be directly addressed. This is the case
6818 unless it is an expression involving computation or if it involves a
6819 reference to a bitfield or to an object not sufficiently aligned for
6820 its type. If GNU_TYPE is non-null, return true only if GNU_EXPR can
6821 be directly addressed as an object of this type.
6823 *** Notes on addressability issues in the Ada compiler ***
6825 This predicate is necessary in order to bridge the gap between Gigi
6826 and the middle-end about addressability of GENERIC trees. A tree
6827 is said to be addressable if it can be directly addressed, i.e. if
6828 its address can be taken, is a multiple of the type's alignment on
6829 strict-alignment architectures and returns the first storage unit
6830 assigned to the object represented by the tree.
6832 In the C family of languages, everything is in practice addressable
6833 at the language level, except for bit-fields. This means that these
6834 compilers will take the address of any tree that doesn't represent
6835 a bit-field reference and expect the result to be the first storage
6836 unit assigned to the object. Even in cases where this will result
6837 in unaligned accesses at run time, nothing is supposed to be done
6838 and the program is considered as erroneous instead (see PR c/18287).
6840 The implicit assumptions made in the middle-end are in keeping with
6841 the C viewpoint described above:
6842 - the address of a bit-field reference is supposed to be never
6843 taken; the compiler (generally) will stop on such a construct,
6844 - any other tree is addressable if it is formally addressable,
6845 i.e. if it is formally allowed to be the operand of ADDR_EXPR.
6847 In Ada, the viewpoint is the opposite one: nothing is addressable
6848 at the language level unless explicitly declared so. This means
6849 that the compiler will both make sure that the trees representing
6850 references to addressable ("aliased" in Ada parlance) objects are
6851 addressable and make no real attempts at ensuring that the trees
6852 representing references to non-addressable objects are addressable.
6854 In the first case, Ada is effectively equivalent to C and handing
6855 down the direct result of applying ADDR_EXPR to these trees to the
6856 middle-end works flawlessly. In the second case, Ada cannot afford
6857 to consider the program as erroneous if the address of trees that
6858 are not addressable is requested for technical reasons, unlike C;
6859 as a consequence, the Ada compiler must arrange for either making
6860 sure that this address is not requested in the middle-end or for
6861 compensating by inserting temporaries if it is requested in Gigi.
6863 The first goal can be achieved because the middle-end should not
6864 request the address of non-addressable trees on its own; the only
6865 exception is for the invocation of low-level block operations like
6866 memcpy, for which the addressability requirements are lower since
6867 the type's alignment can be disregarded. In practice, this means
6868 that Gigi must make sure that such operations cannot be applied to
6869 non-BLKmode bit-fields.
6871 The second goal is achieved by means of the addressable_p predicate
6872 and by inserting SAVE_EXPRs around trees deemed non-addressable.
6873 They will be turned during gimplification into proper temporaries
6874 whose address will be used in lieu of that of the original tree. */
6876 static bool
6878 {
6879 /* The size of the real type of the object must not be smaller than
6880 that of the expected type, otherwise an indirect access in the
6881 latter type would be larger than the object. Only records need
6882 to be considered in practice. */
6889 {
6894 /* All DECLs are addressable: if they are in a register, we can force
6895 them to memory. */
6914 /* All rvalues are deemed addressable since taking their address will
6915 force a temporary to be created by the middle-end. */
6919 /* We accept &COND_EXPR as soon as both operands are addressable and
6920 expect the outcome to be the address of the selected operand. */
6926 /* Even with DECL_BIT_FIELD cleared, we have to ensure that
6927 the field is sufficiently aligned, in case it is subject
6928 to a pragma Component_Alignment. But we don't need to
6929 check the alignment of the containing record, as it is
6930 guaranteed to be not smaller than that of its most
6931 aligned field that is not a bit-field. */
6932 && (!STRICT_ALIGNMENT
6935 /* The field of a padding record is always addressable. */
6949 {
6950 /* This is addressable if we can avoid a copy. */
6954 && (!STRICT_ALIGNMENT
6959 && (!STRICT_ALIGNMENT
6965 }
6969 }
6970 }
6971 \f
6972 /* Do the processing for the declaration of a GNAT_ENTITY, a type. If
6973 a separate Freeze node exists, delay the bulk of the processing. Otherwise
6974 make a GCC type for GNAT_ENTITY and set up the correspondence. */
6976 void
6978 {
6979 tree gnu_old
6981 tree gnu_new;
6983 /* If we are to delay elaboration of this type, just do any
6984 elaborations needed for expressions within the declaration and
6985 make a dummy type entry for this node and its Full_View (if
6986 any) in case something points to it. Don't do this if it
6987 has already been done (the only way that can happen is if
6988 the private completion is also delayed). */
6994 {
6998 {
7004 }
7007 }
7009 /* If we saved away a dummy type for this node it means that this
7010 made the type that corresponds to the full type of an incomplete
7011 type. Clear that type for now and then update the type in the
7012 pointers. */
7014 {
7019 }
7021 /* Now fully elaborate the type. */
7025 /* If we have an old type and we've made pointers to this type,
7026 update those pointers. */
7031 /* If this is a record type corresponding to a task or protected type
7032 that is a completion of an incomplete type, perform a similar update
7033 on the type. ??? Including protected types here is a guess. */
7037 {
7038 tree gnu_task_old
7048 }
7049 }
7050 \f
7051 /* GNAT_ENTITY is the type of the resulting constructors,
7052 GNAT_ASSOC is the front of the Component_Associations of an N_Aggregate,
7053 and GNU_TYPE is the GCC type of the corresponding record.
7055 Return a CONSTRUCTOR to build the record. */
7057 static tree
7059 {
7062 /* We test for GNU_FIELD being empty in the case where a variant
7063 was the last thing since we don't take things off GNAT_ASSOC in
7064 that case. We check GNAT_ASSOC in case we have a variant, but it
7065 has no fields. */
7069 {
7074 /* The expander is supposed to put a single component selector name
7075 in every record component association. */
7078 /* Ignore fields that have Corresponding_Discriminants since we'll
7079 be setting that field in the parent. */
7084 /* Also ignore discriminants of Unchecked_Unions. */
7089 /* Before assigning a value in an aggregate make sure range checks
7090 are done if required. Then convert to the type of the field. */
7096 /* Add the field and expression to the list. */
7098 }
7102 #ifdef ENABLE_CHECKING
7103 {
7104 tree gnu_field;
7106 /* Verify every entry in GNU_LIST was used. */
7109 }
7110 #endif
7113 }
7115 /* Build a possibly nested constructor for array aggregates. GNAT_EXPR is
7116 the first element of an array aggregate. It may itself be an aggregate.
7117 GNU_ARRAY_TYPE is the GCC type corresponding to the array aggregate.
7118 GNAT_COMPONENT_TYPE is the type of the array component; it is needed
7119 for range checking. */
7121 static tree
7123 Entity_Id gnat_component_type)
7124 {
7127 tree gnu_expr;
7130 {
7131 /* If the expression is itself an array aggregate then first build the
7132 innermost constructor if it is part of our array (multi-dimensional
7133 case). */
7139 gnat_component_type);
7140 else
7141 {
7144 /* Before assigning the element to the array, make sure it is
7145 in range. */
7148 }
7150 gnu_expr_list
7152 gnu_expr_list);
7155 }
7158 }
7159 \f
7160 /* Subroutine of assoc_to_constructor: VALUES is a list of field associations,
7161 some of which are from RECORD_TYPE. Return a CONSTRUCTOR consisting
7162 of the associations that are from RECORD_TYPE. If we see an internal
7163 record, make a recursive call to fill it in as well. */
7165 static tree
7167 {
7172 {
7175 /* _Parent is an internal field, but may have values in the aggregate,
7176 so check for values first. */
7178 {
7181 }
7184 {
7189 }
7190 else
7191 /* If we have a record subtype, the names will match, but not the
7192 actual FIELD_DECLs. */
7195 {
7198 }
7204 }
7207 }
7208 \f
7209 /* EXP is to be treated as an array or record. Handle the cases when it is
7210 an access object and perform the required dereferences. */
7212 static tree
7214 {
7215 /* If the type is a pointer, dereference it. */
7220 /* If we got a padded type, remove it too. */
7225 }
7226 \f
7227 /* Convert SLOC into LOCUS. Return true if SLOC corresponds to a source code
7228 location and false if it doesn't. In the former case, set the Gigi global
7229 variable REF_FILENAME to the simple debug file name as given by sinput. */
7231 bool
7233 {
7238 {
7241 }
7242 else
7243 {
7249 /* Translate the location according to the line-map.h formula. */
7253 }
7255 ref_filename
7256 = IDENTIFIER_POINTER
7257 (get_identifier
7261 }
7263 /* Similar to set_expr_location, but start with the Sloc of GNAT_NODE and
7264 don't do anything if it doesn't correspond to a source location. */
7266 static void
7268 {
7269 location_t locus;
7275 }
7276 \f
7277 /* Return a colon-separated list of encodings contained in encoded Ada
7278 name. */
7282 {
7286 }
7288 /* Extract the Ada name from an encoded name. */
7292 {
7296 }
7297 \f
7298 /* Post an error message. MSG is the error message, properly annotated.
7299 NODE is the node at which to post the error and the node to use for the
7300 "&" substitution. */
7302 void
7304 {
7305 String_Template temp;
7306 Fat_Pointer fp;
7312 }
7314 /* Similar, but NODE is the node at which to post the error and ENT
7315 is the node to use for the "&" substitution. */
7317 void
7319 {
7320 String_Template temp;
7321 Fat_Pointer fp;
7327 }
7329 /* Similar, but NODE is the node at which to post the error, ENT is the node
7330 to use for the "&" substitution, and N is the number to use for the ^. */
7332 void
7334 {
7335 String_Template temp;
7336 Fat_Pointer fp;
7344 }
7345 \f
7346 /* Similar to post_error_ne_num, but T is a GCC tree representing the
7347 number to write. If the tree represents a constant that fits within
7348 a host integer, the text inside curly brackets in MSG will be output
7349 (presumably including a '^'). Otherwise that text will not be output
7350 and the text inside square brackets will be output instead. */
7352 void
7354 {
7357 Fat_Pointer fp;
7365 #if HOST_BITS_PER_WIDE_INT > HOST_BITS_PER_INT
7366 &&
7367 compare_tree_int
7369 #endif
7370 )
7371 {
7374 }
7375 else
7379 {
7385 ;
7386 else
7388 }
7395 }
7397 /* Similar to post_error_ne_tree, except that NUM is a second
7398 integer to write in the message. */
7400 void
7403 {
7406 }
7407 \f
7408 /* Initialize the table that maps GNAT codes to GCC codes for simple
7409 binary and unary operations. */
7411 static void
7413 {
7439 }
7441 /* Return a label to branch to for the exception type in KIND or NULL_TREE
7442 if none. */
7444 tree
7446 {
7453 else
7455 }