-- --
-- B o d y --
-- --
--- Copyright (C) 1997-2005, Free Software Foundation, Inc. --
+-- Copyright (C) 1997-2009, Free Software Foundation, Inc. --
-- (Version for Alpha OpenVMS) --
-- --
-- GNAT is free software; you can redistribute it and/or modify it under --
-- terms of the GNU General Public License as published by the Free Soft- --
--- ware Foundation; either version 2, or (at your option) any later ver- --
+-- ware Foundation; either version 3, or (at your option) any later ver- --
-- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
--- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License --
--- for more details. You should have received a copy of the GNU General --
--- Public License distributed with GNAT; see file COPYING. If not, write --
--- to the Free Software Foundation, 51 Franklin Street, Fifth Floor, --
--- Boston, MA 02110-1301, USA. --
+-- or FITNESS FOR A PARTICULAR PURPOSE. --
-- --
--- As a special exception, if other files instantiate generics from this --
--- unit, or you link this unit with other files to produce an executable, --
--- this unit does not by itself cause the resulting executable to be --
--- covered by the GNU General Public License. This exception does not --
--- however invalidate any other reasons why the executable file might be --
--- covered by the GNU Public License. --
+-- As a special exception under Section 7 of GPL version 3, you are granted --
+-- additional permissions described in the GCC Runtime Library Exception, --
+-- version 3.1, as published by the Free Software Foundation. --
+-- --
+-- You should have received a copy of the GNU General Public License and --
+-- a copy of the GCC Runtime Library Exception along with this program; --
+-- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see --
+-- <http://www.gnu.org/licenses/>. --
-- --
-- GNAT was originally developed by the GNAT team at New York University. --
-- Extensive contributions were provided by Ada Core Technologies Inc. --
-- --
------------------------------------------------------------------------------
-with System.IO; use System.IO;
+with System.IO;
with System.Machine_Code; use System.Machine_Code;
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));
- 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));
+ 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);
return C;
end D_To_G;
A : T;
B : G;
begin
- 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));
+ 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);
return B;
end F_To_G;
-- 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));
+ Asm ("ldf %0,%1", T'Asm_Output ("=f", A), F'Asm_Input ("m", X),
+ Volatile => True);
B := S (Cvt_G_T (A));
return B;
A, B : T;
C : D;
begin
- 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));
+ 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);
return C;
end G_To_D;
B : S;
C : F;
begin
- 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));
+ 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);
return C;
end G_To_F;
A : T;
B : Q;
begin
- 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));
+ 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);
return B;
end G_To_Q;
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));
+ Asm ("ldg %0,%1", T'Asm_Output ("=f", A), G'Asm_Input ("m", X),
+ Volatile => True);
B := Cvt_G_T (A);
return B;
end G_To_T;
A : S;
B : F;
begin
- 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));
+ 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);
return B;
end Q_To_F;
A : T;
B : G;
begin
- 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));
+ 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);
return B;
end Q_To_G;
B : F;
begin
A := Cvt_T_F (T (X));
- Asm ("stf %1,%0", F'Asm_Output ("=m", B), S'Asm_Input ("f", A));
+ Asm ("stf %1,%0", F'Asm_Output ("=m", B), S'Asm_Input ("f", A),
+ Volatile => True);
return B;
end S_To_F;
B : G;
begin
A := Cvt_T_G (X);
- Asm ("stg %1,%0", G'Asm_Output ("=m", B), T'Asm_Input ("f", A));
+ Asm ("stg %1,%0", G'Asm_Output ("=m", B), T'Asm_Input ("f", A),
+ Volatile => True);
return B;
end T_To_G;
A, B : S;
C : F;
begin
- 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));
+ 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);
return C;
end Abs_F;
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));
- Asm ("stg %1,%0", G'Asm_Output ("=m", C), T'Asm_Input ("f", B));
+ 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);
return C;
end Abs_G;
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));
+ Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y),
+ Volatile => True);
Asm ("addf %1,%2,%0", S'Asm_Output ("=f", R),
- (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)));
- Asm ("stf %1,%0", F'Asm_Output ("=m", R1), S'Asm_Input ("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);
return R1;
end Add_F;
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));
+ Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y),
+ Volatile => True);
Asm ("addg %1,%2,%0", T'Asm_Output ("=f", R),
- (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)));
- Asm ("stg %1,%0", G'Asm_Output ("=m", R1), T'Asm_Input ("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);
return R1;
end Add_G;
procedure Debug_Output_D (Arg : D) is
begin
- Put (D'Image (Arg));
+ System.IO.Put (D'Image (Arg));
end Debug_Output_D;
--------------------
procedure Debug_Output_F (Arg : F) is
begin
- Put (F'Image (Arg));
+ System.IO.Put (F'Image (Arg));
end Debug_Output_F;
--------------------
procedure Debug_Output_G (Arg : G) is
begin
- Put (G'Image (Arg));
+ System.IO.Put (G'Image (Arg));
end Debug_Output_G;
--------------------
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));
+ Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y),
+ Volatile => True);
Asm ("divf %1,%2,%0", S'Asm_Output ("=f", R),
- (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)));
- Asm ("stf %1,%0", F'Asm_Output ("=m", R1), S'Asm_Input ("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);
return R1;
end Div_F;
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));
+ Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y),
+ Volatile => True);
Asm ("divg %1,%2,%0", T'Asm_Output ("=f", R),
- (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)));
- Asm ("stg %1,%0", G'Asm_Output ("=m", R1), T'Asm_Input ("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);
return R1;
end Div_G;
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));
+ Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y),
+ Volatile => True);
Asm ("cmpgeq %1,%2,%0", S'Asm_Output ("=f", R),
- (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)));
+ (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)),
+ Volatile => True);
return R /= 0.0;
end Eq_F;
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));
+ Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y),
+ Volatile => True);
Asm ("cmpgeq %1,%2,%0", T'Asm_Output ("=f", R),
- (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)));
+ (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)),
+ Volatile => True);
return R /= 0.0;
end Eq_G;
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));
+ Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y),
+ Volatile => True);
Asm ("cmpgle %1,%2,%0", S'Asm_Output ("=f", R),
- (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)));
+ (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)),
+ Volatile => True);
return R /= 0.0;
end Le_F;
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));
+ Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y),
+ Volatile => True);
Asm ("cmpgle %1,%2,%0", T'Asm_Output ("=f", R),
- (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)));
+ (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)),
+ Volatile => True);
return R /= 0.0;
end Le_G;
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));
+ Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y),
+ Volatile => True);
Asm ("cmpglt %1,%2,%0", S'Asm_Output ("=f", R),
- (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)));
+ (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)),
+ Volatile => True);
return R /= 0.0;
end Lt_F;
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));
+ Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y),
+ Volatile => True);
Asm ("cmpglt %1,%2,%0", T'Asm_Output ("=f", R),
- (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)));
+ (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)),
+ Volatile => True);
return R /= 0.0;
end Lt_G;
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));
+ Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y),
+ Volatile => True);
Asm ("mulf %1,%2,%0", S'Asm_Output ("=f", R),
- (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)));
- Asm ("stf %1,%0", F'Asm_Output ("=m", R1), S'Asm_Input ("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);
return R1;
end Mul_F;
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));
+ Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y),
+ Volatile => True);
Asm ("mulg %1,%2,%0", T'Asm_Output ("=f", R),
- (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)));
- Asm ("stg %1,%0", G'Asm_Output ("=m", R1), T'Asm_Input ("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);
return R1;
end Mul_G;
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));
+ Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y),
+ Volatile => True);
Asm ("cmpgeq %1,%2,%0", S'Asm_Output ("=f", R),
- (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)));
+ (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)),
+ Volatile => True);
return R = 0.0;
end Ne_F;
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));
+ Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y),
+ Volatile => True);
Asm ("cmpgeq %1,%2,%0", T'Asm_Output ("=f", R),
- (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)));
+ (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)),
+ Volatile => True);
return R = 0.0;
end Ne_G;
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));
- Asm ("stf %1,%0", F'Asm_Output ("=m", C), S'Asm_Input ("f", B));
+ 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);
return C;
end Neg_F;
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));
- Asm ("stg %1,%0", G'Asm_Output ("=m", C), T'Asm_Input ("f", B));
+ 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);
return C;
end Neg_G;
procedure pd (Arg : D) is
begin
- Put_Line (D'Image (Arg));
+ System.IO.Put_Line (D'Image (Arg));
end pd;
--------
procedure pf (Arg : F) is
begin
- Put_Line (F'Image (Arg));
+ System.IO.Put_Line (F'Image (Arg));
end pf;
--------
procedure pg (Arg : G) is
begin
- Put_Line (G'Image (Arg));
+ System.IO.Put_Line (G'Image (Arg));
end pg;
+ --------------
+ -- Return_D --
+ --------------
+
+ 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);
+ Asm ("stg $f0,%0", D'Asm_Output ("=m", R), Volatile => True);
+ return R;
+ end Return_D;
+
+ --------------
+ -- Return_F --
+ --------------
+
+ 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);
+ return R;
+ end Return_F;
+
+ --------------
+ -- Return_G --
+ --------------
+
+ 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);
+ return R;
+ end Return_G;
+
-----------
-- Sub_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));
+ Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y),
+ Volatile => True);
Asm ("subf %1,%2,%0", S'Asm_Output ("=f", R),
- (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)));
- Asm ("stf %1,%0", F'Asm_Output ("=m", R1), S'Asm_Input ("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);
return R1;
end Sub_F;
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));
+ Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y),
+ Volatile => True);
Asm ("subg %1,%2,%0", T'Asm_Output ("=f", R),
- (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)));
- Asm ("stg %1,%0", G'Asm_Output ("=m", R1), T'Asm_Input ("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);
return R1;
end Sub_G;
OSDN Git Service
