2011-08-29 Robert Dewar <dewar@adacore.com>

	* sem_type.adb, einfo.ads, freeze.adb, exp_ch4.adb, sem_ch13.adb:
	Minor reformatting.

2011-08-29  Hristian Kirtchev  <kirtchev@adacore.com>

	* exp_util.adb (Requires_Cleanup_Actions (List_Id, Boolean, Boolean)):
	Correct the check which involves the freeze node of a controlled or
	access-to-controlled type.

2011-08-29  Geert Bosch  <bosch@adacore.com>

	* sem_warn.adb (Check_Code_Statement): Remove check for consecutive Asm
	statements.
	* s-vaflop-vms-alpha.adb: Remove bogus Volatile => True arguments from
	Asm statements.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@178160 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog
index 65e36ed..dd9bef6 100644 (file)
--- a/gcc/ada/ChangeLog
+++ b/gcc/ada/ChangeLog
@@ -1,3 +1,21 @@
+2011-08-29  Robert Dewar  <dewar@adacore.com>
+
+       * sem_type.adb, einfo.ads, freeze.adb, exp_ch4.adb, sem_ch13.adb:
+       Minor reformatting.
+
+2011-08-29  Hristian Kirtchev  <kirtchev@adacore.com>
+
+       * exp_util.adb (Requires_Cleanup_Actions (List_Id, Boolean, Boolean)):
+       Correct the check which involves the freeze node of a controlled or
+       access-to-controlled type.
+
+2011-08-29  Geert Bosch  <bosch@adacore.com>
+
+       * sem_warn.adb (Check_Code_Statement): Remove check for consecutive Asm
+       statements.
+       * s-vaflop-vms-alpha.adb: Remove bogus Volatile => True arguments from
+       Asm statements.
+
 2011-08-29  Yannick Moy  <moy@adacore.com>
 
        * sem_ch3.adb (Array_Type_Declaration): Insert a subtype declaration

diff --git a/gcc/ada/einfo.ads b/gcc/ada/einfo.ads
index b1b1b90..7ed878d 100644 (file)
--- a/gcc/ada/einfo.ads
+++ b/gcc/ada/einfo.ads
@@ -3515,12 +3515,12 @@ package Einfo is
 --       by-reference-type or because it uses explicitly the secondary stack.
 
 --    Reverse_Bit_Order (Flag164) [base type only]
---       Present in all record type entities. Set if a valid pragma an
---       attribute representation clause for Bit_Order has reversed the order
---       of bits from the default value. When this flag is set, a component
---       clause must specify a set of bits entirely contained in a single
---       storage unit (Ada 95) or a single machine scalar (see Ada 2005
---       AI-133), or must occupy in integral number of storage units.
+--       Present in all record type entities. Set if entity has a Bit_Order
+--       aspect (set by an aspect clause or attribute definition clause) that
+--       has reversed the order of bits from the default value. When this flag
+--       is set, a component clause must specify a set of bits entirely within
+--       a single storage unit (Ada 95) or within a single machine scalar (see
+--       Ada 2005 AI-133), or must occupy an integral number of storage units.
 
 --    RM_Size (Uint13)
 --       Present in all type and subtype entities. Contains the value of

diff --git a/gcc/ada/exp_ch4.adb b/gcc/ada/exp_ch4.adb
index 230e76e..ec58d31 100644 (file)
--- a/gcc/ada/exp_ch4.adb
+++ b/gcc/ada/exp_ch4.adb
@@ -6193,6 +6193,12 @@ package body Exp_Ch4 is
    begin
       Binary_Op_Validity_Checks (N);
 
+      --  CodePeer and GNATprove want to see the unexpanded N_Op_Expon node
+
+      if CodePeer_Mode or ALFA_Mode then
+         return;
+      end if;
+
       --  If either operand is of a private type, then we have the use of an
       --  intrinsic operator, and we get rid of the privateness, by using root
       --  types of underlying types for the actual operation. Otherwise the
