From b3b5c6a236cf0816e987626120419845c8177eb5 Mon Sep 17 00:00:00 2001 From: Eric Botcazou Date: Thu, 12 Nov 2015 11:06:34 +0000 Subject: [PATCH] sem_ch13.adb (Analyze_Attribute_Definition_Clause): For a variable, if this is not an overlay, set on Treat_As_Volatile on it. 2015-11-12 Eric Botcazou * sem_ch13.adb (Analyze_Attribute_Definition_Clause): For a variable, if this is not an overlay, set on Treat_As_Volatile on it. * gcc-interface/decl.c (E_Variable): Do not force the type to volatile for address clauses. Tweak and adjust various RM references. 2015-11-12 Eric Botcazou * checks.ads: Minor comment fix. From-SVN: r230233 --- gcc/ada/ChangeLog | 11 +++++++++++ gcc/ada/checks.ads | 2 +- gcc/ada/gcc-interface/decl.c | 27 ++++++++++++--------------- gcc/ada/sem_ch13.adb | 20 +++++++++++++++++--- 4 files changed, 41 insertions(+), 19 deletions(-) diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog index 6d211bcbba3..b8542eee6ab 100644 --- a/gcc/ada/ChangeLog +++ b/gcc/ada/ChangeLog @@ -1,3 +1,14 @@ +2015-11-12 Eric Botcazou + + * sem_ch13.adb (Analyze_Attribute_Definition_Clause): For a + variable, if this is not an overlay, set on Treat_As_Volatile on it. + * gcc-interface/decl.c (E_Variable): Do not force the type to volatile + for address clauses. Tweak and adjust various RM references. + +2015-11-12 Eric Botcazou + + * checks.ads: Minor comment fix. + 2015-11-12 Arnaud Charlet * gnat_rm.texi, gnat_ugn.texi, diff --git a/gcc/ada/checks.ads b/gcc/ada/checks.ads index 5375eed48a2..9883c830bf2 100644 --- a/gcc/ada/checks.ads +++ b/gcc/ada/checks.ads @@ -573,7 +573,7 @@ package Checks is -- For scalar types, constructs a range check action that first tests that -- the expression is contained in the Target_Typ range. The difference -- between this and Apply_Scalar_Range_Check is that the latter generates - -- the actual checking code in gigi against the Etype of the expression. + -- the actual checking code against the Etype of the expression. -- -- For constrained array types, construct series of range check actions -- to check that each Expr range is properly contained in the range of diff --git a/gcc/ada/gcc-interface/decl.c b/gcc/ada/gcc-interface/decl.c index 0c59ab3aabb..ceeb9958617 100644 --- a/gcc/ada/gcc-interface/decl.c +++ b/gcc/ada/gcc-interface/decl.c @@ -1068,14 +1068,12 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition) } /* Make a volatile version of this object's type if we are to make - the object volatile. We also interpret 13.3(19) conservatively - and disallow any optimizations for such a non-constant object. */ + the object volatile. We also implement RM 13.3(19) for exported + and imported (non-constant) objects by making them volatile. */ if ((Treat_As_Volatile (gnat_entity) || (!const_flag && gnu_type != except_type_node - && (Is_Exported (gnat_entity) - || imported_p - || Present (Address_Clause (gnat_entity))))) + && (Is_Exported (gnat_entity) || imported_p))) && !TYPE_VOLATILE (gnu_type)) { const int quals @@ -1118,7 +1116,8 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition) gnu_expr = convert (gnu_type, gnu_expr); /* If this is a pointer that doesn't have an initializing expression, - initialize it to NULL, unless the object is imported. */ + initialize it to NULL, unless the object is declared imported as + per RM B.1(24). */ if (definition && (POINTER_TYPE_P (gnu_type) || TYPE_IS_FAT_POINTER_P (gnu_type)) && !gnu_expr @@ -1141,7 +1140,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition) save_gnu_tree (gnat_entity, NULL_TREE, false); /* Convert the type of the object to a reference type that can - alias everything as per 13.3(19). */ + alias everything as per RM 13.3(19). */ gnu_type = build_reference_type_for_mode (gnu_type, ptr_mode, true); gnu_address = convert (gnu_type, gnu_address); @@ -1206,11 +1205,10 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition) as an indirect object. Likewise for Stdcall objects that are imported. */ if ((!definition && Present (Address_Clause (gnat_entity))) - || (Is_Imported (gnat_entity) - && Has_Stdcall_Convention (gnat_entity))) + || (imported_p && Has_Stdcall_Convention (gnat_entity))) { /* Convert the type of the object to a reference type that can - alias everything as per 13.3(19). */ + alias everything as per RM 13.3(19). */ gnu_type = build_reference_type_for_mode (gnu_type, ptr_mode, true); used_by_ref = true; @@ -1402,10 +1400,9 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition) /* If this name is external or a name was specified, use it, but don't use the Interface_Name with an address clause (see cd30005). */ - if ((Present (Interface_Name (gnat_entity)) - && No (Address_Clause (gnat_entity))) - || (Is_Public (gnat_entity) - && (!Is_Imported (gnat_entity) || Is_Exported (gnat_entity)))) + if ((Is_Public (gnat_entity) && !Is_Imported (gnat_entity)) + || (Present (Interface_Name (gnat_entity)) + && No (Address_Clause (gnat_entity)))) gnu_ext_name = create_concat_name (gnat_entity, NULL); /* If this is an aggregate constant initialized to a constant, force it @@ -4618,7 +4615,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition) save_gnu_tree (gnat_entity, NULL_TREE, false); /* Convert the type of the object to a reference type that can - alias everything as per 13.3(19). */ + alias everything as per RM 13.3(19). */ gnu_type = build_reference_type_for_mode (gnu_type, ptr_mode, true); if (gnu_address) diff --git a/gcc/ada/sem_ch13.adb b/gcc/ada/sem_ch13.adb index bbcd7afde76..3d33e639e34 100644 --- a/gcc/ada/sem_ch13.adb +++ b/gcc/ada/sem_ch13.adb @@ -4724,10 +4724,24 @@ package body Sem_Ch13 is Find_Overlaid_Entity (N, O_Ent, Off); - -- If the object overlays a constant view, mark it so + if Present (O_Ent) then + -- If the object overlays a constant object, mark it so - if Present (O_Ent) and then Is_Constant_Object (O_Ent) then - Set_Overlays_Constant (U_Ent); + if Is_Constant_Object (O_Ent) then + Set_Overlays_Constant (U_Ent); + end if; + else + -- If this is not an overlay, mark a variable as being + -- volatile to prevent unwanted optimizations. It's a + -- conservative interpretation of RM 13.3(19) for the + -- cases where the compiler cannot detect potential + -- aliasing issues easily and it also covers the case + -- of an absolute address where the volatile aspect is + -- kind of implicit. + + if Ekind (U_Ent) = E_Variable then + Set_Treat_As_Volatile (U_Ent); + end if; end if; -- Overlaying controlled objects is erroneous. -- 2.30.2