OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

[multiple changes]

Browse Source 
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.

From-SVN: r178160
This commit is contained in:
Arnaud Charlet 2011-08-29 10:32:46 +02:00
parent cf161d6620
commit 8f66cda7be
9 changed files with 119 additions and 190 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
gcc/ada/ChangeLog
View File

@ -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

12
gcc/ada/einfo.ads
View File

@ -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

20
gcc/ada/exp_ch4.adb
View File

@ -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));

16
gcc/ada/exp_util.adb
View File

@ -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;

3
gcc/ada/freeze.adb
View File

@ -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

224
gcc/ada/s-vaflop-vms-alpha.adb
View File

@ -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;

2
gcc/ada/sem_ch13.adb
View File

@ -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

2
gcc/ada/sem_type.adb
View File

@ -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)

12
gcc/ada/sem_warn.adb
View File

@ -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;
---------------------------------