@@ -6200,18 +6206,10 @@ package body Exp_Ch4 is
       --  shifts etc. We also do this transformation if the result type is
       --  different from the base type.
 
-      if CodePeer_Mode or ALFA_Mode then
-         --  CodePeer and GNATprove want to see the unexpanded N_Op_Expon node
-         return;
-      end if;
-
       if Is_Private_Type (Etype (Base))
-           or else
-         Is_Private_Type (Typ)
-           or else
-         Is_Private_Type (Exptyp)
-           or else
-         Rtyp /= Root_Type (Bastyp)
+        or else Is_Private_Type (Typ)
+        or else Is_Private_Type (Exptyp)
+        or else Rtyp /= Root_Type (Bastyp)
       then
          declare
             Bt : constant Entity_Id := Root_Type (Underlying_Type (Bastyp));

diff --git a/gcc/ada/exp_util.adb b/gcc/ada/exp_util.adb
index 55090e7..2771964 100644 (file)
--- a/gcc/ada/exp_util.adb
+++ b/gcc/ada/exp_util.adb
@@ -6430,13 +6430,15 @@ package body Exp_Util is
          then
             Typ := Entity (Decl);
 
-            if (Is_Access_Type (Typ)
-                  and then not Is_Access_Subprogram_Type (Typ)
-                  and then Needs_Finalization
-                             (Available_View (Designated_Type (Typ))))
-              or else
-               (Is_Type (Typ)
-                  and then Needs_Finalization (Typ))
+            if ((Is_Access_Type (Typ)
+                   and then not Is_Access_Subprogram_Type (Typ)
+                   and then Needs_Finalization
+                              (Available_View (Designated_Type (Typ))))
+                 or else
+                (Is_Type (Typ)
+                   and then Needs_Finalization (Typ)))
+              and then Requires_Cleanup_Actions
+                         (Actions (Decl), For_Package, Nested_Constructs)
             then
                return True;
             end if;

diff --git a/gcc/ada/freeze.adb b/gcc/ada/freeze.adb
index 099f9eb..462ed34 100644 (file)
--- a/gcc/ada/freeze.adb
+++ b/gcc/ada/freeze.adb
@@ -2029,8 +2029,7 @@ package body Freeze is
             Next_Entity (Comp);
          end loop;
 
-         --  Deal with Bit_Order attribute definition specifying a non-default
-         --  bit order.
+         --  Deal with Bit_Order aspect specifying a non-default bit order
 
          if Reverse_Bit_Order (Rec) and then Base_Type (Rec) = Rec then
             if not Placed_Component then

diff --git a/gcc/ada/s-vaflop-vms-alpha.adb b/gcc/ada/s-vaflop-vms-alpha.adb
index 2c1e684..02e4be4 100644 (file)
--- a/gcc/ada/s-vaflop-vms-alpha.adb
+++ b/gcc/ada/s-vaflop-vms-alpha.adb
@@ -6,7 +6,7 @@
 --                                                                          --
 --                                 B o d y                                  --
 --                                                                          --
---          Copyright (C) 1997-2009, Free Software Foundation, Inc.         --
+--          Copyright (C) 1997-2011, Free Software Foundation, Inc.         --
 --                       (Version for Alpha OpenVMS)                        --
 --                                                                          --
 -- GNAT is free software;  you can  redistribute it  and/or modify it under --
@@ -67,12 +67,9 @@ package body System.Vax_Float_Operations is
       A, B : T;
       C    : G;
    begin
-      Asm ("ldg %0,%1", T'Asm_Output ("=f", A), D'Asm_Input ("m", X),
-           Volatile => True);
-      Asm ("cvtdg %1,%0", T'Asm_Output ("=f", B), T'Asm_Input ("f", A),
-           Volatile => True);
-      Asm ("stg %1,%0", G'Asm_Output ("=m", C), T'Asm_Input ("f", B),
-           Volatile => True);
+      Asm ("ldg %0,%1", T'Asm_Output ("=f", A), D'Asm_Input ("m", X));
+      Asm ("cvtdg %1,%0", T'Asm_Output ("=f", B), T'Asm_Input ("f", A));
+      Asm ("stg %1,%0", G'Asm_Output ("=m", C), T'Asm_Input ("f", B));
       return C;
    end D_To_G;
 
