| blob | 3b6d5bd0d5e14a23ff18de6b21ea336cb16ddfd3 |
1 /****************************************************************************
2 * *
3 * GNAT COMPILER COMPONENTS *
4 * *
5 * T R A N S *
6 * *
7 * C Implementation File *
8 * *
9 * Copyright (C) 1992-2014, 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 ****************************************************************************/
67 /* We should avoid allocating more than ALLOCA_THRESHOLD bytes via alloca,
68 for fear of running out of stack space. If we need more, we use xmalloc
69 instead. */
70 #define ALLOCA_THRESHOLD 1000
72 /* In configurations where blocks have no end_locus attached, just
73 sink assignments into a dummy global. */
74 #ifndef BLOCK_SOURCE_END_LOCATION
76 #define BLOCK_SOURCE_END_LOCATION(BLOCK) block_end_locus_sink
77 #endif
79 /* For efficient float-to-int rounding, it is necessary to know whether
80 floating-point arithmetic may use wider intermediate results. When
81 FP_ARITH_MAY_WIDEN is not defined, be conservative and only assume
82 that arithmetic does not widen if double precision is emulated. */
83 #ifndef FP_ARITH_MAY_WIDEN
84 #if defined(HAVE_extendsfdf2)
85 #define FP_ARITH_MAY_WIDEN HAVE_extendsfdf2
86 #else
87 #define FP_ARITH_MAY_WIDEN 0
88 #endif
89 #endif
91 /* Pointers to front-end tables accessed through macros. */
102 /* Highest number in the front-end node table. */
105 /* Current node being treated, in case abort called. */
106 Node_Id error_gnat_node;
108 /* True when gigi is being called on an analyzed but unexpanded
109 tree, and the only purpose of the call is to properly annotate
110 types with representation information. */
113 /* Current filename without path. */
117 /* List of N_Validate_Unchecked_Conversion nodes in the unit. */
120 /* When not optimizing, we cache the 'First, 'Last and 'Length attributes
121 of unconstrained array IN parameters to avoid emitting a great deal of
122 redundant instructions to recompute them each time. */
126 tree first;
127 tree last;
128 tree length;
129 };
136 bitmap named_ret_val;
139 };
141 #define f_parm_attr_cache \
142 DECL_STRUCT_FUNCTION (current_function_decl)->language->parm_attr_cache
144 #define f_named_ret_val \
145 DECL_STRUCT_FUNCTION (current_function_decl)->language->named_ret_val
147 #define f_other_ret_val \
148 DECL_STRUCT_FUNCTION (current_function_decl)->language->other_ret_val
150 #define f_gnat_ret \
151 DECL_STRUCT_FUNCTION (current_function_decl)->language->gnat_ret
153 /* A structure used to gather together information about a statement group.
154 We use this to gather related statements, for example the "then" part
155 of a IF. In the case where it represents a lexical scope, we may also
156 have a BLOCK node corresponding to it and/or cleanups. */
163 };
167 /* List of unused struct stmt_group nodes. */
170 /* A structure used to record information on elaboration procedures
171 we've made and need to process.
173 ??? gnat_node should be Node_Id, but gengtype gets confused. */
179 };
183 /* Stack of exception pointer variables. Each entry is the VAR_DECL
184 that stores the address of the raised exception. Nonzero means we
185 are in an exception handler. Not used in the zero-cost case. */
188 /* In ZCX case, current exception pointer. Used to re-raise it. */
191 /* Stack for storing the current elaboration procedure decl. */
194 /* Stack of labels to be used as a goto target instead of a return in
195 some functions. See processing for N_Subprogram_Body. */
198 /* Stack of variable for the return value of a function with copy-in/copy-out
199 parameters. See processing for N_Subprogram_Body. */
202 /* Structure used to record information for a range check. */
204 tree low_bound;
205 tree high_bound;
206 tree type;
207 tree invariant_cond;
208 };
213 /* Structure used to record information for a loop. */
215 tree stmt;
216 tree loop_var;
218 };
223 /* Stack of loop_info structures associated with LOOP_STMT nodes. */
226 /* The stacks for N_{Push,Pop}_*_Label. */
231 /* Map GNAT tree codes to GCC tree codes for simple expressions. */
268 /* Hooks for debug info back-ends, only supported and used in a restricted set
269 of configurations. */
272 \f
273 /* This is the main program of the back-end. It sets up all the table
274 structures and then generates code. */
276 void
289 Nat number_file,
291 Entity_Id standard_boolean,
292 Entity_Id standard_integer,
293 Entity_Id standard_character,
294 Entity_Id standard_long_long_float,
295 Entity_Id standard_exception_type,
296 Int gigi_operating_mode)
297 {
298 Node_Id gnat_iter;
299 Entity_Id gnat_literal;
319 #if TARGET_ABI_OPEN_VMS
321 #endif
324 {
325 /* Use the identifier table to make a permanent copy of the filename as
326 the name table gets reallocated after Gigi returns but before all the
327 debugging information is output. The __gnat_to_canonical_file_spec
328 call translates filenames from pragmas Source_Reference that contain
329 host style syntax not understood by gdb. */
331 = IDENTIFIER_POINTER
332 (get_identifier
333 (__gnat_to_canonical_file_spec
336 /* We rely on the order isomorphism between files and line maps. */
339 /* We create the line map for a source file at once, with a fixed number
340 of columns chosen to avoid jumping over the next power of 2. */
345 }
349 /* Declare the name of the compilation unit as the first global
350 name in order to make the middle-end fully deterministic. */
354 /* Initialize ourselves. */
359 /* If we are just annotating types, give VOID_TYPE zero sizes to avoid
360 errors. */
362 {
365 }
367 /* Enable GNAT stack checking method if needed */
371 /* Retrieve alignment settings. */
375 /* Record the builtin types. Define `integer' and `character' first so that
376 dbx will output them first. */
382 /* Save the type we made for integer as the type for Standard.Integer. */
387 /* Likewise for character as the type for Standard.Character. */
392 /* Likewise for boolean as the type for Standard.Boolean. */
416 /* Now declare run-time functions. */
419 /* malloc is a function declaration tree for a function to allocate
420 memory. */
421 malloc_decl
427 /* malloc32 is a function declaration tree for a function to allocate
428 32-bit memory on a 64-bit system. Needed only on 64-bit VMS. */
429 malloc32_decl
435 /* free is a function declaration tree for a function to free memory. */
436 free_decl
439 ptr_void_type_node,
440 NULL_TREE),
442 Empty);
444 /* This is used for 64-bit multiplication with overflow checking. */
445 mulv64_decl
450 Empty);
452 /* Name of the _Parent field in tagged record types. */
455 /* Name of the Exception_Data type defined in System.Standard_Library. */
456 exception_data_name_id
459 /* Make the types and functions used for exception processing. */
460 jmpbuf_type
466 /* Functions to get and set the jumpbuf pointer for the current thread. */
467 get_jmpbuf_decl
468 = create_subprog_decl
474 set_jmpbuf_decl
475 = create_subprog_decl
478 NULL_TREE),
482 /* setjmp returns an integer and has one operand, which is a pointer to
483 a jmpbuf. */
484 setjmp_decl
485 = create_subprog_decl
488 NULL_TREE),
493 /* update_setjmp_buf updates a setjmp buffer from the current stack pointer
494 address. */
495 update_setjmp_buf_decl
496 = create_subprog_decl
503 /* Hooks to call when entering/leaving an exception handler. */
504 ftype
507 begin_handler_decl
513 end_handler_decl
519 unhandled_except_decl
521 NULL_TREE,
526 reraise_zcx_decl
530 /* Indicate that these never return. */
537 /* If in no exception handlers mode, all raise statements are redirected to
538 __gnat_last_chance_handler. No need to redefine raise_nodefer_decl since
539 this procedure will never be called in this mode. */
541 {
542 tree decl
543 = create_subprog_decl
546 build_pointer_type
556 }
557 else
558 {
559 /* Otherwise, make one decl for each exception reason. */
565 i == CE_Index_Check_Failed
569 }
571 /* Set the types that GCC and Gigi use from the front end. */
572 exception_type
576 /* Make other functions used for exception processing. */
577 get_excptr_decl
578 = create_subprog_decl
581 NULL_TREE),
585 set_exception_parameter_decl
586 = create_subprog_decl
589 ptr_void_type_node,
590 ptr_void_type_node,
591 NULL_TREE),
594 raise_nodefer_decl
595 = create_subprog_decl
599 NULL_TREE),
602 /* Indicate that it never returns. */
607 TYPE_QUAL_VOLATILE);
609 /* Build the special descriptor type and its null node if needed. */
611 {
623 {
624 tree field
631 elt--;
632 }
637 }
639 long_long_float_type
643 {
644 /* In this case, the builtin floating point types are VAX float,
645 so make up a type for use. */
651 }
652 else
655 /* Dummy objects to materialize "others" and "all others" in the exception
656 tables. These are exported by a-exexpr-gcc.adb, so see this unit for
657 the types to use. */
658 others_decl
661 unsigned_char_type_node,
664 all_others_decl
667 unsigned_char_type_node,
670 unhandled_others_decl
673 unsigned_char_type_node,
678 /* Install the builtins we might need, either internally or as
679 user available facilities for Intrinsic imports. */
687 /* Process any Pragma Ident for the main unit. */
692 /* If we are using the GCC exception mechanism, let GCC know. */
696 /* Initialize the GCC support for FP operations. */
699 /* Now translate the compilation unit proper. */
702 /* Then process the N_Validate_Unchecked_Conversion nodes. We do this at
703 the very end to avoid having to second-guess the front-end when we run
704 into dummy nodes during the regular processing. */
709 /* Finally see if we have any elaboration procedures to deal with. */
711 {
714 /* We should have a BIND_EXPR but it may not have any statements in it.
715 If it doesn't have any, we have nothing to do except for setting the
716 flag on the GNAT node. Otherwise, process the function as others. */
722 else
723 {
727 }
728 }
730 /* Destroy ourselves. */
734 /* We cannot track the location of errors past this point. */
736 }
737 \f
738 /* Return a subprogram decl corresponding to __gnat_rcheck_xx for the given
739 CHECK if KIND is EXCEPTION_SIMPLE, or else to __gnat_rcheck_xx_ext. */
741 static tree
743 {
752 {
754 ftype
756 build_pointer_type
759 }
760 else
761 {
766 ftype
768 build_pointer_type
772 }
774 result
779 /* Indicate that it never returns. */
786 }
787 \f
788 /* Return a positive value if an lvalue is required for GNAT_NODE, which is
789 an N_Attribute_Reference. */
791 static int
793 {
795 {
832 }
833 }
835 /* Return a positive value if an lvalue is required for GNAT_NODE. GNU_TYPE
836 is the type that will be used for GNAT_NODE in the translated GNU tree.
837 CONSTANT indicates whether the underlying object represented by GNAT_NODE
838 is constant in the Ada sense. If it is, ADDRESS_OF_CONSTANT indicates
839 whether its value is the address of a constant and ALIASED whether it is
840 aliased. If it isn't, ADDRESS_OF_CONSTANT and ALIASED are ignored.
842 The function climbs up the GNAT tree starting from the node and returns 1
843 upon encountering a node that effectively requires an lvalue downstream.
844 It returns int instead of bool to facilitate usage in non-purely binary
845 logic contexts. */
847 static int
850 {
854 {
864 /* If the parameter is by reference, an lvalue is required. */
870 /* Only the array expression can require an lvalue. */
874 /* ??? Consider that referencing an indexed component with a
875 non-constant index forces the whole aggregate to memory.
876 Note that N_Integer_Literal is conservative, any static
877 expression in the RM sense could probably be accepted. */
884 /* ... fall through ... */
887 /* Only the array expression can require an lvalue. */
901 /* We need to make a real renaming only if the constant object is
902 aliased or if we may use a renaming pointer; otherwise we can
903 optimize and return the rvalue. We make an exception if the object
904 is an identifier since in this case the rvalue can be propagated
905 attached to the CONST_DECL. */
907 || aliased
908 /* This should match the constant case of the renaming code. */
909 || Is_Composite_Type
914 /* We cannot use a constructor if this is an atomic object because
915 the actual assignment might end up being done component-wise. */
919 /* We don't use a constructor if this is a class-wide object
920 because the effective type of the object is the equivalent
921 type of the class-wide subtype and it smashes most of the
922 data into an array of bytes to which we cannot convert. */
927 /* We cannot use a constructor if the LHS is an atomic object because
928 the actual assignment might end up being done component-wise. */
938 /* ... fall through ... */
942 /* We must look through all conversions because we may need to bypass
943 an intermediate conversion that is meant to be purely formal. */
949 /* We should only reach here through the N_Qualified_Expression case.
950 Force an lvalue for composite types since a block-copy to the newly
951 allocated area of memory is made. */
955 /* We look through dereferences for address of constant because we need
956 to handle the special cases listed above. */
962 /* ... fall through ... */
966 }
969 }
971 /* Subroutine of gnat_to_gnu to translate gnat_node, an N_Identifier,
972 to a GCC tree, which is returned. GNU_RESULT_TYPE_P is a pointer
973 to where we should place the result type. */
975 static tree
977 {
981 /* Whether we should require an lvalue for GNAT_NODE. Needed in
982 specific circumstances only, so evaluated lazily. < 0 means
983 unknown, > 0 means known true, 0 means known false. */
986 /* If GNAT_NODE is a constant, whether we should use the initialization
987 value instead of the constant entity, typically for scalars with an
988 address clause when the parent doesn't require an lvalue. */
991 /* If the Etype of this node does not equal the Etype of the Entity,
992 something is wrong with the entity map, probably in generic
993 instantiation. However, this does not apply to types. Since we sometime
994 have strange Ekind's, just do this test for objects. Also, if the Etype of
995 the Entity is private, the Etype of the N_Identifier is allowed to be the
996 full type and also we consider a packed array type to be the same as the
997 original type. Similarly, a class-wide type is equivalent to a subtype of
998 itself. Finally, if the types are Itypes, one may be a copy of the other,
999 which is also legal. */
1022 /* If this is a reference to a deferred constant whose partial view is an
1023 unconstrained private type, the proper type is on the full view of the
1024 constant, not on the full view of the type, which may be unconstrained.
1026 This may be a reference to a type, for example in the prefix of the
1027 attribute Position, generated for dispatching code (see Make_DT in
1028 exp_disp,adb). In that case we need the type itself, not is parent,
1029 in particular if it is a derived type */
1036 {
1039 }
1040 else
1041 {
1042 /* We want to use the Actual_Subtype if it has already been elaborated,
1043 otherwise the Etype. Avoid using Actual_Subtype for packed arrays to
1044 simplify things. */
1052 else
1054 }
1056 /* Expand the type of this identifier first, in case it is an enumeral
1057 literal, which only get made when the type is expanded. There is no
1058 order-of-elaboration issue here. */
1061 /* If this is a non-imported elementary constant with an address clause,
1062 retrieve the value instead of a pointer to be dereferenced unless
1063 an lvalue is required. This is generally more efficient and actually
1064 required if this is a static expression because it might be used
1065 in a context where a dereference is inappropriate, such as a case
1066 statement alternative or a record discriminant. There is no possible
1067 volatile-ness short-circuit here since Volatile constants must be
1068 imported per C.6. */
1073 {
1077 }
1080 {
1081 /* If this is a deferred constant, the initializer is attached to
1082 the full view. */
1087 }
1088 else
1091 /* Some objects (such as parameters passed by reference, globals of
1092 variable size, and renamed objects) actually represent the address
1093 of the object. In that case, we must do the dereference. Likewise,
1094 deal with parameters to foreign convention subprograms. */
1099 {
1102 /* If it's a PARM_DECL to foreign convention subprogram, convert it. */
1105 gnu_result
1108 /* If it's a CONST_DECL, return the underlying constant like below. */
1115 /* If it's a renaming pointer and we are at the right binding level,
1116 we can reference the renamed object directly, since the renamed
1117 expression has been protected against multiple evaluations. */
1124 /* Otherwise, do the final dereference. */
1125 else
1126 {
1136 }
1137 }
1139 /* If we have a constant declaration and its initializer, try to return the
1140 latter to avoid the need to call fold in lots of places and the need for
1141 elaboration code if this identifier is used as an initializer itself.
1142 Don't do it for aggregate types that contain a placeholder since their
1143 initializers cannot be manipulated easily. */
1150 {
1156 /* If there is a (corresponding) variable or this is the address of a
1157 constant, we only want to return the initializer if an lvalue isn't
1158 required. Evaluate this now if we have not already done so. */
1160 require_lvalue
1164 /* Finally retrieve the initializer if this is deemed valid. */
1167 }
1169 /* The GNAT tree has the type of a function set to its result type, so we
1170 adjust here. Also use the type of the result if the Etype is a subtype
1171 that is nominally unconstrained. Likewise if this is a deferred constant
1172 of a discriminated type whose full view can be elaborated statically, to
1173 avoid problematic conversions to the nominal subtype. But remove any
1174 padding from the resulting type. */
1181 {
1185 }
1190 }
1191 \f
1192 /* Subroutine of gnat_to_gnu to process gnat_node, an N_Pragma. Return
1193 any statements we generate. */
1195 static tree
1197 {
1200 Node_Id gnat_temp;
1202 /* Do nothing if we are just annotating types and check for (and ignore)
1203 unrecognized pragmas. */
1210 {
1212 /* Do nothing at top level: all such variables are already viewable. */
1219 {
1225 #ifdef ASM_COMMENT_START
1227 #endif
1232 /* Use the value only if it fits into a normal register,
1233 otherwise use the address. */
1242 #ifdef ASM_COMMENT_START
1248 NULL);
1251 #endif
1253 asm_constraint,
1254 NULL_TREE,
1255 tree_cons
1263 }
1270 {
1274 {
1297 }
1298 }
1304 {
1322 }
1332 {
1333 Node_Id gnat_expr;
1334 /* Preserve the location of the pragma. */
1338 diagnostic_t kind;
1343 /* This is the String form: pragma Warning{s|_As_Error}(String). */
1345 {
1347 {
1360 }
1363 }
1365 /* This is the On/Off form: pragma Warnings (On | Off [,String]). */
1367 {
1369 {
1380 }
1383 {
1384 /* pragma Warnings (On | Off, Name) is handled differently. */
1389 }
1390 else
1394 }
1396 else
1399 /* This is the same implementation as in the C family of compilers. */
1401 {
1409 option_index++)
1413 {
1416 }
1417 }
1418 else
1425 }
1430 }
1433 }
1434 \f
1435 /* Subroutine of gnat_to_gnu to translate GNAT_NODE, an N_Attribute node,
1436 to a GCC tree, which is returned. GNU_RESULT_TYPE_P is a pointer to
1437 where we should place the result type. ATTRIBUTE is the attribute ID. */
1439 static tree
1441 {
1447 /* ??? If this is an access attribute for a public subprogram to be used in
1448 a dispatch table, do not translate its type as it's useless there and the
1449 parameter types might be incomplete types coming from a limited with. */
1457 else
1461 /* If the input is a NULL_EXPR, make a new one. */
1463 {
1467 }
1470 {
1473 /* These are just conversions since representation clauses for
1474 enumeration types are handled in the front-end. */
1475 {
1481 }
1486 /* These just add or subtract the constant 1 since representation
1487 clauses for enumeration types are handled in the front-end. */
1492 {
1494 gnu_expr
1495 = emit_check
1497 gnu_expr,
1498 attribute == Attr_Pred
1502 }
1504 gnu_result
1512 /* Conversions don't change addresses but can cause us to miss the
1513 COMPONENT_REF case below, so strip them off. */
1517 /* If we are taking 'Address of an unconstrained object, this is the
1518 pointer to the underlying array. */
1522 /* If we are building a static dispatch table, we have to honor
1523 TARGET_VTABLE_USES_DESCRIPTORS if we want to be compatible
1524 with the C++ ABI. We do it in the non-static case as well,
1525 see gnat_to_gnu_entity, case E_Access_Subprogram_Type. */
1528 {
1530 /* Descriptors can only be built here for top-level functions. */
1538 /* If we're not going to build the descriptor, we have to retrieve
1539 the one which will be built by the linker (or by the compiler
1540 later if a static chain is requested). */
1542 {
1545 gnu_result);
1547 }
1554 {
1556 {
1560 }
1561 else
1567 elt--;
1568 }
1572 }
1574 /* ... fall through ... */
1580 gnu_result
1587 /* For 'Code_Address, find an inner ADDR_EXPR and mark it so that we
1588 don't try to build a trampoline. */
1590 {
1595 }
1597 /* For 'Access, issue an error message if the prefix is a C++ method
1598 since it can use a special calling convention on some platforms,
1599 which cannot be propagated to the access type. */
1604 gnat_node);
1606 /* For other address attributes applied to a nested function,
1607 find an inner ADDR_EXPR and annotate it so that we can issue
1608 a useful warning with -Wtrampolines. */
1610 {
1615 {
1618 /* Check that we're not violating the No_Implicit_Dynamic_Code
1619 restriction. Be conservative if we don't know anything
1620 about the trampoline strategy for the target. */
1622 }
1623 }
1627 {
1629 tree gnu_obj_type;
1633 /* If this is fat pointer, the object must have been allocated with the
1634 template in front of the array. So compute the template address; do
1635 it by converting to a thin pointer. */
1637 gnu_ptr
1639 (TYPE_OBJECT_RECORD_TYPE
1641 gnu_ptr);
1645 /* If this is a thin pointer, the object must have been allocated with
1646 the template in front of the array. So compute the template address
1647 and return it. */
1649 gnu_ptr
1651 gnu_ptr,
1653 byte_position
1654 (DECL_CHAIN
1658 }
1667 /* Remove NOPs and conversions between original and packable version
1668 from GNU_EXPR, and conversions from GNU_PREFIX. We use GNU_EXPR
1669 to see if a COMPONENT_REF was involved. */
1674 == RECORD_TYPE
1683 /* Replace an unconstrained array type with the type of the underlying
1684 array. We can't do this with a call to maybe_unconstrained_array
1685 since we may have a TYPE_DECL. For 'Max_Size_In_Storage_Elements,
1686 use the record type that will be used to allocate the object and its
1687 template. */
1689 {
1693 }
1695 /* If we're looking for the size of a field, return the field size. */
1699 /* Otherwise, if the prefix is an object, or if we are looking for
1700 'Object_Size or 'Max_Size_In_Storage_Elements, the result is the
1701 GCC size of the type. We make an exception for padded objects,
1702 as we do not take into account alignment promotions for the size.
1703 This is in keeping with the object case of gnat_to_gnu_entity. */
1709 {
1710 /* If this is a dereference and we have a special dynamic constrained
1711 subtype on the prefix, use it to compute the size; otherwise, use
1712 the designated subtype. */
1714 {
1715 Node_Id gnat_actual_subtype
1717 tree gnu_ptr_type
1722 {
1723 tree gnu_actual_obj_type
1725 gnu_type
1727 gnu_actual_obj_type,
1730 }
1731 }
1734 }
1736 /* Otherwise, the result is the RM size of the type. */
1737 else
1740 /* Deal with a self-referential size by returning the maximum size for
1741 a type and by qualifying the size with the object otherwise. */
1743 {
1746 else
1748 }
1750 /* If the type contains a template, subtract its size. */
1756 /* For 'Max_Size_In_Storage_Elements, adjust the unit. */
1764 {
1777 else
1778 {
1783 /* If the default alignment of "double" or larger scalar types is
1784 specifically capped and there is an alignment clause neither
1785 on the type nor on the prefix itself, return the cap. */
1787 is_capped_double
1790 is_capped_double
1792 else
1802 else
1804 }
1807 }
1816 {
1823 else
1824 gnu_result
1825 = build_binary_op
1827 build_binary_op
1839 }
1841 /* ... fall through ... */
1844 {
1852 /* Make sure any implicit dereference gets done. */
1856 /* We treat unconstrained array In parameters specially. We also note
1857 whether we are dereferencing a pointer to unconstrained array. */
1860 {
1862 /* This is the direct case. */
1868 /* This is the indirect case. Note that we need to be sure that
1869 the access value cannot be null as we'll hoist the load. */
1872 {
1875 }
1876 else
1882 }
1884 /* If the prefix is the view conversion of a constrained array to an
1885 unconstrained form, we retrieve the constrained array because we
1886 might not be able to substitute the PLACEHOLDER_EXPR coming from
1887 the conversion. This can occur with the 'Old attribute applied
1888 to a parameter with an unconstrained type, which gets rewritten
1889 into a constrained local variable very late in the game. */
1892 && !CONTAINS_PLACEHOLDER_P
1895 else
1902 {
1904 tree gnu_type_temp;
1910 ;
1913 }
1920 /* When not optimizing, look up the slot associated with the parameter
1921 and the dimension in the cache and create a new one on failure. */
1923 {
1929 {
1934 }
1935 }
1937 /* Return the cached expression or build a new one. */
1939 {
1941 {
1944 }
1946 gnu_result
1948 }
1951 {
1953 {
1956 }
1958 gnu_result
1960 }
1963 {
1965 {
1968 }
1969 else
1970 {
1971 /* We used to compute the length as max (hb - lb + 1, 0),
1972 which could overflow for some cases of empty arrays, e.g.
1973 when lb == index_type'first. We now compute the length as
1974 (hb >= lb) ? hb - lb + 1 : 0, which would only overflow in
1975 much rarer cases, for extremely large arrays we expect
1976 never to encounter in practice. In addition, the former
1977 computation required the use of potentially constraining
1978 signed arithmetic while the latter doesn't. Note that
1979 the comparison must be done in the original index type,
1980 to avoid any overflow during the conversion. */
1985 gnu_result
1988 comp_type,
1992 gnu_result
1995 boolean_type_node,
1997 gnu_result,
1999 }
2000 }
2002 /* If this has a PLACEHOLDER_EXPR, qualify it by the object we are
2003 handling. Note that these attributes could not have been used on
2004 an unconstrained array type. */
2007 /* Cache the expression we have just computed. Since we want to do it
2008 at run time, we force the use of a SAVE_EXPR and let the gimplifier
2009 create the temporary in the outermost binding level. We will make
2010 sure in Subprogram_Body_to_gnu that it is evaluated on all possible
2011 paths by forcing its evaluation on entry of the function. */
2013 {
2014 gnu_result
2017 {
2033 }
2034 }
2036 /* Otherwise, evaluate it each time it is referenced. */
2037 else
2039 {
2042 /* If we are dereferencing a pointer to unconstrained array, we
2043 need to capture the value because the pointed-to bounds may
2044 subsequently be released. */
2046 gnu_result
2052 /* Set the source location onto the predicate of the condition
2053 but not if the expression is cached to avoid messing up the
2054 debug info. */
2058 gnat_node);
2063 }
2066 }
2073 {
2074 HOST_WIDE_INT bitsize;
2075 HOST_WIDE_INT bitpos;
2076 tree gnu_offset;
2077 tree gnu_field_bitpos;
2078 tree gnu_field_offset;
2079 tree gnu_inner;
2087 /* We can have 'Bit on any object, but if it isn't a COMPONENT_REF,
2088 the result is 0. Don't allow 'Bit on a bare component, though. */
2092 {
2095 }
2097 else
2106 {
2114 {
2115 gnu_field_bitpos
2118 gnu_field_offset
2121 }
2122 }
2124 {
2127 }
2128 else
2129 {
2132 }
2135 {
2149 /* ??? Avoid a large unsigned result that will overflow when
2150 converted to the signed universal_integer. */
2153 else
2154 gnu_result
2161 }
2163 /* If this has a PLACEHOLDER_EXPR, qualify it by the object we are
2164 handling. */
2167 }
2171 {
2179 }
2205 /* Note this size cannot be self-referential. */
2215 /* What we want is the offset of the ARRAY field in the record
2216 that the thin pointer designates. */
2224 /* This is just a zero cast to the pointer type for our prefix and
2225 dereferenced. */
2227 gnu_result
2230 integer_zero_node));
2235 {
2242 {
2247 ;
2248 }
2256 && (DECL_BY_COMPONENT_PTR_P
2260 }
2264 /* This abort means that we have an unimplemented attribute. */
2266 }
2268 /* If this is an attribute where the prefix was unused, force a use of it if
2269 it has a side-effect. But don't do it if the prefix is just an entity
2270 name. However, if an access check is needed, we must do it. See second
2271 example in AARM 11.6(5.e). */
2275 gnu_result
2280 }
2281 \f
2282 /* Subroutine of gnat_to_gnu to translate gnat_node, an N_Case_Statement,
2283 to a GCC tree, which is returned. */
2285 static tree
2287 {
2289 Node_Id gnat_when;
2290 location_t end_locus;
2296 /* The range of values in a case statement is determined by the rules in
2297 RM 5.4(7-9). In almost all cases, this range is represented by the Etype
2298 of the expression. One exception arises in the case of a simple name that
2299 is parenthesized. This still has the Etype of the name, but since it is
2300 not a name, para 7 does not apply, and we need to go to the base type.
2301 This is the only case where parenthesization affects the dynamic
2302 semantics (i.e. the range of possible values at run time that is covered
2303 by the others alternative).
2305 Another exception is if the subtype of the expression is non-static. In
2306 that case, we also have to use the base type. */
2312 /* We build a SWITCH_EXPR that contains the code with interspersed
2313 CASE_LABEL_EXPRs for each label. */
2323 {
2325 Node_Id gnat_choice;
2327 /* First compile all the different case choices for the current WHEN
2328 alternative. */
2331 {
2335 {
2350 /* This represents either a subtype range or a static value of
2351 some kind; Ekind says which. */
2353 {
2359 }
2361 /* ... fall through ... */
2373 }
2375 /* If the case value is a subtype that raises Constraint_Error at
2376 run time because of a wrong bound, then gnu_low or gnu_high is
2377 not translated into an INTEGER_CST. In such a case, we need
2378 to ensure that the when statement is not added in the tree,
2379 otherwise it will crash the gimplifier. */
2382 {
2386 gnat_choice);
2388 }
2389 }
2391 /* This construct doesn't define a scope so we shouldn't push a binding
2392 level around the statement list. Except that we have always done so
2393 historically and this makes it possible to reduce stack usage. As a
2394 compromise, we keep doing it for case statements, for which this has
2395 never been problematic, but not for case expressions in Ada 2012. */
2397 {
2398 const bool is_case_expression
2400 tree group
2405 {
2410 }
2411 }
2412 }
2414 /* Now emit a definition of the label the cases branch to, if any. */
2421 }
2422 \f
2423 /* Find out whether VAR is an iteration variable of an enclosing loop in the
2424 current function. If so, push a range_check_info structure onto the stack
2425 of this enclosing loop and return it. Otherwise, return NULL. */
2429 {
2446 i--)
2451 {
2455 }
2458 }
2460 /* Return true if VAL (of type TYPE) can equal the minimum value if MAX is
2461 false, or the maximum value if MAX is true, of TYPE. */
2463 static bool
2465 {
2472 val = (max
2481 else
2483 }
2485 /* Return true if VAL (of type TYPE) can equal the minimum value of TYPE.
2486 If REVERSE is true, minimum value is taken as maximum value. */
2490 {
2492 }
2494 /* Return true if VAL (of type TYPE) can equal the maximum value of TYPE.
2495 If REVERSE is true, maximum value is taken as minimum value. */
2499 {
2501 }
2503 /* Return true if VAL1 can be lower than VAL2. */
2505 static bool
2507 {
2521 }
2523 /* Subroutine of gnat_to_gnu to translate gnat_node, an N_Loop_Statement,
2524 to a GCC tree, which is returned. */
2526 static tree
2528 {
2535 tree gnu_result;
2537 /* Push the loop_info structure associated with the LOOP_STMT. */
2540 /* Set location information for statement and end label. */
2546 /* Save the statement for later reuse. */
2549 /* Set the condition under which the loop must keep going.
2550 For the case "LOOP .... END LOOP;" the condition is always true. */
2552 ;
2554 /* For the case "WHILE condition LOOP ..... END LOOP;" it's immediate. */
2559 /* Otherwise we have an iteration scheme and the condition is given by the
2560 bounds of the subtype of the iteration variable. */
2561 else
2562 {
2576 /* We must disable modulo reduction for the iteration variable, if any,
2577 in order for the loop comparison to be effective. */
2579 {
2585 }
2586 else
2587 {
2593 }
2595 /* We use two different strategies to translate the loop, depending on
2596 whether optimization is enabled.
2598 If it is, we generate the canonical loop form expected by the loop
2599 optimizer and the loop vectorizer, which is the do-while form:
2601 ENTRY_COND
2602 loop:
2603 TOP_UPDATE
2604 BODY
2605 BOTTOM_COND
2606 GOTO loop
2608 This avoids an implicit dependency on loop header copying and makes
2609 it possible to turn BOTTOM_COND into an inequality test.
2611 If optimization is disabled, loop header copying doesn't come into
2612 play and we try to generate the loop form with the fewer conditional
2613 branches. First, the default form, which is:
2615 loop:
2616 TOP_COND
2617 BODY
2618 BOTTOM_UPDATE
2619 GOTO loop
2621 It should catch most loops with constant ending point. Then, if we
2622 cannot, we try to generate the shifted form:
2624 loop:
2625 TOP_COND
2626 TOP_UPDATE
2627 BODY
2628 GOTO loop
2630 which should catch loops with constant starting point. Otherwise, if
2631 we cannot, we generate the fallback form:
2633 ENTRY_COND
2634 loop:
2635 BODY
2636 BOTTOM_COND
2637 BOTTOM_UPDATE
2638 GOTO loop
2640 which works in all cases. */
2643 {
2644 /* We can use the do-while form directly if GNU_FIRST-1 doesn't
2645 overflow. */
2647 ;
2649 /* Otherwise, use the do-while form with the help of a special
2650 induction variable in the unsigned version of the base type
2651 or the unsigned version of the size type, whichever is the
2652 largest, in order to have wrap-around arithmetics for it. */
2653 else
2654 {
2657 gnu_base_type
2659 else
2666 }
2668 gnu_first
2670 gnu_one_node);
2673 }
2674 else
2675 {
2676 /* We can use the default form if GNU_LAST+1 doesn't overflow. */
2678 ;
2680 /* Otherwise, we can use the shifted form if neither GNU_FIRST-1 nor
2681 GNU_LAST-1 does. */
2684 {
2685 gnu_first
2687 gnu_one_node);
2688 gnu_last
2690 gnu_one_node);
2692 }
2694 /* Otherwise, use the fallback form. */
2695 else
2697 }
2699 /* If we use the BOTTOM_COND, we can turn the test into an inequality
2700 test but we may have to add ENTRY_COND to protect the empty loop. */
2702 {
2705 {
2706 gnu_cond_expr
2712 }
2713 }
2715 /* Open a new nesting level that will surround the loop to declare the
2716 iteration variable. */
2720 /* If we use the special induction variable, create it and set it to
2721 its initial value. Morever, the regular iteration variable cannot
2722 itself be initialized, lest the initial value wrapped around. */
2724 {
2725 gnu_loop_iv
2729 }
2730 else
2733 /* Declare the iteration variable and set it to its initial value. */
2738 {
2741 }
2744 /* Do all the arithmetics in the base type. */
2747 /* Set either the top or bottom exit condition. */
2751 gnu_last);
2752 else
2755 gnu_last);
2757 /* Set either the top or bottom update statement and give it the source
2758 location of the iteration for better coverage info. */
2760 {
2761 gnu_stmt
2768 gnu_stmt
2770 gnu_loop_iv);
2774 }
2775 else
2776 {
2777 gnu_stmt
2783 }
2784 }
2786 /* If the loop was named, have the name point to this loop. In this case,
2787 the association is not a DECL node, but the end label of the loop. */
2791 /* Make the loop body into its own block, so any allocated storage will be
2792 released every iteration. This is needed for stack allocation. */
2797 /* If we have an iteration scheme, then we are in a statement group. Add
2798 the LOOP_STMT to it, finish it and make it the "loop". */
2800 {
2805 /* First, if we have computed a small number of invariant conditions for
2806 range checks applied to the iteration variable, then initialize these
2807 conditions in front of the loop. Otherwise, leave them set to true.
2809 ??? The heuristics need to be improved, by taking into account the
2810 following datapoints:
2811 - loop unswitching is disabled for big loops. The cap is the
2812 parameter PARAM_MAX_UNSWITCH_INSNS (50).
2813 - loop unswitching can only be applied a small number of times
2814 to a given loop. The cap is PARAM_MAX_UNSWITCH_LEVEL (3).
2815 - the front-end quickly generates useless or redundant checks
2816 that can be entirely optimized away in the end. */
2820 i++)
2821 {
2822 tree low_ok
2829 tree high_ok
2836 tree range_ok
2844 }
2849 }
2851 /* If we have an outer COND_EXPR, that's our result and this loop is its
2852 "true" statement. Otherwise, the result is the LOOP_STMT. */
2854 {
2858 }
2859 else
2865 }
2866 \f
2867 /* Emit statements to establish __gnat_handle_vms_condition as a VMS condition
2868 handler for the current function. */
2870 /* This is implemented by issuing a call to the appropriate VMS specific
2871 builtin. To avoid having VMS specific sections in the global gigi decls
2872 array, we maintain the decls of interest here. We can't declare them
2873 inside the function because we must mark them never to be GC'd, which we
2874 can only do at the global level. */
2879 static void
2881 {
2882 tree establish_stmt;
2884 /* Elaborate the required decls on the first call. Check on the decl for
2885 the gnat condition handler to decide, as this is one we create so we are
2886 sure that it will be non null on subsequent calls. The builtin decl is
2887 looked up so remains null on targets where it is not implemented yet. */
2889 {
2890 vms_builtin_establish_handler_decl
2891 = builtin_decl_for
2894 gnat_vms_condition_handler_decl
2896 NULL_TREE,
2898 ptr_void_type_node,
2899 ptr_void_type_node,
2900 NULL_TREE),
2902 Empty);
2904 /* ??? DECL_CONTEXT shouldn't have been set because of DECL_EXTERNAL. */
2906 }
2908 /* Do nothing if the establish builtin is not available, which might happen
2909 on targets where the facility is not implemented. */
2913 establish_stmt
2915 build_unary_op
2917 gnat_vms_condition_handler_decl));
2920 }
2922 /* This page implements a form of Named Return Value optimization modelled
2923 on the C++ optimization of the same name. The main difference is that
2924 we disregard any semantical considerations when applying it here, the
2925 counterpart being that we don't try to apply it to semantically loaded
2926 return types, i.e. types with the TYPE_BY_REFERENCE_P flag set.
2928 We consider a function body of the following GENERIC form:
2930 return_type R1;
2931 [...]
2932 RETURN_EXPR [<retval> = ...]
2933 [...]
2934 RETURN_EXPR [<retval> = R1]
2935 [...]
2936 return_type Ri;
2937 [...]
2938 RETURN_EXPR [<retval> = ...]
2939 [...]
2940 RETURN_EXPR [<retval> = Ri]
2941 [...]
2943 and we try to fulfill a simple criterion that would make it possible to
2944 replace one or several Ri variables with the RESULT_DECL of the function.
2946 The first observation is that RETURN_EXPRs that don't directly reference
2947 any of the Ri variables on the RHS of their assignment are transparent wrt
2948 the optimization. This is because the Ri variables aren't addressable so
2949 any transformation applied to them doesn't affect the RHS; moreover, the
2950 assignment writes the full <retval> object so existing values are entirely
2951 discarded.
2953 This property can be extended to some forms of RETURN_EXPRs that reference
2954 the Ri variables, for example CONSTRUCTORs, but isn't true in the general
2955 case, in particular when function calls are involved.
2957 Therefore the algorithm is as follows:
2959 1. Collect the list of candidates for a Named Return Value (Ri variables
2960 on the RHS of assignments of RETURN_EXPRs) as well as the list of the
2961 other expressions on the RHS of such assignments.
2963 2. Prune the members of the first list (candidates) that are referenced
2964 by a member of the second list (expressions).
2966 3. Extract a set of candidates with non-overlapping live ranges from the
2967 first list. These are the Named Return Values.
2969 4. Adjust the relevant RETURN_EXPRs and replace the occurrences of the
2970 Named Return Values in the function with the RESULT_DECL.
2972 If the function returns an unconstrained type, things are a bit different
2973 because the anonymous return object is allocated on the secondary stack
2974 and RESULT_DECL is only a pointer to it. Each return object can be of a
2975 different size and is allocated separately so we need not care about the
2976 aforementioned overlapping issues. Therefore, we don't collect the other
2977 expressions and skip step #2 in the algorithm. */
2979 struct nrv_data
2980 {
2981 bitmap nrv;
2982 tree result;
2983 Node_Id gnat_ret;
2985 };
2987 /* Return true if T is a Named Return Value. */
2991 {
2993 }
2995 /* Helper function for walk_tree, used by finalize_nrv below. */
2997 static tree
2999 {
3003 /* No need to walk into types or decls. */
3011 }
3013 /* Prune Named Return Values in BLOCK and return true if there is still a
3014 Named Return Value in BLOCK or one of its sub-blocks. */
3016 static bool
3018 {
3020 tree t;
3022 /* First recurse on the sub-blocks. */
3026 /* Then make sure to keep at most one NRV per block. */
3029 {
3032 else
3034 }
3037 }
3039 /* Helper function for walk_tree, used by finalize_nrv below. */
3041 static tree
3043 {
3047 /* No need to walk into types. */
3051 /* Change RETURN_EXPRs of NRVs to just refer to the RESULT_DECL; this is a
3052 nop, but differs from using NULL_TREE in that it indicates that we care
3053 about the value of the RESULT_DECL. */
3056 {
3059 /* If this is the temporary created for a return value with variable
3060 size in Call_to_gnu, we replace the RHS with the init expression. */
3065 {
3068 }
3069 else
3072 /* Strip useless conversions around the return value. */
3077 {
3080 else
3082 }
3083 }
3085 /* Replace the DECL_EXPR of NRVs with an initialization of the RESULT_DECL,
3086 if needed. */
3089 {
3093 {
3098 }
3099 else
3103 /* Identify the NRV to the RESULT_DECL for debugging purposes. */
3106 /* ??? Kludge to avoid an assertion failure during inlining. */
3109 }
3111 /* And replace all uses of NRVs with the RESULT_DECL. */
3115 /* Avoid walking into the same tree more than once. Unfortunately, we
3116 can't just use walk_tree_without_duplicates because it would only
3117 call us for the first occurrence of NRVs in the function body. */
3122 }
3124 /* Likewise, but used when the function returns an unconstrained type. */
3126 static tree
3128 {
3132 /* No need to walk into types. */
3136 /* We need to see the DECL_EXPR of NRVs before any other references so we
3137 walk the body of BIND_EXPR before walking its variables. */
3141 /* Change RETURN_EXPRs of NRVs to assign to the RESULT_DECL only the final
3142 return value built by the allocator instead of the whole construct. */
3145 {
3148 /* This is the construct returned by the allocator. */
3151 {
3153 ret_val
3156 else
3158 }
3160 /* Strip useless conversions around the return value. */
3165 /* Strip unpadding around the return value. */
3170 /* Assign the new return value to the RESULT_DECL. */
3174 }
3176 /* Adjust the DECL_EXPR of NRVs to call the allocator and save the result
3177 into a new variable. */
3180 {
3187 /* Create an artificial context to build the allocation. */
3192 /* This will return a COMPOUND_EXPR with the allocation in the first
3193 arm and the final return value in the second arm. */
3200 /* The new variable is built as a reference to the allocated space. */
3201 new_var
3207 {
3208 /* The new initial value is a COMPOUND_EXPR with the allocation in
3209 the first arm and the value of P_ARRAY in the second arm. */
3215 /* Build a modified CONSTRUCTOR that references NEW_VAR. */
3223 }
3224 else
3225 {
3226 /* The new initial value is just the allocation. */
3229 }
3233 /* Destroy the artificial context and insert the new statements. */
3238 /* Chain NEW_VAR immediately after VAR and ignore the latter. */
3243 /* Save the new return value and the dereference of NEW_VAR. */
3247 /* ??? Kludge to avoid messing up during inlining. */
3249 }
3251 /* And replace all uses of NRVs with the dereference of NEW_VAR. */
3255 /* Avoid walking into the same tree more than once. Unfortunately, we
3256 can't just use walk_tree_without_duplicates because it would only
3257 call us for the first occurrence of NRVs in the function body. */
3262 }
3264 /* Finalize the Named Return Value optimization for FNDECL. The NRV bitmap
3265 contains the candidates for Named Return Value and OTHER is a list of
3266 the other return values. GNAT_RET is a representative return node. */
3268 static void
3270 {
3273 walk_tree_fn func;
3275 tree iter;
3277 /* We shouldn't be applying the optimization to return types that we aren't
3278 allowed to manipulate freely. */
3281 /* Prune the candidates that are referenced by other return values. */
3290 /* Prune also the candidates that are referenced by nested functions. */
3298 /* Extract a set of NRVs with non-overlapping live ranges. */
3302 /* Adjust the relevant RETURN_EXPRs and replace the occurrences of NRVs. */
3309 else
3313 }
3315 /* Return true if RET_VAL can be used as a Named Return Value for the
3316 anonymous return object RET_OBJ. */
3318 static bool
3320 {
3340 }
3342 /* Build a RETURN_EXPR. If RET_VAL is non-null, build a RETURN_EXPR around
3343 the assignment of RET_VAL to RET_OBJ. Otherwise build a bare RETURN_EXPR
3344 around RESULT_OBJ, which may be null in this case. */
3346 static tree
3348 {
3349 tree result_expr;
3352 {
3353 /* The gimplifier explicitly enforces the following invariant:
3355 RETURN_EXPR
3356 |
3357 MODIFY_EXPR
3358 / \
3359 / \
3360 RET_OBJ ...
3362 As a consequence, type consistency dictates that we use the type
3363 of the RET_OBJ as the operation type. */
3366 /* Convert the right operand to the operation type. Note that it's the
3367 same transformation as in the MODIFY_EXPR case of build_binary_op,
3368 with the assumption that the type cannot involve a placeholder. */
3374 /* If the function returns an aggregate type, find out whether this is
3375 a candidate for Named Return Value. If so, record it. Otherwise,
3376 if this is an expression of some kind, record it elsewhere. */
3382 {
3383 /* Recognize the temporary created for a return value with variable
3384 size in Call_to_gnu. We want to eliminate it if possible. */
3391 /* Strip useless conversions around the return value. */
3395 /* Now apply the test to the return value. */
3397 {
3401 }
3403 /* Note that we need not care about CONSTRUCTORs here, as they are
3404 totally transparent given the read-compose-write semantics of
3405 assignments from CONSTRUCTORs. */
3408 }
3409 }
3410 else
3414 }
3416 /* Build a stub for the subprogram specified by the GCC tree GNU_SUBPROG
3417 and the GNAT node GNAT_SUBPROG. */
3419 static void
3421 {
3429 /* Initialize the information structure for the function. */
3438 /* Loop over the parameters of the stub and translate any of them
3439 passed by descriptor into a by reference one. */
3442 gnu_stub_param;
3445 {
3447 {
3449 gnu_param
3451 gnu_stub_param,
3453 gnat_subprog);
3454 }
3455 else
3459 }
3461 /* Invoke the internal subprogram. */
3463 gnu_subprog);
3467 /* Propagate the return value, if any. */
3470 else
3472 gnu_subprog_call));
3477 }
3478 \f
3479 /* Subroutine of gnat_to_gnu to process gnat_node, an N_Subprogram_Body. We
3480 don't return anything. */
3482 static void
3484 {
3485 /* Defining identifier of a parameter to the subprogram. */
3486 Entity_Id gnat_param;
3487 /* The defining identifier for the subprogram body. Note that if a
3488 specification has appeared before for this body, then the identifier
3489 occurring in that specification will also be a defining identifier and all
3490 the calls to this subprogram will point to that specification. */
3491 Entity_Id gnat_subprog_id
3494 /* The FUNCTION_DECL node corresponding to the subprogram spec. */
3495 tree gnu_subprog_decl;
3496 /* Its RESULT_DECL node. */
3497 tree gnu_result_decl;
3498 /* Its FUNCTION_TYPE node. */
3499 tree gnu_subprog_type;
3500 /* The TYPE_CI_CO_LIST of its FUNCTION_TYPE node, if any. */
3501 tree gnu_cico_list;
3502 /* The entry in the CI_CO_LIST that represents a function return, if any. */
3504 tree gnu_result;
3508 /* If this is a generic object or if it has been eliminated,
3509 ignore it. */
3515 /* If this subprogram acts as its own spec, define it. Otherwise, just get
3516 the already-elaborated tree node. However, if this subprogram had its
3517 elaboration deferred, we will already have made a tree node for it. So
3518 treat it as not being defined in that case. Such a subprogram cannot
3519 have an address clause or a freeze node, so this test is safe, though it
3520 does disable some otherwise-useful error checking. */
3521 gnu_subprog_decl
3531 /* If the function returns by invisible reference, make it explicit in the
3532 function body. See gnat_to_gnu_entity, E_Subprogram_Type case.
3533 Handle the explicit case here and the copy-in/copy-out case below. */
3535 {
3539 }
3541 /* Set the line number in the decl to correspond to that of the body so that
3542 the line number notes are written correctly. */
3545 /* Initialize the information structure for the function. */
3553 /* If there are In Out or Out parameters, we need to ensure that the return
3554 statement properly copies them out. We do this by making a new block and
3555 converting any return into a goto to a label at the end of the block. */
3557 {
3566 /* If this is a function with In Out or Out parameters, we also need a
3567 variable for the return value to be placed. */
3569 {
3570 tree gnu_return_type
3573 /* If the function returns by invisible reference, make it
3574 explicit in the function body. See gnat_to_gnu_entity,
3575 E_Subprogram_Type case. */
3579 gnu_return_var
3584 }
3588 /* See whether there are parameters for which we don't have a GCC tree
3589 yet. These must be Out parameters. Make a VAR_DECL for them and
3590 put it into TYPE_CI_CO_LIST, which must contain an empty entry too.
3591 We can match up the entries because TYPE_CI_CO_LIST is in the order
3592 of the parameters. */
3597 {
3599 tree gnu_decl;
3601 /* Skip any entries that have been already filled in; they must
3602 correspond to In Out parameters. */
3606 /* Do any needed dereferences for by-ref objects. */
3612 /* Do any needed references for padded types. */
3615 }
3616 }
3617 else
3620 /* Get a tree corresponding to the code for the subprogram. */
3624 /* On VMS, establish our condition handler to possibly turn a condition into
3625 the corresponding exception if the subprogram has a foreign convention or
3626 is exported.
3628 To ensure proper execution of local finalizations on condition instances,
3629 we must turn a condition into the corresponding exception even if there
3630 is no applicable Ada handler, and need at least one condition handler per
3631 possible call chain involving GNAT code. OTOH, establishing the handler
3632 has a cost so we want to minimize the number of subprograms into which
3633 this happens. The foreign or exported condition is expected to satisfy
3634 all the constraints. */
3642 /* Generate the code of the subprogram itself. A return statement will be
3643 present and any Out parameters will be handled there. */
3648 /* If we populated the parameter attributes cache, we need to make sure that
3649 the cached expressions are evaluated on all the possible paths leading to
3650 their uses. So we force their evaluation on entry of the function. */
3653 {
3660 {
3667 }
3673 }
3675 /* If we are dealing with a return from an Ada procedure with parameters
3676 passed by copy-in/copy-out, we need to return a record containing the
3677 final values of these parameters. If the list contains only one entry,
3678 return just that entry though.
3680 For a full description of the copy-in/copy-out parameter mechanism, see
3681 the part of the gnat_to_gnu_entity routine dealing with the translation
3682 of subprograms.
3684 We need to make a block that contains the definition of that label and
3685 the copying of the return value. It first contains the function, then
3686 the label and copy statement. */
3688 {
3689 tree gnu_retval;
3699 else
3701 gnu_cico_list);
3707 }
3711 /* Attempt setting the end_locus of our GCC body tree, typically a
3712 BIND_EXPR or STATEMENT_LIST, then the end_locus of our GCC subprogram
3713 declaration tree. */
3717 /* On SEH targets, install an exception handler around the main entry
3718 point to catch unhandled exceptions. */
3721 {
3722 tree t;
3723 tree etype;
3735 }
3739 /* Finally annotate the parameters and disconnect the trees for parameters
3740 that we have turned into variables since they are now unusable. */
3744 {
3753 }
3755 /* Disconnect the variable created for the return value. */
3759 /* If the function returns an aggregate type and we have candidates for
3760 a Named Return Value, finalize the optimization. */
3762 {
3769 }
3773 /* If there is a stub associated with the function, build it now. */
3776 }
3777 \f
3778 /* Return true if GNAT_NODE requires atomic synchronization. */
3780 static bool
3782 {
3784 Node_Kind kind;
3787 /* First, scan the node to find the Atomic_Sync_Required flag. */
3790 {
3793 }
3796 {
3808 }
3810 /* Then, scan the parent to find out cases where the flag is irrelevant. */
3813 {
3816 /* Do not mess up machine code insertions. */
3822 /* Do not generate a function call as a renamed object. */
3827 }
3830 }
3831 \f
3832 /* Create a temporary variable with PREFIX and TYPE, and return it. */
3834 static tree
3836 {
3844 }
3846 /* Create a temporary variable with PREFIX and initialize it with GNU_INIT.
3847 Put the initialization statement into GNU_INIT_STMT and annotate it with
3848 the SLOC of GNAT_NODE. Return the temporary variable. */
3850 static tree
3852 Node_Id gnat_node)
3853 {
3860 }
3862 /* Subroutine of gnat_to_gnu to translate gnat_node, either an N_Function_Call
3863 or an N_Procedure_Call_Statement, to a GCC tree, which is returned.
3864 GNU_RESULT_TYPE_P is a pointer to where we should place the result type.
3865 If GNU_TARGET is non-null, this must be a function call on the RHS of a
3866 N_Assignment_Statement and the result is to be placed into that object.
3867 If, in addition, ATOMIC_SYNC is true, then the assignment to GNU_TARGET
3868 requires atomic synchronization. */
3870 static tree
3873 {
3876 /* The GCC node corresponding to the GNAT subprogram name. This can either
3877 be a FUNCTION_DECL node if we are dealing with a standard subprogram call,
3878 or an indirect reference expression (an INDIRECT_REF node) pointing to a
3879 subprogram. */
3881 /* The FUNCTION_TYPE node giving the GCC type of the subprogram. */
3883 /* The return type of the FUNCTION_TYPE. */
3894 Entity_Id gnat_formal;
3895 Node_Id gnat_actual;
3899 /* If we are calling a stubbed function, raise Program_Error, but Elaborate
3900 all our args first. */
3902 {
3912 {
3915 }
3918 }
3920 /* The only way we can be making a call via an access type is if Name is an
3921 explicit dereference. In that case, get the list of formal args from the
3922 type the access type is pointing to. Otherwise, get the formals from the
3923 entity being called. */
3927 /* Assume here that this must be 'Elab_Body or 'Elab_Spec. */
3929 else
3932 /* The lifetime of the temporaries created for the call ends right after the
3933 return value is copied, so we can give them the scope of the elaboration
3934 routine at top level. */
3936 {
3939 }
3941 /* First, create the temporary for the return value when:
3943 1. There is no target and the function has copy-in/copy-out parameters,
3944 because we need to preserve the return value before copying back the
3945 parameters.
3947 2. There is no target and this is not an object declaration, and the
3948 return type has variable size, because in these cases the gimplifier
3949 cannot create the temporary.
3951 3. There is a target and it is a slice or an array with fixed size,
3952 and the return type has variable size, because the gimplifier
3953 doesn't handle these cases.
3955 This must be done before we push a binding level around the call, since
3956 we will pop it before copying the return value. */
3959 || (!gnu_target
3962 || (gnu_target
3970 /* Create the list of the actual parameters as GCC expects it, namely a
3971 chain of TREE_LIST nodes in which the TREE_VALUE field of each node
3972 is an expression and the TREE_PURPOSE field is null. But skip Out
3973 parameters not passed by reference and that need not be copied in. */
3978 {
3982 const bool is_true_formal_parm
3984 const bool is_by_ref_formal_parm
3985 = is_true_formal_parm
3989 /* In the Out or In Out case, we must suppress conversions that yield
3990 an lvalue but can nevertheless cause the creation of a temporary,
3991 because we need the real object in this case, either to pass its
3992 address if it's passed by reference or as target of the back copy
3993 done after the call if it uses the copy-in/copy-out mechanism.
3994 We do it in the In case too, except for an unchecked conversion
3995 because it alone can cause the actual to be misaligned and the
3996 addressability test is applied to the real object. */
3997 const bool suppress_type_conversion
4002 Node_Id gnat_name = suppress_type_conversion
4005 tree gnu_actual;
4007 /* If it's possible we may need to use this expression twice, make sure
4008 that any side-effects are handled via SAVE_EXPRs; likewise if we need
4009 to force side-effects before the call.
4010 ??? This is more conservative than we need since we don't need to do
4011 this for pass-by-ref with no conversion. */
4015 /* If we are passing a non-addressable parameter by reference, pass the
4016 address of a copy. In the Out or In Out case, set up to copy back
4017 out after the call. */
4021 {
4025 /* Do not issue warnings for CONSTRUCTORs since this is not a copy
4026 but sort of an instantiation for them. */
4028 ;
4030 /* If the type is passed by reference, a copy is not allowed. */
4033 gnat_actual);
4035 /* For users of Starlet we issue a warning because the interface
4036 apparently assumes that by-ref parameters outlive the procedure
4037 invocation. The code still will not work as intended, but we
4038 cannot do much better since low-level parts of the back-end
4039 would allocate temporaries at will because of the misalignment
4040 if we did not do so here. */
4042 {
4043 post_error
4045 post_error_ne
4049 gnat_formal);
4050 }
4052 /* If the actual type of the object is already the nominal type,
4053 we have nothing to do, except if the size is self-referential
4054 in which case we'll remove the unpadding below. */
4057 ;
4059 /* Otherwise remove the unpadding from all the objects. */
4061 && TYPE_IS_PADDING_P
4065 /* Otherwise convert to the nominal type of the object if needed.
4066 There are several cases in which we need to make the temporary
4067 using this type instead of the actual type of the object when
4068 they are distinct, because the expectations of the callee would
4069 otherwise not be met:
4070 - if it's a justified modular type,
4071 - if the actual type is a smaller form of it,
4072 - if it's a smaller form of the actual type. */
4076 gnu_name_type)))
4082 /* If this is an In Out or Out parameter and we're returning a value,
4083 we need to create a temporary for the return value because we must
4084 preserve it before copying back at the very end. */
4088 /* If we haven't pushed a binding level, push a new one. This will
4089 narrow the lifetime of the temporary we are about to make as much
4090 as possible. The drawback is that we'd need to create a temporary
4091 for the return value, if any (see comment before the loop). So do
4092 it only when this temporary was already created just above. */
4094 {
4098 }
4100 /* Create an explicit temporary holding the copy. */
4101 gnu_temp
4104 /* But initialize it on the fly like for an implicit temporary as
4105 we aren't necessarily having a statement list. */
4107 gnu_temp);
4109 /* Set up to move the copy back to the original if needed. */
4111 {
4112 /* If the original is a COND_EXPR whose first arm isn't meant to
4113 be further used, just deal with the second arm. This is very
4114 likely the conditional expression built for a check. */
4117 && integer_zerop
4121 gnu_stmt
4126 }
4127 }
4129 /* Start from the real object and build the actual. */
4132 /* If this is an atomic access of an In or In Out parameter for which
4133 synchronization is required, build the atomic load. */
4135 && !is_by_ref_formal_parm
4140 /* If this was a procedure call, we may not have removed any padding.
4141 So do it here for the part we will use as an input, if any. */
4144 gnu_actual
4147 /* Put back the conversion we suppressed above in the computation of the
4148 real object. And even if we didn't suppress any conversion there, we
4149 may have suppressed a conversion to the Etype of the actual earlier,
4150 since the parent is a procedure call, so put it back here. */
4153 gnu_actual
4156 else
4157 gnu_actual
4160 /* Make sure that the actual is in range of the formal's type. */
4163 gnu_actual
4166 /* Unless this is an In parameter, we must remove any justified modular
4167 building from GNU_NAME to get an lvalue. */
4172 gnu_name
4175 /* First see if the parameter is passed by reference. */
4177 {
4179 {
4180 /* In Out or Out parameters passed by reference don't use the
4181 copy-in/copy-out mechanism so the address of the real object
4182 must be passed to the function. */
4185 /* If we have a padded type, be sure we've removed padding. */
4188 gnu_actual);
4190 /* If we have the constructed subtype of an aliased object
4191 with an unconstrained nominal subtype, the type of the
4192 actual includes the template, although it is formally
4193 constrained. So we need to convert it back to the real
4194 constructed subtype to retrieve the constrained part
4195 and takes its address. */
4203 gnu_actual);
4204 }
4206 /* There is no need to convert the actual to the formal's type before
4207 taking its address. The only exception is for unconstrained array
4208 types because of the way we build fat pointers. */
4210 {
4211 /* Put back a view conversion for In Out or Out parameters. */
4214 gnu_actual);
4216 }
4218 /* The symmetry of the paths to the type of an entity is broken here
4219 since arguments don't know that they will be passed by ref. */
4222 }
4224 /* Then see if the parameter is an array passed to a foreign convention
4225 subprogram. */
4227 {
4233 {
4236 }
4238 /* Take the address of the object and convert to the proper pointer
4239 type. We'd like to actually compute the address of the beginning
4240 of the array using an ADDR_EXPR of an ARRAY_REF, but there's a
4241 possibility that the ARRAY_REF might return a constant and we'd be
4242 getting the wrong address. Neither approach is exactly correct,
4243 but this is the most likely to work in all cases. */
4245 }
4247 /* Then see if the parameter is passed by descriptor. */
4249 {
4252 /* If this is 'Null_Parameter, pass a zero descriptor. */
4256 gnu_actual
4258 else
4260 fill_vms_descriptor
4263 }
4265 /* Otherwise the parameter is passed by copy. */
4266 else
4267 {
4268 tree gnu_size;
4273 /* If we didn't create a PARM_DECL for the formal, this means that
4274 it is an Out parameter not passed by reference and that need not
4275 be copied in. In this case, the value of the actual need not be
4276 read. However, we still need to make sure that its side-effects
4277 are evaluated before the call, so we evaluate its address. */
4279 {
4281 {
4284 }
4286 }
4290 /* If this is 'Null_Parameter, pass a zero even though we are
4291 dereferencing it. */
4297 gnu_actual
4301 integer_zero_node),
4303 else
4305 }
4308 }
4310 gnu_call
4314 /* If we have created a temporary for the return value, initialize it. */
4316 {
4317 tree gnu_stmt
4322 }
4324 /* If this is a subprogram with copy-in/copy-out parameters, we need to
4325 unpack the valued returned from the function into the In Out or Out
4326 parameters. We deal with the function return (if this is an Ada
4327 function) below. */
4329 {
4330 /* List of FIELD_DECLs associated with the PARM_DECLs of the copy-in/
4331 copy-out parameters. */
4335 /* The call sequence must contain one and only one call, even though the
4336 function is pure. Save the result into a temporary if needed. */
4338 {
4340 {
4341 tree gnu_stmt;
4342 /* If we haven't pushed a binding level, push a new one. This
4343 will narrow the lifetime of the temporary we are about to
4344 make as much as possible. */
4346 {
4350 }
4351 gnu_call
4354 }
4357 }
4359 /* The first entry is for the actual return value if this is a
4360 function, so skip it. */
4366 else
4373 /* If we are dealing with a copy-in/copy-out parameter, we must
4374 retrieve its value from the record returned in the call. */
4380 || (DECL_BY_DESCRIPTOR_P
4383 {
4384 /* Get the value to assign to this Out or In Out parameter. It is
4385 either the result of the function if there is only a single such
4386 parameter or the appropriate field from the record returned. */
4387 tree gnu_result
4389 ? gnu_call
4393 /* If the actual is a conversion, get the inner expression, which
4394 will be the real destination, and convert the result to the
4395 type of the actual parameter. */
4396 tree gnu_actual
4399 /* If the result is a padded type, remove the padding. */
4401 gnu_result
4403 gnu_result);
4405 /* If the actual is a type conversion, the real target object is
4406 denoted by the inner Expression and we need to convert the
4407 result to the associated type.
4408 We also need to convert our gnu assignment target to this type
4409 if the corresponding GNU_NAME was constructed from the GNAT
4410 conversion node and not from the inner Expression. */
4412 {
4413 gnu_result
4414 = convert_with_check
4422 }
4424 /* Unchecked conversions as actuals for Out parameters are not
4425 allowed in user code because they are not variables, but do
4426 occur in front-end expansions. The associated GNU_NAME is
4427 always obtained from the inner expression in such cases. */
4430 gnu_result,
4432 else
4433 {
4435 gnu_result
4437 gnat_actual);
4442 }
4446 else
4453 }
4454 }
4456 /* If this is a function call, the result is the call expression unless a
4457 target is specified, in which case we copy the result into the target
4458 and return the assignment statement. */
4460 {
4461 /* If this is a function with copy-in/copy-out parameters, extract the
4462 return value from it and update the return type. */
4464 {
4469 }
4471 /* If the function returns an unconstrained array or by direct reference,
4472 we have to dereference the pointer. */
4478 {
4482 /* If range check is needed, emit code to generate it. */
4484 gnu_call
4486 gnat_parent);
4488 /* ??? If the return type has variable size, then force the return
4489 slot optimization as we would not be able to create a temporary.
4490 Likewise if it was unconstrained as we would copy too much data.
4491 That's what has been done historically. */
4494 && CONTAINS_PLACEHOLDER_P
4497 else
4502 else
4503 gnu_call
4507 }
4508 else
4510 }
4512 /* Otherwise, if this is a procedure call statement without copy-in/copy-out
4513 parameters, the result is just the call statement. */
4517 /* Finally, add the copy back statements, if any. */
4523 /* If we have pushed a binding level, pop it and finish up the enclosing
4524 statement group. */
4526 {
4530 }
4532 /* Otherwise, retrieve the statement list, if any. */
4536 /* Otherwise, just return the call expression. */
4537 else
4540 /* If we nevertheless need a value, make a COMPOUND_EXPR to return it.
4541 But first simplify if we have only one statement in the list. */
4543 {
4547 gnu_result
4549 }
4552 }
4553 \f
4554 /* Subroutine of gnat_to_gnu to translate gnat_node, an
4555 N_Handled_Sequence_Of_Statements, to a GCC tree, which is returned. */
4557 static tree
4559 {
4562 /* If just annotating, ignore all EH and cleanups. */
4566 bool setjmp_longjmp
4572 tree gnu_result;
4573 tree gnu_expr;
4574 Node_Id gnat_temp;
4575 /* Node providing the sloc for the cleanup actions. */
4578 gnat_node);
4580 /* The GCC exception handling mechanism can handle both ZCX and SJLJ schemes
4581 and we have our own SJLJ mechanism. To call the GCC mechanism, we call
4582 add_cleanup, and when we leave the binding, end_stmt_group will create
4583 the TRY_FINALLY_EXPR.
4585 ??? The region level calls down there have been specifically put in place
4586 for a ZCX context and currently the order in which things are emitted
4587 (region/handlers) is different from the SJLJ case. Instead of putting
4588 other calls with different conditions at other places for the SJLJ case,
4589 it seems cleaner to reorder things for the SJLJ case and generalize the
4590 condition to make it not ZCX specific.
4592 If there are any exceptions or cleanup processing involved, we need an
4593 outer statement group (for Setjmp_Longjmp) and binding level. */
4595 {
4598 }
4600 /* If using setjmp_longjmp, make the variables for the setjmp buffer and save
4601 area for address of previous buffer. Do this first since we need to have
4602 the setjmp buf known for any decls in this block. */
4604 {
4605 gnu_jmpsave_decl
4607 jmpbuf_ptr_type,
4612 /* The __builtin_setjmp receivers will immediately reinstall it. Now
4613 because of the unstructured form of EH used by setjmp_longjmp, there
4614 might be forward edges going to __builtin_setjmp receivers on which
4615 it is uninitialized, although they will never be actually taken. */
4617 gnu_jmpbuf_decl
4619 jmpbuf_type,
4620 NULL_TREE,
4626 /* When we exit this block, restore the saved value. */
4628 gnat_cleanup_loc_node);
4629 }
4631 /* If we are to call a function when exiting this block, add a cleanup
4632 to the binding level we made above. Note that add_cleanup is FIFO
4633 so we must register this cleanup after the EH cleanup just above. */
4636 gnat_cleanup_loc_node);
4638 /* Now build the tree for the declarations and statements inside this block.
4639 If this is SJLJ, set our jmp_buf as the current buffer. */
4645 gnu_jmpbuf_decl)));
4651 /* Generate code for each statement in the block. */
4659 /* Now generate code for the two exception models, if either is relevant for
4660 this block. */
4662 {
4664 tree gnu_handler;
4666 /* Make a binding level for the exception handling declarations and code
4667 and set up gnu_except_ptr_stack for the handlers to use. */
4678 /* Generate code for each handler. The N_Exception_Handler case does the
4679 real work and returns a COND_EXPR for each handler, which we chain
4680 together here. */
4683 {
4686 /* If this is the first one, set it as the outer one. Otherwise,
4687 point the "else" part of the previous handler to us. Then point
4688 to our "else" part. */
4691 else
4695 }
4697 /* If none of the exception handlers did anything, re-raise but do not
4698 defer abortion. */
4701 set_expr_location_from_node
4707 else
4710 /* End the binding level dedicated to the exception handlers and get the
4711 whole statement group. */
4716 /* If the setjmp returns 1, we restore our incoming longjmp value and
4717 then check the handlers. */
4720 gnu_jmpsave_decl),
4721 gnat_node);
4725 /* This block is now "if (setjmp) ... <handlers> else <block>". */
4727 (build_call_n_expr
4730 gnu_jmpbuf_decl))),
4732 }
4734 {
4735 tree gnu_handlers;
4736 location_t locus;
4738 /* First make a block containing the handlers. */
4746 /* Now make the TRY_CATCH_EXPR for the block. */
4749 /* Set a location. We need to find a unique location for the dispatching
4750 code, otherwise we can get coverage or debugging issues. Try with
4751 the location of the end label. */
4755 else
4756 /* Clear column information so that the exception handler of an
4757 implicit transient block does not incorrectly inherit the slocs
4758 of a decision, which would otherwise confuse control flow based
4759 coverage analysis tools. */
4761 }
4762 else
4765 /* Now close our outer block, if we had to make one. */
4767 {
4771 }
4774 }
4775 \f
4776 /* Subroutine of gnat_to_gnu to translate gnat_node, an N_Exception_Handler,
4777 to a GCC tree, which is returned. This is the variant for Setjmp_Longjmp
4778 exception handling. */
4780 static tree
4782 {
4783 /* Unless this is "Others" or the special "Non-Ada" exception for Ada, make
4784 an "if" statement to select the proper exceptions. For "Others", exclude
4785 exceptions where Handled_By_Others is nonzero unless the All_Others flag
4786 is set. For "Non-ada", accept an exception if "Lang" is 'V'. */
4789 Node_Id gnat_temp;
4793 {
4794 tree this_choice;
4797 {
4800 else
4801 this_choice
4802 = build_binary_op
4804 convert
4806 build_component_ref
4807 (build_unary_op
4812 integer_zero_node);
4813 }
4817 {
4819 tree gnu_expr;
4821 /* Exception may be a renaming. Recover original exception which is
4822 the one elaborated and registered. */
4828 this_choice
4829 = build_binary_op
4835 /* If this is the distinguished exception "Non_Ada_Error" (and we are
4836 in VMS mode), also allow a non-Ada exception (a VMS condition) t
4837 match. */
4839 {
4840 tree gnu_comp
4841 = build_component_ref
4846 this_choice
4847 = build_binary_op
4851 this_choice);
4852 }
4853 }
4854 else
4859 }
4862 }
4863 \f
4864 /* Subroutine of gnat_to_gnu to translate gnat_node, an N_Exception_Handler,
4865 to a GCC tree, which is returned. This is the variant for ZCX. */
4867 static tree
4869 {
4872 Node_Id gnat_temp;
4874 /* We build a TREE_LIST of nodes representing what exception types this
4875 handler can catch, with special cases for others and all others cases.
4877 Each exception type is actually identified by a pointer to the exception
4878 id, or to a dummy object for "others" and "all others". */
4881 {
4885 {
4888 }
4891 {
4894 /* Exception may be a renaming. Recover original exception which is
4895 the one elaborated and registered. */
4902 /* The Non_Ada_Error case for VMS exceptions is handled
4903 by the personality routine. */
4904 }
4905 else
4908 /* The GCC interface expects NULL to be passed for catch all handlers, so
4909 it would be quite tempting to set gnu_etypes_list to NULL if gnu_etype
4910 is integer_zero_node. It would not work, however, because GCC's
4911 notion of "catch all" is stronger than our notion of "others". Until
4912 we correctly use the cleanup interface as well, doing that would
4913 prevent the "all others" handlers from being seen, because nothing
4914 can be caught beyond a catch all from GCC's point of view. */
4916 }
4921 /* Expand a call to the begin_handler hook at the beginning of the handler,
4922 and arrange for a call to the end_handler hook to occur on every possible
4923 exit path.
4925 The hooks expect a pointer to the low level occurrence. This is required
4926 for our stack management scheme because a raise inside the handler pushes
4927 a new occurrence on top of the stack, which means that this top does not
4928 necessarily match the occurrence this handler was dealing with.
4930 __builtin_eh_pointer references the exception occurrence being
4931 propagated. Upon handler entry, this is the exception for which the
4932 handler is triggered. This might not be the case upon handler exit,
4933 however, as we might have a new occurrence propagated by the handler's
4934 body, and the end_handler hook called as a cleanup in this context.
4936 We use a local variable to retrieve the incoming value at handler entry
4937 time, and reuse it to feed the end_handler hook's argument at exit. */
4939 gnu_current_exc_ptr
4949 gnu_incoming_exc_ptr),
4950 gnat_node);
4952 /* Declare and initialize the choice parameter, if present. */
4954 {
4955 tree gnu_param
4961 gnu_incoming_exc_ptr));
4962 }
4964 /* We don't have an End_Label at hand to set the location of the cleanup
4965 actions, so we use that of the exception handler itself instead. */
4967 gnat_node);
4973 return
4975 }
4976 \f
4977 /* Subroutine of gnat_to_gnu to generate code for an N_Compilation unit. */
4979 static void
4981 {
4986 Node_Id gnat_pragma;
4987 /* Make the decl for the elaboration procedure. */
4988 tree gnu_elab_proc_decl
4989 = create_subprog_decl
4992 gnat_unit);
4998 /* Initialize the information structure for the function. */
5007 /* For a body, first process the spec if there is one. */
5013 {
5020 }
5022 /* Then process any pragmas and declarations preceding the unit. */
5031 /* Process the unit itself. */
5034 /* If we can inline, generate code for all the inlined subprograms. */
5036 {
5037 Entity_Id gnat_entity;
5042 {
5046 {
5047 /* ??? This really should always be present. */
5050 gnat_body
5052 }
5055 {
5056 /* Define the entity first so we set DECL_EXTERNAL. */
5059 }
5060 }
5061 }
5063 /* Process any pragmas and actions following the unit. */
5068 /* Save away what we've made so far and record this potential elaboration
5069 procedure. */
5082 /* Generate elaboration code for this unit, if necessary, and say whether
5083 we did or not. */
5086 /* Invalidate the global renaming pointers. This is necessary because
5087 stabilization of the renamed entities may create SAVE_EXPRs which
5088 have been tied to a specific elaboration routine just above. */
5090 }
5091 \f
5092 /* Subroutine of gnat_to_gnu to translate gnat_node, an N_Raise_xxx_Error,
5093 to a GCC tree, which is returned. GNU_RESULT_TYPE_P is a pointer to where
5094 we should place the result type. LABEL_P is true if there is a label to
5095 branch to for the exception. */
5097 static tree
5099 {
5103 const bool with_extra_info
5104 = Exception_Extra_Info
5112 {
5122 {
5128 {
5148 }
5155 && gnu_low_bound
5156 && gnu_high_bound
5159 gnu_result
5163 /* If loop unswitching is enabled, we try to compute invariant
5164 conditions for checks applied to iteration variables, i.e.
5165 conditions that are both independent of the variable and
5166 necessary in order for the check to fail in the course of
5167 some iteration, and prepend them to the original condition
5168 of the checks. This will make it possible later for the
5169 loop unswitching pass to replace the loop with two loops,
5170 one of which has the checks eliminated and the other has
5171 the original checks reinstated, and a run time selection.
5172 The former loop will be suitable for vectorization. */
5174 && (!gnu_low_bound
5176 && (!gnu_high_bound
5179 {
5184 boolean_true_node);
5186 boolean_type_node,
5189 }
5190 }
5195 }
5197 common:
5202 /* If the type is VOID, this is a statement, so we need to generate the code
5203 for the call. Handle a condition, if there is one. */
5205 {
5207 {
5212 }
5213 }
5214 else
5218 }
5219 \f
5220 /* Return true if GNAT_NODE is on the LHS of an assignment or an actual
5221 parameter of a call. */
5223 static bool
5225 {
5240 }
5242 /* Return true if either GNAT_NODE or a view of GNAT_NODE is on the LHS
5243 of an assignment or an actual parameter of a call. */
5245 static bool
5247 {
5248 Node_Kind kind;
5260 }
5262 /* Return true if GNAT_NODE, an unchecked type conversion, is a no-op as far
5263 as gigi is concerned. This is used to avoid conversions on the LHS. */
5265 static bool
5267 {
5270 /* The conversion must be on the LHS of an assignment or an actual parameter
5271 of a call. Otherwise, even if the conversion was essentially a no-op, it
5272 could de facto ensure type consistency and this should be preserved. */
5278 /* We're interested in artificial conversions generated by the front-end
5279 to make private types explicit, e.g. in Expand_Assign_Array. */
5286 /* The direct conversion to the underlying type is a no-op. */
5290 /* For an array subtype, the conversion to the PAT is a no-op. */
5295 /* For a record subtype, the conversion to the type is a no-op. */
5301 }
5303 /* This function is the driver of the GNAT to GCC tree transformation process.
5304 It is the entry point of the tree transformer. GNAT_NODE is the root of
5305 some GNAT tree. Return the root of the corresponding GCC tree. If this
5306 is an expression, return the GCC equivalent of the expression. If this
5307 is a statement, return the statement or add it to the current statement
5308 group, in which case anything returned is to be interpreted as occurring
5309 after anything added. */
5311 tree
5313 {
5319 Node_Id gnat_temp;
5321 /* Save node number for error message and set location information. */
5325 /* If this node is a statement and we are only annotating types, return an
5326 empty statement list. */
5330 /* If this node is a non-static subexpression and we are only annotating
5331 types, make this into a NULL_EXPR. */
5338 N_Raise_Constraint_Error));
5347 {
5350 /* If this is a statement and we are at top level, it must be part of
5351 the elaboration procedure, so mark us as being in that procedure. */
5353 {
5356 }
5358 /* If we are in the elaboration procedure, check if we are violating a
5359 No_Elaboration_Code restriction by having a statement there. Don't
5360 check for a possible No_Elaboration_Code restriction violation on
5361 N_Handled_Sequence_Of_Statements, as we want to signal an error on
5362 every nested real statement instead. This also avoids triggering
5363 spurious errors on dummy (empty) sequences created by the front-end
5364 for package bodies in some cases. */
5368 }
5371 {
5372 /********************************/
5373 /* Chapter 2: Lexical Elements */
5374 /********************************/
5382 /* If this is an atomic access on the RHS for which synchronization is
5383 required, build the atomic load. */
5390 {
5391 tree gnu_type;
5393 /* Get the type of the result, looking inside any padding and
5394 justified modular types. Then get the value in that type. */
5403 /* If the result overflows (meaning it doesn't fit in its base type),
5404 abort. We would like to check that the value is within the range
5405 of the subtype, but that causes problems with subtypes whose usage
5406 will raise Constraint_Error and with biased representation, so
5407 we don't. */
5409 }
5413 /* If a Entity is present, it means that this was one of the
5414 literals in a user-defined character type. In that case,
5415 just return the value in the CONST_DECL. Otherwise, use the
5416 character code. In that case, the base type should be an
5417 INTEGER_TYPE, but we won't bother checking for that. */
5421 else
5422 gnu_result
5423 = build_int_cst_type
5430 /* If this is of a fixed-point type, the value we want is the
5431 value of the corresponding integer. */
5433 {
5435 gnu_result_type);
5437 }
5439 /* Convert the Ureal to a vax float (represented on a signed type). */
5441 {
5443 gnu_result_type);
5444 }
5446 else
5447 {
5450 /* First convert the real value to a machine number if it isn't
5451 already. That forces BASE to 2 for non-zero values and simplifies
5452 the rest of our logic. */
5455 ur_realval
5461 else
5462 {
5463 REAL_VALUE_TYPE tmp;
5465 gnu_result
5468 /* The base must be 2 as Machine guarantees this, so we scale
5469 the value, which we know can fit in the mantissa of the type
5470 (hence the use of that type above). */
5476 }
5478 /* Now see if we need to negate the result. Do it this way to
5479 properly handle -0. */
5481 gnu_result
5483 gnu_result);
5484 }
5491 {
5498 else
5501 /* Build the string with the characters in the literal. Note
5502 that Ada strings are 1-origin. */
5506 /* Put a null at the end of the string in case it's in a context
5507 where GCC will want to treat it as a C string. */
5512 /* Strings in GCC don't normally have types, but we want
5513 this to not be converted to the array type. */
5518 }
5519 else
5520 {
5521 /* Build a list consisting of each character, then make
5522 the aggregate. */
5531 {
5537 }
5540 }
5547 /**************************************/
5548 /* Chapter 3: Declarations and Types */
5549 /**************************************/
5566 /* If we are just annotating types and this object has an unconstrained
5567 or task type, don't elaborate it. */
5577 && (!type_annotate_only
5579 {
5582 gnu_expr
5585 /* If this object has its elaboration delayed, we must force
5586 evaluation of GNU_EXPR right now and save it for when the object
5587 is frozen. */
5589 {
5591 ;
5593 gnu_expr
5598 else
5602 }
5603 }
5604 else
5610 /* If this is a deferred constant with an address clause, we ignore the
5611 full view since the clause is on the partial view and we cannot have
5612 2 different GCC trees for the object. The only bits of the full view
5613 we will use is the initializer, but it will be directly fetched. */
5626 /* Don't do anything if this renaming is handled by the front end or if
5627 we are just annotating types and this object has a composite or task
5628 type, don't elaborate it. We return the result in case it has any
5629 SAVE_EXPRs in it that need to be evaluated here. */
5631 && ! (type_annotate_only
5635 gnu_result
5638 else
5651 /* These are fully handled in the front end. */
5655 /*************************************/
5656 /* Chapter 4: Names and Expressions */
5657 /*************************************/
5664 /* If this is an atomic access on the RHS for which synchronization is
5665 required, build the atomic load. */
5672 {
5674 tree gnu_type;
5681 /* Convert vector inputs to their representative array type, to fit
5682 what the code below expects. */
5684 {
5688 }
5692 /* If we got a padded type, remove it too. */
5694 gnu_array_object
5696 gnu_array_object);
5700 /* The failure of this assertion will very likely come from a missing
5701 expansion for a packed array access. */
5704 /* First compute the number of dimensions of the array, then
5705 fill the expression array, the order depending on whether
5706 this is a Convention_Fortran array or not. */
5711 ;
5720 else
5728 {
5734 gnu_expr
5735 = emit_index_check
5739 gnat_temp);
5743 }
5747 /* If this is an atomic access on the RHS for which synchronization is
5748 required, build the atomic load. */
5752 }
5756 {
5758 tree gnu_type;
5763 /* Do any implicit dereferences of the prefix and do any needed
5764 range check. */
5769 {
5770 /* Get the bounds of the slice. */
5771 tree gnu_index_type
5775 /* Get the permitted bounds. */
5776 tree gnu_base_index_type
5778 tree gnu_base_min_expr = SUBSTITUTE_PLACEHOLDER_IN_EXPR
5780 tree gnu_base_max_expr = SUBSTITUTE_PLACEHOLDER_IN_EXPR
5787 /* Derive a good type to convert everything to. */
5790 /* Test whether the minimum slice value is too small. */
5793 gnu_min_expr),
5795 gnu_base_min_expr));
5797 /* Test whether the maximum slice value is too large. */
5800 gnu_max_expr),
5802 gnu_base_max_expr));
5804 /* Build a slice index check that returns the low bound,
5805 assuming the slice is not empty. */
5806 gnu_expr = emit_check
5811 /* Build a conditional expression that does the index checks and
5812 returns the low bound if the slice is not empty (max >= min),
5813 and returns the naked low bound otherwise (max < min), unless
5814 it is non-constant and the high bound is; this prevents VRP
5815 from inferring bogus ranges on the unlikely path. */
5819 gnu_max_expr),
5821 gnu_min_expr)),
5822 gnu_expr,
5826 }
5827 else
5828 /* Simply return the naked low bound. */
5831 /* If this is a slice with non-constant size of an array with constant
5832 size, set the maximum size for the allocation of temporaries. */
5839 }
5843 {
5847 tree gnu_field;
5851 {
5856 }
5860 /* For discriminant references in tagged types always substitute the
5861 corresponding discriminant as the actual selected component. */
5866 /* For discriminant references of untagged types always substitute the
5867 corresponding stored discriminant. */
5871 /* Handle extracting the real or imaginary part of a complex.
5872 The real part is the first field and the imaginary the last. */
5877 else
5878 {
5881 /* If there are discriminants, the prefix might be evaluated more
5882 than once, which is a problem if it has side-effects. */
5889 gnu_result
5893 && lvalue_required_for_attribute_p
5895 }
5899 /* If this is an atomic access on the RHS for which synchronization is
5900 required, build the atomic load. */
5904 }
5908 {
5909 /* The attribute designator. */
5912 /* The Elab_Spec and Elab_Body attributes are special in that Prefix
5913 is a unit, not an object with a GCC equivalent. */
5915 return
5923 }
5927 /* Like 'Access as far as we are concerned. */
5935 {
5936 tree gnu_aggr_type;
5938 /* ??? It is wrong to evaluate the type now, but there doesn't
5939 seem to be any other practical way of doing it. */
5943 gnu_aggr_type = gnu_result_type
5948 gnu_aggr_type
5955 NULL);
5959 gnu_result
5962 gnu_aggr_type);
5965 gnu_aggr_type,
5968 gnu_result
5969 = build_binary_op
5974 (Next
5976 else
5980 }
5988 else
5995 /* Get the operand expression. */
5999 /* If this is a qualified expression for a tagged type, we mark the type
6000 as used. Because of polymorphism, this might be the only reference to
6001 the tagged type in the program while objects have it as dynamic type.
6002 The debugger needs to see it to display these objects properly. */
6006 gnu_result
6010 kind == N_Type_Conversion
6017 /* Skip further processing if the conversion is deemed a no-op. */
6019 {
6022 }
6026 /* If the result is a pointer type, see if we are improperly
6027 converting to a stricter alignment. */
6030 {
6036 post_error_ne_tree_2
6040 }
6042 /* If we are converting a descriptor to a function pointer, first
6043 build the pointer. */
6055 {
6060 /* GNAT_RANGE is either an N_Range node or an identifier denoting a
6061 subtype. */
6063 {
6066 }
6069 {
6074 }
6075 else
6080 /* If LOW and HIGH are identical, perform an equality test. Otherwise,
6081 ensure that GNU_OBJ is evaluated only once and perform a full range
6082 test. */
6084 gnu_result
6086 else
6087 {
6096 gnu_result
6098 }
6101 gnu_result
6103 }
6111 ? RDIV_EXPR
6118 /* These can either be operations on booleans or on modular types.
6119 Fall through for boolean types since that's the way GNU_CODES is
6120 set up. */
6122 Modular_Integer_Kind))
6123 {
6124 enum tree_code code
6135 }
6137 /* ... fall through ... */
6149 {
6153 tree gnu_type;
6159 /* Pending generic support for efficient vector logical operations in
6160 GCC, convert vectors to their representative array type view and
6161 fallthrough. */
6165 /* If this is a comparison operator, convert any references to
6166 an unconstrained array value into a reference to the
6167 actual array. */
6169 {
6172 }
6174 /* If the result type is a private type, its full view may be a
6175 numeric subtype. The representation we need is that of its base
6176 type, given that it is the result of an arithmetic operation. */
6178 gnu_type = gnu_result_type
6181 /* If this is a shift whose count is not guaranteed to be correct,
6182 we need to adjust the shift count. */
6184 {
6186 tree gnu_max_shift
6193 gnu_rhs
6194 = build_binary_op
6197 gnu_count_type,
6198 gnu_max_shift,
6200 integer_one_node)),
6201 gnu_rhs);
6202 }
6204 /* For right shifts, the type says what kind of shift to do,
6205 so we may need to choose a different type. In this case,
6206 we have to ignore integer overflow lest it propagates all
6207 the way down and causes a CE to be explicitly raised. */
6209 {
6212 }
6215 {
6218 }
6221 {
6227 }
6229 /* Instead of expanding overflow checks for addition, subtraction
6230 and multiplication itself, the front end will leave this to
6231 the back end when Backend_Overflow_Checks_On_Target is set.
6232 As the GCC back end itself does not know yet how to properly
6233 do overflow checking, do it here. The goal is to push
6234 the expansions further into the back end over time. */
6243 else
6244 {
6245 /* Some operations, e.g. comparisons of arrays, generate complex
6246 trees that need to be annotated while they are being built. */
6249 }
6251 /* If this is a logical shift with the shift count not verified,
6252 we must return zero if it is too large. We cannot compensate
6253 above in this case. */
6256 gnu_result
6257 = build_cond_expr
6260 gnu_rhs,
6264 gnu_result);
6265 }
6269 {
6272 tree gnu_false
6276 gnu_result
6278 }
6287 /* This case can apply to a boolean or a modular type.
6288 Fall through for a boolean operand since GNU_CODES is set
6289 up to handle this. */
6293 {
6297 gnu_expr);
6299 }
6301 /* ... fall through ... */
6310 gnu_result
6313 else
6319 {
6321 tree gnu_type;
6326 /* The Expression operand can either be an N_Identifier or
6327 Expanded_Name, which must represent a type, or a
6328 N_Qualified_Expression, which contains both the object type and an
6329 initial value for the object. */
6334 {
6335 Entity_Id gnat_desig_type
6343 gnu_init
6349 else
6350 {
6354 }
6356 /* See the N_Qualified_Expression case for the rationale. */
6361 }
6362 else
6369 ignore_init_type);
6370 }
6373 /**************************/
6374 /* Chapter 5: Statements */
6375 /**************************/
6383 /* When not optimizing, turn null statements from source into gotos to
6384 the next statement that the middle-end knows how to preserve. */
6386 {
6397 }
6398 else
6403 /* Get the LHS and RHS of the statement and convert any reference to an
6404 unconstrained array into a reference to the underlying array. */
6407 /* If the type has a size that overflows, convert this into raise of
6408 Storage_Error: execution shouldn't have gotten here anyway. */
6412 N_Raise_Storage_Error);
6414 gnu_result
6417 else
6418 {
6419 gnu_rhs
6422 /* If range check is needed, emit code to generate it. */
6425 gnat_node);
6429 else
6430 gnu_result
6433 /* If the type being assigned is an array type and the two sides are
6434 not completely disjoint, play safe and use memmove. But don't do
6435 it for a bit-packed array as it might not be byte-aligned. */
6440 {
6454 }
6455 }
6459 {
6462 /* Make the outer COND_EXPR. Avoid non-determinism. */
6471 /* Now make a COND_EXPR for each of the "else if" parts. Put each
6472 into the previous "else" part and point to where to put any
6473 outer "else". Also avoid non-determinism. */
6477 {
6487 }
6490 }
6502 /* The only way to enter the block is to fall through to it. */
6504 {
6511 }
6512 else
6517 gnu_result
6527 {
6530 /* If the subprogram is a function, we must return the expression. */
6532 {
6535 /* If this function has copy-in/copy-out parameters, get the real
6536 object for the return. See Subprogram_to_gnu. */
6539 else
6542 /* Get the GCC tree for the expression to be returned. */
6545 /* Do not remove the padding from GNU_RET_VAL if the inner type is
6546 self-referential since we want to allocate the fixed size. */
6548 && TYPE_IS_PADDING_P
6550 && CONTAINS_PLACEHOLDER_P
6554 /* If the function returns by direct reference, return a pointer
6555 to the return value. */
6560 /* Otherwise, if it returns an unconstrained array, we have to
6561 allocate a new version of the result and return it. */
6563 {
6566 /* And find out whether this is a candidate for Named Return
6567 Value. If so, record it. */
6569 {
6572 /* Strip useless conversions around the return value. */
6576 /* Strip unpadding around the return value. */
6578 && TYPE_IS_PADDING_P
6582 /* Now apply the test to the return value. */
6584 {
6590 }
6591 }
6594 gnu_ret_val,
6599 }
6601 /* Otherwise, if it returns by invisible reference, dereference
6602 the pointer it is passed using the type of the return value
6603 and build the copy operation manually. This ensures that we
6604 don't copy too much data, for example if the return type is
6605 unconstrained with a maximum size. */
6607 {
6608 tree gnu_ret_deref
6610 gnu_ret_obj);
6615 }
6616 }
6618 else
6621 /* If we have a return label defined, convert this into a branch to
6622 that label. The return proper will be handled elsewhere. */
6624 {
6627 gnu_ret_val));
6632 /* When not optimizing, make sure the return is preserved. */
6635 }
6637 /* Otherwise, build a regular return. */
6638 else
6640 }
6644 gnu_result
6648 /***************************/
6649 /* Chapter 6: Subprograms */
6650 /***************************/
6653 /* Unless there is a freeze node, declare the subprogram. We consider
6654 this a "definition" even though we're not generating code for
6655 the subprogram because we will be making the corresponding GCC
6656 node here. */
6665 /* This subprogram doesn't exist for code generation purposes, but we
6666 have to elaborate the types of any parameters and result, unless
6667 they are imported types (nothing to generate in this case).
6669 The parameter list may contain types with freeze nodes, e.g. not null
6670 subtypes, so the subprogram itself may carry a freeze node, in which
6671 case its elaboration must be deferred. */
6673 /* Process the parameter types first. */
6676 = First_Formal_With_Extras
6684 /* Then the result type, set to Standard_Void_Type for procedures. */
6685 {
6686 Entity_Id gnat_temp_type
6691 }
6697 /* For a child unit identifier go up a level to get the specification.
6698 We get this when we try to find the spec of a child unit package
6699 that is the compilation unit being compiled. */
6713 /************************/
6714 /* Chapter 7: Packages */
6715 /************************/
6731 /* If this is the body of a generic package - do nothing. */
6733 {
6736 }
6747 /********************************/
6748 /* Chapter 8: Visibility Rules */
6749 /********************************/
6753 /* Nothing to do here - but these may appear in list of declarations. */
6757 /*********************/
6758 /* Chapter 9: Tasks */
6759 /*********************/
6770 /*********************************************************/
6771 /* Chapter 10: Program Structure and Compilation Issues */
6772 /*********************************************************/
6775 /* This is not called for the main unit on which gigi is invoked. */
6784 /* Simply process whatever unit is being inserted. */
6787 else
6788 {
6791 }
6798 /***************************/
6799 /* Chapter 11: Exceptions */
6800 /***************************/
6803 /* If there is an At_End procedure attached to this node, and the EH
6804 mechanism is SJLJ, we must have at least a corresponding At_End
6805 handler, unless the No_Exception_Handlers restriction is set. */
6820 else
6825 /* Only for reraise in back-end exceptions mode. */
6832 /* Clear the current exception pointer so that the occurrence won't be
6833 deallocated. */
6872 /******************************/
6873 /* Chapter 12: Generic Units */
6874 /******************************/
6884 /* These nodes can appear on a declaration list but there is nothing to
6885 to be done with them. */
6889 /**************************************************/
6890 /* Chapter 13: Representation Clauses and */
6891 /* Implementation-Dependent Features */
6892 /**************************************************/
6897 /* The only one we need to deal with is 'Address since, for the others,
6898 the front-end puts the information elsewhere. */
6902 /* And we only deal with 'Address if the object has a Freeze node. */
6907 /* Get the value to use as the address and save it as the equivalent
6908 for the object. When it is frozen, gnat_to_gnu_entity will do the
6909 right thing. */
6916 /* We do nothing with these. SEM puts the information elsewhere. */
6922 {
6932 /* First retrieve the 3 operand lists built by the front-end. */
6935 {
6942 }
6946 {
6953 }
6957 gnu_clobbers
6960 gnu_clobbers);
6962 /* Then perform some standard checking and processing on the
6963 operands. In particular, mark them addressable if needed. */
6971 {
6973 constraint
6979 {
6980 /* If the operand is going to end up in memory,
6981 mark it addressable. Note that we don't test
6982 allows_mem like in the input case below; this
6983 is modelled on the C front-end. */
6985 {
6992 }
6993 }
6994 else
6998 }
7001 {
7003 constraint
7009 {
7010 /* If the operand is going to end up in memory,
7011 mark it addressable. */
7013 {
7020 }
7021 }
7022 else
7026 }
7032 }
7033 else
7038 /****************/
7039 /* Added Nodes */
7040 /****************/
7043 /* This construct doesn't define a scope so we don't push a binding level
7044 around the statement list; but we wrap it in a SAVE_EXPR to protect it
7045 from unsharing. */
7050 gnu_result
7075 {
7080 /* If this is a thin pointer, we must first dereference it to create
7081 a fat pointer, then go back below to a thin pointer. The reason
7082 for this is that we need to have a fat pointer someplace in order
7083 to properly compute the size. */
7087 gnu_ptr));
7089 /* If this is a fat pointer, the object must have been allocated with
7090 the template in front of the array. So pass the template address,
7091 and get the total size; do it by converting to a thin pointer. */
7093 gnu_ptr
7095 (TYPE_OBJECT_RECORD_TYPE
7097 gnu_ptr);
7101 /* If this is a thin pointer, the object must have been allocated with
7102 the template in front of the array. So pass the template address,
7103 and get the total size. */
7105 gnu_ptr
7107 gnu_ptr,
7109 byte_position
7110 (DECL_CHAIN
7113 /* If we have a special dynamic constrained subtype on the node, use
7114 it to compute the size; otherwise, use the designated subtype. */
7116 {
7117 gnu_actual_obj_type
7121 gnu_actual_obj_type
7123 gnu_actual_obj_type,
7126 }
7127 else
7130 gnu_result
7133 gnu_obj_type,
7136 gnat_node);
7137 }
7145 else
7150 /* The only validation we currently do on an unchecked conversion is
7151 that of aliasing assumptions. */
7163 /* These nodes should only be present when annotating types. */
7169 /* Other nodes are not supposed to reach here. */
7171 }
7173 /* If we pushed the processing of the elaboration routine, pop it back. */
7177 /* When not optimizing, turn boolean rvalues B into B != false tests
7178 so that the code just below can put the location information of the
7179 reference to B on the inequality operator for better debug info. */
7193 boolean_false_node));
7195 /* Set the location information on the result. Note that we may have
7196 no result if we tried to build a CALL_EXPR node to a procedure with
7197 no side-effects and optimization is enabled. */
7201 /* If we're supposed to return something of void_type, it means we have
7202 something we're elaborating for effect, so just return. */
7206 /* If the result is a constant that overflowed, raise Constraint_Error. */
7208 {
7210 gnu_result
7213 N_Raise_Constraint_Error));
7214 }
7216 /* If the result has side-effects and is of an unconstrained type, make a
7217 SAVE_EXPR so that we can be sure it will only be referenced once. But
7218 this is useless for a call to a function that returns an unconstrained
7219 type with default discriminant, as we cannot compute the size of the
7220 actual returned object. We must do this before any conversions. */
7228 /* Now convert the result to the result type, unless we are in one of the
7229 following cases:
7231 1. If this is the LHS of an assignment or an actual parameter of a
7232 call, return the result almost unmodified since the RHS will have
7233 to be converted to our type in that case, unless the result type
7234 has a simpler size. Likewise if there is just a no-op unchecked
7235 conversion in-between. Similarly, don't convert integral types
7236 that are the operands of an unchecked conversion since we need
7237 to ignore those conversions (for 'Valid).
7239 2. If we have a label (which doesn't have any well-defined type), a
7240 field or an error, return the result almost unmodified. Similarly,
7241 if the two types are record types with the same name, don't convert.
7242 This will be the case when we are converting from a packable version
7243 of a type to its original type and we need those conversions to be
7244 NOPs in order for assignments into these types to work properly.
7246 3. If the type is void or if we have no result, return error_mark_node
7247 to show we have no result.
7249 4. If this a call to a function that returns an unconstrained type with
7250 default discriminant, return the call expression unmodified since we
7251 cannot compute the size of the actual returned object.
7253 5. Finally, if the type of the result is already correct. */
7271 && (CONTAINS_PLACEHOLDER_P
7275 {
7276 /* Remove padding only if the inner object is of self-referential
7277 size: in that case it must be an object of unconstrained type
7278 with a default discriminant and we want to avoid copying too
7279 much data. */
7284 gnu_result);
7285 }
7294 {
7295 /* Remove any padding. */
7298 gnu_result);
7299 }
7307 == gnu_result_type
7309 ;
7314 /* We don't need any NOP_EXPR or NON_LVALUE_EXPR on the result. */
7321 }
7322 \f
7323 /* Subroutine of above to push the exception label stack. GNU_STACK is
7324 a pointer to the stack to update and GNAT_LABEL, if present, is the
7325 label to push onto the stack. */
7327 static void
7329 {
7335 }
7336 \f
7337 /* Record the current code position in GNAT_NODE. */
7339 static void
7341 {
7346 }
7348 /* Insert the code for GNAT_NODE at the position saved for that node. */
7350 static void
7352 {
7355 }
7356 \f
7357 /* Start a new statement group chained to the previous group. */
7359 void
7361 {
7364 /* First see if we can get one from the free list. */
7367 else
7373 }
7375 /* Add GNU_STMT to the current statement group. If it is an expression with
7376 no effects, it is ignored. */
7378 void
7380 {
7382 }
7384 /* Similar, but the statement is always added, regardless of side-effects. */
7386 void
7388 {
7390 }
7392 /* Like add_stmt, but set the location of GNU_STMT to that of GNAT_NODE. */
7394 void
7396 {
7400 }
7402 /* Similar, but the statement is always added, regardless of side-effects. */
7404 void
7406 {
7410 }
7412 /* Add a declaration statement for GNU_DECL to the current statement group.
7413 Get SLOC from Entity_Id. */
7415 void
7417 {
7421 /* If this is a variable that Gigi is to ignore, we may have been given
7422 an ERROR_MARK. So test for it. We also might have been given a
7423 reference for a renaming. So only do something for a decl. Also
7424 ignore a TYPE_DECL for an UNCONSTRAINED_ARRAY_TYPE. */
7432 /* If we are external or global, we don't want to output the DECL_EXPR for
7433 this DECL node since we already have evaluated the expressions in the
7434 sizes and positions as globals and doing it again would be wrong. */
7436 {
7437 /* Mark everything as used to prevent node sharing with subprograms.
7438 Note that walk_tree knows how to deal with TYPE_DECL, but neither
7439 VAR_DECL nor CONST_DECL. This appears to be somewhat arbitrary. */
7443 {
7447 }
7448 /* In any case, we have to deal with our own TYPE_ADA_SIZE field. */
7453 }
7454 else
7457 /* If this is a variable and an initializer is attached to it, it must be
7458 valid for the context. Similar to init_const in create_var_decl_1. */
7465 {
7466 /* If GNU_DECL has a padded type, convert it to the unpadded
7467 type so the assignment is done properly. */
7470 else
7477 {
7480 }
7483 }
7484 }
7486 /* Callback for walk_tree to mark the visited trees rooted at *TP. */
7488 static tree
7490 {
7496 /* Don't mark a dummy type as visited because we want to mark its sizes
7497 and fields once it's filled in. */
7505 }
7507 /* Mark nodes rooted at T with TREE_VISITED and types as having their
7508 sized gimplified. We use this to indicate all variable sizes and
7509 positions in global types may not be shared by any subprogram. */
7511 void
7513 {
7515 }
7517 /* Add GNU_CLEANUP, a cleanup action, to the current code group and
7518 set its location to that of GNAT_NODE if present, but with column info
7519 cleared so that conditional branches generated as part of the cleanup
7520 code do not interfere with coverage analysis tools. */
7522 static void
7524 {
7528 }
7530 /* Set the BLOCK node corresponding to the current code group to GNU_BLOCK. */
7532 void
7534 {
7537 }
7539 /* Return code corresponding to the current code group. It is normally
7540 a STATEMENT_LIST, but may also be a BIND_EXPR or TRY_FINALLY_EXPR if
7541 BLOCK or cleanups were set. */
7543 tree
7545 {
7549 /* If this is a null list, allocate a new STATEMENT_LIST. Then, if there
7550 are cleanups, make a TRY_FINALLY_EXPR. Last, if there is a BLOCK,
7551 make a BIND_EXPR. Note that we nest in that because the cleanup may
7552 reference variables in the block. */
7564 /* Remove this group from the stack and add it to the free list. */
7570 }
7572 /* Return whether the current statement group may fall through. */
7576 {
7579 else
7581 }
7583 /* Add a list of statements from GNAT_LIST, a possibly-empty list of
7584 statements.*/
7586 static void
7588 {
7589 Node_Id gnat_node;
7595 }
7597 /* Build a tree from GNAT_LIST, a possibly-empty list of statements.
7598 If BINDING_P is true, push and pop a binding level around the list. */
7600 static tree
7602 {
7612 }
7613 \f
7614 /* Generate GIMPLE in place for the expression at *EXPR_P. */
7616 int
7619 {
7621 tree op;
7627 {
7629 /* If this is for a scalar, just make a VAR_DECL for it. If for
7630 an aggregate, get a null pointer of the appropriate type and
7631 dereference it. */
7635 integer_zero_node));
7636 else
7637 {
7640 }
7646 /* We should only do this if we are just elaborating for side-effects,
7647 but we can't know that yet. */
7654 /* If we are taking the address of a constant CONSTRUCTOR, make sure it
7655 is put into static memory. We know that it's going to be read-only
7656 given the semantics we have and it must be in static memory when the
7657 reference is in an elaboration procedure. */
7659 {
7663 }
7670 /* If we are view-converting a CONSTRUCTOR or a call from an aggregate
7671 type to a scalar one, explicitly create the local temporary. That's
7672 required if the type is passed by reference. */
7676 {
7685 }
7692 /* The expressions for the RM bounds must be gimplified to ensure that
7693 they are properly elaborated. See gimplify_decl_expr. */
7697 {
7702 {
7707 {
7711 }
7715 {
7719 }
7721 }
7726 }
7728 /* ... fall through ... */
7732 }
7733 }
7735 /* Generate GIMPLE in place for the statement at *STMT_P. */
7737 static enum gimplify_status
7739 {
7743 {
7749 {
7755 /* Build the condition expression from the test, if any. */
7757 {
7758 /* Deal with the optimization hints. */
7762 annot_expr_ivdep_kind));
7767 annot_expr_no_vector_kind));
7771 annot_expr_vector_kind));
7773 gnu_cond
7776 }
7778 /* Set to emit the statements of the loop. */
7781 /* We first emit the start label and then a conditional jump to the
7782 end label if there's a top condition, then the update if it's at
7783 the top, then the body of the loop, then a conditional jump to
7784 the end label if there's a bottom condition, then the update if
7785 it's at the bottom, and finally a jump to the start label and the
7786 definition of the end label. */
7788 gnu_start_label),
7789 stmt_p);
7810 gnu_end_label),
7811 stmt_p);
7813 }
7816 /* Build a statement to jump to the corresponding end label, then
7817 see if it needs to be conditional. */
7826 }
7827 }
7828 \f
7829 /* Force references to each of the entities in packages withed by GNAT_NODE.
7830 Operate recursively but check that we aren't elaborating something more
7831 than once.
7833 This routine is exclusively called in type_annotate mode, to compute DDA
7834 information for types in withed units, for ASIS use. */
7836 static void
7838 {
7841 /* Process each unit only once. As we trace the context of all relevant
7842 units transitively, including generic bodies, we may encounter the
7843 same generic unit repeatedly. */
7847 /* Save entities in all context units. A body may have an implicit_with
7848 on its own spec, if the context includes a child unit, so don't save
7849 the spec twice. */
7856 {
7860 {
7877 }
7879 {
7880 Node_Id gnat_body
7883 /* Retrieve compilation unit node of generic body. */
7888 /* If body is available, elaborate its context. */
7891 }
7892 }
7896 }
7897 \f
7898 /* Do the processing of GNAT_NODE, an N_Freeze_Entity. */
7900 static void
7902 {
7907 /* If this is a package, we need to generate code for the package. */
7909 {
7910 insert_code_for
7914 }
7916 /* Don't do anything for class-wide types as they are always transformed
7917 into their root type. */
7921 /* Check for an old definition. This freeze node might be for an Itype. */
7922 gnu_old
7925 /* If this entity has an address representation clause, GNU_OLD is the
7926 address, so discard it here. */
7930 /* Don't do anything for subprograms that may have been elaborated before
7931 their freeze nodes. This can happen, for example, because of an inner
7932 call in an instance body or because of previous compilation of a spec
7933 for inlining purposes. */
7941 /* If we have a non-dummy type old tree, we have nothing to do, except
7942 aborting if this is the public view of a private type whose full view was
7943 not delayed, as this node was never delayed as it should have been. We
7944 let this happen for concurrent types and their Corresponding_Record_Type,
7945 however, because each might legitimately be elaborated before its own
7946 freeze node, e.g. while processing the other. */
7950 {
7958 }
7960 /* Reset the saved tree, if any, and elaborate the object or type for real.
7961 If there is a full view, elaborate it and use the result. And, if this
7962 is the root type of a class-wide type, reuse it for the latter. */
7964 {
7974 }
7978 {
7981 /* Propagate back-annotations from full view to partial view. */
7991 /* The above call may have defined this entity (the simplest example
7992 of this is when we have a private enumeral type since the bounds
7993 will have the public view). */
7996 }
7997 else
7998 {
7999 tree gnu_init
8005 }
8012 /* If we have an old type and we've made pointers to this type, update those
8013 pointers. If this is a Taft amendment type in the main unit, we need to
8014 mark the type as used since other units referencing it don't see the full
8015 declaration and, therefore, cannot mark it as used themselves. */
8017 {
8022 }
8023 }
8024 \f
8025 /* Elaborate decls in the lists GNAT_DECLS and GNAT_DECLS2, if present.
8026 We make two passes, one to elaborate anything other than bodies (but
8027 we declare a function if there was no spec). The second pass
8028 elaborates the bodies.
8030 GNAT_END_LIST gives the element in the list past the end. Normally,
8031 this is Empty, but can be First_Real_Statement for a
8032 Handled_Sequence_Of_Statements.
8034 We make a complete pass through both lists if PASS1P is true, then make
8035 the second pass over both lists if PASS2P is true. The lists usually
8036 correspond to the public and private parts of a package. */
8038 static void
8041 {
8043 Node_Id gnat_decl;
8053 {
8054 /* For package specs, we recurse inside the declarations,
8055 thus taking the two pass approach inside the boundary. */
8063 /* Similarly for any declarations in the actions of a
8064 freeze node. */
8066 {
8069 }
8071 /* Package bodies with freeze nodes get their elaboration deferred
8072 until the freeze node, but the code must be placed in the right
8073 place, so record the code position now. */
8081 (Corresponding_Spec
8084 record_code_position
8087 /* We defer most subprogram bodies to the second pass. */
8089 {
8091 {
8097 }
8098 }
8100 /* For bodies and stubs that act as their own specs, the entity
8101 itself must be elaborated in the first pass, because it may
8102 be used in other declarations. */
8104 {
8105 Node_Id gnat_subprog_id
8112 }
8114 /* Concurrent stubs stand for the corresponding subprogram bodies,
8115 which are deferred like other bodies. */
8118 ;
8120 else
8122 }
8124 /* Here we elaborate everything we deferred above except for package bodies,
8125 which are elaborated at their freeze nodes. Note that we must also
8126 go inside things (package specs and freeze nodes) the first pass did. */
8132 {
8148 }
8149 }
8150 \f
8151 /* Make a unary operation of kind CODE using build_unary_op, but guard
8152 the operation by an overflow check. CODE can be one of NEGATE_EXPR
8153 or ABS_EXPR. GNU_TYPE is the type desired for the result. Usually
8154 the operation is to be performed in that type. GNAT_NODE is the gnat
8155 node conveying the source location for which the error should be
8156 signaled. */
8158 static tree
8160 Node_Id gnat_node)
8161 {
8170 }
8172 /* Make a binary operation of kind CODE using build_binary_op, but guard
8173 the operation by an overflow check. CODE can be one of PLUS_EXPR,
8174 MINUS_EXPR or MULT_EXPR. GNU_TYPE is the type desired for the result.
8175 Usually the operation is to be performed in that type. GNAT_NODE is
8176 the GNAT node conveying the source location for which the error should
8177 be signaled. */
8179 static tree
8182 {
8187 tree gnu_expr;
8190 tree rhs_lt_zero;
8191 tree check_pos;
8192 tree check_neg;
8193 tree check;
8198 /* Prefer a constant or known-positive rhs to simplify checks. */
8203 {
8207 }
8210 ? boolean_false_node
8213 /* ??? Should use more efficient check for operand_equal_p (lhs, rhs, 0) */
8215 /* Try a few strategies that may be cheaper than the general
8216 code at the end of the function, if the rhs is not known.
8217 The strategies are:
8218 - Call library function for 64-bit multiplication (complex)
8219 - Widen, if input arguments are sufficiently small
8220 - Determine overflow using wrapped result for addition/subtraction. */
8223 {
8224 /* Even for add/subtract double size to get another base type. */
8228 {
8234 }
8239 {
8246 tree check = build_binary_op
8255 return
8257 }
8260 {
8262 tree wrapped_expr = convert
8267 tree result = convert
8270 /* Overflow when (rhs < 0) ^ (wrapped_expr < lhs)), for addition
8271 or when (rhs < 0) ^ (wrapped_expr > lhs) for subtraction. */
8272 tree check = build_binary_op
8277 return
8279 }
8280 }
8283 {
8285 /* When rhs >= 0, overflow when lhs > type_max - rhs. */
8290 /* When rhs < 0, overflow when lhs < type_min - rhs. */
8297 /* When rhs >= 0, overflow when lhs < type_min + rhs. */
8302 /* When rhs < 0, overflow when lhs > type_max + rhs. */
8309 /* The check here is designed to be efficient if the rhs is constant,
8310 but it will work for any rhs by using integer division.
8311 Four different check expressions determine whether X * C overflows,
8312 depending on C.
8313 C == 0 => false
8314 C > 0 => X > type_max / C || X < type_min / C
8315 C == -1 => X == type_min
8316 C < -1 => X > type_min / C || X < type_max / C */
8321 check_pos
8324 rhs),
8327 boolean_type_node,
8330 boolean_type_node,
8333 check_neg
8338 type_min),
8341 boolean_type_node,
8344 boolean_type_node,
8350 }
8354 /* If we can fold the expression to a constant, just return it.
8355 The caller will deal with overflow, no need to generate a check. */
8360 check_pos);
8363 }
8365 /* Emit code for a range check. GNU_EXPR is the expression to be checked,
8366 GNAT_RANGE_TYPE the gnat type or subtype containing the bounds against
8367 which we have to check. GNAT_NODE is the GNAT node conveying the source
8368 location for which the error should be signaled. */
8370 static tree
8372 {
8376 /* If GNU_EXPR has GNAT_RANGE_TYPE as its base type, no check is needed.
8377 This can for example happen when translating 'Val or 'Value. */
8381 /* Range checks can only be applied to types with ranges. */
8385 /* If GNU_EXPR has an integral type that is narrower than GNU_RANGE_TYPE,
8386 we can't do anything since we might be truncating the bounds. No
8387 check is needed in this case. */
8393 /* Checked expressions must be evaluated only once. */
8396 /* Note that the form of the check is
8397 (not (expr >= lo)) or (not (expr <= hi))
8398 the reason for this slightly convoluted form is that NaNs
8399 are not considered to be in range in the float case. */
8400 return emit_check
8402 invert_truthvalue
8406 TYPE_MIN_VALUE
8408 invert_truthvalue
8412 TYPE_MAX_VALUE
8415 }
8416 \f
8417 /* Emit code for an index check. GNU_ARRAY_OBJECT is the array object which
8418 we are about to index, GNU_EXPR is the index expression to be checked,
8419 GNU_LOW and GNU_HIGH are the lower and upper bounds against which GNU_EXPR
8420 has to be checked. Note that for index checking we cannot simply use the
8421 emit_range_check function (although very similar code needs to be generated
8422 in both cases) since for index checking the array type against which we are
8423 checking the indices may be unconstrained and consequently we need to get
8424 the actual index bounds from the array object itself (GNU_ARRAY_OBJECT).
8425 The place where we need to do that is in subprograms having unconstrained
8426 array formal parameters. GNAT_NODE is the GNAT node conveying the source
8427 location for which the error should be signaled. */
8429 static tree
8432 {
8433 tree gnu_expr_check;
8435 /* Checked expressions must be evaluated only once. */
8438 /* Must do this computation in the base type in case the expression's
8439 type is an unsigned subtypes. */
8442 /* If GNU_LOW or GNU_HIGH are a PLACEHOLDER_EXPR, qualify them by
8443 the object we are handling. */
8447 return emit_check
8450 gnu_expr_check,
8452 gnu_low)),
8454 gnu_expr_check,
8456 gnu_high))),
8458 }
8459 \f
8460 /* GNU_COND contains the condition corresponding to an access, discriminant or
8461 range check of value GNU_EXPR. Build a COND_EXPR that returns GNU_EXPR if
8462 GNU_COND is false and raises a CONSTRAINT_ERROR if GNU_COND is true.
8463 REASON is the code that says why the exception was raised. GNAT_NODE is
8464 the GNAT node conveying the source location for which the error should be
8465 signaled. */
8467 static tree
8469 {
8470 tree gnu_call
8472 tree gnu_result
8476 gnu_expr);
8478 /* GNU_RESULT has side effects if and only if GNU_EXPR has:
8479 we don't need to evaluate it just for the check. */
8483 }
8484 \f
8485 /* Return an expression that converts GNU_EXPR to GNAT_TYPE, doing overflow
8486 checks if OVERFLOW_P is true and range checks if RANGE_P is true.
8487 GNAT_TYPE is known to be an integral type. If TRUNCATE_P true, do a
8488 float to integer conversion with truncation; otherwise round.
8489 GNAT_NODE is the GNAT node conveying the source location for which the
8490 error should be signaled. */
8492 static tree
8495 {
8502 /* If we are not doing any checks, the output is an integral type, and
8503 the input is not a floating type, just do the conversion. This
8504 shortcut is required to avoid problems with packed array types
8505 and simplifies code in all cases anyway. */
8510 /* First convert the expression to its base type. This
8511 will never generate code, but makes the tests below much simpler.
8512 But don't do this if converting from an integer type to an unconstrained
8513 array type since then we need to get the bounds from the original
8514 (unpacked) type. */
8518 /* If overflow checks are requested, we need to be sure the result will
8519 fit in the output base type. But don't do this if the input
8520 is integer and the output floating-point. */
8523 {
8524 /* Ensure GNU_EXPR only gets evaluated once. */
8532 /* Convert the lower bounds to signed types, so we're sure we're
8533 comparing them properly. Likewise, convert the upper bounds
8534 to unsigned types. */
8548 /* Check each bound separately and only if the result bound
8549 is tighter than the bound on the input type. Note that all the
8550 types are base types, so the bounds must be constant. Also,
8551 the comparison is done in the base type of the input, which
8552 always has the proper signedness. First check for input
8553 integer (which means output integer), output float (which means
8554 both float), or mixed, in which case we always compare.
8555 Note that we have to do the comparison which would *fail* in the
8556 case of an error since if it's an FP comparison and one of the
8557 values is a NaN or Inf, the comparison will fail. */
8564 gnu_cond
8565 = invert_truthvalue
8568 gnu_out_lb)));
8576 gnu_cond
8578 invert_truthvalue
8580 gnu_input,
8582 gnu_out_ub))));
8587 }
8589 /* Now convert to the result base type. If this is a non-truncating
8590 float-to-integer conversion, round. */
8593 {
8599 /* The following calculations depend on proper rounding to even
8600 of each arithmetic operation. In order to prevent excess
8601 precision from spoiling this property, use the widest hardware
8602 floating-point type if FP_ARITH_MAY_WIDEN is true. */
8603 calc_type
8606 /* FIXME: Should not have padding in the first place. */
8610 /* Compute the exact value calc_type'Pred (0.5) at compile time. */
8614 half_minus_pred_half);
8617 /* If the input is strictly negative, subtract this value
8618 and otherwise add it from the input. For 0.5, the result
8619 is exactly between 1.0 and the machine number preceding 1.0
8620 (for calc_type). Since the last bit of 1.0 is even, this 0.5
8621 will round to 1.0, while all other number with an absolute
8622 value less than 0.5 round to 0.0. For larger numbers exactly
8623 halfway between integers, rounding will always be correct as
8624 the true mathematical result will be closer to the higher
8625 integer compared to the lower one. So, this constant works
8626 for all floating-point numbers.
8628 The reason to use the same constant with subtract/add instead
8629 of a positive and negative constant is to allow the comparison
8630 to be scheduled in parallel with retrieval of the constant and
8631 conversion of the input to the calc_type (if necessary). */
8636 gnu_comp
8638 gnu_add_pred_half
8640 gnu_subtract_pred_half
8644 }
8650 else
8653 /* Finally, do the range check if requested. Note that if the result type
8654 is a modular type, the range check is actually an overflow check. */
8661 }
8662 \f
8663 /* Return true if GNU_EXPR can be directly addressed. This is the case
8664 unless it is an expression involving computation or if it involves a
8665 reference to a bitfield or to an object not sufficiently aligned for
8666 its type. If GNU_TYPE is non-null, return true only if GNU_EXPR can
8667 be directly addressed as an object of this type.
8669 *** Notes on addressability issues in the Ada compiler ***
8671 This predicate is necessary in order to bridge the gap between Gigi
8672 and the middle-end about addressability of GENERIC trees. A tree
8673 is said to be addressable if it can be directly addressed, i.e. if
8674 its address can be taken, is a multiple of the type's alignment on
8675 strict-alignment architectures and returns the first storage unit
8676 assigned to the object represented by the tree.
8678 In the C family of languages, everything is in practice addressable
8679 at the language level, except for bit-fields. This means that these
8680 compilers will take the address of any tree that doesn't represent
8681 a bit-field reference and expect the result to be the first storage
8682 unit assigned to the object. Even in cases where this will result
8683 in unaligned accesses at run time, nothing is supposed to be done
8684 and the program is considered as erroneous instead (see PR c/18287).
8686 The implicit assumptions made in the middle-end are in keeping with
8687 the C viewpoint described above:
8688 - the address of a bit-field reference is supposed to be never
8689 taken; the compiler (generally) will stop on such a construct,
8690 - any other tree is addressable if it is formally addressable,
8691 i.e. if it is formally allowed to be the operand of ADDR_EXPR.
8693 In Ada, the viewpoint is the opposite one: nothing is addressable
8694 at the language level unless explicitly declared so. This means
8695 that the compiler will both make sure that the trees representing
8696 references to addressable ("aliased" in Ada parlance) objects are
8697 addressable and make no real attempts at ensuring that the trees
8698 representing references to non-addressable objects are addressable.
8700 In the first case, Ada is effectively equivalent to C and handing
8701 down the direct result of applying ADDR_EXPR to these trees to the
8702 middle-end works flawlessly. In the second case, Ada cannot afford
8703 to consider the program as erroneous if the address of trees that
8704 are not addressable is requested for technical reasons, unlike C;
8705 as a consequence, the Ada compiler must arrange for either making
8706 sure that this address is not requested in the middle-end or for
8707 compensating by inserting temporaries if it is requested in Gigi.
8709 The first goal can be achieved because the middle-end should not
8710 request the address of non-addressable trees on its own; the only
8711 exception is for the invocation of low-level block operations like
8712 memcpy, for which the addressability requirements are lower since
8713 the type's alignment can be disregarded. In practice, this means
8714 that Gigi must make sure that such operations cannot be applied to
8715 non-BLKmode bit-fields.
8717 The second goal is achieved by means of the addressable_p predicate,
8718 which computes whether a temporary must be inserted by Gigi when the
8719 address of a tree is requested; if so, the address of the temporary
8720 will be used in lieu of that of the original tree and some glue code
8721 generated to connect everything together. */
8723 static bool
8725 {
8726 /* For an integral type, the size of the actual type of the object may not
8727 be greater than that of the expected type, otherwise an indirect access
8728 in the latter type wouldn't correctly set all the bits of the object. */
8734 /* The size of the actual type of the object may not be smaller than that
8735 of the expected type, otherwise an indirect access in the latter type
8736 would be larger than the object. But only record types need to be
8737 considered in practice for this case. */
8744 {
8749 /* All DECLs are addressable: if they are in a register, we can force
8750 them to memory. */
8755 /* Taking the address of a dereference yields the original pointer. */
8760 /* Taking the address yields a pointer to the constant pool. */
8764 /* Taking the address of a static constructor yields a pointer to the
8765 tree constant pool. */
8777 /* All rvalues are deemed addressable since taking their address will
8778 force a temporary to be created by the middle-end. */
8782 /* The address of a compound expression is that of its 2nd operand. */
8786 /* We accept &COND_EXPR as soon as both operands are addressable and
8787 expect the outcome to be the address of the selected operand. */
8793 /* Even with DECL_BIT_FIELD cleared, we have to ensure that
8794 the field is sufficiently aligned, in case it is subject
8795 to a pragma Component_Alignment. But we don't need to
8796 check the alignment of the containing record, as it is
8797 guaranteed to be not smaller than that of its most
8798 aligned field that is not a bit-field. */
8799 && (!STRICT_ALIGNMENT
8802 /* The field of a padding record is always addressable. */
8816 {
8817 /* This is addressable if we can avoid a copy. */
8821 && (!STRICT_ALIGNMENT
8826 && (!STRICT_ALIGNMENT
8832 }
8836 }
8837 }
8838 \f
8839 /* Do the processing for the declaration of a GNAT_ENTITY, a type. If
8840 a separate Freeze node exists, delay the bulk of the processing. Otherwise
8841 make a GCC type for GNAT_ENTITY and set up the correspondence. */
8843 void
8845 {
8846 tree gnu_old
8848 tree gnu_new;
8850 /* If we are to delay elaboration of this type, just do any
8851 elaborations needed for expressions within the declaration and
8852 make a dummy type entry for this node and its Full_View (if
8853 any) in case something points to it. Don't do this if it
8854 has already been done (the only way that can happen is if
8855 the private completion is also delayed). */
8861 {
8865 {
8870 {
8874 }
8875 }
8878 }
8880 /* If we saved away a dummy type for this node it means that this
8881 made the type that corresponds to the full type of an incomplete
8882 type. Clear that type for now and then update the type in the
8883 pointers. */
8885 {
8890 }
8892 /* Now fully elaborate the type. */
8896 /* If we have an old type and we've made pointers to this type, update those
8897 pointers. If this is a Taft amendment type in the main unit, we need to
8898 mark the type as used since other units referencing it don't see the full
8899 declaration and, therefore, cannot mark it as used themselves. */
8901 {
8906 }
8908 /* If this is a record type corresponding to a task or protected type
8909 that is a completion of an incomplete type, perform a similar update
8910 on the type. ??? Including protected types here is a guess. */
8914 {
8915 tree gnu_task_old
8925 }
8926 }
8927 \f
8928 /* GNAT_ENTITY is the type of the resulting constructor, GNAT_ASSOC is the
8929 front of the Component_Associations of an N_Aggregate and GNU_TYPE is the
8930 GCC type of the corresponding record type. Return the CONSTRUCTOR. */
8932 static tree
8934 {
8937 /* We test for GNU_FIELD being empty in the case where a variant
8938 was the last thing since we don't take things off GNAT_ASSOC in
8939 that case. We check GNAT_ASSOC in case we have a variant, but it
8940 has no fields. */
8943 {
8948 /* The expander is supposed to put a single component selector name
8949 in every record component association. */
8952 /* Ignore fields that have Corresponding_Discriminants since we'll
8953 be setting that field in the parent. */
8958 /* Also ignore discriminants of Unchecked_Unions. */
8963 /* Before assigning a value in an aggregate make sure range checks
8964 are done if required. Then convert to the type of the field. */
8970 /* Add the field and expression to the list. */
8972 }
8976 #ifdef ENABLE_CHECKING
8977 /* Verify that every entry in GNU_LIST was used. */
8980 #endif
8983 }
8985 /* Build a possibly nested constructor for array aggregates. GNAT_EXPR is
8986 the first element of an array aggregate. It may itself be an aggregate.
8987 GNU_ARRAY_TYPE is the GCC type corresponding to the array aggregate.
8988 GNAT_COMPONENT_TYPE is the type of the array component; it is needed
8989 for range checking. */
8991 static tree
8993 Entity_Id gnat_component_type)
8994 {
8996 tree gnu_expr;
9000 {
9001 /* If the expression is itself an array aggregate then first build the
9002 innermost constructor if it is part of our array (multi-dimensional
9003 case). */
9009 gnat_component_type);
9010 else
9011 {
9014 /* Before assigning the element to the array, make sure it is
9015 in range. */
9018 }
9024 }
9027 }
9028 \f
9029 /* Subroutine of assoc_to_constructor: VALUES is a list of field associations,
9030 some of which are from RECORD_TYPE. Return a CONSTRUCTOR consisting
9031 of the associations that are from RECORD_TYPE. If we see an internal
9032 record, make a recursive call to fill it in as well. */
9034 static tree
9036 {
9041 {
9044 /* _Parent is an internal field, but may have values in the aggregate,
9045 so check for values first. */
9047 {
9050 }
9053 {
9058 }
9059 else
9060 /* If we have a record subtype, the names will match, but not the
9061 actual FIELD_DECLs. */
9064 {
9067 }
9073 }
9076 }
9077 \f
9078 /* Process a N_Validate_Unchecked_Conversion node. */
9080 static void
9082 {
9086 /* If the target is a pointer type, see if we are either converting from a
9087 non-pointer or from a pointer to a type with a different alias set and
9088 warn if so, unless the pointer has been marked to alias everything. */
9091 {
9101 target_alias_set)))
9102 {
9106 gnat_node);
9109 }
9110 }
9112 /* Likewise if the target is a fat pointer type, but we have no mechanism to
9113 mitigate the problem in this case, so we unconditionally warn. */
9115 {
9116 tree gnu_source_desig_type
9120 tree gnu_target_desig_type
9127 target_alias_set)))
9128 {
9132 gnat_node);
9133 }
9134 }
9135 }
9136 \f
9137 /* EXP is to be treated as an array or record. Handle the cases when it is
9138 an access object and perform the required dereferences. */
9140 static tree
9142 {
9143 /* If the type is a pointer, dereference it. */
9148 /* If we got a padded type, remove it too. */
9153 }
9154 \f
9155 /* Convert SLOC into LOCUS. Return true if SLOC corresponds to a source code
9156 location and false if it doesn't. In the former case, set the Gigi global
9157 variable REF_FILENAME to the simple debug file name as given by sinput.
9158 If clear_column is true, set column information to 0. */
9160 static bool
9162 {
9167 {
9170 }
9171 else
9172 {
9178 /* We can have zero if pragma Source_Reference is in effect. */
9182 /* Translate the location. */
9184 }
9186 ref_filename
9187 = IDENTIFIER_POINTER
9188 (get_identifier
9192 }
9194 /* Similar to the above, not clearing the column information. */
9196 bool
9198 {
9200 }
9202 /* Similar to set_expr_location, but start with the Sloc of GNAT_NODE and
9203 don't do anything if it doesn't correspond to a source location. */
9205 static void
9207 {
9208 location_t locus;
9214 }
9216 /* Similar to the above, not clearing the column information. */
9218 static void
9220 {
9222 }
9224 /* More elaborate version of set_expr_location_from_node to be used in more
9225 general contexts, for example the result of the translation of a generic
9226 GNAT node. */
9228 static void
9230 {
9231 /* Set the location information on the node if it is a real expression.
9232 References can be reused for multiple GNAT nodes and they would get
9233 the location information of their last use. Also make sure not to
9234 overwrite an existing location as it is probably more precise. */
9237 {
9238 CASE_CONVERT:
9246 /* ... fall through ... */
9250 {
9253 }
9255 }
9256 }
9257 \f
9258 /* Return a colon-separated list of encodings contained in encoded Ada
9259 name. */
9263 {
9267 }
9269 /* Extract the Ada name from an encoded name. */
9273 {
9277 }
9278 \f
9279 /* Post an error message. MSG is the error message, properly annotated.
9280 NODE is the node at which to post the error and the node to use for the
9281 '&' substitution. */
9283 void
9285 {
9286 String_Template temp;
9287 Fat_Pointer fp;
9297 }
9299 /* Similar to post_error, but NODE is the node at which to post the error and
9300 ENT is the node to use for the '&' substitution. */
9302 void
9304 {
9305 String_Template temp;
9306 Fat_Pointer fp;
9316 }
9318 /* Similar to post_error_ne, but NUM is the number to use for the '^'. */
9320 void
9322 {
9325 }
9327 /* Set the end_locus information for GNU_NODE, if any, from an explicit end
9328 location associated with GNAT_NODE or GNAT_NODE itself, whichever makes
9329 most sense. Return true if a sensible assignment was performed. */
9331 static bool
9333 {
9335 location_t end_locus;
9337 /* Pick the GNAT node of which we'll take the sloc to assign to the GCC node
9338 end_locus when there is one. We consider only GNAT nodes with a possible
9339 End_Label attached. If the End_Label actually was unassigned, fallback
9340 on the original node. We'd better assign an explicit sloc associated with
9341 the outer construct in any case. */
9344 {
9357 }
9361 /* Some expanded subprograms have neither an End_Label nor a Sloc
9362 attached. Notify that to callers. For a block statement with no
9363 End_Label, clear column information, so that the tree for a
9364 transient block does not receive the sloc of a source condition. */
9372 {
9383 }
9384 }
9385 \f
9386 /* Similar to post_error_ne, but T is a GCC tree representing the number to
9387 write. If T represents a constant, the text inside curly brackets in
9388 MSG will be output (presumably including a '^'). Otherwise it will not
9389 be output and the text inside square brackets will be output instead. */
9391 void
9393 {
9400 {
9403 }
9404 else
9408 {
9414 ;
9415 else
9417 }
9422 }
9424 /* Similar to post_error_ne_tree, but NUM is a second integer to write. */
9426 void
9429 {
9432 }
9433 \f
9434 /* Initialize the table that maps GNAT codes to GCC codes for simple
9435 binary and unary operations. */
9437 static void
9439 {
9465 }
9467 /* Return a label to branch to for the exception type in KIND or NULL_TREE
9468 if none. */
9470 tree
9472 {
9479 else
9481 }
9483 /* Return the decl for the current elaboration procedure. */
9485 tree
9487 {
9489 }