| blob | b8a0d5d5d30bb8ea2ed8491610e3a2b8d9c8f973 |
1 /****************************************************************************
2 * *
3 * GNAT COMPILER COMPONENTS *
4 * *
5 * T R A N S *
6 * *
7 * C Implementation File *
8 * *
9 * Copyright (C) 1992-2022, 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 ****************************************************************************/
72 /* We should avoid allocating more than ALLOCA_THRESHOLD bytes via alloca,
73 for fear of running out of stack space. If we need more, we use xmalloc
74 instead. */
75 #define ALLOCA_THRESHOLD 1000
77 /* Pointers to front-end tables accessed through macros. */
88 /* Highest number in the front-end node table. */
91 /* True when gigi is being called on an analyzed but unexpanded
92 tree, and the only purpose of the call is to properly annotate
93 types with representation information. */
96 /* List of N_Validate_Unchecked_Conversion nodes in the unit. */
99 /* List of expressions of pragma Compile_Time_{Error|Warning} in the unit. */
102 /* When not optimizing, we cache the 'First, 'Last and 'Length attributes
103 of unconstrained array IN parameters to avoid emitting a great deal of
104 redundant instructions to recompute them each time. */
108 tree first;
109 tree last;
110 tree length;
111 };
115 /* Structure used to record information for a function. */
118 bitmap named_ret_val;
121 };
123 #define f_parm_attr_cache \
124 DECL_STRUCT_FUNCTION (current_function_decl)->language->parm_attr_cache
126 #define f_named_ret_val \
127 DECL_STRUCT_FUNCTION (current_function_decl)->language->named_ret_val
129 #define f_other_ret_val \
130 DECL_STRUCT_FUNCTION (current_function_decl)->language->other_ret_val
132 #define f_gnat_ret \
133 DECL_STRUCT_FUNCTION (current_function_decl)->language->gnat_ret
135 /* A structure used to gather together information about a statement group.
136 We use this to gather related statements, for example the "then" part
137 of a IF. In the case where it represents a lexical scope, we may also
138 have a BLOCK node corresponding to it and/or cleanups. */
145 };
149 /* List of unused struct stmt_group nodes. */
152 /* A structure used to record information on elaboration procedures
153 we've made and need to process.
155 ??? gnat_node should be Node_Id, but gengtype gets confused. */
161 };
165 /* Stack of exception pointer variables. Each entry is the VAR_DECL
166 that stores the address of the raised exception. Nonzero means we
167 are in an exception handler. Not used in the zero-cost case. */
170 /* In ZCX case, current exception pointer. Used to re-raise it. */
173 /* Stack for storing the current elaboration procedure decl. */
176 /* Stack of labels to be used as a goto target instead of a return in
177 some functions. See processing for N_Subprogram_Body. */
180 /* Stack of variable for the return value of a function with copy-in/copy-out
181 parameters. See processing for N_Subprogram_Body. */
184 /* Structure used to record information for a range check. */
186 tree low_bound;
187 tree high_bound;
188 tree disp;
190 tree type;
191 tree invariant_cond;
192 tree inserted_cond;
193 };
197 /* Structure used to record information for a loop. */
199 tree fndecl;
200 tree stmt;
201 tree loop_var;
202 tree low_bound;
203 tree high_bound;
204 tree omp_loop_clauses;
205 tree omp_construct_clauses;
209 };
213 /* Stack of loop_info structures associated with LOOP_STMT nodes. */
216 /* The stacks for N_{Push,Pop}_*_Label. */
221 /* Map GNAT tree codes to GCC tree codes for simple expressions. */
254 /* This makes gigi's file_info_ptr visible in this translation unit,
255 so that Sloc_to_locus can look it up when deciding whether to map
256 decls to instances. */
260 /* Return the string of the identifier allocated for the file name Id. */
264 {
265 /* __gnat_to_canonical_file_spec translates file names from pragmas
266 Source_Reference that contain host style syntax not understood by GDB. */
269 /* Use the identifier table to make a permanent copy of the file name as
270 the name table gets reallocated after Gigi returns but before all the
271 debugging information is output. */
273 }
275 /* This is the main program of the back-end. It sets up all the table
276 structures and then generates code. */
278 void
291 Nat number_file,
293 Entity_Id standard_boolean,
294 Entity_Id standard_integer,
295 Entity_Id standard_character,
296 Entity_Id standard_long_long_float,
297 Entity_Id standard_exception_type,
298 Int gigi_operating_mode)
299 {
300 Node_Id gnat_iter;
301 Entity_Id gnat_literal;
321 {
324 }
327 {
328 /* We rely on the order isomorphism between files and line maps. */
330 {
334 }
336 /* We create the line map for a source file at once, with a fixed number
337 of columns chosen to avoid jumping over the next power of 2. */
343 }
347 /* Declare the name of the compilation unit as the first global
348 name in order to make the middle-end fully deterministic. */
352 /* Initialize ourselves. */
357 /* If we are just annotating types, give VOID_TYPE zero sizes to avoid
358 errors. */
360 {
363 }
365 /* Enable GNAT stack checking method if needed */
369 /* Retrieve alignment settings. */
373 /* Record the builtin types. Define `integer' and `character' first so that
374 dbx will output them first. */
380 /* Save the type we made for integer as the type for Standard.Integer. */
385 /* Likewise for character as the type for Standard.Character. */
391 /* Likewise for boolean as the type for Standard.Boolean. */
410 /* Declare the building blocks of function nodes. */
415 /* Now declare run-time functions. */
416 malloc_decl
419 NULL_TREE),
424 free_decl
431 realloc_decl
435 NULL_TREE),
439 /* This is used for 64-bit multiplication with overflow checking. */
441 mulv64_decl
449 {
451 mulv128_decl
454 int128_type,
455 int128_type,
456 NULL_TREE),
459 }
461 /* Name of the _Parent field in tagged record types. */
464 /* Name of the Not_Handled_By_Others field in exception record types. */
467 /* Make the types and functions used for exception processing. */
472 {
475 }
478 jmpbuf_type
484 /* Functions to get and set the jumpbuf pointer for the current thread. */
485 get_jmpbuf_decl
486 = create_subprog_decl
491 set_jmpbuf_decl
492 = create_subprog_decl
495 NULL_TREE),
498 get_excptr_decl
499 = create_subprog_decl
502 NULL_TREE),
505 /* setjmp returns an integer and has one operand, which is a pointer to
506 a jmpbuf. */
507 setjmp_decl
508 = create_subprog_decl
511 NULL_TREE),
515 /* update_setjmp_buf updates a setjmp buffer from the current stack pointer
516 address. */
517 update_setjmp_buf_decl
518 = create_subprog_decl
523 BUILT_IN_UPDATE_SETJMP_BUF);
525 /* Indicate that it never returns. */
528 NULL_TREE);
530 raise_nodefer_decl
531 = create_subprog_decl
535 set_exception_parameter_decl
536 = create_subprog_decl
539 NULL_TREE),
542 /* Hooks to call when entering/leaving an exception handler. */
545 begin_handler_decl
549 Empty);
550 /* __gnat_begin_handler_v1 is not a dummy procedure, but we arrange
551 for it not to throw. */
557 end_handler_decl
561 Empty);
564 unhandled_except_decl
568 Empty);
570 /* Indicate that it never returns. */
572 reraise_zcx_decl
576 Empty);
578 /* Dummy objects to materialize "others" and "all others" in the exception
579 tables. These are exported by a-exexpr-gcc.adb, so see this unit for
580 the types to use. */
581 others_decl
588 all_others_decl
595 unhandled_others_decl
602 /* If in no exception handlers mode, all raise statements are redirected to
603 __gnat_last_chance_handler. No need to redefine raise_nodefer_decl since
604 this procedure will never be called in this mode. */
606 {
607 /* Indicate that it never returns. */
612 tree decl
613 = create_subprog_decl
616 Empty);
619 }
620 else
621 {
622 /* Otherwise, make one decl for each exception reason. */
628 i == CE_Index_Check_Failed
632 }
634 /* Build the special descriptor type and its null node if needed. */
636 {
648 {
649 tree field
656 elt--;
657 }
662 }
664 longest_float_type_node
671 /* Initialize the GCC support for FP operations. */
674 /* Install the builtins we might need, either internally or as user-available
675 facilities for Intrinsic imports. Note that this must be done after the
676 GCC exception mechanism is initialized. */
685 /* Process any Pragma Ident for the main unit. */
690 /* Force -fno-strict-aliasing if the configuration pragma was seen. */
694 /* Save the current optimization options again after the above possible
695 global_options changes. */
696 optimization_default_node
700 /* Now translate the compilation unit proper. */
703 /* Then process the N_Validate_Unchecked_Conversion nodes. We do this at
704 the very end to avoid having to second-guess the front-end when we run
705 into dummy nodes during the regular processing. */
710 /* Finally see if we have any elaboration procedures to deal with. */
712 {
715 /* We should have a BIND_EXPR but it may not have any statements in it.
716 If it doesn't have any, we have nothing to do except for setting the
717 flag on the GNAT node. Otherwise, process the function as others. */
723 else
724 {
728 }
729 }
731 /* Destroy ourselves. */
736 /* We cannot track the location of errors past this point. */
738 }
740 /* Return a subprogram decl corresponding to __gnat_rcheck_xx for the given
741 CHECK if KIND is EXCEPTION_SIMPLE, or else to __gnat_rcheck_xx_ext. */
743 static tree
745 {
754 {
756 ftype
760 }
761 else
762 {
767 ftype
772 }
774 /* Indicate that it never returns. */
776 result
782 }
784 /* Return a positive value if an lvalue is required for GNAT_NODE, which is
785 an N_Attribute_Reference. */
787 static int
789 {
791 {
829 }
830 }
832 /* Return a positive value if an lvalue is required for GNAT_NODE. GNU_TYPE
833 is the type that will be used for GNAT_NODE in the translated GNU tree.
834 CONSTANT indicates whether the underlying object represented by GNAT_NODE
835 is constant in the Ada sense. If it is, ADDRESS_OF_CONSTANT indicates
836 whether its value is the address of another constant. If it isn't, then
837 ADDRESS_OF_CONSTANT is ignored.
839 The function climbs up the GNAT tree starting from the node and returns 1
840 upon encountering a node that effectively requires an lvalue downstream.
841 It returns int instead of bool to facilitate usage in non-purely binary
842 logic contexts. */
844 static int
847 {
851 {
861 /* If the parameter is by reference, an lvalue is required. */
868 address_of_constant);
872 {
873 const unsigned char id
876 }
877 else
881 /* Only the array expression can require an lvalue. */
885 /* ??? Consider that referencing an indexed component with a variable
886 index forces the whole aggregate to memory. Note that testing only
887 for literals is conservative, any static expression in the RM sense
888 could probably be accepted with some additional work. */
898 /* ... fall through ... */
902 /* Only the prefix expression can require an lvalue. */
911 /* We need to preserve addresses through a renaming. */
915 /* We cannot use a constructor if this is an atomic object because
916 the actual assignment might end up being done component-wise. */
920 /* We don't use a constructor if this is a class-wide object
921 because the effective type of the object is the equivalent
922 type of the class-wide subtype and it smashes most of the
923 data into an array of bytes to which we cannot convert. */
928 /* We cannot use a constructor if the LHS is an atomic object because
929 the actual assignment might end up being done component-wise. */
940 /* ... fall through ... */
944 /* We must look through all conversions because we may need to bypass
945 an intermediate conversion that is meant to be purely formal. */
951 /* We look through dereferences for address of constant because we need
952 to handle the special cases listed above. */
958 /* ... fall through ... */
962 }
965 }
967 /* Return true if an lvalue should be used for GNAT_NODE. GNU_TYPE is the type
968 that will be used for GNAT_NODE in the translated GNU tree and is assumed to
969 be an aggregate type.
971 The function climbs up the GNAT tree starting from the node and returns true
972 upon encountering a node that makes it doable to decide. lvalue_required_p
973 should have been previously invoked on the arguments and returned false. */
975 static bool
977 {
981 {
985 /* Even if the parameter is by copy, prefer an lvalue. */
989 /* Likewise for a return value. */
994 /* If an elementary component is used, take it from the constant. */
998 /* ... fall through ... */
1005 /* For an aggregate object declaration, return false consistently. */
1009 /* For an aggregate assignment, decide based on the size. */
1010 {
1013 }
1022 /* We should only reach here through the N_Qualified_Expression case.
1023 Force an lvalue for aggregate types since a block-copy to the newly
1024 allocated area of memory is made. */
1029 }
1032 }
1035 /* Return true if T is a constant DECL node that can be safely replaced
1036 by its initializer. */
1038 static bool
1040 {
1044 /* Return false for aggregate types that contain a placeholder since
1045 their initializers cannot be manipulated easily. */
1052 }
1054 /* Return an expression equivalent to EXP but where constant DECL nodes
1055 have been replaced by their initializer. */
1057 static tree
1059 {
1061 tree op0;
1064 {
1090 /* If the index is not itself constant, then nothing can be folded. */
1111 }
1114 }
1116 /* Return true if TYPE and DEF_TYPE are compatible GNAT types for Gigi. */
1118 static bool
1120 {
1121 /* The trivial case. */
1125 /* A class-wide type is equivalent to a subtype of itself. */
1129 /* A packed array type is compatible with its implementation type. */
1133 /* If both types are Itypes, one may be a copy of the other. */
1137 /* If the type is incomplete and comes from a limited context, then also
1138 consider its non-limited view. */
1144 /* If the type is incomplete/private, then also consider its full view. */
1150 }
1152 /* Subroutine of gnat_to_gnu to translate GNAT_NODE, an N_Identifier, to a GCC
1153 tree, which is returned. GNU_RESULT_TYPE_P is a pointer to where we should
1154 place the result type. */
1156 static tree
1158 {
1159 /* The entity of GNAT_NODE and its type. */
1164 /* If GNAT_NODE is a constant, whether we should use the initialization
1165 value instead of the constant entity, typically for scalars with an
1166 address clause when the parent doesn't require an lvalue. */
1168 /* Whether we should require an lvalue for GNAT_NODE. Needed in
1169 specific circumstances only, so evaluated lazily. < 0 means
1170 unknown, > 0 means known true, 0 means known false. */
1172 Entity_Id gnat_result_type;
1175 /* If the Etype of this node is not the same as that of the Entity, then
1176 something went wrong, probably in generic instantiation. However, this
1177 does not apply to types. Since we sometime have strange Ekind's, just
1178 do this test for objects, except for discriminants because their type
1179 may have been changed to a subtype by Exp_Ch3.Adjust_Discriminants. */
1185 /* If this is a reference to a deferred constant whose partial view is an
1186 unconstrained private type, the proper type is on the full view of the
1187 constant, not on the full view of the type, which may be unconstrained.
1189 This may be a reference to a type, for example in the prefix of the
1190 attribute Position, generated for dispatching code (see Make_DT in
1191 exp_disp,adb). In that case we need the type itself, not is parent,
1192 in particular if it is a derived type */
1199 {
1202 }
1203 else
1204 {
1205 /* We use the Actual_Subtype only if it has already been elaborated,
1206 as we may be invoked precisely during its elaboration, otherwise
1207 the Etype. Avoid using it for packed arrays to simplify things,
1208 except in a return statement because we need the actual size and
1209 the front-end does not make it explicit in this case. */
1219 else
1221 }
1223 /* Expand the type of this identifier first, in case it is an enumeral
1224 literal, which only get made when the type is expanded. There is no
1225 order-of-elaboration issue here. */
1228 /* If this is a non-imported elementary constant with an address clause,
1229 retrieve the value instead of a pointer to be dereferenced unless
1230 an lvalue is required. This is generally more efficient and actually
1231 required if this is a static expression because it might be used
1232 in a context where a dereference is inappropriate, such as a case
1233 statement alternative or a record discriminant. There is no possible
1234 volatile-ness short-circuit here since Volatile constants must be
1235 imported per C.6. */
1240 {
1241 require_lvalue
1244 }
1247 {
1248 /* If this is a deferred constant, the initializer is attached to
1249 the full view. */
1254 }
1255 else
1258 /* Some objects (such as parameters passed by reference, globals of
1259 variable size, and renamed objects) actually represent the address
1260 of the object. In that case, we must do the dereference. Likewise,
1261 deal with parameters to foreign convention subprograms. */
1266 {
1269 /* If it's a PARM_DECL to foreign convention subprogram, convert it. */
1272 gnu_result
1275 /* If it's a CONST_DECL, return the underlying constant like below. */
1282 /* Do the final dereference. */
1292 }
1294 /* If we have a constant declaration and its initializer, try to return the
1295 latter to avoid the need to call fold in lots of places and the need for
1296 elaboration code if this identifier is used as an initializer itself. */
1298 {
1304 /* If there is a (corresponding) variable or this is the address of a
1305 constant, we only want to return the initializer if an lvalue isn't
1306 required. Evaluate this now if we have not already done so. */
1308 require_lvalue
1310 address_of_constant)
1314 /* Finally retrieve the initializer if this is deemed valid. */
1317 }
1319 /* But for a constant renaming we couldn't do that incrementally for its
1320 definition because of the need to return an lvalue so, if the present
1321 context doesn't itself require an lvalue, we try again here. */
1325 {
1327 require_lvalue
1331 }
1333 /* The GNAT tree has the type of a function set to its result type, so we
1334 adjust here. Also use the type of the result if the Etype is a subtype
1335 that is nominally unconstrained. Likewise if this is a deferred constant
1336 of a discriminated type whose full view can be elaborated statically, to
1337 avoid problematic conversions to the nominal subtype. But remove any
1338 padding from the resulting type. */
1345 {
1349 }
1354 }
1356 /* Subroutine of gnat_to_gnu to translate GNAT_NODE, an N_Pragma, to a GCC
1357 tree, which is returned. */
1359 static tree
1361 {
1363 Node_Id gnat_temp;
1365 /* Check for (and ignore) unrecognized pragmas. */
1369 const unsigned char id
1372 /* Save the expression of pragma Compile_Time_{Error|Warning} for later. */
1374 {
1378 }
1380 /* Stop there if we are just annotating types. */
1385 {
1387 /* Do nothing at top level: all such variables are already viewable. */
1394 {
1398 #ifdef ASM_COMMENT_START
1400 #endif
1407 #ifdef ASM_COMMENT_START
1412 NULL);
1415 #endif
1417 asm_constraint,
1418 NULL_TREE,
1419 tree_cons
1427 }
1434 {
1438 {
1461 }
1462 }
1468 {
1486 }
1496 {
1497 Node_Id gnat_expr;
1498 /* Preserve the location of the pragma. */
1502 diagnostic_t kind;
1507 /* This is the String form: pragma Warning{s|_As_Error}(String). */
1509 {
1511 {
1524 }
1527 }
1529 /* This is the On/Off form: pragma Warnings (On | Off [,String]). */
1531 {
1533 {
1544 }
1546 /* Deal with optional pattern (but ignore Reason => "..."). */
1549 {
1550 /* pragma Warnings (On | Off, Name) is handled differently. */
1555 }
1556 else
1557 {
1560 /* For pragma Warnings (Off), we save the current state... */
1564 /* ...so that, for pragma Warnings (On), we do not enable all
1565 the warnings but just restore the previous state. */
1566 else
1567 {
1570 }
1571 }
1574 }
1576 else
1579 /* This is the same implementation as in the C family of compilers. */
1583 {
1591 {
1594 }
1596 {
1599 }
1601 {
1604 }
1607 }
1608 else
1615 }
1620 }
1623 }
1625 /* Check the inline status of nested function FNDECL wrt its parent function.
1627 If a non-inline nested function is referenced from an inline external
1628 function, we cannot honor both requests at the same time without cloning
1629 the nested function in the current unit since it is private to its unit.
1630 We could inline it as well but it's probably better to err on the side
1631 of too little inlining.
1633 This must be done only on nested functions present in the source code
1634 and not on nested functions generated by the compiler, e.g. finalizers,
1635 because they may be not marked inline and we don't want them to block
1636 the inlining of the parent function. */
1638 static void
1640 {
1649 {
1654 {
1656 fndecl);
1658 }
1659 else
1660 {
1662 fndecl);
1664 }
1668 }
1669 }
1671 /* Return an expression for the length of TYPE, an integral type, computed in
1672 RESULT_TYPE, another integral type.
1674 We used to compute the length as MAX (hb - lb + 1, 0) which could overflow
1675 when lb == TYPE'First. We now compute it as (hb >= lb) ? hb - lb + 1 : 0
1676 which would only overflow in much rarer cases, for extremely large arrays
1677 we expect never to encounter in practice. Besides, the former computation
1678 required the use of potentially constraining signed arithmetics while the
1679 latter does not. Note that the comparison must be done in the original
1680 base index type in order to avoid any overflow during the conversion. */
1682 static tree
1684 {
1689 tree length
1695 length
1701 }
1703 /* Subroutine of gnat_to_gnu to translate GNAT_NODE, an N_Attribute node, to a
1704 GCC tree, which is returned. GNU_RESULT_TYPE_P is a pointer to where we
1705 should place the result type. ATTRIBUTE is the attribute ID. */
1707 static tree
1709 {
1716 /* If the input is a NULL_EXPR, make a new one. */
1718 {
1722 }
1725 {
1728 /* These just add or subtract the constant 1 since representation
1729 clauses for enumeration types are handled in the front-end. */
1735 gnu_result
1742 /* Conversions don't change the address of references but can cause
1743 build_unary_op to miss the references below, so strip them off.
1744 On the contrary, if the address-of operation causes a temporary
1745 to be created, then it must be created with the proper type. */
1751 /* If we are taking 'Address of an unconstrained object, this is the
1752 pointer to the underlying array. */
1756 /* If we are building a static dispatch table, we have to honor
1757 TARGET_VTABLE_USES_DESCRIPTORS if we want to be compatible
1758 with the C++ ABI. We do it in the non-static case as well,
1759 see gnat_to_gnu_entity, case E_Access_Subprogram_Type. */
1762 {
1764 /* Descriptors can only be built here for top-level functions. */
1772 /* If we're not going to build the descriptor, we have to retrieve
1773 the one which will be built by the linker (or by the compiler
1774 later if a static chain is requested). */
1776 {
1779 gnu_result);
1781 }
1788 {
1790 {
1794 }
1795 else
1801 elt--;
1802 }
1806 }
1808 /* ... fall through ... */
1813 /* Taking the address of a type does not make sense. */
1817 gnu_result
1824 /* For 'Code_Address, find an inner ADDR_EXPR and mark it so that we
1825 don't try to build a trampoline. */
1827 {
1833 /* On targets for which function symbols denote a descriptor, the
1834 code address is stored within the first slot of the descriptor
1835 so we do an additional dereference:
1836 result = *((result_type *) result)
1837 where we expect result to be of some pointer type already. */
1839 gnu_result
1842 gnu_result));
1843 }
1845 /* For 'Access, issue an error message if the prefix is a C++ method
1846 since it can use a special calling convention on some platforms,
1847 which cannot be propagated to the access type. */
1851 gnat_node);
1853 /* For other address attributes applied to a nested function,
1854 find an inner ADDR_EXPR and annotate it so that we can issue
1855 a useful warning with -Wtrampolines. */
1860 {
1863 /* Also check the inlining status. */
1866 /* Moreover, for 'Access or 'Unrestricted_Access with non-
1867 foreign-compatible representation, mark the ADDR_EXPR so
1868 that we can build a descriptor instead of a trampoline. */
1875 /* Otherwise, we need to check that we are not violating the
1876 No_Implicit_Dynamic_Code restriction. */
1879 }
1883 {
1885 tree gnu_obj_type;
1889 /* If this is fat pointer, the object must have been allocated with the
1890 template in front of the array. So compute the template address; do
1891 it by converting to a thin pointer. */
1893 gnu_ptr
1895 (TYPE_OBJECT_RECORD_TYPE
1897 gnu_ptr);
1901 /* If this is a thin pointer, the object must have been allocated with
1902 the template in front of the array. So compute the template address
1903 and return it. */
1905 gnu_ptr
1907 gnu_ptr,
1909 byte_position
1910 (DECL_CHAIN
1914 }
1921 /* Strip NOPs, conversions between original and packable versions, and
1922 unpadding from GNU_PREFIX. Note that we cannot simply strip every
1923 VIEW_CONVERT_EXPR because some of them may give the actual size, e.g.
1924 for nominally unconstrained packed array. We use GNU_EXPR to see
1925 if a COMPONENT_REF was involved. */
1931 == RECORD_TYPE
1942 /* Replace an unconstrained array type with the type of the underlying
1943 array, except for 'Max_Size_In_Storage_Elements because we need to
1944 return the (maximum) size requested for an allocator. */
1946 {
1950 }
1952 /* The type must be frozen at this point. */
1955 /* If we're looking for the size of a field, return the field size. */
1959 /* Otherwise, if the prefix is an object, or if we are looking for
1960 'Object_Size or 'Max_Size_In_Storage_Elements, the result is the
1961 GCC size of the type. We make an exception for padded objects,
1962 as we do not take into account alignment promotions for the size.
1963 This is in keeping with the object case of gnat_to_gnu_entity. */
1970 {
1971 /* If this is a dereference and we have a special dynamic constrained
1972 subtype on the prefix, use it to compute the size; otherwise, use
1973 the designated subtype. */
1975 {
1976 Node_Id gnat_actual_subtype
1978 tree gnu_ptr_type
1983 {
1984 tree gnu_actual_obj_type
1986 gnu_type
1988 gnu_actual_obj_type,
1991 }
1992 }
1995 }
1997 /* Otherwise, the result is the RM size of the type. */
1998 else
2001 /* Deal with a self-referential size by qualifying the size with the
2002 object or returning the maximum size for a type. */
2008 /* If the type contains a template, subtract the padded size of the
2009 template, except for 'Max_Size_In_Storage_Elements because we need
2010 to return the (maximum) size requested for an allocator. */
2014 gnu_result
2018 /* For 'Max_Size_In_Storage_Elements, adjust the unit. */
2026 {
2039 else
2040 {
2045 /* If the default alignment of "double" or larger scalar types is
2046 specifically capped and there is an alignment clause neither
2047 on the type nor on the prefix itself, return the cap. */
2049 is_capped_double
2052 is_capped_double
2054 else
2064 else
2066 }
2069 }
2078 {
2085 else
2088 }
2090 /* ... fall through ... */
2093 {
2104 /* We treat unconstrained array In parameters specially. We also note
2105 whether we are dereferencing a pointer to unconstrained array. */
2108 {
2110 /* This is the direct case. */
2116 /* This is the indirect case. Note that we need to be sure that
2117 the access value cannot be null as we'll hoist the load. */
2120 {
2123 }
2124 else
2130 }
2132 /* If the prefix is the view conversion of a constrained array to an
2133 unconstrained form, we retrieve the constrained array because we
2134 might not be able to substitute the PLACEHOLDER_EXPR coming from
2135 the conversion. This can occur with the 'Old attribute applied
2136 to a parameter with an unconstrained type, which gets rewritten
2137 into a constrained local variable very late in the game. */
2140 && !CONTAINS_PLACEHOLDER_P
2143 else
2150 {
2152 tree gnu_type_temp;
2158 ;
2161 }
2168 /* When not optimizing, look up the slot associated with the parameter
2169 and the dimension in the cache and create a new one on failure.
2170 Don't do this when the actual subtype needs debug info (this happens
2171 with -gnatD): in elaborate_expression_1, we create variables that
2172 hold the bounds, so caching attributes isn't very interesting and
2173 causes dependency issues between these variables and cached
2174 expressions. */
2179 {
2185 {
2190 }
2191 }
2193 /* Return the cached expression or build a new one. */
2195 {
2197 {
2200 }
2202 gnu_result
2204 }
2207 {
2209 {
2212 }
2214 gnu_result
2216 }
2219 {
2221 {
2224 }
2226 gnu_result
2228 gnu_result_type);
2229 }
2231 /* If this has a PLACEHOLDER_EXPR, qualify it by the object we are
2232 handling. Note that these attributes could not have been used on
2233 an unconstrained array type. */
2236 /* Cache the expression we have just computed. Since we want to do it
2237 at run time, we force the use of a SAVE_EXPR and let the gimplifier
2238 create the temporary in the outermost binding level. We will make
2239 sure in Subprogram_Body_to_gnu that it is evaluated on all possible
2240 paths by forcing its evaluation on entry of the function. */
2242 {
2243 gnu_result
2246 {
2262 }
2263 }
2265 /* Otherwise, evaluate it each time it is referenced. */
2266 else
2268 {
2271 /* If we are dereferencing a pointer to unconstrained array, we
2272 need to capture the value because the pointed-to bounds may
2273 subsequently be released. */
2275 gnu_result
2281 /* Set the source location onto the predicate of the condition
2282 but not if the expression is cached to avoid messing up the
2283 debug info. */
2287 gnat_node);
2292 }
2295 }
2302 {
2303 poly_int64 bitsize;
2304 poly_int64 bitpos;
2305 tree gnu_offset;
2306 tree gnu_field_bitpos;
2307 tree gnu_field_offset;
2308 tree gnu_inner;
2309 machine_mode mode;
2316 /* We can have 'Bit on any object, but if it isn't a COMPONENT_REF,
2317 the result is 0. Don't allow 'Bit on a bare component, though. */
2321 {
2324 }
2326 else
2335 {
2343 {
2344 gnu_field_bitpos
2347 gnu_field_offset
2350 }
2351 }
2353 {
2356 }
2357 else
2358 {
2361 }
2364 {
2378 /* ??? Avoid a large unsigned result that will overflow when
2379 converted to the signed universal_integer. */
2382 else
2383 gnu_result
2390 }
2392 /* If this has a PLACEHOLDER_EXPR, qualify it by the object we are
2393 handling. */
2396 }
2400 {
2406 /* The result of {MIN,MAX}_EXPR is unspecified if either operand is
2407 a NaN so we implement the semantics of C99 f{min,max} to make it
2408 predictable in this case: if either operand is a NaN, the other
2409 is returned; if both operands are NaN's, a NaN is returned. */
2412 {
2418 /* If the operands have side-effects, they need to be evaluated
2419 only once in spite of the multiple references in the result. */
2427 integer_zero_node);
2431 integer_zero_node);
2441 /* If the operands have side-effects, they need to be evaluated
2442 before doing the tests above since the place they otherwise
2443 would end up being evaluated at run time could be wrong. */
2445 gnu_result
2449 gnu_result
2451 }
2452 else
2456 }
2478 /* Note this size cannot be self-referential. */
2488 /* Return the padded size of the template in the object record type. */
2496 /* This is just a zero cast to the pointer type for our prefix and
2497 dereferenced. */
2499 gnu_result
2502 integer_zero_node));
2506 {
2513 {
2518 ;
2519 }
2527 && (DECL_BY_COMPONENT_PTR_P
2531 }
2535 /* We treat Model as identical to Machine. This is true for at least
2536 IEEE and some other nice floating-point systems. */
2538 /* ... fall through ... */
2541 /* The trick is to force the compiler to store the result in memory so
2542 that we do not have extra precision used. But do this only when this
2543 is necessary, i.e. if FP_ARITH_MAY_WIDEN is true and the precision of
2544 the type is lower than that of the longest floating-point type. */
2551 && fp_arith_may_widen
2554 {
2556 tree field
2566 asm_expr
2578 gnu_result
2582 }
2589 /* This can be a random address so build an alias-all pointer type. */
2590 gnu_expr
2593 gnu_expr);
2598 /* This abort means that we have an unimplemented attribute. */
2600 }
2602 /* If this is an attribute where the prefix was unused, force a use of it if
2603 it has a side-effect. But don't do it if the prefix is just an entity
2604 name. However, if an access check is needed, we must do it. See second
2605 example in AARM 11.6(5.e). */
2609 gnu_result
2614 }
2616 /* Subroutine of gnat_to_gnu to translate GNAT_NODE, an N_Case_Statement, to a
2617 GCC tree, which is returned. */
2619 static tree
2621 {
2623 Node_Id gnat_when;
2624 location_t end_locus;
2632 /* We build a SWITCH_EXPR that contains the code with interspersed
2633 CASE_LABEL_EXPRs for each label. */
2642 {
2644 Node_Id gnat_choice;
2646 /* First compile all the different case choices for the current WHEN
2647 alternative. */
2651 {
2656 {
2671 /* This represents either a subtype range or a static value of
2672 some kind; Ekind says which. */
2674 {
2680 }
2682 /* ... fall through ... */
2694 }
2696 /* Everything should be folded into constants at this point. */
2706 gnat_choice);
2708 }
2710 /* This construct doesn't define a scope so we shouldn't push a binding
2711 level around the statement list. Except that we have always done so
2712 historically and this makes it possible to reduce stack usage. As a
2713 compromise, we keep doing it for case statements, for which this has
2714 never been problematic, but not for case expressions in Ada 2012. */
2716 {
2717 const bool is_case_expression
2719 tree group
2724 {
2729 }
2730 }
2731 }
2733 /* Now emit a definition of the label the cases branch to, if any. */
2739 }
2741 /* Return true if we are in the body of a loop. */
2745 {
2747 }
2749 /* Find out whether EXPR is a simple additive expression based on the iteration
2750 variable of some enclosing loop in the current function. If so, return the
2751 loop and set *DISP to the displacement and *NEG_P to true if this is for a
2752 subtraction; otherwise, return NULL. */
2756 {
2763 {
2769 }
2770 else
2771 {
2777 }
2791 }
2793 /* Return the innermost enclosing loop in the current function. */
2797 {
2808 }
2810 /* Return true if VAL (of type TYPE) can equal the minimum value if MAX is
2811 false, or the maximum value if MAX is true, of TYPE. */
2813 static bool
2815 {
2822 val = (max
2831 else
2833 }
2835 /* Return true if VAL (of type TYPE) can equal the minimum value of TYPE.
2836 If REVERSE is true, minimum value is taken as maximum value. */
2840 {
2842 }
2844 /* Return true if VAL (of type TYPE) can equal the maximum value of TYPE.
2845 If REVERSE is true, maximum value is taken as minimum value. */
2849 {
2851 }
2853 /* Replace EXPR1 and EXPR2 by invariant expressions if possible. Return
2854 true if both expressions have been replaced and false otherwise. */
2856 static bool
2858 {
2869 }
2871 /* Helper function for walk_tree, used by independent_iterations_p below. */
2873 static tree
2875 {
2879 /* No need to walk into types or decls. */
2887 }
2889 /* Return true if STMT_LIST generates independent iterations in a loop. */
2891 static bool
2893 {
2894 tree_stmt_iterator tsi;
2897 tree iter;
2903 /* Scan the list and return false on anything that is not either a check
2904 or an assignment to a parameter with restricted aliasing. */
2906 {
2910 {
2912 {
2921 }
2924 {
2937 }
2941 }
2942 }
2944 /* At this point we know that the list contains only statements that will
2945 modify parameters with restricted aliasing. Check that the statements
2946 don't at the time read from these parameters. */
2952 }
2954 /* Subroutine of gnat_to_gnu to translate GNAT_NODE, an N_Loop_Statement, to a
2955 GCC tree, which is returned. */
2957 static tree
2959 {
2966 tree gnu_result;
2968 /* Push the loop_info structure associated with the LOOP_STMT. */
2973 /* Set location information for statement and end label. */
2979 /* Set the condition under which the loop must keep going. If we have an
2980 explicit condition, use it to set the location information throughout
2981 the translation of the loop statement to avoid having multiple SLOCs.
2983 For the case "LOOP .... END LOOP;" the condition is always true. */
2985 ;
2987 /* For the case "WHILE condition LOOP ..... END LOOP;" it's immediate. */
2989 {
2994 }
2996 /* Otherwise we have an iteration scheme and the condition is given by the
2997 bounds of the subtype of the iteration variable. */
2998 else
2999 {
3013 /* We must disable modulo reduction for the iteration variable, if any,
3014 in order for the loop comparison to be effective. */
3016 {
3022 }
3023 else
3024 {
3030 }
3032 /* We use two different strategies to translate the loop, depending on
3033 whether optimization is enabled.
3035 If it is, we generate the canonical loop form expected by the loop
3036 optimizer and the loop vectorizer, which is the do-while form:
3038 ENTRY_COND
3039 loop:
3040 TOP_UPDATE
3041 BODY
3042 BOTTOM_COND
3043 GOTO loop
3045 This avoids an implicit dependency on loop header copying and makes
3046 it possible to turn BOTTOM_COND into an inequality test.
3048 If optimization is disabled, loop header copying doesn't come into
3049 play and we try to generate the loop form with the fewer conditional
3050 branches. First, the default form, which is:
3052 loop:
3053 TOP_COND
3054 BODY
3055 BOTTOM_UPDATE
3056 GOTO loop
3058 It should catch most loops with constant ending point. Then, if we
3059 cannot, we try to generate the shifted form:
3061 loop:
3062 TOP_COND
3063 TOP_UPDATE
3064 BODY
3065 GOTO loop
3067 which should catch loops with constant starting point. Otherwise, if
3068 we cannot, we generate the fallback form:
3070 ENTRY_COND
3071 loop:
3072 BODY
3073 BOTTOM_COND
3074 BOTTOM_UPDATE
3075 GOTO loop
3077 which works in all cases. */
3080 {
3081 /* We can use the do-while form directly if GNU_FIRST-1 doesn't
3082 overflow. */
3084 ;
3086 /* Otherwise, use the do-while form with the help of a special
3087 induction variable in the unsigned version of the base type
3088 or the unsigned version of the size type, whichever is the
3089 largest, in order to have wrap-around arithmetics for it. */
3090 else
3091 {
3094 gnu_base_type
3096 else
3103 }
3105 gnu_first
3107 gnu_one_node);
3110 }
3111 else
3112 {
3113 /* We can use the default form if GNU_LAST+1 doesn't overflow. */
3115 ;
3117 /* Otherwise, we can use the shifted form if neither GNU_FIRST-1 nor
3118 GNU_LAST-1 does. */
3121 {
3122 gnu_first
3124 gnu_one_node);
3125 gnu_last
3127 gnu_one_node);
3129 }
3131 /* Otherwise, use the fallback form. */
3132 else
3134 }
3136 /* If we use the BOTTOM_COND, we can turn the test into an inequality
3137 test but we have to add ENTRY_COND to protect the empty loop. */
3139 {
3141 gnu_cond_expr
3147 }
3149 /* Open a new nesting level that will surround the loop to declare the
3150 iteration variable. */
3154 /* If we use the special induction variable, create it and set it to
3155 its initial value. Morever, the regular iteration variable cannot
3156 itself be initialized, lest the initial value wrapped around. */
3158 {
3159 gnu_loop_iv
3163 }
3164 else
3167 /* Declare the iteration variable and set it to its initial value. */
3172 {
3175 }
3180 /* Do all the arithmetics in the base type. */
3183 /* Set either the top or bottom exit condition. */
3187 gnu_last);
3188 else
3191 gnu_last);
3193 /* Set either the top or bottom update statement and give it the source
3194 location of the iteration for better coverage info. */
3196 {
3197 gnu_stmt
3204 gnu_stmt
3206 gnu_loop_iv);
3210 }
3211 else
3212 {
3213 gnu_stmt
3219 }
3222 }
3224 /* If the loop was named, have the name point to this loop. In this case,
3225 the association is not a DECL node, but the end label of the loop. */
3229 /* Make the loop body into its own block, so any allocated storage will be
3230 released every iteration. This is needed for stack allocation. */
3235 /* If we have an iteration scheme, then we are in a statement group. Add
3236 the LOOP_STMT to it, finish it and make it the "loop". */
3238 {
3239 /* First, if we have computed invariant conditions for range (or index)
3240 checks applied to the iteration variable, find out whether they can
3241 be evaluated to false at compile time; otherwise, if there are not
3242 too many of them, combine them with the original checks. If loop
3243 unswitching is enabled, do not require the loop bounds to be also
3244 invariant, as their evaluation will still be ahead of the loop. */
3247 {
3252 {
3256 {
3259 gnu_adjusted_low
3262 low_ok
3265 }
3266 else
3270 {
3273 gnu_adjusted_high
3276 high_ok
3279 }
3280 else
3283 tree range_ok
3287 rci->invariant_cond
3292 else
3293 n_remaining_checks++;
3294 }
3296 /* Note that loop unswitching can only be applied a small number of
3297 times to a given loop (PARAM_MAX_UNSWITCH_LEVEL default to 3). */
3303 {
3308 }
3309 }
3311 /* Second, if we have recorded invariants to be hoisted, emit them. */
3313 {
3318 }
3320 /* Third, if loop vectorization is enabled and the iterations of the
3321 loop can easily be proved as independent, mark the loop. */
3329 }
3331 /* If we have an outer COND_EXPR, that's our result and this loop is its
3332 "true" statement. Otherwise, the result is the LOOP_STMT. */
3334 {
3338 }
3339 else
3345 }
3347 /* This page implements a form of Named Return Value optimization modeled
3348 on the C++ optimization of the same name. The main difference is that
3349 we disregard any semantical considerations when applying it here, the
3350 counterpart being that we don't try to apply it to semantically loaded
3351 return types, i.e. types with the TYPE_BY_REFERENCE_P flag set.
3353 We consider a function body of the following GENERIC form:
3355 return_type R1;
3356 [...]
3357 RETURN_EXPR [<retval> = ...]
3358 [...]
3359 RETURN_EXPR [<retval> = R1]
3360 [...]
3361 return_type Ri;
3362 [...]
3363 RETURN_EXPR [<retval> = ...]
3364 [...]
3365 RETURN_EXPR [<retval> = Ri]
3366 [...]
3368 where the Ri are not addressable and we try to fulfill a simple criterion
3369 that would make it possible to replace one or several Ri variables by the
3370 single RESULT_DECL of the function.
3372 The first observation is that RETURN_EXPRs that don't directly reference
3373 any of the Ri variables on the RHS of their assignment are transparent wrt
3374 the optimization. This is because the Ri variables aren't addressable so
3375 any transformation applied to them doesn't affect the RHS; moreover, the
3376 assignment writes the full <retval> object so existing values are entirely
3377 discarded.
3379 This property can be extended to some forms of RETURN_EXPRs that reference
3380 the Ri variables, for example CONSTRUCTORs, but isn't true in the general
3381 case, in particular when function calls are involved.
3383 Therefore the algorithm is as follows:
3385 1. Collect the list of candidates for a Named Return Value (Ri variables
3386 on the RHS of assignments of RETURN_EXPRs) as well as the list of the
3387 other expressions on the RHS of such assignments.
3389 2. Prune the members of the first list (candidates) that are referenced
3390 by a member of the second list (expressions).
3392 3. Extract a set of candidates with non-overlapping live ranges from the
3393 first list. These are the Named Return Values.
3395 4. Adjust the relevant RETURN_EXPRs and replace the occurrences of the
3396 Named Return Values in the function with the RESULT_DECL.
3398 If the function returns an unconstrained type, things are a bit different
3399 because the anonymous return object is allocated on the secondary stack
3400 and RESULT_DECL is only a pointer to it. Each return object can be of a
3401 different size and is allocated separately so we need not care about the
3402 addressability and the aforementioned overlapping issues. Therefore, we
3403 don't collect the other expressions and skip step #2 in the algorithm. */
3405 struct nrv_data
3406 {
3407 bitmap nrv;
3408 tree result;
3409 Node_Id gnat_ret;
3411 };
3413 /* Return true if T is a Named Return Value. */
3417 {
3419 }
3421 /* Helper function for walk_tree, used by finalize_nrv below. */
3423 static tree
3425 {
3429 /* No need to walk into types or decls. */
3437 }
3439 /* Prune Named Return Values in BLOCK and return true if there is still a
3440 Named Return Value in BLOCK or one of its sub-blocks. */
3442 static bool
3444 {
3446 tree t;
3448 /* First recurse on the sub-blocks. */
3452 /* Then make sure to keep at most one NRV per block. */
3455 {
3458 else
3460 }
3463 }
3465 /* Helper function for walk_tree, used by finalize_nrv below. */
3467 static tree
3469 {
3473 /* No need to walk into types. */
3477 /* Change RETURN_EXPRs of NRVs to just refer to the RESULT_DECL; this is a
3478 nop, but differs from using NULL_TREE in that it indicates that we care
3479 about the value of the RESULT_DECL. */
3482 {
3485 /* Strip useless conversions around the return value. */
3491 }
3493 /* Replace the DECL_EXPR of NRVs with an initialization of the RESULT_DECL,
3494 if needed. */
3497 {
3501 {
3506 }
3507 else
3511 /* Identify the NRV to the RESULT_DECL for debugging purposes. */
3514 /* ??? Kludge to avoid an assertion failure during inlining. */
3517 }
3519 /* And replace all uses of NRVs with the RESULT_DECL. */
3523 /* Avoid walking into the same tree more than once. Unfortunately, we
3524 can't just use walk_tree_without_duplicates because it would only
3525 call us for the first occurrence of NRVs in the function body. */
3530 }
3532 /* Likewise, but used when the function returns an unconstrained type. */
3534 static tree
3536 {
3540 /* No need to walk into types. */
3544 /* We need to see the DECL_EXPR of NRVs before any other references so we
3545 walk the body of BIND_EXPR before walking its variables. */
3549 /* Change RETURN_EXPRs of NRVs to assign to the RESULT_DECL only the final
3550 return value built by the allocator instead of the whole construct. */
3553 {
3556 /* This is the construct returned by the allocator. */
3559 {
3564 else
3566 }
3568 /* Strip useless conversions around the return value. */
3573 /* Strip unpadding around the return value. */
3578 /* Assign the new return value to the RESULT_DECL. */
3582 }
3584 /* Adjust the DECL_EXPR of NRVs to call the allocator and save the result
3585 into a new variable. */
3588 {
3595 /* Create an artificial context to build the allocation. */
3600 /* This will return a COMPOUND_EXPR with the allocation in the first
3601 arm and the final return value in the second arm. */
3608 /* The new variable is built as a reference to the allocated space. */
3609 new_var
3615 {
3618 /* The new initial value is a COMPOUND_EXPR with the allocation in
3619 the first arm and the value of P_ARRAY in the second arm. */
3625 /* Build a modified CONSTRUCTOR that references NEW_VAR. */
3632 }
3633 else
3634 {
3635 /* The new initial value is just the allocation. */
3638 }
3642 /* Destroy the artificial context and insert the new statements. */
3647 /* Chain NEW_VAR immediately after VAR and ignore the latter. */
3652 /* Save the new return value and the dereference of NEW_VAR. */
3656 /* ??? Kludge to avoid messing up during inlining. */
3658 }
3660 /* And replace all uses of NRVs with the dereference of NEW_VAR. */
3664 /* Avoid walking into the same tree more than once. Unfortunately, we
3665 can't just use walk_tree_without_duplicates because it would only
3666 call us for the first occurrence of NRVs in the function body. */
3671 }
3673 /* Apply FUNC to all the sub-trees of nested functions in NODE. FUNC is called
3674 with the DATA and the address of each sub-tree. If FUNC returns a non-NULL
3675 value, the traversal is stopped. */
3677 static void
3679 {
3682 {
3685 }
3686 }
3688 /* Finalize the Named Return Value optimization for FNDECL. The NRV bitmap
3689 contains the candidates for Named Return Value and OTHER is a list of
3690 the other return values. GNAT_RET is a representative return node. */
3692 static void
3694 {
3696 walk_tree_fn func;
3698 tree iter;
3700 /* We shouldn't be applying the optimization to return types that we aren't
3701 allowed to manipulate freely. */
3704 /* Prune the candidates that are referenced by other return values. */
3714 /* Prune also the candidates that are referenced by nested functions. */
3719 /* Extract a set of NRVs with non-overlapping live ranges. */
3723 /* Adjust the relevant RETURN_EXPRs and replace the occurrences of NRVs. */
3730 else
3734 }
3736 /* Return true if RET_VAL can be used as a Named Return Value for the
3737 anonymous return object RET_OBJ. */
3739 static bool
3741 {
3754 /* For the constrained case, test for addressability. */
3758 /* For the constrained case, test for overalignment. */
3762 /* For the unconstrained case, test for bogus initialization. */
3769 }
3771 /* Build a RETURN_EXPR. If RET_VAL is non-null, build a RETURN_EXPR around
3772 the assignment of RET_VAL to RET_OBJ. Otherwise build a bare RETURN_EXPR
3773 around RESULT_OBJ, which may be null in this case. */
3775 static tree
3777 {
3778 tree result_expr;
3781 {
3782 /* The gimplifier explicitly enforces the following invariant:
3784 RETURN_EXPR
3785 |
3786 INIT_EXPR
3787 / \
3788 / \
3789 RET_OBJ ...
3791 As a consequence, type consistency dictates that we use the type
3792 of the RET_OBJ as the operation type. */
3795 /* Convert the right operand to the operation type. Note that this is
3796 the transformation applied in the INIT_EXPR case of build_binary_op,
3797 with the assumption that the type cannot involve a placeholder. */
3801 /* We always can use an INIT_EXPR for the return object. */
3804 /* If the function returns an aggregate type, find out whether this is
3805 a candidate for Named Return Value. If so, record it. Otherwise,
3806 if this is an expression of some kind, record it elsewhere. */
3808 && !optimize_debug
3813 {
3814 /* Strip useless conversions around the return value. */
3818 /* Now apply the test to the return value. */
3820 {
3824 }
3826 /* Note that we need not care about CONSTRUCTORs here, as they are
3827 totally transparent given the read-compose-write semantics of
3828 assignments from CONSTRUCTORs. */
3831 }
3832 }
3833 else
3837 }
3839 /* Subroutine of gnat_to_gnu to translate GNAT_NODE, an N_Subprogram_Body. */
3841 static void
3843 {
3844 /* The defining identifier for the subprogram body. Note that if a
3845 specification has appeared before for this body, then the identifier
3846 occurring in that specification will also be a defining identifier
3847 and calls to this subprogram will point to that specification. */
3848 Entity_Id gnat_subprog
3851 /* The FUNCTION_DECL node corresponding to the defining identifier. */
3852 tree gnu_subprog;
3853 /* Its RESULT_DECL node. */
3854 tree gnu_result_decl;
3855 /* Its FUNCTION_TYPE node. */
3856 tree gnu_subprog_type;
3857 /* The TYPE_CI_CO_LIST of its FUNCTION_TYPE node, if any. */
3858 tree gnu_cico_list;
3859 /* The entry in the CI_CO_LIST that represents a function return, if any. */
3860 tree gnu_return_var_elmt;
3861 /* Its source location. */
3862 location_t locus;
3864 /* If this is a generic subprogram or it has been eliminated, ignore it. */
3868 /* If this subprogram acts as its own spec, define it. Otherwise, just get
3869 the already-elaborated tree node. However, if this subprogram had its
3870 elaboration deferred, we will already have made a tree node for it. So
3871 treat it as not being defined in that case. Such a subprogram cannot
3872 have an address clause or a freeze node, so this test is safe, though it
3873 does disable some otherwise-useful error checking. */
3874 gnu_subprog
3884 else
3887 /* If the function returns by invisible reference, make it explicit in the
3888 function body. See gnat_to_gnu_subprog_type for more details. */
3890 {
3894 }
3896 /* Set the line number in the decl to correspond to that of the body. */
3903 /* Try to create a bona-fide thunk and hand it over to the middle-end. */
3908 /* Initialize the information structure for the function. */
3917 /* If there are copy-in/copy-out parameters, we need to ensure that they are
3918 properly copied out by the return statement. We do this by making a new
3919 block and converting any return into a goto to a label at the end of the
3920 block. */
3922 {
3923 tree gnu_return_var;
3931 /* If this is a function with copy-in/copy-out parameters and which does
3932 not return by invisible reference, we also need a variable for the
3933 return value to be placed. */
3935 {
3936 tree gnu_return_type
3939 gnu_return_var
3945 }
3946 else
3951 /* See whether there are parameters for which we don't have a GCC tree
3952 yet. These must be Out parameters. Make a VAR_DECL for them and
3953 put it into TYPE_CI_CO_LIST, which must contain an empty entry too.
3954 We can match up the entries because TYPE_CI_CO_LIST is in the order
3955 of the parameters. */
3960 {
3962 tree gnu_decl;
3964 /* Skip any entries that have been already filled in; they must
3965 correspond to In Out parameters. */
3969 /* Do any needed dereferences for by-ref objects. */
3975 /* Do any needed references for padded types. */
3978 }
3979 }
3980 else
3983 /* Get a tree corresponding to the code for the subprogram. */
3987 /* First translate the declarations of the subprogram. */
3990 /* Then generate the code of the subprogram itself. A return statement will
3991 be present and any Out parameters will be handled there. */
3997 /* Attempt setting the end_locus of our GCC body tree, typically a BIND_EXPR,
3998 then the end_locus of our GCC subprogram declaration tree. */
4002 /* If we populated the parameter attributes cache, we need to make sure that
4003 the cached expressions are evaluated on all the possible paths leading to
4004 their uses. So we force their evaluation on entry of the function. */
4007 {
4014 {
4021 }
4027 }
4029 /* If we are dealing with a return from an Ada procedure with parameters
4030 passed by copy-in/copy-out, we need to return a record containing the
4031 final values of these parameters. If the list contains only one entry,
4032 return just that entry though.
4034 For a full description of the copy-in/copy-out parameter mechanism, see
4035 the part of the gnat_to_gnu_entity routine dealing with the translation
4036 of subprograms.
4038 We need to make a block that contains the definition of that label and
4039 the copying of the return value. It first contains the function, then
4040 the label and copy statement. */
4042 {
4043 const Node_Id gnat_end_label
4052 /* If this is a function which returns by invisible reference, the
4053 return value has already been dealt with at the return statements,
4054 so we only need to indirectly copy out the parameters. */
4056 {
4057 tree gnu_ret_deref
4059 tree t;
4064 {
4065 tree gnu_field_deref
4070 }
4071 }
4073 /* Otherwise, if this is a procedure or a function which does not return
4074 by invisible reference, we can do a direct block-copy out. */
4075 else
4076 {
4077 tree gnu_retval;
4081 else
4082 gnu_retval
4084 gnu_cico_list);
4088 }
4092 }
4096 /* On SEH targets, install an exception handler around the main entry
4097 point to catch unhandled exceptions. */
4100 {
4101 tree t;
4102 tree etype;
4114 }
4118 /* Finally annotate the parameters and disconnect the trees for parameters
4119 that we have turned into variables since they are now unusable. */
4123 {
4132 }
4134 /* Disconnect the variable created for the return value. */
4138 /* If the function returns an aggregate type and we have candidates for
4139 a Named Return Value, finalize the optimization. */
4141 {
4148 }
4150 /* If this is an inlined external function that has been marked uninlinable,
4151 drop the body and stop there. Otherwise compile the body. */
4154 else
4156 }
4158 /* The type of an atomic access. */
4162 /* Return true if GNAT_NODE references an Atomic entity. This is modeled on
4163 the Is_Atomic_Object predicate of the front-end, but additionally handles
4164 explicit dereferences. */
4166 static bool
4168 {
4169 Entity_Id gnat_entity;
4172 {
4195 }
4198 }
4200 /* Return true if GNAT_NODE references a Volatile_Full_Access entity. This is
4201 modeled on the Is_Volatile_Full_Access_Object predicate of the front-end,
4202 but additionally handles explicit dereferences. */
4204 static bool
4206 {
4207 Entity_Id gnat_entity;
4210 {
4229 }
4232 }
4234 /* Return true if GNAT_NODE references a component of a larger object. */
4238 {
4240 return
4242 }
4244 /* Compute whether GNAT_NODE requires atomic access and set TYPE to the type
4245 of access and SYNC according to the associated synchronization setting.
4247 We implement 3 different semantics of atomicity in this function:
4249 1. the Ada 95/2005/2012 semantics of the Atomic aspect/pragma,
4250 2. the Ada 2022 semantics of the Atomic aspect/pragma,
4251 3. the semantics of the Volatile_Full_Access GNAT aspect/pragma.
4253 They are mutually exclusive and the FE should have rejected conflicts. */
4255 static void
4257 {
4261 /* First, scan the parent to filter out irrelevant cases. */
4264 {
4267 /* Do not mess up machine code insertions. */
4271 /* Nothing to do if we are the prefix of an attribute, since we do not
4272 want an atomic access for things like 'Size. */
4274 /* ... fall through ... */
4277 /* The N_Reference node is like an attribute. */
4283 /* Nothing to do for the identifier in an object renaming declaration,
4284 the renaming itself does not need atomic access. */
4289 }
4291 /* Now strip any type conversion from GNAT_NODE. */
4296 /* Up to Ada 2012, for Atomic itself, only reads and updates of the object as
4297 a whole require atomic access (RM C.6(15)). But, starting with Ada 2022,
4298 reads of or writes to a nonatomic subcomponent of the object also require
4299 atomic access (RM C.6(19)). */
4301 {
4304 /* If we are the prefix of the parent, then the access is partial. */
4310 else
4313 /* We consider that partial accesses are not sequential actions and,
4314 therefore, do not require synchronization. */
4318 }
4320 /* Look for an outer atomic access of a nonatomic subcomponent. Note that,
4321 for VFA, we do this before looking at the node itself because we need to
4322 access the outermost VFA object atomically, unlike for Atomic where it is
4323 the innermost atomic object (RM C.6(19)). */
4329 {
4333 }
4335 /* Unlike Atomic, accessing a VFA object always requires atomic access. */
4337 {
4341 }
4343 not_atomic:
4346 }
4348 /* Return true if GNAT_NODE requires simple atomic access and, if so, set SYNC
4349 according to the associated synchronization setting. */
4353 {
4354 atomic_acces_t type;
4357 }
4359 /* Create a temporary variable with PREFIX and TYPE, and return it. */
4361 static tree
4363 {
4364 tree gnu_temp
4370 }
4372 /* Create a temporary variable with PREFIX and initialize it with GNU_INIT.
4373 Put the initialization statement into GNU_INIT_STMT and annotate it with
4374 the SLOC of GNAT_NODE. Return the temporary variable. */
4376 static tree
4378 Node_Id gnat_node)
4379 {
4386 }
4388 /* Return true if TYPE is an array of scalar type. */
4390 static bool
4392 {
4399 }
4401 /* Helper function for walk_tree, used by return_slot_opt_for_pure_call_p. */
4403 static tree
4405 {
4415 }
4417 /* Return whether the assignment TARGET = CALL can be subject to the return
4418 slot optimization, under the assumption that the called function be pure
4419 in the Ada sense and return an array of scalar type. */
4421 static bool
4423 {
4424 /* Check that the target is a DECL. */
4429 call_expr_arg_iterator iter;
4430 tree arg;
4432 /* Check that all the arguments have either a scalar type (we assume that
4433 this means by-copy passing mechanism) or array of scalar type. */
4435 {
4445 }
4447 /* Check that the target is not referenced by the non-scalar arguments. */
4449 }
4451 /* Elaborate types referenced in the profile (FIRST_FORMAL, RESULT_TYPE). */
4453 static void
4455 {
4456 Entity_Id formal;
4465 }
4467 /* Subroutine of gnat_to_gnu to translate GNAT_NODE, an N_Function_Call
4468 or an N_Procedure_Call_Statement, to a GCC tree, which is returned.
4469 GNU_RESULT_TYPE_P is a pointer to where we should place the result type.
4470 If GNU_TARGET is non-null, this must be a function call on the RHS of a
4471 N_Assignment_Statement and the result is to be placed into that object.
4472 ATOMIC_ACCESS is the type of atomic access to be used for the assignment
4473 to GNU_TARGET. If, in addition, ATOMIC_SYNC is true, then the assignment
4474 to GNU_TARGET requires atomic synchronization. */
4476 static tree
4479 {
4482 /* The GCC node corresponding to the GNAT subprogram name. This can either
4483 be a FUNCTION_DECL node if we are dealing with a standard subprogram call,
4484 or an indirect reference expression (an INDIRECT_REF node) pointing to a
4485 subprogram. */
4488 /* The FUNCTION_TYPE node giving the GCC type of the subprogram. */
4490 /* The return type of the FUNCTION_TYPE. */
4491 tree gnu_result_type;;
4492 const bool frontend_builtin
4505 Entity_Id gnat_formal;
4506 Entity_Id gnat_result_type;
4507 Node_Id gnat_actual;
4508 atomic_acces_t aa_type;
4511 /* The only way we can make a call via an access type is if GNAT_NAME is an
4512 explicit dereference. In that case, get the list of formal args from the
4513 type the access type is pointing to. Otherwise, get the formals from the
4514 entity being called. */
4516 {
4517 const Entity_Id gnat_prefix_type
4524 /* If the access type doesn't require foreign-compatible representation,
4525 be prepared for descriptors. */
4526 by_descriptor
4529 }
4532 {
4533 /* Assume here that this must be 'Elab_Body or 'Elab_Spec. */
4538 }
4540 else
4541 {
4549 /* If we are calling a stubbed function, then raise Program_Error, but
4550 elaborate all our args first. */
4552 {
4562 {
4566 }
4569 }
4570 }
4572 /* We must elaborate the entire profile now because, if it references types
4573 that were initially incomplete,, their elaboration changes the contents
4574 of GNU_SUBPROG_TYPE and, in particular, may change the result type. */
4581 {
4582 /* For a call to a nested function, check the inlining status. */
4586 /* For a recursive call, avoid explosion due to recursive inlining. */
4589 }
4591 /* The lifetime of the temporaries created for the call ends right after the
4592 return value is copied, so we can give them the scope of the elaboration
4593 routine at top level. */
4595 {
4598 }
4599 else
4602 /* First, create the temporary for the return value when:
4604 1. There is no target and the function has copy-in/copy-out parameters,
4605 because we need to preserve the return value before copying back the
4606 parameters.
4608 2. There is no target and the call is made for neither the declaration
4609 of an object (regular or renaming), nor a return statement, nor an
4610 allocator, nor an aggregate, and the return type has variable size
4611 because in this case the gimplifier cannot create the temporary, or
4612 more generally is an aggregate type, because the gimplifier would
4613 create the temporary in the outermost scope instead of locally here.
4614 But there is an exception for an allocator of unconstrained record
4615 type with default discriminant because we allocate the actual size
4616 in this case, unlike in the other cases, so we need a temporary to
4617 fetch the discriminant and we create it here.
4619 3. There is a target and it is a slice or an array with fixed size,
4620 and the return type has variable size, because the gimplifier
4621 doesn't handle these cases.
4623 4. There is a target which is a bit-field and the function returns an
4624 unconstrained record type with default discriminant, because the
4625 return may copy more data than the bit-field can contain.
4627 5. There is no target and we have misaligned In Out or Out parameters
4628 passed by reference, because we need to preserve the return value
4629 before copying back the parameters. However, in this case, we'll
4630 defer creating the temporary, see below.
4632 This must be done before we push a binding level around the call, since
4633 we will pop it before copying the return value. */
4636 || (!gnu_target
4646 || (gnu_target
4652 || (gnu_target
4658 {
4661 }
4663 /* If we don't need a value or have already created it, push a binding level
4664 around the call. This will narrow the lifetime of the temporaries we may
4665 need to make when translating the parameters as much as possible. */
4667 {
4671 }
4672 else
4675 /* Create the list of the actual parameters as GCC expects it, namely a
4676 chain of TREE_LIST nodes in which the TREE_VALUE field of each node
4677 is an expression and the TREE_PURPOSE field is null. But skip Out
4678 parameters not passed by reference and that need not be copied in. */
4683 {
4689 const bool is_true_formal_parm
4691 const bool is_by_ref_formal_parm
4692 = is_true_formal_parm
4695 /* In the In Out or Out case, we must suppress conversions that yield
4696 an lvalue but can nevertheless cause the creation of a temporary,
4697 because we need the real object in this case, either to pass its
4698 address if it's passed by reference or as target of the back copy
4699 done after the call if it uses the copy-in/copy-out mechanism.
4700 We do it in the In case too, except for an unchecked conversion
4701 to an elementary type or a constrained composite type because it
4702 alone can cause the actual to be misaligned and the addressability
4703 test is applied to the real object. */
4704 const bool suppress_type_conversion
4706 && (!in_param
4707 || !is_by_ref_formal_parm
4712 Node_Id gnat_name = suppress_type_conversion
4716 /* If it's possible we may need to use this expression twice, make sure
4717 that any side-effects are handled via SAVE_EXPRs; likewise if we need
4718 to force side-effects before the call. */
4720 {
4724 gnu_name
4726 }
4728 /* If we are passing a non-addressable parameter by reference, pass the
4729 address of a copy. In the In Out or Out case, set up to copy back
4730 out after the call. */
4734 {
4737 /* Do not issue warnings for CONSTRUCTORs since this is not a copy
4738 but sort of an instantiation for them. */
4740 ;
4742 /* If the formal is passed by reference, a copy is not allowed. */
4746 gnat_actual);
4748 /* If the mechanism was forced to by-ref, a copy is not allowed but
4749 we issue only a warning because this case is not strict Ada. */
4752 gnat_actual);
4754 /* If the actual type of the object is already the nominal type,
4755 we have nothing to do, except if the size is self-referential
4756 in which case we'll remove the unpadding below. */
4759 ;
4761 /* Otherwise remove the unpadding from all the objects. */
4763 && TYPE_IS_PADDING_P
4767 /* Otherwise convert to the nominal type of the object if needed.
4768 There are several cases in which we need to make the temporary
4769 using this type instead of the actual type of the object when
4770 they are distinct, because the expectations of the callee would
4771 otherwise not be met:
4772 - if it's a justified modular type,
4773 - if the actual type is a smaller form of it,
4774 - if it's a smaller form of the actual type. */
4778 gnu_name_type)))
4784 /* If this is an In Out or Out parameter and we're returning a value,
4785 we need to create a temporary for the return value because we must
4786 preserve it before copying back at the very end. */
4788 {
4791 }
4793 /* If we haven't pushed a binding level, push it now. This will
4794 narrow the lifetime of the temporary we are about to make as
4795 much as possible. */
4797 {
4801 }
4803 /* Create an explicit temporary holding the copy. */
4804 /* Do not initialize it for the _Init parameter of an initialization
4805 procedure since no data is meant to be passed in. */
4811 /* Initialize it on the fly like for an implicit temporary in the
4812 other cases, as we don't necessarily have a statement list. */
4813 else
4814 {
4816 gnat_actual);
4818 gnu_temp);
4819 }
4821 /* Set up to move the copy back to the original if needed. */
4823 {
4824 /* If the original is a COND_EXPR whose first arm isn't meant to
4825 be further used, just deal with the second arm. This is very
4826 likely the conditional expression built for a check. */
4829 && integer_zerop
4833 gnu_stmt
4838 }
4839 }
4841 /* Start from the real object and build the actual. */
4844 /* If atomic access is required for an In or In Out actual parameter,
4845 build the atomic load. */
4847 && !is_by_ref_formal_parm
4852 /* If this was a procedure call, we may not have removed any padding.
4853 So do it here for the part we will use as an input, if any. */
4856 gnu_actual
4859 /* Put back the conversion we suppressed above in the computation of the
4860 real object. And even if we didn't suppress any conversion there, we
4861 may have suppressed a conversion to the Etype of the actual earlier,
4862 since the parent is a procedure call, so put it back here. Note that
4863 we might have a dummy type here if the actual is the dereference of a
4864 pointer to it, but that's OK when the formal is passed by reference.
4865 We also do not put back a conversion between an actual and a formal
4866 that are unconstrained array types to avoid creating local bounds. */
4878 ;
4879 else
4884 /* First see if the parameter is passed by reference. */
4886 {
4888 {
4889 /* In Out or Out parameters passed by reference don't use the
4890 copy-in/copy-out mechanism so the address of the real object
4891 must be passed to the function. */
4894 /* If we have a padded type, be sure we've removed padding. */
4897 gnu_actual);
4899 /* If we have the constructed subtype of an aliased object
4900 with an unconstrained nominal subtype, the type of the
4901 actual includes the template, although it is formally
4902 constrained. So we need to convert it back to the real
4903 constructed subtype to retrieve the constrained part
4904 and takes its address. */
4910 }
4912 /* There is no need to convert the actual to the formal's type before
4913 taking its address. The only exception is for unconstrained array
4914 types because of the way we build fat pointers. */
4916 {
4917 /* Put back the conversion we suppressed above for In Out or Out
4918 parameters, since it may set the bounds of the actual. */
4922 }
4924 /* Take the address of the object and convert to the proper pointer
4925 type. */
4928 }
4930 /* Then see if the parameter is an array passed to a foreign convention
4931 subprogram. */
4933 {
4937 /* Take the address of the object and convert to the proper pointer
4938 type. We'd like to actually compute the address of the beginning
4939 of the array using an ADDR_EXPR of an ARRAY_REF, but there's a
4940 possibility that the ARRAY_REF might return a constant and we'd be
4941 getting the wrong address. Neither approach is exactly correct,
4942 but this is the most likely to work in all cases. */
4945 }
4947 /* Then see if the parameter is passed by copy. */
4949 {
4955 /* If this is a front-end built-in function, there is no need to
4956 convert to the type used to pass the argument. */
4959 }
4961 /* Then see if this is an unnamed parameter in a variadic C function. */
4963 {
4964 /* This is based on the processing done in gnat_to_gnu_param, but
4965 we expect the mechanism to be set in (almost) all cases. */
4968 /* Strip off possible padding type. */
4972 /* Arrays are passed as pointers to element type. First check for
4973 unconstrained array and get the underlying array. */
4975 gnu_formal_type
4976 = TREE_TYPE
4979 /* Arrays are passed as pointers to element type. */
4981 {
4985 /* Strip off any multi-dimensional entries, then strip
4986 off the last array to get the component type. */
4993 gnu_actual
4995 }
4997 /* Fat pointers are passed as thin pointers. */
4999 gnu_formal_type
5003 /* If we were requested or muss pass by reference, do so.
5004 If we were requested to pass by copy, do so.
5005 Otherwise, pass In Out or Out parameters or aggregates by
5006 reference. */
5011 {
5013 gnu_actual
5015 }
5017 /* Otherwise pass by copy after applying default C promotions. */
5018 else
5019 {
5029 }
5032 }
5034 /* If we didn't create a PARM_DECL for the formal, this means that
5035 it is an Out parameter not passed by reference and that need not
5036 be copied in. In this case, the value of the actual need not be
5037 read. However, we still need to make sure that its side-effects
5038 are evaluated before the call, so we evaluate its address. */
5039 else
5040 {
5045 {
5048 }
5051 }
5054 }
5057 {
5062 {
5073 }
5077 gnu_call
5079 icode,
5080 gnu_result_type,
5083 }
5084 else
5085 {
5086 gnu_call
5088 gnu_result_type,
5090 gnu_subprog),
5094 }
5098 /* If we have created a temporary for the return value, initialize it. */
5100 {
5101 tree gnu_stmt
5106 }
5108 /* If this is a subprogram with copy-in/copy-out parameters, we need to
5109 unpack the valued returned from the function into the In Out or Out
5110 parameters. We deal with the function return (if this is an Ada
5111 function) below. */
5113 {
5114 /* List of FIELD_DECLs associated with the PARM_DECLs of the copy-in/
5115 copy-out parameters. */
5119 /* The call sequence must contain one and only one call, even though the
5120 function is pure. Save the result into a temporary if needed. */
5122 {
5124 {
5125 tree gnu_stmt;
5126 gnu_call
5129 }
5132 }
5134 /* The first entry is for the actual return value if this is a
5135 function, so skip it. */
5141 else
5148 /* If we are dealing with a copy-in/copy-out parameter, we must
5149 retrieve its value from the record returned in the call. */
5155 {
5156 /* Get the value to assign to this In Out or Out parameter. It is
5157 either the result of the function if there is only a single such
5158 parameter or the appropriate field from the record returned. */
5159 tree gnu_result
5161 ? gnu_call
5165 /* If the actual is a conversion, get the inner expression, which
5166 will be the real destination, and convert the result to the
5167 type of the actual parameter. */
5168 tree gnu_actual
5171 /* If the result is padded, remove the padding. */
5174 /* If the actual is a type conversion, the real target object is
5175 denoted by the inner Expression and we need to convert the
5176 result to the associated type.
5177 We also need to convert our gnu assignment target to this type
5178 if the corresponding GNU_NAME was constructed from the GNAT
5179 conversion node and not from the inner Expression. */
5181 {
5186 gnu_result
5190 gnat_actual);
5194 }
5196 /* Unchecked conversions as actuals for Out parameters are not
5197 allowed in user code because they are not variables, but do
5198 occur in front-end expansions. The associated GNU_NAME is
5199 always obtained from the inner expression in such cases. */
5202 gnu_result,
5204 else
5205 {
5211 }
5215 /* If an outer atomic access is required for an actual parameter,
5216 build the load-modify-store sequence. */
5218 gnu_result
5221 /* Or else, if a simple atomic access is required, build the atomic
5222 store. */
5224 gnu_result
5227 /* Otherwise build a regular assignment. */
5228 else
5237 }
5238 }
5240 /* If this is a function call, the result is the call expression unless a
5241 target is specified, in which case we copy the result into the target
5242 and return the assignment statement. */
5244 {
5245 /* If this is a function with copy-in/copy-out parameters, extract the
5246 return value from it and update the return type. */
5248 {
5250 gnu_call
5253 }
5255 /* If the function returns an unconstrained array or by direct reference,
5256 we have to dereference the pointer. */
5262 {
5268 /* ??? If the return type has variable size, then force the return
5269 slot optimization as we would not be able to create a temporary.
5270 That's what has been done historically. */
5274 /* If this is a call to a pure function returning an array of scalar
5275 type, try to apply the return slot optimization. */
5284 else
5287 /* Use the required method to move the result to the target. */
5289 gnu_call
5293 else
5294 gnu_call
5300 }
5301 else
5303 }
5305 /* Otherwise, if this is a procedure call statement without copy-in/copy-out
5306 parameters, the result is just the call statement. */
5310 /* Finally, add the copy back statements, if any. */
5316 /* If we have pushed a binding level, pop it and finish up the enclosing
5317 statement group. */
5319 {
5323 }
5325 /* Otherwise, retrieve the statement list, if any. */
5329 /* Otherwise, just return the call expression. */
5330 else
5333 /* If we nevertheless need a value, make a COMPOUND_EXPR to return it.
5334 But first simplify if we have only one statement in the list. */
5336 {
5340 gnu_result
5342 }
5345 }
5347 /* Subroutine of gnat_to_gnu to translate GNAT_NODE, an
5348 N_Handled_Sequence_Of_Statements, to a GCC tree, which is returned. */
5350 static tree
5352 {
5353 /* If just annotating, ignore all EH and cleanups. */
5354 const bool gcc_eh
5359 tree gnu_result;
5360 Node_Id gnat_temp;
5362 /* The GCC exception handling mechanism can handle both ZCX and SJLJ schemes.
5363 To call the GCC mechanism, we call add_cleanup, and when we leave the
5364 binding, end_stmt_group will create the TRY_FINALLY_EXPR construct.
5366 ??? The region level calls down there have been specifically put in place
5367 for a ZCX context and currently the order in which things are emitted
5368 (region/handlers) is different from the SJLJ case. Instead of putting
5369 other calls with different conditions at other places for the SJLJ case,
5370 it seems cleaner to reorder things for the SJLJ case and generalize the
5371 condition to make it not ZCX specific.
5373 If there are any exceptions or cleanup processing involved, we need an
5374 outer statement group and binding level. */
5376 {
5379 }
5381 /* If we are to call a function when exiting this block, add a cleanup
5382 to the binding level we made above. Note that add_cleanup is FIFO
5383 so we must register this cleanup after the EH cleanup just above. */
5385 {
5388 /* When not optimizing, disable inlining of finalizers as this can
5389 create a more complex CFG in the parent function. */
5393 /* If there is no end label attached, we use the location of the At_End
5394 procedure because Expand_Cleanup_Actions might reset the location of
5395 the enclosing construct to that of an inner statement. */
5399 }
5401 /* Now build the tree for the declarations and statements inside this
5402 block. */
5409 /* Generate code for each statement in the block. */
5419 {
5420 tree gnu_handlers;
5421 location_t locus;
5423 /* First make a block containing the handlers. */
5431 /* Now make the TRY_CATCH_EXPR for the block. */
5434 /* Set a location. We need to find a unique location for the dispatching
5435 code, otherwise we can get coverage or debugging issues. Try with
5436 the location of the end label. */
5440 else
5441 /* Clear column information so that the exception handler of an
5442 implicit transient block does not incorrectly inherit the slocs
5443 of a decision, which would otherwise confuse control flow based
5444 coverage analysis tools. */
5446 }
5447 else
5450 /* Now close our outer block, if we had to make one. */
5452 {
5456 }
5459 }
5461 /* Return true if no statement in GNAT_LIST can alter the control flow. */
5463 static bool
5465 {
5469 /* This is very conservative, we reject everything except for simple
5470 assignments between identifiers or literals. */
5474 {
5486 }
5489 }
5491 /* Subroutine of gnat_to_gnu to translate GNAT_NODE, an N_Exception_Handler,
5492 to a GCC tree, which is returned. */
5494 static tree
5496 {
5499 /* We build a TREE_LIST of nodes representing what exception types this
5500 handler can catch, with special cases for others and all others cases.
5502 Each exception type is actually identified by a pointer to the exception
5503 id, or to a dummy object for "others" and "all others". */
5505 gnat_temp;
5507 {
5511 {
5514 }
5517 {
5520 /* Exception may be a renaming. Recover original exception which is
5521 the one elaborated and registered. */
5527 }
5528 else
5531 /* The GCC interface expects NULL to be passed for catch all handlers, so
5532 it would be quite tempting to set gnu_etypes_list to NULL if gnu_etype
5533 is integer_zero_node. It would not work, however, because GCC's
5534 notion of "catch all" is stronger than our notion of "others". Until
5535 we correctly use the cleanup interface as well, doing that would
5536 prevent the "all others" handlers from being seen, because nothing
5537 can be caught beyond a catch all from GCC's point of view. */
5539 }
5544 /* Expand a call to the begin_handler hook at the beginning of the
5545 handler, and arrange for a call to the end_handler hook to occur
5546 on every possible exit path. GDB sets a breakpoint in the
5547 begin_handler for catchpoints.
5549 A v1 begin handler saves the cleanup from the exception object,
5550 and marks the exception as in use, so that it will not be
5551 released by other handlers. A v1 end handler restores the
5552 cleanup and releases the exception object, unless it is still
5553 claimed, or the exception is being propagated (reraised).
5555 __builtin_eh_pointer references the exception occurrence being
5556 handled or propagated. Within the handler region, it is the
5557 former, but within the else branch of the EH_ELSE_EXPR, i.e. the
5558 exceptional cleanup path, it is the latter, so we must save the
5559 occurrence being handled early on, so that, should an exception
5560 be (re)raised, we can release the current exception, or figure
5561 out we're not to release it because we're propagating a reraise
5562 thereof.
5564 We use local variables to retrieve the incoming value at handler
5565 entry time (EXPTR), the saved cleanup (EXCLN) and the token
5566 (EXVTK), and reuse them to feed the end_handler hook's argument
5567 at exit. */
5569 /* CODE: void *EXPTR = __builtin_eh_pointer (0); */
5570 tree gnu_current_exc_ptr
5573 tree exc_ptr
5582 /* begin_handler_decl must not throw, so we can use it as an
5583 initializer for a variable used in cleanups.
5585 CODE: void *EXCLN = __gnat_begin_handler_v1 (EXPTR); */
5586 tree exc_cleanup
5588 ptr_type_node,
5590 exc_ptr),
5594 /* Declare and initialize the choice parameter, if present. */
5596 {
5597 tree gnu_param
5600 /* CODE: __gnat_set_exception_parameter (&choice_param, EXPTR); */
5604 gnu_incoming_exc_ptr));
5605 }
5607 /* CODE: <handler proper> */
5611 exc_ptr,
5612 exc_cleanup,
5613 null_pointer_node);
5614 /* If the handler can only end by falling off the end, don't bother
5615 with cleanups. */
5617 /* CODE: __gnat_end_handler_v1 (EXPTR, EXCLN, NULL); */
5619 /* Otherwise, all of the above is after
5620 CODE: try {
5622 The call above will appear after
5623 CODE: } finally {
5625 And the code below will appear after
5626 CODE: } else {
5628 The else block to a finally block is taken instead of the finally
5629 block when an exception propagates out of the try block. */
5630 else
5631 {
5634 /* CODE: void *EXPRP = __builtin_eh_handler (0); */
5635 tree prop_ptr
5637 ptr_type_node,
5644 /* CODE: __gnat_end_handler_v1 (EXPTR, EXCLN, EXPRP); */
5646 exc_ptr,
5647 exc_cleanup,
5648 prop_ptr);
5652 /* CODE: } */
5657 }
5663 return
5665 }
5667 /* Subroutine of gnat_to_gnu to translate GNAT_NODE, an N_Compilation_Unit. */
5669 static void
5671 {
5676 Entity_Id gnat_entity;
5678 /* Make the decl for the elaboration procedure. Emit debug info for it, so
5679 that users can break into their elaboration code in debuggers. Kludge:
5680 don't consider it as a definition so that we have a line map for its
5681 body, but no subprogram description in debug info. In addition, don't
5682 qualify it as artificial, even though it is not a user subprogram per se,
5683 in particular for specs. Unlike, say, clones created internally by the
5684 compiler, this subprogram materializes specific user code and flagging it
5685 artificial would take elab code away from gcov's analysis. */
5686 tree gnu_elab_proc_decl
5687 = create_subprog_decl
5696 /* Initialize the information structure for the function. */
5705 /* For a body, first process the spec if there is one. */
5711 {
5718 }
5720 /* Then process any pragmas and declarations preceding the unit. */
5729 /* Process the unit itself. */
5732 /* Generate code for all the inlined subprograms. */
5736 {
5737 Node_Id gnat_body;
5739 /* Without optimization, process only the required subprograms. */
5743 /* The set of inlined subprograms is computed from data recorded early
5744 during expansion and it can be a strict superset of the final set
5745 computed after semantic analysis, for example if a call to such a
5746 subprogram occurs in a pragma Assert and assertions are disabled.
5747 In that case, semantic analysis resets Is_Public to false but the
5748 entry for the subprogram in the inlining tables is stalled. */
5754 {
5755 /* ??? This happens when only the spec of a package is provided. */
5759 gnat_body
5761 }
5763 /* Define the entity first so we set DECL_EXTERNAL. */
5766 }
5768 /* Process any pragmas and actions following the unit. */
5773 /* Then process the expressions of pragma Compile_Time_{Error|Warning} to
5774 annotate types referenced therein if they have not been annotated. */
5779 /* Save away what we've made so far and finish it up. */
5786 /* Record this potential elaboration procedure for later processing. */
5793 /* Force the processing for all nodes that remain in the queue. */
5795 }
5797 /* Mark COND, a boolean expression, as predicating a call to a noreturn
5798 function, i.e. predict that it is very likely false, and return it.
5800 The compiler will automatically predict the last edge leading to a call
5801 to a noreturn function as very unlikely taken. This function makes it
5802 possible to extend the prediction to predecessors in case the condition
5803 is made up of several short-circuit operators. */
5805 static tree
5807 {
5809 return
5813 }
5815 /* Subroutine of gnat_to_gnu to translate GNAT_RANGE, a node representing a
5816 range of values, into GNU_LOW and GNU_HIGH bounds. */
5818 static void
5820 {
5821 /* GNAT_RANGE is either an N_Range or an identifier denoting a subtype. */
5823 {
5831 {
5835 *gnu_low
5837 *gnu_high
5839 }
5844 }
5845 }
5847 /* Subroutine of gnat_to_gnu to translate GNAT_NODE, an N_Raise_xxx_Error,
5848 to a GCC tree, which is returned. GNU_RESULT_TYPE_P is a pointer to
5849 where we should place the result type. */
5851 static tree
5853 {
5857 const bool with_extra_info
5858 = Exception_Extra_Info
5862 Node_Id gnat_rcond;
5864 /* The following processing is not required for correctness. Its purpose is
5865 to give more precise error messages and to record some information. */
5867 {
5882 {
5892 {
5910 }
5914 {
5918 }
5923 gnu_result
5927 /* If optimization is enabled and we are inside a loop, we try to
5928 compute invariant conditions for checks applied to the iteration
5929 variable, i.e. conditions that are independent of the variable
5930 and necessary in order for the checks to fail in the course of
5931 some iteration. If we succeed, we consider an alternative:
5933 1. If loop unswitching is enabled, we prepend these conditions
5934 to the original conditions of the checks. This will make it
5935 possible for the loop unswitching pass to replace the loop
5936 with two loops, one of which has the checks eliminated and
5937 the other has the original checks reinstated, and a prologue
5938 implementing a run-time selection. The former loop will be
5939 for example suitable for vectorization.
5941 2. Otherwise, we instead append the conditions to the original
5942 conditions of the checks. At worse, if the conditions cannot
5943 be evaluated at compile time, they will be evaluated as true
5944 at run time only when the checks have already failed, thus
5945 contributing negatively only to the size of the executable.
5946 But the hope is that these invariant conditions be evaluated
5947 at compile time to false, thus taking away the entire checks
5948 with them. */
5951 && (!gnu_low_bound
5953 && (!gnu_high_bound
5956 {
5963 rci->inserted_cond
5969 boolean_type_node,
5971 gnu_cond);
5972 else
5974 boolean_type_node,
5975 gnu_cond,
5977 }
5978 }
5983 }
5985 /* The following processing does the real work, but we must nevertheless make
5986 sure not to override the result of the previous processing. */
5993 /* If the type is VOID, this is a statement, so we need to generate the code
5994 for the call. Handle a condition, if there is one. */
5996 {
5998 {
6005 }
6006 }
6007 else
6008 {
6009 /* The condition field must not be present when the node is used as an
6010 expression form. */
6013 }
6016 }
6018 /* Return true if GNAT_NODE is on the LHS of an assignment or an actual
6019 parameter of a call. */
6021 static bool
6023 {
6038 }
6040 /* Return true if either GNAT_NODE or a view of GNAT_NODE is on the LHS
6041 of an assignment or an actual parameter of a call. */
6043 static bool
6045 {
6056 }
6058 /* Return true if GNAT_NODE, an unchecked type conversion, is a no-op as far
6059 as gigi is concerned. This is used to avoid conversions on the LHS. */
6061 static bool
6063 {
6066 /* The conversion must be on the LHS of an assignment or an actual parameter
6067 of a call. Otherwise, even if the conversion was essentially a no-op, it
6068 could de facto ensure type consistency and this should be preserved. */
6074 /* We're interested in artificial conversions generated by the front-end
6075 to make private types explicit, e.g. in Expand_Assign_Array. */
6082 /* The direct conversion to the underlying type is a no-op. */
6086 /* For an array subtype, the conversion to the PAIT is a no-op. */
6091 /* For a record subtype, the conversion to the type is a no-op. */
6097 }
6099 /* Return true if GNAT_NODE represents a statement. */
6101 static bool
6103 {
6119 }
6121 /* This function is the driver of the GNAT to GCC tree transformation process.
6122 It is the entry point of the tree transformer. GNAT_NODE is the root of
6123 some GNAT tree. Return the root of the corresponding GCC tree. If this
6124 is an expression, return the GCC equivalent of the expression. If this
6125 is a statement, return the statement or add it to the current statement
6126 group, in which case anything returned is to be interpreted as occurring
6127 after anything added. */
6129 tree
6131 {
6136 Node_Id gnat_temp;
6137 atomic_acces_t aa_type;
6141 /* Save node number for error message and set location information. */
6145 /* If we are only annotating types and this node is a statement, return
6146 an empty statement list. */
6150 /* If we are only annotating types and this node is a subexpression, return
6151 a NULL_EXPR, but filter out nodes appearing in the expressions attached
6152 to packed array implementation types. */
6168 N_Raise_Constraint_Error));
6170 /* If this is a statement and we are at top level, it must be part of the
6171 elaboration procedure, so mark us as being in that procedure. */
6176 {
6179 }
6180 else
6184 {
6185 /********************************/
6186 /* Chapter 2: Lexical Elements */
6187 /********************************/
6196 /* If atomic access is required on the RHS, build the atomic load. */
6203 {
6204 tree gnu_type;
6206 /* Get the type of the result, looking inside any padding and
6207 justified modular types. Then get the value in that type. */
6216 /* If the result overflows (meaning it doesn't fit in its base type),
6217 abort, unless this is for a named number because that's not fatal.
6218 We would like to check that the value is within the range of the
6219 subtype, but that causes problems with subtypes whose usage will
6220 raise Constraint_Error and also with biased representation. */
6222 {
6225 else
6227 }
6228 }
6232 /* If a Entity is present, it means that this was one of the
6233 literals in a user-defined character type. In that case,
6234 just return the value in the CONST_DECL. Otherwise, use the
6235 character code. In that case, the base type should be an
6236 INTEGER_TYPE, but we won't bother checking for that. */
6240 else
6241 gnu_result
6249 /* If this is of a fixed-point type, the value we want is the value of
6250 the corresponding integer. */
6252 {
6254 gnu_result_type);
6256 }
6258 else
6259 {
6262 /* First convert the value to a machine number if it isn't already.
6263 That will force the base to 2 for non-zero values and simplify
6264 the rest of the logic. */
6266 ur_realval
6272 else
6273 {
6274 REAL_VALUE_TYPE tmp;
6278 /* The base must be 2 as Machine guarantees this, so we scale
6279 the value, which we know can fit in the mantissa of the type
6280 (hence the use of that type above). */
6285 }
6287 /* Now see if we need to negate the result. Do it this way to
6288 properly handle -0. */
6290 gnu_result
6292 gnu_result);
6293 }
6300 {
6307 else
6310 /* Build the string with the characters in the literal. Note
6311 that Ada strings are 1-origin. */
6317 /* Strings in GCC don't normally have types, but we want
6318 this to not be converted to the array type. */
6323 }
6324 else
6325 {
6326 /* Build a list consisting of each character, then make
6327 the aggregate. */
6337 {
6343 }
6346 }
6353 /**************************************/
6354 /* Chapter 3: Declarations and Types */
6355 /**************************************/
6373 /* If we are just annotating types and this object has an unconstrained
6374 or task type, don't elaborate it. */
6384 && (!type_annotate_only
6386 {
6391 /* First deal with erroneous expressions. */
6393 {
6394 /* If this is a named number for which we cannot manipulate
6395 the value, just skip the declaration altogether. */
6400 }
6402 /* Then a special case: we do not want the SLOC of the expression
6403 of the tag to pop up every time it is referenced somewhere. */
6406 }
6407 else
6410 /* If this is a deferred constant with an address clause, we ignore the
6411 full view since the clause is on the partial view and we cannot have
6412 2 different GCC trees for the object. The only bits of the full view
6413 we will use is the initializer, but it will be directly fetched. */
6419 /* If this object has its elaboration delayed, we must force evaluation
6420 of GNU_EXPR now and save it for the freeze point. Note that we need
6421 not do anything special at the global level since the lifetime of the
6422 temporary is fully contained within the elaboration routine. */
6424 {
6426 {
6429 }
6430 }
6431 else
6439 /* Don't do anything if this renaming is handled by the front end and it
6440 does not need debug info. Note that we consider renamings don't need
6441 debug info when optimizing: our way to describe them has a
6442 memory/elaboration footprint.
6444 Don't do anything neither if we are just annotating types and this
6445 object has a composite or task type, don't elaborate it. */
6448 && !optimize
6449 && can_materialize_object_renaming_p
6451 && ! (type_annotate_only
6471 {
6477 /* Materializing renamed subprograms will only benefit the debugging
6478 information as they aren't referenced in the generated code. So
6479 skip them when they aren't needed. Avoid doing this if:
6481 - there is a freeze node: in this case the renamed entity is not
6482 elaborated yet,
6483 - the renamed subprogram is intrinsic: it will not be available in
6484 the debugging information (note that both or only one of the
6485 renaming and the renamed subprograms can be intrinsic). */
6496 }
6504 /* These are fully handled in the front end. */
6505 /* ??? For package renamings, find a way to use GENERIC namespaces so
6506 that we get proper debug information for them. */
6510 /*************************************/
6511 /* Chapter 4: Names and Expressions */
6512 /*************************************/
6515 /* Make sure the designated type is complete before dereferencing. */
6520 /* If atomic access is required on the RHS, build the atomic load. */
6527 {
6529 tree gnu_type;
6536 /* Convert vector inputs to their representative array type, to fit
6537 what the code below expects. */
6539 {
6543 }
6545 /* The failure of this assertion will very likely come from a missing
6546 expansion for a packed array access. */
6549 /* First compute the number of dimensions of the array, then
6550 fill the expression array, the order depending on whether
6551 this is a Convention_Fortran array or not. */
6556 ;
6565 else
6571 /* Start with the prefix and build the successive references. */
6577 {
6582 gnu_result
6584 }
6588 /* If atomic access is required on the RHS, build the atomic load. */
6592 }
6596 {
6607 /* If this is a slice with non-constant size of an array with constant
6608 size, set the maximum size for the allocation of temporaries. */
6616 }
6620 {
6627 /* gnat_to_gnu_entity does not save the GNU tree made for renamed
6628 discriminants so avoid making recursive calls on each reference
6629 to them by following the appropriate link directly here. */
6631 {
6632 /* For discriminant references in tagged types always substitute
6633 the corresponding discriminant as the actual component. */
6638 /* For discriminant references in untagged types always substitute
6639 the corresponding stored discriminant. */
6642 }
6644 /* Handle extracting the real or imaginary part of a complex.
6645 The real part is the first field and the imaginary the last. */
6650 else
6651 {
6653 tree gnu_offset;
6656 gnu_result
6660 && lvalue_required_for_attribute_p
6663 /* If optimization is enabled and we are inside a loop, we try to
6664 hoist nonconstant but invariant offset computations outside of
6665 the loop, since they very likely contain loads that could turn
6666 out to be hard to move if they end up in active EH regions. */
6674 {
6675 tree invariant
6679 tree factor
6681 /* Divide the offset by its alignment. */
6684 }
6685 }
6689 /* If atomic access is required on the RHS, build the atomic load. */
6693 }
6697 {
6698 /* The attribute designator. */
6701 /* The Elab_Spec and Elab_Body attributes are special in that Prefix
6702 is a unit, not an object with a GCC equivalent. */
6704 return
6710 gnat_node);
6713 }
6717 /* Like 'Access as far as we are concerned. */
6725 {
6726 tree gnu_aggr_type;
6728 /* Check that this aggregate has not slipped through the cracks. */
6735 gnu_aggr_type
6739 else
6747 gnu_result
6750 gnu_aggr_type);
6753 gnu_aggr_type);
6755 gnu_result
6756 = build_binary_op
6761 (Next
6763 else
6767 }
6775 else
6785 /* If this is a qualified expression for a tagged type, we mark the type
6786 as used. Because of polymorphism, this might be the only reference to
6787 the tagged type in the program while objects have it as dynamic type.
6788 The debugger needs to see it to display these objects properly. */
6794 gnu_result
6797 kind == N_Type_Conversion
6805 /* Skip further processing if the conversion is deemed a no-op. */
6807 {
6811 }
6813 /* If the result is a pointer type, see if we are improperly
6814 converting to a stricter alignment. */
6817 {
6823 post_error_ne_tree_2
6827 }
6829 /* If we are converting a descriptor to a function pointer, first
6830 build the pointer. */
6842 {
6851 {
6855 }
6857 /* If LOW and HIGH are identical, perform an equality test. Otherwise,
6858 ensure that GNU_OBJ is evaluated only once and perform a full range
6859 test. */
6861 gnu_result
6863 else
6864 {
6873 gnu_result
6875 }
6878 gnu_result
6880 }
6888 ? RDIV_EXPR
6915 {
6921 /* Fix operations set up for boolean types in GNU_CODES above. */
6924 {
6936 }
6942 /* If this is a shift, take the count as unsigned since that is what
6943 most machines do and will generate simpler adjustments below. */
6945 {
6946 tree gnu_count_type
6949 gnu_max_shift
6951 }
6953 /* Pending generic support for efficient vector logical operations in
6954 GCC, convert vectors to their representative array type view and
6955 fallthrough. */
6959 /* If this is a comparison operator, convert any references to an
6960 unconstrained array value into a reference to the actual array. */
6962 {
6968 {
6971 }
6972 }
6974 /* If this is a shift whose count is not guaranteed to be correct,
6975 we need to adjust the shift count. */
6982 gnu_rhs
6986 gnu_max_shift,
6987 build_int_cst
6989 gnu_rhs);
6991 /* For right shifts, the type says what kind of shift to do,
6992 so we may need to choose a different type. In this case,
6993 we have to ignore integer overflow lest it propagates all
6994 the way down and causes a CE to be explicitly raised. */
6996 {
6999 }
7002 {
7005 }
7008 {
7016 }
7018 /* For signed integer addition, subtraction and multiplication, do an
7019 overflow check if required. */
7024 gnu_result
7026 gnat_node);
7027 else
7028 {
7029 /* Some operations, e.g. comparisons of arrays, generate complex
7030 trees that need to be annotated while they are being built. */
7033 }
7035 /* If this is a logical shift with the shift count not verified,
7036 we must return zero if it is too large. We cannot compensate
7037 beforehand in this case. */
7040 gnu_result
7045 gnu_result);
7046 }
7050 {
7053 tree gnu_false
7057 gnu_result
7059 }
7068 /* This case can apply to a boolean or a modular type.
7069 Fall through for a boolean operand since GNU_CODES is set
7070 up to handle this. */
7072 {
7076 gnu_expr);
7078 }
7080 /* ... fall through ... */
7087 /* For signed integer negation and absolute value, do an overflow check
7088 if required. */
7092 gnu_result
7094 gnat_node);
7095 else
7096 gnu_result
7101 {
7107 /* The expression can be either an N_Identifier or an Expanded_Name,
7108 which must represent a type, or a N_Qualified_Expression, which
7109 contains both the type and an initial value for the object. */
7112 {
7116 }
7119 {
7120 const Entity_Id gnat_desig_type
7133 else
7134 {
7138 }
7140 /* See the N_Qualified_Expression case for the rationale. */
7145 }
7146 else
7153 ignore_init_type);
7154 }
7157 /**************************/
7158 /* Chapter 5: Statements */
7159 /**************************/
7167 /* When not optimizing, turn null statements from source into gotos to
7168 the next statement that the middle-end knows how to preserve. */
7170 {
7181 }
7182 else
7187 /* Get the LHS and RHS of the statement and convert any reference to an
7188 unconstrained array into a reference to the underlying array. */
7191 /* If the type has a size that overflows, convert this into raise of
7192 Storage_Error: execution shouldn't have gotten here anyway. */
7196 N_Raise_Storage_Error);
7198 {
7200 gnu_result
7203 }
7204 else
7205 {
7207 const Node_Id gnat_inner
7211 const Entity_Id gnat_type
7213 const bool use_memset_p
7218 /* If we use memset, we need to find the innermost expression. */
7220 {
7223 gnat_temp
7228 }
7229 else
7236 /* If an outer atomic access is required on the LHS, build the load-
7237 modify-store sequence. */
7241 /* Or else, if a simple atomic access is required, build the atomic
7242 store. */
7246 /* Or else, use memset when the conditions are met. This has already
7247 been validated by Aggr_Assignment_OK_For_Backend in the front-end
7248 and the RHS is thus guaranteed to be of the appropriate form. */
7250 {
7251 tree value
7253 ? integer_zero_node
7257 /* Be extra careful not to write too much data. */
7258 tree size;
7263 else
7267 {
7268 tree mask
7272 }
7274 }
7276 /* Otherwise build a regular assignment. */
7277 else
7278 gnu_result
7281 /* If the assignment type is a regular array and the two sides are
7282 not completely disjoint, play safe and use memmove. But don't do
7283 it for a bit-packed array as it might not be byte-aligned. */
7288 {
7292 tree size
7298 }
7299 }
7303 {
7306 /* Make the outer COND_EXPR. Avoid non-determinism. */
7315 /* Now make a COND_EXPR for each of the "else if" parts. Put each
7316 into the previous "else" part and point to where to put any
7317 outer "else". Also avoid non-determinism. */
7321 {
7331 }
7334 }
7346 /* The only way to enter the block is to fall through to it. */
7348 {
7355 }
7356 else
7361 gnu_result
7371 {
7374 /* If the subprogram is a function, we must return the expression. */
7376 {
7379 /* If this function has copy-in/copy-out parameters parameters and
7380 doesn't return by invisible reference, get the real object for
7381 the return. See Subprogram_Body_to_gnu. */
7385 else
7388 /* Get the GCC tree for the expression to be returned. */
7391 /* Do not remove the padding from GNU_RET_VAL if the inner type is
7392 self-referential since we want to allocate the fixed size. */
7394 && type_is_padding_self_referential
7398 /* If the function returns by direct reference, return a pointer
7399 to the return value. */
7404 /* Otherwise, if it returns an unconstrained array, we have to
7405 allocate a new version of the result and return it. */
7407 {
7410 /* And find out whether this is a candidate for Named Return
7411 Value. If so, record it. */
7413 && !optimize_debug
7415 {
7418 /* Strip useless conversions around the return value. */
7422 /* Strip unpadding around the return value. */
7424 && TYPE_IS_PADDING_P
7428 /* Now apply the test to the return value. */
7430 {
7436 }
7437 }
7440 gnu_ret_val,
7445 }
7447 /* Otherwise, if it returns by invisible reference, dereference
7448 the pointer it is passed using the type of the return value
7449 and build the copy operation manually. This ensures that we
7450 don't copy too much data, for example if the return type is
7451 unconstrained with a maximum size. */
7453 {
7454 tree gnu_ret_deref
7456 gnu_ret_obj);
7459 /* Avoid a useless copy with __builtin_return_slot. */
7461 gnu_result
7465 gnu_ret_obj),
7469 }
7470 }
7472 else
7475 /* If we have a return label defined, convert this into a branch to
7476 that label. The return proper will be handled elsewhere. */
7478 {
7482 gnu_ret_val),
7483 gnat_node);
7488 /* When not optimizing, make sure the return is preserved. */
7491 }
7493 /* Otherwise, build a regular return. */
7494 else
7496 }
7505 /***************************/
7506 /* Chapter 6: Subprograms */
7507 /***************************/
7510 /* Unless there is a freeze node, declare the entity. We consider
7511 this a definition even though we're not generating code for the
7512 subprogram because we will be making the corresponding GCC node.
7513 When there is a freeze node, it is considered the definition of
7514 the subprogram and we do nothing until after it is encountered.
7515 That's an efficiency issue: the types involved in the profile
7516 are far more likely to be frozen between the declaration and
7517 the freeze node than before the declaration, so we save some
7518 updates of the GCC node by waiting until the freeze node.
7519 The counterpart is that we assume that there is no reference
7520 to the subprogram between the declaration and the freeze node
7521 in the expanded code; otherwise, it will be interpreted as an
7522 external reference and very likely give rise to a link failure. */
7530 /* This subprogram doesn't exist for code generation purposes, but we
7531 have to elaborate the types of any parameters and result, unless
7532 they are imported types (nothing to generate in this case).
7534 The parameter list may contain types with freeze nodes, e.g. not null
7535 subtypes, so the subprogram itself may carry a freeze node, in which
7536 case its elaboration must be deferred. */
7538 /* Process the parameter types first. */
7541 = First_Formal_With_Extras
7549 /* Then the result type, set to Standard_Void_Type for procedures. */
7550 {
7551 Entity_Id gnat_temp_type
7556 }
7562 /* For a child unit identifier go up a level to get the specification.
7563 We get this when we try to find the spec of a child unit package
7564 that is the compilation unit being compiled. */
7579 /************************/
7580 /* Chapter 7: Packages */
7581 /************************/
7597 /* If this is the body of a generic package - do nothing. */
7599 {
7602 }
7613 /********************************/
7614 /* Chapter 8: Visibility Rules */
7615 /********************************/
7619 /* Nothing to do here - but these may appear in list of declarations. */
7623 /*********************/
7624 /* Chapter 9: Tasks */
7625 /*********************/
7636 /*********************************************************/
7637 /* Chapter 10: Program Structure and Compilation Issues */
7638 /*********************************************************/
7641 /* This is not called for the main unit on which gigi is invoked. */
7653 /* These nodes should only be present when annotating types. */
7663 /* Simply process whatever unit is being inserted. */
7666 else
7667 {
7670 }
7673 /***************************/
7674 /* Chapter 11: Exceptions */
7675 /***************************/
7686 /* Only for reraise in back-end exceptions mode. */
7692 gnu_incoming_exc_ptr),
7693 gnat_node);
7734 /******************************/
7735 /* Chapter 12: Generic Units */
7736 /******************************/
7746 /* These nodes can appear on a declaration list but there is nothing to
7747 to be done with them. */
7751 /**************************************************/
7752 /* Chapter 13: Representation Clauses and */
7753 /* Implementation-Dependent Features */
7754 /**************************************************/
7759 /* The only one we need to deal with is 'Address since, for the others,
7760 the front-end puts the information elsewhere. */
7764 /* And we only deal with 'Address if the object has a Freeze node. */
7767 {
7770 /* Get the value to use as the address and save it as the equivalent
7771 for the object; when it is frozen, gnat_to_gnu_entity will do the
7772 right thing. For a subprogram, put the naked address but build a
7773 meaningfull expression for an object in case its address is taken
7774 before the Freeze node is encountered; this can happen if the type
7775 of the object is limited and it is initialized with the result of
7776 a function call. */
7779 else
7780 {
7782 /* Drop atomic and volatile qualifiers for the expression. */
7784 gnu_type
7787 gnu_temp
7789 }
7792 }
7798 /* We do nothing with these. SEM puts the information elsewhere. */
7804 {
7814 /* First retrieve the 3 operand lists built by the front-end. */
7817 {
7824 }
7828 {
7835 }
7839 gnu_clobbers
7842 gnu_clobbers);
7844 /* Then perform some standard checking and processing on the
7845 operands. In particular, mark them addressable if needed. */
7853 {
7855 constraint
7861 {
7862 /* If the operand is going to end up in memory,
7863 mark it addressable. Note that we don't test
7864 allows_mem like in the input case below; this
7865 is modeled on the C front-end. */
7867 {
7874 }
7875 }
7876 else
7880 }
7883 {
7885 constraint
7891 {
7892 /* If the operand is going to end up in memory,
7893 mark it addressable. */
7895 {
7902 }
7903 }
7904 else
7908 }
7914 }
7915 else
7920 /****************/
7921 /* Added Nodes */
7922 /****************/
7924 /* Markers are created by the ABE mechanism to capture information which
7925 is either unavailable of expensive to recompute. Markers do not have
7926 and runtime semantics, and should be ignored. */
7934 /* This construct doesn't define a scope so we don't push a binding
7935 level around the statement list, but we wrap it in a SAVE_EXPR to
7936 protect it from unsharing. Elaborate the expression as part of the
7937 same statement group as the actions so that the type declaration
7938 gets inserted there as well. This ensures that the type elaboration
7939 code is issued past the actions computing values on which it might
7940 depend. */
7949 gnu_result
7975 {
7978 const Entity_Id gnat_desig_type
7981 /* Make sure the designated type is complete before dereferencing,
7982 in case it is a Taft Amendment type. */
7988 /* If this is a thin pointer, we must first dereference it to create
7989 a fat pointer, then go back below to a thin pointer. The reason
7990 for this is that we need to have a fat pointer someplace in order
7991 to properly compute the size. */
7995 gnu_ptr));
7997 /* If this is a fat pointer, the object must have been allocated with
7998 the template in front of the array. So pass the template address,
7999 and get the total size; do it by converting to a thin pointer. */
8001 gnu_ptr
8003 (TYPE_OBJECT_RECORD_TYPE
8005 gnu_ptr);
8009 /* If this is a thin pointer, the object must have been allocated with
8010 the template in front of the array. So pass the template address,
8011 and get the total size. */
8013 gnu_ptr
8015 gnu_ptr,
8017 byte_position
8018 (DECL_CHAIN
8021 /* If we have a special dynamic constrained subtype on the node, use
8022 it to compute the size; otherwise, use the designated subtype. */
8024 {
8025 gnu_actual_obj_type
8029 gnu_actual_obj_type
8031 gnu_actual_obj_type,
8034 }
8035 else
8041 gnu_result
8045 gnat_node);
8046 }
8054 else
8059 /* The only validation we currently do on an unchecked conversion is
8060 that of aliasing assumptions. */
8070 /* These nodes should only be present when annotating types. */
8076 /* Other nodes are not supposed to reach here. */
8078 }
8080 /* If we are in the elaboration procedure, check if we are violating the
8081 No_Elaboration_Code restriction by having a non-empty statement. */
8088 /* If we pushed the processing of the elaboration routine, pop it back. */
8092 /* When not optimizing, turn boolean rvalues B into B != false tests
8093 so that we can put the location information of the reference to B on
8094 the inequality operator for better debug info. */
8108 {
8109 gnu_result
8115 }
8117 /* Set the location information on the result if it's not a simple name
8118 or something that contains a simple name, for example a tag, because
8119 we don"t want all the references to get the location of the first use.
8120 Note that we may have no result if we tried to build a CALL_EXPR node
8121 to a procedure with no side-effects and optimization is enabled. */
8125 && gnu_result
8129 /* If we're supposed to return something of void_type, it means we have
8130 something we're elaborating for effect, so just return. */
8134 /* If the result is a constant that overflowed, raise Constraint_Error. */
8136 {
8138 gnu_result
8141 N_Raise_Constraint_Error));
8142 }
8144 /* If the result has side-effects and is of an unconstrained type, protect
8145 the expression in case it will be referenced multiple times, i.e. for
8146 its value and to compute the size of an object. But do it neither for
8147 an object nor a renaming declaration, nor a return statement of a call
8148 to a function that returns an unconstrained record type with default
8149 discriminant, because there is no size to be computed in these cases
8150 and this will create a useless temporary. We must do this before any
8151 conversions. */
8162 /* Now convert the result to the result type, unless we are in one of the
8163 following cases:
8165 1. If this is the LHS of an assignment or an actual parameter of a
8166 call, return the result almost unmodified since the RHS will have
8167 to be converted to our type in that case, unless the result type
8168 has a simpler size or for array types because this size might be
8169 changed in-between. Likewise if there is just a no-op unchecked
8170 conversion in-between. Similarly, don't convert integral types
8171 that are the operands of an unchecked conversion since we need
8172 to ignore those conversions (for 'Valid).
8174 2. If we have a label (which doesn't have any well-defined type), a
8175 field or an error, return the result almost unmodified. Similarly,
8176 if the two types are record types with the same name, don't convert.
8177 This will be the case when we are converting from a packable version
8178 of a type to its original type and we need those conversions to be
8179 NOPs in order for assignments into these types to work properly.
8181 3. If the type is void or if we have no result, return error_mark_node
8182 to show we have no result.
8184 4. If this is a call to a function that returns with variable size and
8185 the call is used as the expression in either an object or a renaming
8186 declaration, return the result unmodified because we want to use the
8187 return slot optimization in this case.
8189 5. If this is a reference to an unconstrained array which is used as the
8190 prefix of an attribute reference that requires an lvalue, return the
8191 result unmodified because we want to return the original bounds.
8193 6. Finally, if the type of the result is already correct. */
8211 && (CONTAINS_PLACEHOLDER_P
8217 {
8218 /* Remove padding only if the inner object is of self-referential
8219 size: in that case it must be an object of unconstrained type
8220 with a default discriminant and we want to avoid copying too
8221 much data. But do not remove it if it is already too small. */
8228 gnu_result);
8229 }
8238 {
8239 /* Remove any padding. */
8241 }
8251 ;
8257 ;
8262 /* We don't need any NOP_EXPR or NON_LVALUE_EXPR on the result. */
8269 }
8271 /* Similar to gnat_to_gnu, but discard any object that might be created in
8272 the course of the translation of GNAT_NODE, which must be an "external"
8273 expression in the sense that it will be elaborated elsewhere. */
8275 tree
8277 {
8281 /* Force the local context and create a fake scope that we zap
8282 at the end so declarations will not be stuck either in the
8283 global varpool or in the current scope. */
8285 {
8288 }
8289 else
8301 /* Do not import locations from external units. */
8306 }
8308 /* Return true if the statement list STMT_LIST is empty. */
8310 static bool
8312 {
8313 tree_stmt_iterator tsi;
8316 {
8319 /* Anything else than an empty STMT_STMT counts as something. */
8322 }
8325 }
8327 /* Record the current code position in GNAT_NODE. */
8329 static void
8331 {
8336 }
8338 /* Insert the code for GNAT_NODE at the position saved for that node. */
8340 static void
8342 {
8345 /* It's too late to remove the STMT_STMT itself at this point. */
8350 }
8352 /* Start a new statement group chained to the previous group. */
8354 void
8356 {
8359 /* First see if we can get one from the free list. */
8362 else
8368 }
8370 /* Add GNU_STMT to the current statement group. If it is an expression with
8371 no effects, it is ignored. */
8373 void
8375 {
8377 }
8379 /* Similar, but the statement is always added, regardless of side-effects. */
8381 void
8383 {
8385 }
8387 /* Like add_stmt, but set the location of GNU_STMT to that of GNAT_NODE. */
8389 void
8391 {
8395 }
8397 /* Similar, but the statement is always added, regardless of side-effects. */
8399 void
8401 {
8405 }
8407 /* Add a declaration statement for GNU_DECL to the current statement group.
8408 Get the SLOC to be put onto the statement from GNAT_NODE. */
8410 void
8412 {
8416 /* If this is a variable that Gigi is to ignore, we may have been given
8417 an ERROR_MARK. So test for it. We also might have been given a
8418 reference for a renaming. So only do something for a decl. Also
8419 ignore a TYPE_DECL for an UNCONSTRAINED_ARRAY_TYPE. */
8427 /* If we are external or global, we don't want to output the DECL_EXPR for
8428 this DECL node since we already have evaluated the expressions in the
8429 sizes and positions as globals and doing it again would be wrong. */
8431 {
8432 /* Mark everything as used to prevent node sharing with subprograms.
8433 Note that walk_tree knows how to deal with TYPE_DECL, but neither
8434 VAR_DECL nor CONST_DECL. This appears to be somewhat arbitrary. */
8438 {
8442 }
8443 }
8444 else
8447 /* Mark our TYPE_ADA_SIZE field now since it will not be gimplified. */
8453 /* If this is a variable and an initializer is attached to it, it must be
8454 valid for the context. Similar to init_const in create_var_decl. */
8461 {
8464 {
8467 }
8469 /* Remove any padding so the assignment is done properly. */
8474 }
8475 }
8477 /* Callback for walk_tree to mark the visited trees rooted at *TP. */
8479 static tree
8481 {
8487 /* Don't mark a dummy type as visited because we want to mark its sizes
8488 and fields once it's filled in. */
8492 /* The test in gimplify_type_sizes is on the main variant. */
8497 }
8499 /* Mark nodes rooted at T with TREE_VISITED and types as having their
8500 sized gimplified. We use this to indicate all variable sizes and
8501 positions in global types may not be shared by any subprogram. */
8503 void
8505 {
8507 }
8509 /* Add GNU_CLEANUP, a cleanup action, to the current code group and
8510 set its location to that of GNAT_NODE if present, but with column info
8511 cleared so that conditional branches generated as part of the cleanup
8512 code do not interfere with coverage analysis tools. */
8514 static void
8516 {
8520 /* An EH_ELSE_EXPR must be by itself, and that's all we need when we
8521 use it. The assert below makes sure that is so. Should we ever
8522 need more than that, we could combine EH_ELSE_EXPRs, and copy
8523 non-EH_ELSE_EXPR stmts into both cleanup paths of an
8524 EH_ELSE_EXPR. */
8526 {
8529 }
8530 else
8531 {
8536 }
8537 }
8539 /* Set the BLOCK node corresponding to the current code group to GNU_BLOCK. */
8541 void
8543 {
8546 }
8548 /* Return code corresponding to the current code group. It is normally
8549 a STATEMENT_LIST, but may also be a BIND_EXPR or TRY_FINALLY_EXPR if
8550 BLOCK or cleanups were set. */
8552 tree
8554 {
8558 /* If this is a null list, allocate a new STATEMENT_LIST. Then, if there
8559 are cleanups, make a TRY_FINALLY_EXPR. Last, if there is a BLOCK,
8560 make a BIND_EXPR. Note that we nest in that because the cleanup may
8561 reference variables in the block. */
8573 /* Remove this group from the stack and add it to the free list. */
8579 }
8581 /* Return whether the current statement group may fall through. */
8585 {
8588 else
8590 }
8592 /* Add a list of statements from GNAT_LIST, a possibly-empty list of
8593 statements.*/
8595 static void
8597 {
8598 Node_Id gnat_node;
8604 }
8606 /* Build a tree from GNAT_LIST, a possibly-empty list of statements.
8607 If BINDING_P is true, push and pop a binding level around the list. */
8609 static tree
8611 {
8623 }
8625 /* Generate GIMPLE in place for the expression at *EXPR_P. */
8627 int
8630 {
8633 tree op;
8639 {
8641 /* If this is an aggregate type, build a null pointer of the appropriate
8642 type and dereference it. */
8647 integer_zero_node));
8648 /* Otherwise, just make a VAR_DECL. */
8649 else
8650 {
8653 }
8659 /* We should only do this if we are just elaborating for side-effects,
8660 but we can't know that yet. */
8667 /* If we are taking the address of a constant CONSTRUCTOR, make sure it
8668 is put into static memory. We know that it's going to be read-only
8669 given the semantics we have and it must be in static memory when the
8670 reference is in an elaboration procedure. */
8672 {
8676 }
8678 /* Replace atomic loads with their first argument. That's necessary
8679 because the gimplifier would create a temporary otherwise. */
8682 {
8685 {
8691 else
8693 }
8694 else
8696 }
8701 /* If we are passing a constant fat pointer CONSTRUCTOR, make sure it is
8702 put into static memory; this performs a restricted version of constant
8703 propagation on fat pointers in calls. But do not do it for strings to
8704 avoid blocking concatenation in the caller when it is inlined. */
8706 {
8712 {
8720 }
8721 }
8728 /* If we are view-converting a CONSTRUCTOR or a call from an aggregate
8729 type to a scalar one, explicitly create the local temporary. That's
8730 required if the type is passed by reference. */
8734 {
8743 }
8750 /* The expressions for the RM bounds must be gimplified to ensure that
8751 they are properly elaborated. See gimplify_decl_expr. */
8755 {
8760 {
8765 {
8769 }
8773 {
8777 }
8779 }
8784 }
8786 /* ... fall through ... */
8790 }
8791 }
8793 /* Generate GIMPLE in place for the statement at *STMT_P. */
8795 static enum gimplify_status
8797 {
8801 {
8807 {
8813 /* Build the condition expression from the test, if any. */
8815 {
8816 /* Deal with the optimization hints. */
8820 annot_expr_ivdep_kind),
8821 integer_zero_node);
8825 annot_expr_unroll_kind),
8826 integer_one_node);
8830 annot_expr_unroll_kind),
8835 annot_expr_no_vector_kind),
8836 integer_zero_node);
8840 annot_expr_vector_kind),
8841 integer_zero_node);
8843 gnu_cond
8846 }
8848 /* Set to emit the statements of the loop. */
8851 /* We first emit the start label and then a conditional jump to the
8852 end label if there's a top condition, then the update if it's at
8853 the top, then the body of the loop, then a conditional jump to
8854 the end label if there's a bottom condition, then the update if
8855 it's at the bottom, and finally a jump to the start label and the
8856 definition of the end label. */
8858 gnu_start_label),
8859 stmt_p);
8880 gnu_end_label),
8881 stmt_p);
8883 }
8886 /* Build a statement to jump to the corresponding end label, then
8887 see if it needs to be conditional. */
8896 }
8897 }
8899 /* Force a reference to each of the entities in GNAT_PACKAGE recursively.
8901 This routine is exclusively called in type_annotate mode, to compute DDA
8902 information for types in withed units, for ASIS use. */
8904 static void
8906 {
8907 Entity_Id gnat_entity;
8912 {
8915 /* We are interested only in entities visible from the main unit. */
8919 /* Skip stuff internal to the compiler. */
8931 /* Skip named numbers. */
8935 /* Skip generic declarations. */
8939 /* Skip formal objects. */
8943 /* Skip package bodies. */
8947 /* Skip limited views that point back to the main unit. */
8953 /* Skip types that aren't frozen. */
8957 /* Recurse on real packages that aren't in the main unit. */
8959 {
8963 }
8964 else
8966 }
8967 }
8969 /* Force a reference to each of the entities in packages withed by GNAT_NODE.
8970 Operate recursively but check that we aren't elaborating something more
8971 than once.
8973 This routine is exclusively called in type_annotate mode, to compute DDA
8974 information for types in withed units, for ASIS use. */
8976 static void
8978 {
8979 Entity_Id gnat_with_clause;
8981 /* Process each unit only once. As we trace the context of all relevant
8982 units transitively, including generic bodies, we may encounter the
8983 same generic unit repeatedly. */
8987 /* Save entities in all context units. A body may have an implicit_with
8988 on its own spec, if the context includes a child unit, so don't save
8989 the spec twice. */
8996 {
9007 {
9010 /* Retrieve compilation unit node of generic body. */
9015 /* If body is available, elaborate its context. */
9018 }
9019 }
9023 }
9025 /* Do the processing of GNAT_NODE, an N_Freeze_Entity. */
9027 static void
9029 {
9034 /* If this is a package, generate code for the package body, if any. */
9036 {
9041 }
9043 /* Don't do anything for class-wide types as they are always transformed
9044 into their root type. */
9048 /* Likewise for the entities internally used by the front-end to register
9049 primitives covering abstract interfaces, see Expand_N_Freeze_Entity. */
9053 /* Check for an old definition if this isn't an object with address clause,
9054 since the saved GCC tree is the address expression in that case. */
9055 gnu_old
9059 /* Don't do anything for subprograms that may have been elaborated before
9060 their freeze nodes. This can happen, for example, because of an inner
9061 call in an instance body or because of previous compilation of a spec
9062 for inlining purposes. */
9070 /* If we have a non-dummy type old tree, we have nothing to do, except for
9071 aborting, since this node was never delayed as it should have been. We
9072 let this happen for concurrent types and their Corresponding_Record_Type,
9073 however, because each might legitimately be elaborated before its own
9074 freeze node, e.g. while processing the other. */
9078 {
9083 }
9085 /* Reset the saved tree, if any, and elaborate the object or type for real.
9086 If there is a full view, elaborate it and use the result. And, if this
9087 is the root type of a class-wide type, reuse it for the latter. */
9089 {
9094 {
9101 {
9104 }
9105 }
9111 }
9115 {
9124 /* Propagate back-annotations from full view to partial view. */
9134 /* The above call may have defined this entity (the simplest example
9135 of this is when we have a private enumeral type since the bounds
9136 will have the public view). */
9139 }
9140 else
9141 {
9142 tree gnu_init
9148 }
9155 /* If we have an old type and we've made pointers to this type, update those
9156 pointers. If this is a Taft amendment type in the main unit, we need to
9157 mark the type as used since other units referencing it don't see the full
9158 declaration and, therefore, cannot mark it as used themselves. */
9160 {
9167 }
9168 }
9170 /* Elaborate decls in the lists GNAT_DECLS and GNAT_DECLS2, if present.
9171 We make two passes, one to elaborate anything other than bodies (but
9172 we declare a function if there was no spec). The second pass
9173 elaborates the bodies.
9175 GNAT_END_LIST gives the element in the list past the end. Normally,
9176 this is Empty, but can be First_Real_Statement for a
9177 Handled_Sequence_Of_Statements.
9179 We make a complete pass through both lists if PASS1P is true, then make
9180 the second pass over both lists if PASS2P is true. The lists usually
9181 correspond to the public and private parts of a package. */
9183 static void
9186 {
9188 Node_Id gnat_decl;
9198 {
9199 /* For package specs, we recurse inside the declarations,
9200 thus taking the two pass approach inside the boundary. */
9208 /* Similarly for any declarations in the actions of a
9209 freeze node. */
9211 {
9214 }
9216 /* Package bodies with freeze nodes get their elaboration deferred
9217 until the freeze node, but the code must be placed in the right
9218 place, so record the code position now. */
9226 (Corresponding_Spec
9229 record_code_position
9232 /* We defer most subprogram bodies to the second pass. For bodies
9233 that act as their own specs and stubs, the entity itself must be
9234 elaborated in the first pass, because it may be used in other
9235 declarations. */
9237 {
9239 {
9244 }
9245 }
9248 {
9249 Entity_Id gnat_subprog
9255 }
9257 /* Concurrent stubs stand for the corresponding subprogram bodies,
9258 which are deferred like other bodies. */
9261 ;
9263 /* Renamed subprograms may not be elaborated yet at this point
9264 since renamings do not trigger freezing. Wait for the second
9265 pass to take care of them. */
9267 ;
9269 else
9271 }
9273 /* Here we elaborate everything we deferred above except for package bodies,
9274 which are elaborated at their freeze nodes. Note that we must also
9275 go inside things (package specs and freeze nodes) the first pass did. */
9281 {
9300 }
9301 }
9303 /* Make a unary operation of kind CODE using build_unary_op, but guard
9304 the operation by an overflow check. CODE can be one of NEGATE_EXPR
9305 or ABS_EXPR. GNU_TYPE is the type desired for the result. Usually
9306 the operation is to be performed in that type. GNAT_NODE is the gnat
9307 node conveying the source location for which the error should be
9308 signaled. */
9310 static tree
9312 Node_Id gnat_node)
9313 {
9322 }
9324 /* Make a binary operation of kind CODE using build_binary_op, but guard
9325 the operation by an overflow check. CODE can be one of PLUS_EXPR,
9326 MINUS_EXPR or MULT_EXPR. GNU_TYPE is the type desired for the result.
9327 Usually the operation is to be performed in that type. GNAT_NODE is
9328 the GNAT node conveying the source location for which the error should
9329 be signaled. */
9331 static tree
9334 {
9343 /* Assert that the precision is a power of 2. */
9346 /* Prefer a constant on the RHS to simplify checks. */
9350 {
9354 }
9358 /* If we can fold the expression to a constant, just return it.
9359 The caller will deal with overflow, no need to generate a check. */
9363 /* If no operand is a constant, we use the generic implementation. */
9365 {
9366 /* First convert the operands to the result type like build_binary_op.
9367 This is where the bias is made explicit for biased types. */
9371 /* Never inline a 64-bit mult for a 32-bit target, it's way too long. */
9373 {
9378 }
9380 /* Likewise for a 128-bit mult and a 64-bit target. */
9382 {
9387 }
9392 {
9404 }
9407 tree call
9415 return
9417 }
9419 /* If one operand is a constant, we expose the overflow condition to enable
9420 a subsequent simplication or even elimination. */
9422 {
9426 /* When rhs > 0, overflow when lhs > type_max - rhs. */
9431 /* When rhs < 0, overflow when lhs < type_min - rhs. */
9435 else
9441 {
9444 /* When lhs > 0, overflow when rhs < lhs - type_max. */
9449 /* When lhs < 0, overflow when rhs > lhs - type_min. */
9453 else
9455 }
9456 else
9457 {
9460 /* When rhs > 0, overflow when lhs < type_min + rhs. */
9465 /* When rhs < 0, overflow when lhs > type_max + rhs. */
9469 else
9471 }
9477 {
9484 /* When rhs > 1, overflow outside [type_min/rhs; type_max/rhs]. */
9485 check
9491 }
9493 {
9498 /* When rhs == -1, overflow if lhs == type_min. */
9499 check
9501 else
9502 /* When rhs < -1, overflow outside [type_max/rhs; type_min/rhs]. */
9503 check
9509 }
9510 else
9516 }
9519 }
9521 /* GNU_COND contains the condition corresponding to an index, overflow or
9522 range check of value GNU_EXPR. Build a COND_EXPR that returns GNU_EXPR
9523 if GNU_COND is false and raises a CONSTRAINT_ERROR if GNU_COND is true.
9524 REASON is the code that says why the exception is raised. GNAT_NODE is
9525 the node conveying the source location for which the error should be
9526 signaled.
9528 We used to propagate TREE_SIDE_EFFECTS from GNU_EXPR to the COND_EXPR,
9529 overwriting the setting inherited from the call statement, on the ground
9530 that the expression need not be evaluated just for the check. However
9531 that's incorrect because, in the GCC type system, its value is presumed
9532 to be valid so its comparison against the type bounds always yields true
9533 and, therefore, could be done without evaluating it; given that it can
9534 be a computation that overflows the bounds, the language may require the
9535 check to fail and thus the expression to be evaluated in this case. */
9537 static tree
9539 {
9540 tree gnu_call
9542 return
9548 gnu_expr);
9549 }
9551 /* Return an expression that converts GNU_EXPR to GNAT_TYPE, doing overflow
9552 checks if OVERFLOW_P is true. If TRUNCATE_P is true, do a fp-to-integer
9553 conversion with truncation, otherwise round. GNAT_NODE is the GNAT node
9554 conveying the source location for which the error should be signaled. */
9556 static tree
9559 {
9566 /* If we are not doing any checks, the output is an integral type and the
9567 input is not a floating-point type, just do the conversion. This is
9568 required for packed array types and is simpler in all cases anyway. */
9574 /* If the mode of the input base type is larger, then converting to it below
9575 may pessimize the final conversion step, for example generate a libcall
9576 instead of a simple instruction, so use a narrower type in this case. */
9583 /* First convert the expression to the base type. This will never generate
9584 code, but makes the tests below simpler. But don't do this if converting
9585 from an integer type to an unconstrained array type since then we need to
9586 get the bounds from the original (unpacked) type. */
9590 /* If overflow checks are requested, we need to be sure the result will fit
9591 in the output base type. But don't do this if the input is integer and
9592 the output floating-point. */
9595 {
9596 /* Ensure GNU_EXPR only gets evaluated once. */
9602 tree gnu_out_ub
9610 /* Convert the lower bounds to signed types, so we're sure we're
9611 comparing them properly. Likewise, convert the upper bounds
9612 to unsigned types. */
9615 gnu_in_lb
9620 gnu_in_ub
9624 gnu_out_lb
9628 gnu_out_ub
9631 /* Check each bound separately and only if the result bound
9632 is tighter than the bound on the input type. Note that all the
9633 types are base types, so the bounds must be constant. Also,
9634 the comparison is done in the base type of the input, which
9635 always has the proper signedness. First check for input
9636 integer (which means output integer), output float (which means
9637 both float), or mixed, in which case we always compare.
9638 Note that we have to do the comparison which would *fail* in the
9639 case of an error since if it's an FP comparison and one of the
9640 values is a NaN or Inf, the comparison will fail. */
9647 gnu_cond
9648 = invert_truthvalue
9651 gnu_out_lb)));
9659 gnu_cond
9661 invert_truthvalue
9663 gnu_input,
9665 gnu_out_ub))));
9670 }
9672 /* Now convert to the result base type. If this is a non-truncating
9673 float-to-integer conversion, round. */
9677 {
9683 /* The following calculations depend on proper rounding to even
9684 of each arithmetic operation. In order to prevent excess
9685 precision from spoiling this property, use the widest hardware
9686 floating-point type if FP_ARITH_MAY_WIDEN is true. */
9687 calc_type
9690 /* Compute the exact value calc_type'Pred (0.5) at compile time. */
9697 /* If the input is strictly negative, subtract this value
9698 and otherwise add it from the input. For 0.5, the result
9699 is exactly between 1.0 and the machine number preceding 1.0
9700 (for calc_type). Since the last bit of 1.0 is even, this 0.5
9701 will round to 1.0, while all other number with an absolute
9702 value less than 0.5 round to 0.0. For larger numbers exactly
9703 halfway between integers, rounding will always be correct as
9704 the true mathematical result will be closer to the higher
9705 integer compared to the lower one. So, this constant works
9706 for all floating-point numbers.
9708 The reason to use the same constant with subtract/add instead
9709 of a positive and negative constant is to allow the comparison
9710 to be scheduled in parallel with retrieval of the constant and
9711 conversion of the input to the calc_type (if necessary). */
9716 gnu_comp
9718 gnu_add_pred_half
9720 gnu_subtract_pred_half
9724 }
9730 else
9734 }
9736 /* Return true if GNU_EXPR can be directly addressed. This is the case
9737 unless it is an expression involving computation or if it involves a
9738 reference to a bitfield or to an object not sufficiently aligned for
9739 its type. If GNU_TYPE is non-null, return true only if GNU_EXPR can
9740 be directly addressed as an object of this type.
9742 *** Notes on addressability issues in the Ada compiler ***
9744 This predicate is necessary in order to bridge the gap between Gigi
9745 and the middle-end about addressability of GENERIC trees. A tree
9746 is said to be addressable if it can be directly addressed, i.e. if
9747 its address can be taken, is a multiple of the type's alignment on
9748 strict-alignment architectures and returns the first storage unit
9749 assigned to the object represented by the tree.
9751 In the C family of languages, everything is in practice addressable
9752 at the language level, except for bit-fields. This means that these
9753 compilers will take the address of any tree that doesn't represent
9754 a bit-field reference and expect the result to be the first storage
9755 unit assigned to the object. Even in cases where this will result
9756 in unaligned accesses at run time, nothing is supposed to be done
9757 and the program is considered as erroneous instead (see PR c/18287).
9759 The implicit assumptions made in the middle-end are in keeping with
9760 the C viewpoint described above:
9761 - the address of a bit-field reference is supposed to be never
9762 taken; the compiler (generally) will stop on such a construct,
9763 - any other tree is addressable if it is formally addressable,
9764 i.e. if it is formally allowed to be the operand of ADDR_EXPR.
9766 In Ada, the viewpoint is the opposite one: nothing is addressable
9767 at the language level unless explicitly declared so. This means
9768 that the compiler will both make sure that the trees representing
9769 references to addressable ("aliased" in Ada parlance) objects are
9770 addressable and make no real attempts at ensuring that the trees
9771 representing references to non-addressable objects are addressable.
9773 In the first case, Ada is effectively equivalent to C and handing
9774 down the direct result of applying ADDR_EXPR to these trees to the
9775 middle-end works flawlessly. In the second case, Ada cannot afford
9776 to consider the program as erroneous if the address of trees that
9777 are not addressable is requested for technical reasons, unlike C;
9778 as a consequence, the Ada compiler must arrange for either making
9779 sure that this address is not requested in the middle-end or for
9780 compensating by inserting temporaries if it is requested in Gigi.
9782 The first goal can be achieved because the middle-end should not
9783 request the address of non-addressable trees on its own; the only
9784 exception is for the invocation of low-level block operations like
9785 memcpy, for which the addressability requirements are lower since
9786 the type's alignment can be disregarded. In practice, this means
9787 that Gigi must make sure that such operations cannot be applied to
9788 non-BLKmode bit-fields.
9790 The second goal is achieved by means of the addressable_p predicate,
9791 which computes whether a temporary must be inserted by Gigi when the
9792 address of a tree is requested; if so, the address of the temporary
9793 will be used in lieu of that of the original tree and some glue code
9794 generated to connect everything together. */
9796 static bool
9798 {
9799 /* For an integral type, the size of the actual type of the object may not
9800 be greater than that of the expected type, otherwise an indirect access
9801 in the latter type wouldn't correctly set all the bits of the object. */
9807 /* The size of the actual type of the object may not be smaller than that
9808 of the expected type, otherwise an indirect access in the latter type
9809 would be larger than the object. But only record types need to be
9810 considered in practice for this case. */
9817 {
9822 /* All DECLs are addressable: if they are in a register, we can force
9823 them to memory. */
9828 /* Taking the address of a dereference yields the original pointer. */
9834 /* Taking the address yields a pointer to the constant pool. */
9838 /* Taking the address of a static constructor yields a pointer to the
9839 tree constant pool. */
9852 /* All rvalues are deemed addressable since taking their address will
9853 force a temporary to be created by the middle-end. */
9857 /* The address of a compound expression is that of its 2nd operand. */
9861 /* We accept &COND_EXPR as soon as both operands are addressable and
9862 expect the outcome to be the address of the selected operand. */
9868 /* Even with DECL_BIT_FIELD cleared, we have to ensure that
9869 the field is sufficiently aligned, in case it is subject
9870 to a pragma Component_Alignment. But we don't need to
9871 check the alignment of the containing record, as it is
9872 guaranteed to be not smaller than that of its most
9873 aligned field that is not a bit-field. */
9874 && (!STRICT_ALIGNMENT
9877 /* The field of a padding record is always addressable. */
9891 {
9892 /* This is addressable if we can avoid a copy. */
9896 && (!STRICT_ALIGNMENT
9901 && (!STRICT_ALIGNMENT
9907 }
9911 }
9912 }
9914 /* Do the processing for the declaration of a GNAT_ENTITY, a type or subtype.
9915 If a Freeze node exists for the entity, delay the bulk of the processing.
9916 Otherwise make a GCC type for GNAT_ENTITY and set up the correspondence. */
9918 void
9920 {
9921 tree gnu_old
9924 /* If we are to delay elaboration of this type, just do any elaboration
9925 needed for expressions within the declaration and make a dummy node
9926 for it and its Full_View (if any), in case something points to it.
9927 Do not do this if it has already been done (the only way that can
9928 happen is if the private completion is also delayed). */
9930 {
9934 {
9939 {
9943 }
9944 }
9947 }
9949 /* If we saved away a dummy type for this node, it means that this made the
9950 type that corresponds to the full type of an incomplete type. Clear that
9951 type for now and then update the type in the pointers below. But, if the
9952 saved type is not dummy, it very likely means that we have a use before
9953 declaration for the type in the tree, what we really cannot handle. */
9955 {
9960 }
9962 /* Now fully elaborate the type. */
9966 /* If we have an old type and we've made pointers to this type, update those
9967 pointers. If this is a Taft amendment type in the main unit, we need to
9968 mark the type as used since other units referencing it don't see the full
9969 declaration and, therefore, cannot mark it as used themselves. */
9971 {
9976 }
9978 /* If this is a record type corresponding to a task or protected type
9979 that is a completion of an incomplete type, perform a similar update
9980 on the type. ??? Including protected types here is a guess. */
9984 {
9985 tree gnu_task_old
9995 }
9996 }
9998 /* Subroutine of assoc_to_constructor: VALUES is a list of field associations,
9999 some of which are from RECORD_TYPE. Return a CONSTRUCTOR consisting of the
10000 associations that are from RECORD_TYPE. If we see an internal record, make
10001 a recursive call to fill it in as well. */
10003 static tree
10005 {
10007 tree field;
10010 {
10013 /* _Parent is an internal field, but may have values in the aggregate,
10014 so check for values first. */
10016 {
10019 }
10022 {
10027 }
10028 else
10029 /* If we have a record subtype, the names will match, but not the
10030 actual FIELD_DECLs. */
10033 {
10036 }
10042 }
10045 }
10047 /* GNAT_ENTITY is the type of the resulting constructor, GNAT_ASSOC is the
10048 front of the Component_Associations of an N_Aggregate and GNU_TYPE is the
10049 GCC type of the corresponding record type. Return the CONSTRUCTOR. */
10051 static tree
10053 {
10056 /* We test for GNU_FIELD being empty in the case where a variant
10057 was the last thing since we don't take things off GNAT_ASSOC in
10058 that case. We check GNAT_ASSOC in case we have a variant, but it
10059 has no fields. */
10062 {
10068 /* The expander is supposed to put a single component selector name
10069 in every record component association. */
10072 /* Ignore discriminants that have Corresponding_Discriminants in tagged
10073 types since we'll be setting those fields in the parent subtype. */
10079 /* Also ignore discriminants of Unchecked_Unions. */
10086 /* Convert to the type of the field. */
10089 /* Add the field and expression to the list. */
10091 }
10096 {
10097 /* Verify that every entry in GNU_LIST was used. */
10100 }
10103 }
10105 /* Build a possibly nested constructor for array aggregates. GNAT_EXPR is
10106 the first element of an array aggregate. It may itself be an aggregate.
10107 GNU_ARRAY_TYPE is the GCC type corresponding to the array aggregate. */
10109 static tree
10111 {
10116 {
10117 tree gnu_expr;
10119 /* If the expression is itself an array aggregate then first build the
10120 innermost constructor if it is part of our array (multi-dimensional
10121 case). */
10127 else
10128 {
10129 /* If the expression is a conversion to an unconstrained array type,
10130 skip it to avoid spilling to memory. */
10135 else
10139 }
10146 integer_one_node));
10147 }
10150 }
10152 /* Process a N_Validate_Unchecked_Conversion node. */
10154 static void
10156 {
10160 /* If the target is a pointer type, see if we are either converting from a
10161 non-pointer or from a pointer to a type with a different alias set and
10162 warn if so, unless the pointer has been marked to alias everything. */
10165 {
10175 target_alias_set)))
10176 {
10180 gnat_node);
10183 }
10184 }
10186 /* Likewise if the target is a fat pointer type, but we have no mechanism to
10187 mitigate the problem in this case, so we unconditionally warn. */
10189 {
10190 tree gnu_source_desig_type
10194 tree gnu_target_desig_type
10201 target_alias_set)))
10202 {
10206 gnat_node);
10207 }
10208 }
10209 }
10211 /* Convert SLOC into LOCUS. Return true if SLOC corresponds to a
10212 source code location and false if it doesn't. If CLEAR_COLUMN is
10213 true, set the column information to 0. If DECL is given and SLOC
10214 refers to a File with an instance, map DECL to that instance. */
10216 bool
10218 const_tree decl)
10219 {
10224 {
10227 }
10234 /* We can have zero if pragma Source_Reference is in effect. */
10238 /* Translate the location. */
10239 *locus
10246 }
10248 /* Return whether GNAT_NODE is a defining identifier for a renaming that comes
10249 from the parameter association for the instantiation of a generic. We do
10250 not want to emit source location for them: the code generated for their
10251 initialization is likely to disturb debugging. */
10253 bool
10255 {
10262 /* Get the object declaration of the renamed object, if any and if the
10263 renamed object is a mere identifier. */
10272 }
10274 /* Similar to set_expr_location, but start with the Sloc of GNAT_NODE and
10275 don't do anything if it doesn't correspond to a source location. And,
10276 if CLEAR_COLUMN is true, set the column information to 0. */
10278 static void
10280 {
10281 location_t locus;
10283 /* Do not set a location for constructs likely to disturb debugging. */
10285 {
10291 }
10297 }
10299 /* More elaborate version of set_expr_location_from_node to be used in more
10300 general contexts, for example the result of the translation of a generic
10301 GNAT node. */
10303 static void
10305 {
10306 /* Set the location information on the node if it is a real expression.
10307 References can be reused for multiple GNAT nodes and they would get
10308 the location information of their last use. Also make sure not to
10309 overwrite an existing location as it is probably more precise. */
10312 {
10313 CASE_CONVERT:
10322 /* ... fall through ... */
10326 {
10329 }
10331 }
10332 }
10334 /* Set the end_locus information for GNU_NODE, if any, from an explicit end
10335 location associated with GNAT_NODE or GNAT_NODE itself, whichever makes
10336 most sense. Return true if a sensible assignment was performed. */
10338 static bool
10340 {
10341 Node_Id gnat_end_label;
10342 location_t end_locus;
10344 /* Pick the GNAT node of which we'll take the sloc to assign to the GCC node
10345 end_locus when there is one. We consider only GNAT nodes with a possible
10346 End_Label attached. If the End_Label actually was unassigned, fallback
10347 on the original node. We'd better assign an explicit sloc associated with
10348 the outer construct in any case. */
10351 {
10357 else
10369 }
10374 /* Some expanded subprograms have neither an End_Label nor a Sloc
10375 attached. Notify that to callers. For a block statement with no
10376 End_Label, clear column information, so that the tree for a
10377 transient block does not receive the sloc of a source condition. */
10384 {
10395 }
10396 }
10398 /* Post an error message. MSG is the error message, properly annotated.
10399 NODE is the node at which to post the error and the node to use for the
10400 '&' substitution. */
10402 void
10404 {
10405 String_Template temp;
10406 String_Pointer sp;
10416 }
10418 /* Similar to post_error, but NODE is the node at which to post the error and
10419 ENT is the node to use for the '&' substitution. */
10421 void
10423 {
10424 String_Template temp;
10425 String_Pointer sp;
10435 }
10437 /* Similar to post_error_ne, but NUM is the number to use for the '^'. */
10439 void
10441 {
10444 }
10446 /* Similar to post_error_ne, but T is a GCC tree representing the number to
10447 write. If T represents a constant, the text inside curly brackets in
10448 MSG will be output (presumably including a '^'). Otherwise it will not
10449 be output and the text inside square brackets will be output instead. */
10451 void
10453 {
10460 {
10463 }
10464 else
10468 {
10474 ;
10475 else
10477 }
10482 }
10484 /* Similar to post_error_ne_tree, but NUM is a second integer to write. */
10486 void
10489 {
10492 }
10494 /* Return a label to branch to for the exception type in KIND or Empty
10495 if none. */
10497 Entity_Id
10499 {
10501 {
10513 }
10516 }
10518 /* Return the decl for the current elaboration procedure. */
10520 static tree
10522 {
10524 }
10526 /* Return the controlling type of a dispatching subprogram. */
10528 static Entity_Id
10530 {
10531 /* This is modeled on Expand_Interface_Thunk. */
10540 }
10542 /* Return whether we should use an alias for the TARGET of a thunk
10543 in order to make the call generated in the thunk local. */
10545 static bool
10547 {
10548 /* We cannot generate a local call in this case. */
10552 /* The call is already local in this case. */
10557 }
10561 /* Create an alias for TARGET to be used as the target of a thunk. */
10563 static tree
10565 {
10586 }
10588 /* Create the local covariant part of {GNAT,GNU}_THUNK. */
10590 static tree
10592 {
10594 tree gnu_cv_thunk
10600 param_decl;
10614 }
10616 /* Try to create a GNU thunk for {GNAT,GNU}_THUNK and return true on success.
10618 GNU thunks are more efficient than GNAT thunks because they don't call into
10619 the runtime to retrieve the offset used in the displacement operation, but
10620 they are tailored to C++ and thus too limited to support the full range of
10621 thunks generated in Ada. Here's the complete list of limitations:
10623 1. Multi-controlling thunks, i.e thunks with more than one controlling
10624 parameter, are simply not supported.
10626 2. Covariant thunks, i.e. thunks for which the result is also controlling,
10627 are split into a pair of (this, covariant-only) thunks.
10629 3. Variable-offset thunks, i.e. thunks for which the offset depends on the
10630 object and not only on its type, are supported as 2nd class citizens.
10632 4. External thunks, i.e. thunks for which the target is not declared in
10633 the same unit as the thunk, are supported as 2nd class citizens.
10635 5. Local thunks, i.e. thunks generated for a local type, are supported as
10636 2nd class citizens. */
10638 static bool
10640 {
10643 /* Check that the first formal of the target is the only controlling one. */
10653 /* Look for the types that control the target and the thunk. */
10657 /* We must have an interface type at this point. */
10660 /* Now compute whether the former covers the latter. */
10661 const Entity_Id gnat_interface_tag
10663 tree gnu_interface_tag
10667 tree gnu_interface_offset
10670 /* There are three ways to retrieve the offset between the interface view
10671 and the base object. Either the controlling type covers the interface
10672 type and the offset of the corresponding tag is fixed, in which case it
10673 can be statically encoded in the thunk (see FIXED_OFFSET below). Or the
10674 controlling type doesn't cover the interface type but is of fixed size,
10675 in which case the offset is stored in the dispatch table, two pointers
10676 above the dispatch table address (see VIRTUAL_VALUE below). Otherwise,
10677 the offset is variable and is stored right after the tag in every object
10678 (see INDIRECT_OFFSET below). See also a-tags.ads for more details. */
10680 tree virtual_offset;
10683 {
10688 }
10691 {
10696 }
10697 else
10698 {
10699 /* Covariant thunks with variable offset are not supported. */
10707 }
10711 /* If the target is local, then thunk and target must have the same context
10712 because cgraph_node::expand_thunk can only forward the static chain. */
10717 /* If the target returns by invisible reference and is external, apply the
10718 same transformation as Subprogram_Body_to_gnu here. */
10722 {
10726 }
10728 /* The thunk expander requires the return types of thunk and target to be
10729 compatible, which is not fully the case with the CICO mechanism. */
10731 {
10736 }
10740 /* We may also need to create an alias for the target in order to make
10741 the call local, depending on the linkage of the target. */
10746 /* If the return type of the target is a controlling type, then we need
10747 both an usual this thunk and a covariant thunk in this order:
10749 this thunk --> covariant thunk --> target
10751 For covariant thunks, we can only handle a fixed offset. */
10753 {
10761 }
10768 }
10770 /* Initialize the table that maps GNAT codes to GCC codes for simple
10771 binary and unary operations. */
10773 static void
10775 {
10800 }