@@ -84,10 +81,8 @@ package body System.Vax_Float_Operations is
       A : T;
       B : G;
    begin
-      Asm ("ldf %0,%1", T'Asm_Output ("=f", A), F'Asm_Input ("m", X),
-           Volatile => True);
-      Asm ("stg %1,%0", G'Asm_Output ("=m", B), T'Asm_Input ("f", A),
-           Volatile => True);
+      Asm ("ldf %0,%1", T'Asm_Output ("=f", A), F'Asm_Input ("m", X));
+      Asm ("stg %1,%0", G'Asm_Output ("=m", B), T'Asm_Input ("f", A));
       return B;
    end F_To_G;
 
@@ -103,8 +98,7 @@ package body System.Vax_Float_Operations is
       --  Because converting to a wider FP format is a no-op, we say
       --  A is 64-bit even though we are loading 32 bits into it.
 
-      Asm ("ldf %0,%1", T'Asm_Output ("=f", A), F'Asm_Input ("m", X),
-           Volatile => True);
+      Asm ("ldf %0,%1", T'Asm_Output ("=f", A), F'Asm_Input ("m", X));
 
       B := S (Cvt_G_T (A));
       return B;
@@ -118,12 +112,9 @@ package body System.Vax_Float_Operations is
       A, B : T;
       C    : D;
    begin
-      Asm ("ldg %0,%1", T'Asm_Output ("=f", A), G'Asm_Input ("m", X),
-           Volatile => True);
-      Asm ("cvtgd %1,%0", T'Asm_Output ("=f", B), T'Asm_Input ("f", A),
-           Volatile => True);
-      Asm ("stg %1,%0", D'Asm_Output ("=m", C), T'Asm_Input ("f", B),
-           Volatile => True);
+      Asm ("ldg %0,%1", T'Asm_Output ("=f", A), G'Asm_Input ("m", X));
+      Asm ("cvtgd %1,%0", T'Asm_Output ("=f", B), T'Asm_Input ("f", A));
+      Asm ("stg %1,%0", D'Asm_Output ("=m", C), T'Asm_Input ("f", B));
       return C;
    end G_To_D;
 
@@ -136,12 +127,9 @@ package body System.Vax_Float_Operations is
       B : S;
       C : F;
    begin
-      Asm ("ldg %0,%1", T'Asm_Output ("=f", A), G'Asm_Input ("m", X),
-           Volatile => True);
-      Asm ("cvtgf %1,%0", S'Asm_Output ("=f", B), T'Asm_Input ("f", A),
-           Volatile => True);
-      Asm ("stf %1,%0", F'Asm_Output ("=m", C), S'Asm_Input ("f", B),
-           Volatile => True);
+      Asm ("ldg %0,%1", T'Asm_Output ("=f", A), G'Asm_Input ("m", X));
+      Asm ("cvtgf %1,%0", S'Asm_Output ("=f", B), T'Asm_Input ("f", A));
+      Asm ("stf %1,%0", F'Asm_Output ("=m", C), S'Asm_Input ("f", B));
       return C;
    end G_To_F;
 
@@ -153,10 +141,8 @@ package body System.Vax_Float_Operations is
       A : T;
       B : Q;
    begin
-      Asm ("ldg %0,%1", T'Asm_Output ("=f", A), G'Asm_Input ("m", X),
-           Volatile => True);
-      Asm ("cvtgq %1,%0", Q'Asm_Output ("=f", B), T'Asm_Input ("f", A),
-           Volatile => True);
+      Asm ("ldg %0,%1", T'Asm_Output ("=f", A), G'Asm_Input ("m", X));
+      Asm ("cvtgq %1,%0", Q'Asm_Output ("=f", B), T'Asm_Input ("f", A));
       return B;
    end G_To_Q;
 
