URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [tags/] [gnu-src/] [gcc-4.5.1/] [gcc-4.5.1-or32-1.0rc3/] [gcc/] [ada/] [s-vaflop-vms-alpha.adb] - Rev 281
Go to most recent revision | Compare with Previous | Blame | View Log
------------------------------------------------------------------------------ -- -- -- GNAT COMPILER COMPONENTS -- -- -- -- S Y S T E M . V A X _ F L O A T _ O P E R A T I O N S -- -- -- -- B o d y -- -- -- -- 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 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. -- -- -- -- 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; with System.Machine_Code; use System.Machine_Code; package body System.Vax_Float_Operations is -- Ensure this gets compiled with -O to avoid extra (and possibly -- improper) memory stores. pragma Optimize (Time); -- Declare the functions that do the conversions between floating-point -- formats. Call the operands IEEE float so they get passed in -- FP registers. function Cvt_G_T (X : T) return T; function Cvt_T_G (X : T) return T; function Cvt_T_F (X : T) return S; pragma Import (C, Cvt_G_T, "OTS$CVT_FLOAT_G_T"); pragma Import (C, Cvt_T_G, "OTS$CVT_FLOAT_T_G"); pragma Import (C, Cvt_T_F, "OTS$CVT_FLOAT_T_F"); -- In each of the conversion routines that are done with OTS calls, -- we define variables of the corresponding IEEE type so that they are -- passed and kept in the proper register class. Debug_String_Buffer : String (1 .. 32); -- Buffer used by all Debug_String_x routines for returning result ------------ -- D_To_G -- ------------ function D_To_G (X : D) return G 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); return C; end D_To_G; ------------ -- F_To_G -- ------------ function F_To_G (X : F) return G 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); return B; end F_To_G; ------------ -- F_To_S -- ------------ function F_To_S (X : F) return S is A : T; B : S; begin -- 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); B := S (Cvt_G_T (A)); return B; end F_To_S; ------------ -- G_To_D -- ------------ function G_To_D (X : G) return D 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); return C; end G_To_D; ------------ -- G_To_F -- ------------ function G_To_F (X : G) return F is A : T; 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); return C; end G_To_F; ------------ -- G_To_Q -- ------------ function G_To_Q (X : G) return Q 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); return B; end G_To_Q; ------------ -- G_To_T -- ------------ 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); B := Cvt_G_T (A); return B; end G_To_T; ------------ -- F_To_Q -- ------------ function F_To_Q (X : F) return Q is begin return G_To_Q (F_To_G (X)); end F_To_Q; ------------ -- Q_To_F -- ------------ function Q_To_F (X : Q) return F 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); return B; end Q_To_F; ------------ -- Q_To_G -- ------------ function Q_To_G (X : Q) return G 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); return B; end Q_To_G; ------------ -- S_To_F -- ------------ function S_To_F (X : S) return F is A : S; 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); return B; end S_To_F; ------------ -- T_To_D -- ------------ function T_To_D (X : T) return D is begin return G_To_D (T_To_G (X)); end T_To_D; ------------ -- T_To_G -- ------------ function T_To_G (X : T) return G is A : T; B : G; begin A := Cvt_T_G (X); Asm ("stg %1,%0", G'Asm_Output ("=m", B), T'Asm_Input ("f", A), Volatile => True); return B; end T_To_G; ----------- -- Abs_F -- ----------- function Abs_F (X : F) return F 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); return C; end Abs_F; ----------- -- Abs_G -- ----------- function Abs_G (X : G) return G is A, B : T; 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); return C; end Abs_G; ----------- -- Add_F -- ----------- function Add_F (X, Y : F) return F is X1, Y1, R : S; 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 ("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); return R1; end Add_F; ----------- -- Add_G -- ----------- function Add_G (X, Y : G) return G is X1, Y1, R : T; 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 ("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); return R1; end Add_G; -------------------- -- Debug_Output_D -- -------------------- procedure Debug_Output_D (Arg : D) is begin System.IO.Put (D'Image (Arg)); end Debug_Output_D; -------------------- -- Debug_Output_F -- -------------------- procedure Debug_Output_F (Arg : F) is begin System.IO.Put (F'Image (Arg)); end Debug_Output_F; -------------------- -- Debug_Output_G -- -------------------- procedure Debug_Output_G (Arg : G) is begin System.IO.Put (G'Image (Arg)); end Debug_Output_G; -------------------- -- Debug_String_D -- -------------------- function Debug_String_D (Arg : D) return System.Address is Image_String : constant String := D'Image (Arg) & ASCII.NUL; Image_Size : constant Integer := Image_String'Length; begin Debug_String_Buffer (1 .. Image_Size) := Image_String; return Debug_String_Buffer (1)'Address; end Debug_String_D; -------------------- -- Debug_String_F -- -------------------- function Debug_String_F (Arg : F) return System.Address is Image_String : constant String := F'Image (Arg) & ASCII.NUL; Image_Size : constant Integer := Image_String'Length; begin Debug_String_Buffer (1 .. Image_Size) := Image_String; return Debug_String_Buffer (1)'Address; end Debug_String_F; -------------------- -- Debug_String_G -- -------------------- function Debug_String_G (Arg : G) return System.Address is Image_String : constant String := G'Image (Arg) & ASCII.NUL; Image_Size : constant Integer := Image_String'Length; begin Debug_String_Buffer (1 .. Image_Size) := Image_String; return Debug_String_Buffer (1)'Address; end Debug_String_G; ----------- -- Div_F -- ----------- function Div_F (X, Y : F) return F is X1, Y1, R : S; 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 ("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); return R1; end Div_F; ----------- -- Div_G -- ----------- function Div_G (X, Y : G) return G is X1, Y1, R : T; 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 ("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); return R1; end Div_G; ---------- -- Eq_F -- ---------- function Eq_F (X, Y : F) return Boolean 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 ("cmpgeq %1,%2,%0", S'Asm_Output ("=f", R), (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)), Volatile => True); return R /= 0.0; end Eq_F; ---------- -- Eq_G -- ---------- function Eq_G (X, Y : G) return Boolean 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 ("cmpgeq %1,%2,%0", T'Asm_Output ("=f", R), (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)), Volatile => True); return R /= 0.0; end Eq_G; ---------- -- Le_F -- ---------- function Le_F (X, Y : F) return Boolean 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 ("cmpgle %1,%2,%0", S'Asm_Output ("=f", R), (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)), Volatile => True); return R /= 0.0; end Le_F; ---------- -- Le_G -- ---------- function Le_G (X, Y : G) return Boolean 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 ("cmpgle %1,%2,%0", T'Asm_Output ("=f", R), (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)), Volatile => True); return R /= 0.0; end Le_G; ---------- -- Lt_F -- ---------- function Lt_F (X, Y : F) return Boolean 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 ("cmpglt %1,%2,%0", S'Asm_Output ("=f", R), (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)), Volatile => True); return R /= 0.0; end Lt_F; ---------- -- Lt_G -- ---------- function Lt_G (X, Y : G) return Boolean 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 ("cmpglt %1,%2,%0", T'Asm_Output ("=f", R), (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)), Volatile => True); return R /= 0.0; end Lt_G; ----------- -- Mul_F -- ----------- function Mul_F (X, Y : F) return F is X1, Y1, R : S; 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 ("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); return R1; end Mul_F; ----------- -- Mul_G -- ----------- function Mul_G (X, Y : G) return G is X1, Y1, R : T; 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 ("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); return R1; end Mul_G; ---------- -- Ne_F -- ---------- function Ne_F (X, Y : F) return Boolean 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 ("cmpgeq %1,%2,%0", S'Asm_Output ("=f", R), (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)), Volatile => True); return R = 0.0; end Ne_F; ---------- -- Ne_G -- ---------- function Ne_G (X, Y : G) return Boolean 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 ("cmpgeq %1,%2,%0", T'Asm_Output ("=f", R), (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)), Volatile => True); return R = 0.0; end Ne_G; ----------- -- Neg_F -- ----------- function Neg_F (X : F) return F is A, B : S; 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); return C; end Neg_F; ----------- -- Neg_G -- ----------- function Neg_G (X : G) return G is A, B : T; 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); return C; end Neg_G; -------- -- pd -- -------- procedure pd (Arg : D) is begin System.IO.Put_Line (D'Image (Arg)); end pd; -------- -- pf -- -------- procedure pf (Arg : F) is begin System.IO.Put_Line (F'Image (Arg)); end pf; -------- -- pg -- -------- procedure pg (Arg : G) is begin 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 -- ----------- function Sub_F (X, Y : F) return F is X1, Y1, R : S; 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 ("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); return R1; end Sub_F; ----------- -- Sub_G -- ----------- function Sub_G (X, Y : G) return G is X1, Y1, R : T; 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 ("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); return R1; end Sub_G; ------------- -- Valid_D -- ------------- -- For now, convert to IEEE and do Valid test on result. This is not quite -- accurate, but is good enough in practice. function Valid_D (Arg : D) return Boolean is Val : constant T := G_To_T (D_To_G (Arg)); begin return Val'Valid; end Valid_D; ------------- -- Valid_F -- ------------- -- For now, convert to IEEE and do Valid test on result. This is not quite -- accurate, but is good enough in practice. function Valid_F (Arg : F) return Boolean is Val : constant S := F_To_S (Arg); begin return Val'Valid; end Valid_F; ------------- -- Valid_G -- ------------- -- For now, convert to IEEE and do Valid test on result. This is not quite -- accurate, but is good enough in practice. function Valid_G (Arg : G) return Boolean is Val : constant T := G_To_T (Arg); begin return Val'Valid; end Valid_G; end System.Vax_Float_Operations;
Go to most recent revision | Compare with Previous | Blame | View Log