* gcc-interface/decl.c: Fix various nits.
From-SVN: r142247
This commit is contained in:
parent
50e0f1313a
commit
2ddc34ba07
@ -1,3 +1,7 @@
|
||||
2008-11-27 Eric Botcazou <ebotcazou@adacore.com>
|
||||
|
||||
* gcc-interface/decl.c: Fix various nits.
|
||||
|
||||
2008-11-20 Eric Botcazou <ebotcazou@adacore.com>
|
||||
|
||||
* gcc-interface/utils.c (init_gigi_decls): Fix type mismatch.
|
||||
|
@ -76,7 +76,7 @@
|
||||
support it and use FORCE_PREFERRED_STACK_BOUNDARY_IN_MAIN for this purpose.
|
||||
|
||||
It is defined on targets where the circuitry is available, and indicates
|
||||
whether the realignment is needed for 'main'. We use this to decide for
|
||||
whether the realignment is needed for 'main'. We use this to decide for
|
||||
foreign subprograms as well.
|
||||
|
||||
It is not defined on targets where the circuitry is not implemented, and
|
||||
@ -181,7 +181,7 @@ gnat_to_gnu_type (Entity_Id gnat_entity)
|
||||
defining identifier.
|
||||
|
||||
If GNAT_ENTITY is a variable or a constant declaration, GNU_EXPR gives its
|
||||
initial value (in GCC tree form). This is optional for variables.
|
||||
initial value (in GCC tree form). This is optional for variables.
|
||||
For renamed entities, GNU_EXPR gives the object being renamed.
|
||||
|
||||
DEFINITION is nonzero if this call is intended for a definition. This is
|
||||
@ -198,7 +198,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
|
||||
tree gnu_entity_id;
|
||||
tree gnu_type = NULL_TREE;
|
||||
/* Contains the gnu XXXX_DECL tree node which is equivalent to the input
|
||||
GNAT tree. This node will be associated with the GNAT node by calling
|
||||
GNAT tree. This node will be associated with the GNAT node by calling
|
||||
the save_gnu_tree routine at the end of the `switch' statement. */
|
||||
tree gnu_decl = NULL_TREE;
|
||||
/* true if we have already saved gnu_decl as a gnat association. */
|
||||
@ -231,7 +231,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
|
||||
unsigned int align = 0;
|
||||
|
||||
/* Since a use of an Itype is a definition, process it as such if it
|
||||
is not in a with'ed unit. */
|
||||
is not in a with'ed unit. */
|
||||
|
||||
if (!definition && Is_Itype (gnat_entity)
|
||||
&& !present_gnu_tree (gnat_entity)
|
||||
@ -437,7 +437,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
|
||||
case E_Discriminant:
|
||||
case E_Component:
|
||||
{
|
||||
/* The GNAT record where the component was defined. */
|
||||
/* The GNAT record where the component was defined. */
|
||||
Entity_Id gnat_record = Underlying_Type (Scope (gnat_entity));
|
||||
|
||||
/* If the variable is an inherited record component (in the case of
|
||||
@ -468,7 +468,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
|
||||
else if (Present (Corresponding_Discriminant (gnat_entity))
|
||||
&& Is_Tagged_Type (gnat_record))
|
||||
{
|
||||
/* A tagged record has no explicit stored discriminants. */
|
||||
/* A tagged record has no explicit stored discriminants. */
|
||||
|
||||
gcc_assert (First_Discriminant (gnat_record)
|
||||
== First_Stored_Discriminant (gnat_record));
|
||||
@ -488,8 +488,8 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
|
||||
break;
|
||||
}
|
||||
|
||||
/* If the enclosing record has explicit stored discriminants,
|
||||
then it is an untagged record. If the Corresponding_Discriminant
|
||||
/* If the enclosing record has explicit stored discriminants, then
|
||||
it is an untagged record. If the Corresponding_Discriminant
|
||||
is not empty then this must be a renamed discriminant and its
|
||||
Original_Record_Component must point to the corresponding explicit
|
||||
stored discriminant (i.e., we should have taken the first
|
||||
@ -532,7 +532,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
|
||||
|
||||
else
|
||||
/* Here we have no GCC type and this is a reference rather than a
|
||||
definition. This should never happen. Most likely the cause is a
|
||||
definition. This should never happen. Most likely the cause is
|
||||
reference before declaration in the gnat tree for gnat_entity. */
|
||||
gcc_unreachable ();
|
||||
}
|
||||
@ -597,7 +597,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
|
||||
gnu_type = get_base_type (gnu_type);
|
||||
|
||||
/* Reject non-renamed objects whose types are unconstrained arrays or
|
||||
any object whose type is a dummy type or VOID_TYPE. */
|
||||
any object whose type is a dummy type or VOID_TYPE. */
|
||||
|
||||
if ((TREE_CODE (gnu_type) == UNCONSTRAINED_ARRAY_TYPE
|
||||
&& No (Renamed_Object (gnat_entity)))
|
||||
@ -624,8 +624,8 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
|
||||
}
|
||||
|
||||
/* If we are defining the object, see if it has a Size value and
|
||||
validate it if so. If we are not defining the object and a Size
|
||||
clause applies, simply retrieve the value. We don't want to ignore
|
||||
validate it if so. If we are not defining the object and a Size
|
||||
clause applies, simply retrieve the value. We don't want to ignore
|
||||
the clause and it is expected to have been validated already. Then
|
||||
get the new type, if any. */
|
||||
if (definition)
|
||||
@ -762,7 +762,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
|
||||
type and validate it.
|
||||
|
||||
??? Note that we ignore Has_Volatile_Components on objects; it's
|
||||
not at all clear what to do in that case. */
|
||||
not at all clear what to do in that case. */
|
||||
|
||||
if (Has_Atomic_Components (gnat_entity))
|
||||
{
|
||||
@ -1410,16 +1410,16 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
|
||||
|
||||
case E_Enumeration_Type:
|
||||
/* A special case, for the types Character and Wide_Character in
|
||||
Standard, we do not list all the literals. So if the literals
|
||||
Standard, we do not list all the literals. So if the literals
|
||||
are not specified, make this an unsigned type. */
|
||||
if (No (First_Literal (gnat_entity)))
|
||||
{
|
||||
gnu_type = make_unsigned_type (esize);
|
||||
TYPE_NAME (gnu_type) = gnu_entity_id;
|
||||
|
||||
/* Set the TYPE_STRING_FLAG for Ada Character and
|
||||
Wide_Character types. This is needed by the dwarf-2 debug writer to
|
||||
distinguish between unsigned integer types and character types. */
|
||||
/* Set TYPE_STRING_FLAG for Ada Character and Wide_Character types.
|
||||
This is needed by the DWARF-2 back-end to distinguish between
|
||||
unsigned integer types and character types. */
|
||||
TYPE_STRING_FLAG (gnu_type) = 1;
|
||||
break;
|
||||
}
|
||||
@ -1563,7 +1563,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
|
||||
unit and one of our bounds is non-static. We do this to ensure
|
||||
consistent naming in the case where several subtypes share the same
|
||||
bounds by always elaborating the first such subtype first, thus
|
||||
using its name. */
|
||||
using its name. */
|
||||
|
||||
if (!definition
|
||||
&& Present (Ancestor_Subtype (gnat_entity))
|
||||
@ -1917,7 +1917,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
|
||||
build_range_type (gnu_ind_subtype,
|
||||
gnu_min, gnu_max),
|
||||
gnat_entity);
|
||||
/* Update the maximum size of the array, in elements. */
|
||||
/* Update the maximum size of the array, in elements. */
|
||||
gnu_max_size
|
||||
= size_binop (MULT_EXPR, gnu_max_size,
|
||||
size_binop (PLUS_EXPR, size_one_node,
|
||||
@ -1954,7 +1954,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
|
||||
check_ok_for_atomic (tem, gnat_entity, true);
|
||||
|
||||
/* Get and validate any specified Component_Size, but if Packed,
|
||||
ignore it since the front end will have taken care of it. */
|
||||
ignore it since the front end will have taken care of it. */
|
||||
gnu_comp_size
|
||||
= validate_size (Component_Size (gnat_entity), tem,
|
||||
gnat_entity,
|
||||
@ -2319,7 +2319,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
|
||||
gnu_type = make_packable_type (gnu_type, false);
|
||||
|
||||
/* Get and validate any specified Component_Size, but if Packed,
|
||||
ignore it since the front end will have taken care of it. */
|
||||
ignore it since the front end will have taken care of it. */
|
||||
gnu_comp_size
|
||||
= validate_size (Component_Size (gnat_entity), gnu_type,
|
||||
gnat_entity,
|
||||
@ -2571,14 +2571,14 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
|
||||
}
|
||||
}
|
||||
|
||||
/* Abort if packed array with no packed array type field set. */
|
||||
/* Abort if packed array with no packed array type field set. */
|
||||
else
|
||||
gcc_assert (!Is_Packed (gnat_entity));
|
||||
|
||||
break;
|
||||
|
||||
case E_String_Literal_Subtype:
|
||||
/* Create the type for a string literal. */
|
||||
/* Create the type for a string literal. */
|
||||
{
|
||||
Entity_Id gnat_full_type
|
||||
= (IN (Ekind (Etype (gnat_entity)), Private_Kind)
|
||||
@ -2637,7 +2637,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
|
||||
Processing of a record type definition comprises starting the list of
|
||||
field declarations here from the discriminants and the calling the
|
||||
function components_to_record to add the rest of the fields from the
|
||||
component list and return the gnu type node. The function
|
||||
component list and return the gnu type node. The function
|
||||
components_to_record will call itself recursively as it traverses
|
||||
the tree. */
|
||||
|
||||
@ -2870,14 +2870,14 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
|
||||
TYPE_BY_REFERENCE_P (gnu_type) = Is_By_Reference_Type (gnat_entity);
|
||||
|
||||
/* If it is a tagged record force the type to BLKmode to insure
|
||||
that these objects will always be placed in memory. Do the
|
||||
same thing for limited record types. */
|
||||
that these objects will always be placed in memory. Do the
|
||||
same thing for limited record types. */
|
||||
if (Is_Tagged_Type (gnat_entity) || Is_Limited_Record (gnat_entity))
|
||||
TYPE_MODE (gnu_type) = BLKmode;
|
||||
|
||||
/* If this is a derived type, we must make the alias set of this type
|
||||
the same as that of the type we are derived from. We assume here
|
||||
that the other type is already frozen. */
|
||||
that the other type is already frozen. */
|
||||
if (Etype (gnat_entity) != gnat_entity
|
||||
&& !(Is_Private_Type (Etype (gnat_entity))
|
||||
&& Full_View (Etype (gnat_entity)) == gnat_entity))
|
||||
@ -3305,7 +3305,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
|
||||
|
||||
/* Nonzero if we make a dummy type here. */
|
||||
bool got_fat_p = false;
|
||||
/* Nonzero if the dummy is a fat pointer. */
|
||||
/* Nonzero if the dummy is a fat pointer. */
|
||||
bool made_dummy = false;
|
||||
tree gnu_desig_type = NULL_TREE;
|
||||
enum machine_mode p_mode = mode_for_size (esize, MODE_INT, 0);
|
||||
@ -3436,7 +3436,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
|
||||
are to defer elaborating incomplete types. We do this
|
||||
since this access type may be the full view of some
|
||||
private type. Note that the unconstrained array case is
|
||||
handled above. */
|
||||
handled above. */
|
||||
|| ((! in_main_unit || imported_p)
|
||||
&& defer_incomplete_level != 0
|
||||
&& ! present_gnu_tree (gnat_desig_equiv)
|
||||
@ -3450,7 +3450,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
|
||||
when the declaration is processed. In both cases, the
|
||||
pointer eventually created below will be automatically
|
||||
adjusted when the Freeze_Node is processed. Note that the
|
||||
unconstrained array case is handled above. */
|
||||
unconstrained array case is handled above. */
|
||||
|| (in_main_unit && is_from_limited_with
|
||||
&& Present (Freeze_Node (gnat_desig_rep))))
|
||||
{
|
||||
@ -3499,7 +3499,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
|
||||
TYPE_QUALS (gnu_desig_type) | TYPE_QUAL_CONST);
|
||||
|
||||
/* Some extra processing is required if we are building a
|
||||
pointer to an incomplete type (in the GCC sense). We might
|
||||
pointer to an incomplete type (in the GCC sense). We might
|
||||
have such a type if we just made a dummy, or directly out
|
||||
of the call to gnat_to_gnu_type above if we are processing
|
||||
an access type for a record component designating the
|
||||
@ -3508,16 +3508,16 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
|
||||
{
|
||||
/* We must ensure that the pointer to variant we make will
|
||||
be processed by update_pointer_to when the initial type
|
||||
is completed. Pretend we made a dummy and let further
|
||||
is completed. Pretend we made a dummy and let further
|
||||
processing act as usual. */
|
||||
made_dummy = true;
|
||||
|
||||
/* We must ensure that update_pointer_to will not retrieve
|
||||
the dummy variant when building a properly qualified
|
||||
version of the complete type. We take advantage of the
|
||||
version of the complete type. We take advantage of the
|
||||
fact that get_qualified_type is requiring TYPE_NAMEs to
|
||||
match to influence build_qualified_type and then also
|
||||
update_pointer_to here. */
|
||||
update_pointer_to here. */
|
||||
TYPE_NAME (gnu_desig_type)
|
||||
= create_concat_name (gnat_desig_type, "INCOMPLETE_CST");
|
||||
}
|
||||
@ -3574,7 +3574,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
|
||||
node as the one we got.
|
||||
|
||||
Besides, variants of this non-dummy type might have been
|
||||
created along the way. update_pointer_to is expected to
|
||||
created along the way. update_pointer_to is expected to
|
||||
properly take care of those situations. */
|
||||
else
|
||||
{
|
||||
@ -3602,9 +3602,9 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
|
||||
gnu_type = ptr_void_type_node;
|
||||
else
|
||||
{
|
||||
/* The runtime representation is the equivalent type. */
|
||||
/* The runtime representation is the equivalent type. */
|
||||
gnu_type = gnat_to_gnu_type (gnat_equiv_type);
|
||||
maybe_present = 1;
|
||||
maybe_present = true;
|
||||
}
|
||||
|
||||
if (Is_Itype (Directly_Designated_Type (gnat_entity))
|
||||
@ -3622,12 +3622,12 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
|
||||
meaningful only to the front end.
|
||||
|
||||
The designated type must be elaborated as well, if it does
|
||||
not have its own freeze node. Designated (sub)types created
|
||||
not have its own freeze node. Designated (sub)types created
|
||||
for constrained components of records with discriminants are
|
||||
not frozen by the front end and thus not elaborated by gigi,
|
||||
because their use may appear before the base type is frozen,
|
||||
and because it is not clear that they are needed anywhere in
|
||||
Gigi. With the current model, there is no correct place where
|
||||
Gigi. With the current model, there is no correct place where
|
||||
they could be elaborated. */
|
||||
|
||||
gnu_type = gnat_to_gnu_type (Etype (gnat_entity));
|
||||
@ -3669,7 +3669,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
|
||||
|
||||
First_Formal The first formal parameter.
|
||||
Is_Imported Indicates that the subprogram has appeared in
|
||||
an INTERFACE or IMPORT pragma. For now we
|
||||
an INTERFACE or IMPORT pragma. For now we
|
||||
assume that the external language is C.
|
||||
Is_Exported Likewise but for an EXPORT pragma.
|
||||
Is_Inlined True if the subprogram is to be inlined.
|
||||
@ -3683,7 +3683,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
|
||||
are copied in, if they are Ada In Out or Out parameters, their return
|
||||
value becomes part of a record which becomes the return type of the
|
||||
function (C function - note that this applies only to Ada procedures
|
||||
so there is no Ada return type). Additional code to store back the
|
||||
so there is no Ada return type). Additional code to store back the
|
||||
parameters will be generated on the caller side. This transformation
|
||||
is done here, not in the front-end.
|
||||
|
||||
@ -3716,7 +3716,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
|
||||
tree gnu_param_list = NULL_TREE;
|
||||
/* Likewise for the stub associated with an exported procedure. */
|
||||
tree gnu_stub_param_list = NULL_TREE;
|
||||
/* The type returned by a function. If the subprogram is a procedure
|
||||
/* The type returned by a function. If the subprogram is a procedure
|
||||
this type should be void_type_node. */
|
||||
tree gnu_return_type = void_type_node;
|
||||
/* List of fields in return type of procedure with copy-in copy-out
|
||||
@ -3802,7 +3802,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
|
||||
|
||||
/* ??? What if we don't find the builtin node above ? warn ? err ?
|
||||
In the current state we neither warn nor err, and calls will just
|
||||
be handled as for regular subprograms. */
|
||||
be handled as for regular subprograms. */
|
||||
|
||||
if (kind == E_Function || kind == E_Subprogram_Type)
|
||||
gnu_return_type = gnat_to_gnu_type (Etype (gnat_entity));
|
||||
@ -4071,7 +4071,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
|
||||
/* A subprogram (something that doesn't return anything) shouldn't
|
||||
be considered const since there would be no reason for such a
|
||||
subprogram. Note that procedures with Out (or In Out) parameters
|
||||
have already been converted into a function with a return type. */
|
||||
have already been converted into a function with a return type. */
|
||||
if (TREE_CODE (gnu_return_type) == VOID_TYPE)
|
||||
const_flag = false;
|
||||
|
||||
@ -4537,7 +4537,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
|
||||
{
|
||||
/* In this mode the tag and the parent components are not
|
||||
generated by the front-end, so the sizes must be adjusted
|
||||
explicitly now. */
|
||||
explicitly now. */
|
||||
int size_offset, new_size;
|
||||
|
||||
if (Is_Derived_Type (gnat_entity))
|
||||
@ -4571,7 +4571,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
|
||||
DECL_IGNORED_P (gnu_decl) = 1;
|
||||
|
||||
/* If we haven't already, associate the ..._DECL node that we just made with
|
||||
the input GNAT entity node. */
|
||||
the input GNAT entity node. */
|
||||
if (!saved)
|
||||
save_gnu_tree (gnat_entity, gnu_decl, false);
|
||||
|
||||
@ -5054,7 +5054,7 @@ elaborate_entity (Entity_Id gnat_entity)
|
||||
|
||||
/* ??? Tests for avoiding static constraint error expression
|
||||
is needed until the front stops generating bogus conversions
|
||||
on bounds of real types. */
|
||||
on bounds of real types. */
|
||||
|
||||
if (!Raises_Constraint_Error (gnat_lb))
|
||||
elaborate_expression (gnat_lb, gnat_entity, get_identifier ("L"),
|
||||
@ -5177,7 +5177,7 @@ copy_alias_set (tree gnu_new_type, tree gnu_old_type)
|
||||
/* Return a TREE_LIST describing the substitutions needed to reflect
|
||||
discriminant substitutions from GNAT_SUBTYPE to GNAT_TYPE and add
|
||||
them to GNU_LIST. If GNAT_TYPE is not specified, use the base type
|
||||
of GNAT_SUBTYPE. The substitutions can be in any order. TREE_PURPOSE
|
||||
of GNAT_SUBTYPE. The substitutions can be in any order. TREE_PURPOSE
|
||||
gives the tree for the discriminant and TREE_VALUES is the replacement
|
||||
value. They are in the form of operands to substitute_in_expr.
|
||||
DEFINITION is as in gnat_to_gnu_entity. */
|
||||
@ -5406,7 +5406,7 @@ elaborate_expression (Node_Id gnat_expr, Entity_Id gnat_entity,
|
||||
gnu_name, definition, need_debug);
|
||||
|
||||
/* Save the expression in case we try to elaborate this entity again. Since
|
||||
this is not a DECL, don't check it. Don't save if it's a discriminant. */
|
||||
it's not a DECL, don't check it. Don't save if it's a discriminant. */
|
||||
if (!CONTAINS_PLACEHOLDER_P (gnu_expr))
|
||||
save_gnu_tree (gnat_expr, gnu_expr, true);
|
||||
|
||||
@ -5869,7 +5869,7 @@ maybe_pad_type (tree type, tree size, unsigned int align,
|
||||
|
||||
/* Unless debugging information isn't being written for the input type,
|
||||
write a record that shows what we are a subtype of and also make a
|
||||
variable that indicates our size, if still variable. */
|
||||
variable that indicates our size, if still variable. */
|
||||
if (TYPE_NAME (record)
|
||||
&& AGGREGATE_TYPE_P (type)
|
||||
&& TREE_CODE (orig_size) != INTEGER_CST
|
||||
@ -6012,7 +6012,9 @@ choices_to_gnu (tree operand, Node_Id choices)
|
||||
operand, high));
|
||||
break;
|
||||
}
|
||||
|
||||
/* ... fall through ... */
|
||||
|
||||
case N_Character_Literal:
|
||||
case N_Integer_Literal:
|
||||
single = gnat_to_gnu (choice);
|
||||
@ -6445,7 +6447,7 @@ components_to_record (tree gnu_record_type, Node_Id component_list,
|
||||
}
|
||||
}
|
||||
|
||||
save_gnu_tree (gnat_field, gnu_field, false);
|
||||
save_gnu_tree (gnat_field, gnu_field, false);
|
||||
}
|
||||
|
||||
/* At the end of the component list there may be a variant part. */
|
||||
@ -6654,7 +6656,7 @@ components_to_record (tree gnu_record_type, Node_Id component_list,
|
||||
else if (gnu_our_rep_list)
|
||||
{
|
||||
/* Otherwise, sort the fields by bit position and put them into their
|
||||
own record if we have any fields without rep clauses. */
|
||||
own record if we have any fields without rep clauses. */
|
||||
tree gnu_rep_type
|
||||
= (gnu_field_list ? make_node (RECORD_TYPE) : gnu_record_type);
|
||||
int len = list_length (gnu_our_rep_list);
|
||||
@ -7009,7 +7011,7 @@ validate_size (Uint uint_size, tree gnu_type, Entity_Id gnat_object,
|
||||
return NULL_TREE;
|
||||
|
||||
/* Get the size as a tree. Give an error if a size was specified, but cannot
|
||||
be represented as in sizetype. */
|
||||
be represented as in sizetype. */
|
||||
size = UI_To_gnu (uint_size, bitsizetype);
|
||||
if (TREE_OVERFLOW (size))
|
||||
{
|
||||
@ -7391,7 +7393,7 @@ check_ok_for_atomic (tree object, Entity_Id gnat_entity, bool comp_p)
|
||||
|
||||
/* Check if FTYPE1 and FTYPE2, two potentially different function type nodes,
|
||||
have compatible signatures so that a call using one type may be safely
|
||||
issued if the actual target function type is the other. Return 1 if it is
|
||||
issued if the actual target function type is the other. Return 1 if it is
|
||||
the case, 0 otherwise, and post errors on the incompatibilities.
|
||||
|
||||
This is used when an Ada subprogram is mapped onto a GCC builtin, to ensure
|
||||
@ -7688,9 +7690,9 @@ create_concat_name (Entity_Id gnat_entity, const char *suffix)
|
||||
Get_External_Name_With_Suffix (gnat_entity, fp);
|
||||
|
||||
/* A variable using the Stdcall convention (meaning we are running
|
||||
on a Windows box) live in a DLL. Here we adjust its name to use
|
||||
on a Windows box) live in a DLL. Here we adjust its name to use
|
||||
the jump-table, the _imp__NAME contains the address for the NAME
|
||||
variable. */
|
||||
variable. */
|
||||
if ((kind == E_Variable || kind == E_Constant)
|
||||
&& Has_Stdcall_Convention (gnat_entity))
|
||||
{
|
||||
|
Loading…
Reference in New Issue
Block a user