@@ -167,8 +153,7 @@ package body System.Vax_Float_Operations is
    function G_To_T (X : G) return T is
       A, B : T;
    begin
-      Asm ("ldg %0,%1", T'Asm_Output ("=f", A), G'Asm_Input ("m", X),
-           Volatile => True);
+      Asm ("ldg %0,%1", T'Asm_Output ("=f", A), G'Asm_Input ("m", X));
       B := Cvt_G_T (A);
       return B;
    end G_To_T;
@@ -190,10 +175,8 @@ package body System.Vax_Float_Operations is
       A : S;
       B : F;
    begin
-      Asm ("cvtqf %1,%0", S'Asm_Output ("=f", A), Q'Asm_Input ("f", X),
-           Volatile => True);
-      Asm ("stf %1,%0", F'Asm_Output ("=m", B), S'Asm_Input ("f", A),
-           Volatile => True);
+      Asm ("cvtqf %1,%0", S'Asm_Output ("=f", A), Q'Asm_Input ("f", X));
+      Asm ("stf %1,%0", F'Asm_Output ("=m", B), S'Asm_Input ("f", A));
       return B;
    end Q_To_F;
 
@@ -205,10 +188,8 @@ package body System.Vax_Float_Operations is
       A : T;
       B : G;
    begin
-      Asm ("cvtqg %1,%0", T'Asm_Output ("=f", A), Q'Asm_Input ("f", X),
-           Volatile => True);
-      Asm ("stg %1,%0", G'Asm_Output ("=m", B), T'Asm_Input ("f", A),
-           Volatile => True);
+      Asm ("cvtqg %1,%0", T'Asm_Output ("=f", A), Q'Asm_Input ("f", X));
+      Asm ("stg %1,%0", G'Asm_Output ("=m", B), T'Asm_Input ("f", A));
       return B;
    end Q_To_G;
 
@@ -221,8 +202,7 @@ package body System.Vax_Float_Operations is
       B : F;
    begin
       A := Cvt_T_F (T (X));
-      Asm ("stf %1,%0", F'Asm_Output ("=m", B), S'Asm_Input ("f", A),
-           Volatile => True);
+      Asm ("stf %1,%0", F'Asm_Output ("=m", B), S'Asm_Input ("f", A));
       return B;
    end S_To_F;
 
@@ -244,8 +224,7 @@ package body System.Vax_Float_Operations is
       B : G;
    begin
       A := Cvt_T_G (X);
-      Asm ("stg %1,%0", G'Asm_Output ("=m", B), T'Asm_Input ("f", A),
-           Volatile => True);
+      Asm ("stg %1,%0", G'Asm_Output ("=m", B), T'Asm_Input ("f", A));
       return B;
    end T_To_G;
 
@@ -257,12 +236,9 @@ package body System.Vax_Float_Operations is
       A, B : S;
       C    : F;
    begin
-      Asm ("ldf %0,%1", S'Asm_Output ("=f", A), F'Asm_Input ("m", X),
-           Volatile => True);
-      Asm ("cpys $f31,%1,%0", S'Asm_Output ("=f", B), S'Asm_Input ("f", A),
-           Volatile => True);
-      Asm ("stf %1,%0", F'Asm_Output ("=m", C), S'Asm_Input ("f", B),
-           Volatile => True);
+      Asm ("ldf %0,%1", S'Asm_Output ("=f", A), F'Asm_Input ("m", X));
+      Asm ("cpys $f31,%1,%0", S'Asm_Output ("=f", B), S'Asm_Input ("f", A));
+      Asm ("stf %1,%0", F'Asm_Output ("=m", C), S'Asm_Input ("f", B));
       return C;
    end Abs_F;
 
@@ -275,10 +251,8 @@ package body System.Vax_Float_Operations is
       C    : G;
    begin
       Asm ("ldg %0,%1", T'Asm_Output ("=f", A), G'Asm_Input ("m", X));
