+2001-10-26 Richard Kenner <kenner@gnat.com>
+
+ * decl.c (gnat_to_gnu_entity, case E_General_Access_Type):
+ Make constant variant of designated type for Is_Access_Constant.
+ Call update_pointer_to with main variant.
+
+ * trans.c (process_freeze_entity, process_type):
+ Call update_pointer_to on main variant.
+
+ * utils.c (update_pointer_to): Make corresponding variant for NEW_TYPE.
+ If main variant, update all other variants.
+
+ * utils2.c (build_unary_op, case INDIRECT_REF): No longer set
+ TREE_STATIC.
+
2001-10-26 Robert Dewar <dewar@gnat.com>
* prj-util.adb: Minor reformatting
: In_Extended_Main_Code_Unit (gnat_desig_type));
int got_fat_p = 0;
int made_dummy = 0;
+ tree gnu_desig_type = 0;
if (No (gnat_desig_full)
&& (Ekind (gnat_desig_type) == E_Class_Wide_Type
/* If we already know what the full type is, use it. */
else if (Present (gnat_desig_full)
&& present_gnu_tree (gnat_desig_full))
- gnu_type
- = build_pointer_type (TREE_TYPE (get_gnu_tree (gnat_desig_full)));
+ gnu_desig_type = TREE_TYPE (get_gnu_tree (gnat_desig_full));
/* Get the type of the thing we are to point to and build a pointer
to it. If it is a reference to an incomplete or private type with a
&& ! present_gnu_tree (gnat_desig_full)
&& Is_Record_Type (gnat_desig_full))
{
- gnu_type = build_pointer_type (make_dummy_type (gnat_desig_type));
+ gnu_desig_type = make_dummy_type (gnat_desig_type);
made_dummy = 1;
}
&& (Is_Record_Type (gnat_desig_full)
|| Is_Array_Type (gnat_desig_full)))))
{
- gnu_type = build_pointer_type (make_dummy_type (gnat_desig_type));
+ gnu_desig_type = make_dummy_type (gnat_desig_type);
made_dummy = 1;
}
else if (gnat_desig_type == gnat_entity)
TREE_TYPE (gnu_type) = TYPE_POINTER_TO (gnu_type) = gnu_type;
}
else
- gnu_type = build_pointer_type (gnat_to_gnu_type (gnat_desig_type));
+ gnu_desig_type = gnat_to_gnu_type (gnat_desig_type);
/* It is possible that the above call to gnat_to_gnu_type resolved our
type. If so, just return it. */
break;
}
+ /* If we have a GCC type for the designated type, possibly
+ modify it if we are pointing only to constant objects and then
+ make a pointer to it. Don't do this for unconstrained arrays. */
+ if (gnu_type == 0 && gnu_desig_type != 0)
+ {
+ if (Is_Access_Constant (gnat_entity)
+ && TREE_CODE (gnu_desig_type) != UNCONSTRAINED_ARRAY_TYPE)
+ gnu_desig_type
+ = build_qualified_type (gnu_desig_type,
+ (TYPE_QUALS (gnu_desig_type)
+ | TYPE_QUAL_CONST));
+
+ gnu_type = build_pointer_type (gnu_desig_type);
+ }
+
/* If we are not defining this object and we made a dummy pointer,
save our current definition, evaluate the actual type, and replace
the tentative type we made with the actual one. If we are to defer
this_made_decl = saved = 1;
if (defer_incomplete_level == 0)
- update_pointer_to
- (gnu_old_type, gnat_to_gnu_type (gnat_desig_type));
+ update_pointer_to (TYPE_MAIN_VARIANT (gnu_old_type),
+ gnat_to_gnu_type (gnat_desig_type));
else
{
struct incomplete *p
next = incp->next;
if (incp->old_type != 0)
- update_pointer_to (incp->old_type,
+ update_pointer_to (TYPE_MAIN_VARIANT (incp->old_type),
gnat_to_gnu_type (incp->full_type));
free (incp);
}
for (incp = defer_incomplete_list; incp; incp = incp->next)
if (incp->old_type != 0 && incp->full_type == gnat_entity)
{
- update_pointer_to (incp->old_type, TREE_TYPE (gnu_decl));
+ update_pointer_to (TYPE_MAIN_VARIANT (incp->old_type),
+ TREE_TYPE (gnu_decl));
incp->old_type = 0;
}
}
if (gnu_old != 0)
{
DECL_NAME (gnu_new) = DECL_NAME (gnu_old);
- update_pointer_to (TREE_TYPE (gnu_old), TREE_TYPE (gnu_new));
+ update_pointer_to (TYPE_MAIN_VARIANT (TREE_TYPE (gnu_old)),
+ TREE_TYPE (gnu_new));
}
}
\f
/* If we have an old type and we've made pointers to this type,
update those pointers. */
if (gnu_old != 0)
- update_pointer_to (TREE_TYPE (gnu_old), TREE_TYPE (gnu_new));
+ update_pointer_to (TYPE_MAIN_VARIANT (TREE_TYPE (gnu_old)),
+ TREE_TYPE (gnu_new));
/* If this is a record type corresponding to a task or protected type
that is a completion of an incomplete type, perform a similar update
save_gnu_tree (Corresponding_Concurrent_Type (gnat_entity),
gnu_new, 0);
- update_pointer_to (TREE_TYPE (gnu_task_old), TREE_TYPE (gnu_new));
+ update_pointer_to (TYPE_MAIN_VARIANT (TREE_TYPE (gnu_task_old)),
+ TREE_TYPE (gnu_new));
}
}
\f
* *
* C Implementation File *
* *
- * $Revision: 1.4 $
+ * $Revision$
* *
* Copyright (C) 1992-2001, Free Software Foundation, Inc. *
* *
{
tree ptr = TYPE_POINTER_TO (old_type);
tree ref = TYPE_REFERENCE_TO (old_type);
+ tree type;
+
+ /* If this is the main variant, process all the other variants first. */
+ if (TYPE_MAIN_VARIANT (old_type) == old_type)
+ for (type = TYPE_NEXT_VARIANT (old_type); type != 0;
+ type = TYPE_NEXT_VARIANT (type))
+ update_pointer_to (type, new_type);
+
+ /* If no pointer or reference, we are done. Otherwise, get the new type with
+ the same qualifiers as the old type and see if it is the same as the old
+ type. */
+ if (ptr == 0 && ref == 0)
+ return;
- if ((ptr == 0 && ref == 0) || old_type == new_type)
+ new_type = build_qualified_type (new_type, TYPE_QUALS (old_type));
+ if (old_type == new_type)
return;
/* First handle the simple case. */
* *
* C Implementation File *
* *
- * $Revision: 1.1 $
+ * $Revision$
* *
* Copyright (C) 1992-2001, Free Software Foundation, Inc. *
* *
else
{
result = fold (build1 (op_code, TREE_TYPE (type), operand));
- TREE_READONLY (result) = TREE_STATIC (result)
- = TREE_READONLY (TREE_TYPE (type));
+ TREE_READONLY (result) = TREE_READONLY (TREE_TYPE (type));
}
side_effects = flag_volatile
projects / gcc.git / commitdiff