-      Asm ("cpys $f31,%1,%0", T'Asm_Output ("=f", B), T'Asm_Input ("f", A),
-           Volatile => True);
-      Asm ("stg %1,%0", G'Asm_Output ("=m", C), T'Asm_Input ("f", B),
-           Volatile => True);
+      Asm ("cpys $f31,%1,%0", T'Asm_Output ("=f", B), T'Asm_Input ("f", A));
+      Asm ("stg %1,%0", G'Asm_Output ("=m", C), T'Asm_Input ("f", B));
       return C;
    end Abs_G;
 
@@ -291,13 +265,10 @@ package body System.Vax_Float_Operations is
       R1        : F;
    begin
       Asm ("ldf %0,%1", S'Asm_Output ("=f", X1), F'Asm_Input ("m", X));
-      Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y),
-           Volatile => True);
+      Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y));
       Asm ("addf %1,%2,%0", S'Asm_Output ("=f", R),
-           (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)),
-           Volatile => True);
-      Asm ("stf %1,%0", F'Asm_Output ("=m", R1), S'Asm_Input ("f", R),
-           Volatile => True);
+           (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)));
+      Asm ("stf %1,%0", F'Asm_Output ("=m", R1), S'Asm_Input ("f", R));
       return R1;
    end Add_F;
 
@@ -310,13 +281,10 @@ package body System.Vax_Float_Operations is
       R1        : G;
    begin
       Asm ("ldg %0,%1", T'Asm_Output ("=f", X1), G'Asm_Input ("m", X));
-      Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y),
-           Volatile => True);
+      Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y));
       Asm ("addg %1,%2,%0", T'Asm_Output ("=f", R),
-           (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)),
-           Volatile => True);
-      Asm ("stg %1,%0", G'Asm_Output ("=m", R1), T'Asm_Input ("f", R),
-           Volatile => True);
+           (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)));
+      Asm ("stg %1,%0", G'Asm_Output ("=m", R1), T'Asm_Input ("f", R));
       return R1;
    end Add_G;
 
@@ -392,13 +360,10 @@ package body System.Vax_Float_Operations is
       R1        : F;
    begin
       Asm ("ldf %0,%1", S'Asm_Output ("=f", X1), F'Asm_Input ("m", X));
-      Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y),
-           Volatile => True);
+      Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y));
       Asm ("divf %1,%2,%0", S'Asm_Output ("=f", R),
-           (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)),
-           Volatile => True);
-      Asm ("stf %1,%0", F'Asm_Output ("=m", R1), S'Asm_Input ("f", R),
-           Volatile => True);
+           (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)));
+      Asm ("stf %1,%0", F'Asm_Output ("=m", R1), S'Asm_Input ("f", R));
       return R1;
    end Div_F;
 
@@ -411,13 +376,10 @@ package body System.Vax_Float_Operations is
       R1        : G;
    begin
       Asm ("ldg %0,%1", T'Asm_Output ("=f", X1), G'Asm_Input ("m", X));
-      Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y),
-           Volatile => True);
+      Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y));
       Asm ("divg %1,%2,%0", T'Asm_Output ("=f", R),
-           (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)),
-           Volatile => True);
-      Asm ("stg %1,%0", G'Asm_Output ("=m", R1), T'Asm_Input ("f", R),
-           Volatile => True);
+           (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)));
+      Asm ("stg %1,%0", G'Asm_Output ("=m", R1), T'Asm_Input ("f", R));
       return R1;
    end Div_G;
 
@@ -429,11 +391,9 @@ package body System.Vax_Float_Operations is
       X1, Y1, R : S;
    begin
       Asm ("ldf %0,%1", S'Asm_Output ("=f", X1), F'Asm_Input ("m", X));
-      Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y),
-           Volatile => True);
+      Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y));
       Asm ("cmpgeq %1,%2,%0", S'Asm_Output ("=f", R),
-           (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)),
-           Volatile => True);
+           (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)));
       return R /= 0.0;
    end Eq_F;
 
@@ -445,11 +405,9 @@ package body System.Vax_Float_Operations is
       X1, Y1, R : T;
    begin
       Asm ("ldg %0,%1", T'Asm_Output ("=f", X1), G'Asm_Input ("m", X));
-      Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y),
-           Volatile => True);
+      Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y));
       Asm ("cmpgeq %1,%2,%0", T'Asm_Output ("=f", R),
-           (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)),
-           Volatile => True);
+           (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)));
       return R /= 0.0;
    end Eq_G;
 
@@ -461,11 +419,9 @@ package body System.Vax_Float_Operations is
       X1, Y1, R : S;
    begin
       Asm ("ldf %0,%1", S'Asm_Output ("=f", X1), F'Asm_Input ("m", X));
-      Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y),
-           Volatile => True);
+      Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y));
       Asm ("cmpgle %1,%2,%0", S'Asm_Output ("=f", R),
-           (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)),
-           Volatile => True);
+           (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)));
       return R /= 0.0;
    end Le_F;
 
@@ -477,11 +433,9 @@ package body System.Vax_Float_Operations is
       X1, Y1, R : T;
    begin
       Asm ("ldg %0,%1", T'Asm_Output ("=f", X1), G'Asm_Input ("m", X));
-      Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y),
-           Volatile => True);
+      Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y));
       Asm ("cmpgle %1,%2,%0", T'Asm_Output ("=f", R),
-           (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)),
-           Volatile => True);
+           (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)));
       return R /= 0.0;
    end Le_G;
 
@@ -493,11 +447,9 @@ package body System.Vax_Float_Operations is
       X1, Y1, R : S;
    begin
       Asm ("ldf %0,%1", S'Asm_Output ("=f", X1), F'Asm_Input ("m", X));
-      Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y),
-           Volatile => True);
+      Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y));
       Asm ("cmpglt %1,%2,%0", S'Asm_Output ("=f", R),
-           (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)),
-           Volatile => True);
+           (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)));
       return R /= 0.0;
    end Lt_F;
 
@@ -509,11 +461,9 @@ package body System.Vax_Float_Operations is
       X1, Y1, R : T;
    begin
       Asm ("ldg %0,%1", T'Asm_Output ("=f", X1), G'Asm_Input ("m", X));
-      Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y),
-           Volatile => True);
+      Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y));
       Asm ("cmpglt %1,%2,%0", T'Asm_Output ("=f", R),
-           (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)),
-           Volatile => True);
+           (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)));
       return R /= 0.0;
    end Lt_G;
 
@@ -526,13 +476,10 @@ package body System.Vax_Float_Operations is
       R1        : F;
    begin
       Asm ("ldf %0,%1", S'Asm_Output ("=f", X1), F'Asm_Input ("m", X));
-      Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y),
-           Volatile => True);
+      Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y));
       Asm ("mulf %1,%2,%0", S'Asm_Output ("=f", R),
-           (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)),
-           Volatile => True);
-      Asm ("stf %1,%0", F'Asm_Output ("=m", R1), S'Asm_Input ("f", R),
-           Volatile => True);
+           (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)));
+      Asm ("stf %1,%0", F'Asm_Output ("=m", R1), S'Asm_Input ("f", R));
       return R1;
    end Mul_F;
 
@@ -545,13 +492,10 @@ package body System.Vax_Float_Operations is
       R1        : G;
    begin
       Asm ("ldg %0,%1", T'Asm_Output ("=f", X1), G'Asm_Input ("m", X));
-      Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y),
-           Volatile => True);
+      Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y));
       Asm ("mulg %1,%2,%0", T'Asm_Output ("=f", R),
-           (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)),
-           Volatile => True);
-      Asm ("stg %1,%0", G'Asm_Output ("=m", R1), T'Asm_Input ("f", R),
-           Volatile => True);
+           (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)));
+      Asm ("stg %1,%0", G'Asm_Output ("=m", R1), T'Asm_Input ("f", R));
       return R1;
    end Mul_G;
 
@@ -563,11 +507,9 @@ package body System.Vax_Float_Operations is
       X1, Y1, R : S;
    begin
       Asm ("ldf %0,%1", S'Asm_Output ("=f", X1), F'Asm_Input ("m", X));
-      Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y),
-           Volatile => True);
+      Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y));
       Asm ("cmpgeq %1,%2,%0", S'Asm_Output ("=f", R),
-           (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)),
-           Volatile => True);
+           (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)));
       return R = 0.0;
    end Ne_F;
 
@@ -579,11 +521,9 @@ package body System.Vax_Float_Operations is
       X1, Y1, R : T;
    begin
       Asm ("ldg %0,%1", T'Asm_Output ("=f", X1), G'Asm_Input ("m", X));
-      Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y),
-           Volatile => True);
+      Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y));
       Asm ("cmpgeq %1,%2,%0", T'Asm_Output ("=f", R),
-           (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)),
-           Volatile => True);
+           (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)));
       return R = 0.0;
    end Ne_G;
 
@@ -596,10 +536,8 @@ package body System.Vax_Float_Operations is
       C    : F;
    begin
       Asm ("ldf %0,%1", S'Asm_Output ("=f", A), F'Asm_Input ("m", X));
-      Asm ("cpysn %1,%1,%0", S'Asm_Output ("=f", B), S'Asm_Input ("f", A),
-           Volatile => True);
-      Asm ("stf %1,%0", F'Asm_Output ("=m", C), S'Asm_Input ("f", B),
-           Volatile => True);
+      Asm ("cpysn %1,%1,%0", S'Asm_Output ("=f", B), S'Asm_Input ("f", A));
+      Asm ("stf %1,%0", F'Asm_Output ("=m", C), S'Asm_Input ("f", B));
       return C;
    end Neg_F;
 
@@ -612,10 +550,8 @@ package body System.Vax_Float_Operations is
       C    : G;
    begin
       Asm ("ldg %0,%1", T'Asm_Output ("=f", A), G'Asm_Input ("m", X));
-      Asm ("cpysn %1,%1,%0", T'Asm_Output ("=f", B), T'Asm_Input ("f", A),
-           Volatile => True);
-      Asm ("stg %1,%0", G'Asm_Output ("=m", C), T'Asm_Input ("f", B),
-           Volatile => True);
+      Asm ("cpysn %1,%1,%0", T'Asm_Output ("=f", B), T'Asm_Input ("f", A));
+      Asm ("stg %1,%0", G'Asm_Output ("=m", C), T'Asm_Input ("f", B));
       return C;
    end Neg_G;
 
@@ -652,13 +588,11 @@ package body System.Vax_Float_Operations is
 
    function Return_D (X : D) return D is
       R : D;
-
    begin
       --  The return value is already in $f0 so we need to trick the compiler
       --  into thinking that we're moving X to $f0.
-
       Asm ("cvtdg $f0,$f0", Inputs => D'Asm_Input ("g", X), Clobber => "$f0",
-           Volatile => True);
+        Volatile => True);
       Asm ("stg $f0,%0", D'Asm_Output ("=m", R), Volatile => True);
       return R;
    end Return_D;
@@ -669,13 +603,11 @@ package body System.Vax_Float_Operations is
 
    function Return_F (X : F) return F is
       R : F;
-
    begin
       --  The return value is already in $f0 so we need to trick the compiler
       --  into thinking that we're moving X to $f0.
-
       Asm ("stf $f0,%0", F'Asm_Output ("=m", R), F'Asm_Input ("g", X),
-           Clobber => "$f0", Volatile => True);
+        Clobber => "$f0", Volatile => True);
       return R;
    end Return_F;
 
@@ -685,13 +617,11 @@ package body System.Vax_Float_Operations is
 
    function Return_G (X : G) return G is
       R : G;
-
    begin
       --  The return value is already in $f0 so we need to trick the compiler
       --  into thinking that we're moving X to $f0.
-
       Asm ("stg $f0,%0", G'Asm_Output ("=m", R), G'Asm_Input ("g", X),
-           Clobber => "$f0", Volatile => True);
+        Clobber => "$f0", Volatile => True);
       return R;
    end Return_G;
 
@@ -705,13 +635,10 @@ package body System.Vax_Float_Operations is
 
    begin
       Asm ("ldf %0,%1", S'Asm_Output ("=f", X1), F'Asm_Input ("m", X));
-      Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y),
-           Volatile => True);
+      Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y));
       Asm ("subf %1,%2,%0", S'Asm_Output ("=f", R),
-           (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)),
-           Volatile => True);
-      Asm ("stf %1,%0", F'Asm_Output ("=m", R1), S'Asm_Input ("f", R),
-           Volatile => True);
+           (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)));
+      Asm ("stf %1,%0", F'Asm_Output ("=m", R1), S'Asm_Input ("f", R));
       return R1;
    end Sub_F;
 
@@ -724,13 +651,10 @@ package body System.Vax_Float_Operations is
       R1        : G;
    begin
       Asm ("ldg %0,%1", T'Asm_Output ("=f", X1), G'Asm_Input ("m", X));
-      Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y),
-           Volatile => True);
+      Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y));
       Asm ("subg %1,%2,%0", T'Asm_Output ("=f", R),
-           (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)),
-           Volatile => True);
-      Asm ("stg %1,%0", G'Asm_Output ("=m", R1), T'Asm_Input ("f", R),
-           Volatile => True);
+           (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)));
+      Asm ("stg %1,%0", G'Asm_Output ("=m", R1), T'Asm_Input ("f", R));
       return R1;
    end Sub_G;
 

diff --git a/gcc/ada/sem_ch13.adb b/gcc/ada/sem_ch13.adb
index 8d6bde5..abaf415 100644 (file)
--- a/gcc/ada/sem_ch13.adb
+++ b/gcc/ada/sem_ch13.adb
@@ -235,7 +235,7 @@ package body Sem_Ch13 is
       --  Processing depends on version of Ada
 
       --  For Ada 95, we just renumber bits within a storage unit. We do the
-      --  same for Ada 83 mode, since we recognize attribute Bit_Order in
+      --  same for Ada 83 mode, since we recognize the Bit_Order attribute in
       --  Ada 83, and are free to add this extension.
 
       if Ada_Version < Ada_2005 then

diff --git a/gcc/ada/sem_type.adb b/gcc/ada/sem_type.adb
index c4d42a3..28b161c 100644 (file)
--- a/gcc/ada/sem_type.adb
+++ b/gcc/ada/sem_type.adb
@@ -627,7 +627,7 @@ package body Sem_Type is
                      --  within the instance must not be included.
 
                      if (Scope (H) = Scope (Ent)
-                           or else Scope (H) = Scope (Scope (Ent)))
+                          or else Scope (H) = Scope (Scope (Ent)))
                         and then In_Instance
                         and then H /= Renamed_Entity (Ent)
                         and then not Is_Inherited_Operation (H)

diff --git a/gcc/ada/sem_warn.adb b/gcc/ada/sem_warn.adb
index fe5f38b..0fee04c 100644 (file)
--- a/gcc/ada/sem_warn.adb
+++ b/gcc/ada/sem_warn.adb
@@ -211,18 +211,6 @@ package body Sem_Warn is
            ("?code statement with no outputs should usually be Volatile!", N);
          return;
       end if;
-
-      --  Check multiple code statements in a row
-
-      if Is_List_Member (N)
-        and then Present (Prev (N))
-        and then Nkind (Prev (N)) = N_Code_Statement
-      then
-         Error_Msg_F
-           ("?code statements in sequence should usually be Volatile!", N);
-         Error_Msg_F
-           ("\?(suggest using template with multiple instructions)!", N);
-      end if;
    end Check_Code_Statement;
 
    ---------------------------------