1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
5 -- S Y S T E M . V A X _ F L O A T _ O P E R A T I O N S --
9 -- Copyright (C) 1997-2008, Free Software Foundation, Inc. --
10 -- (Version for Alpha OpenVMS) --
12 -- GNAT is free software; you can redistribute it and/or modify it under --
13 -- terms of the GNU General Public License as published by the Free Soft- --
14 -- ware Foundation; either version 2, or (at your option) any later ver- --
15 -- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
16 -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
17 -- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License --
18 -- for more details. You should have received a copy of the GNU General --
19 -- Public License distributed with GNAT; see file COPYING. If not, write --
20 -- to the Free Software Foundation, 51 Franklin Street, Fifth Floor, --
21 -- Boston, MA 02110-1301, USA. --
23 -- As a special exception, if other files instantiate generics from this --
24 -- unit, or you link this unit with other files to produce an executable, --
25 -- this unit does not by itself cause the resulting executable to be --
26 -- covered by the GNU General Public License. This exception does not --
27 -- however invalidate any other reasons why the executable file might be --
28 -- covered by the GNU Public License. --
30 -- GNAT was originally developed by the GNAT team at New York University. --
31 -- Extensive contributions were provided by Ada Core Technologies Inc. --
33 ------------------------------------------------------------------------------
36 with System.Machine_Code; use System.Machine_Code;
38 package body System.Vax_Float_Operations is
40 -- Ensure this gets compiled with -O to avoid extra (and possibly
41 -- improper) memory stores.
43 pragma Optimize (Time);
45 -- Declare the functions that do the conversions between floating-point
46 -- formats. Call the operands IEEE float so they get passed in
49 function Cvt_G_T (X : T) return T;
50 function Cvt_T_G (X : T) return T;
51 function Cvt_T_F (X : T) return S;
53 pragma Import (C, Cvt_G_T, "OTS$CVT_FLOAT_G_T");
54 pragma Import (C, Cvt_T_G, "OTS$CVT_FLOAT_T_G");
55 pragma Import (C, Cvt_T_F, "OTS$CVT_FLOAT_T_F");
57 -- In each of the conversion routines that are done with OTS calls,
58 -- we define variables of the corresponding IEEE type so that they are
59 -- passed and kept in the proper register class.
61 Debug_String_Buffer : String (1 .. 32);
62 -- Buffer used by all Debug_String_x routines for returning result
68 function D_To_G (X : D) return G is
72 Asm ("ldg %0,%1", T'Asm_Output ("=f", A), D'Asm_Input ("m", X),
74 Asm ("cvtdg %1,%0", T'Asm_Output ("=f", B), T'Asm_Input ("f", A),
76 Asm ("stg %1,%0", G'Asm_Output ("=m", C), T'Asm_Input ("f", B),
85 function F_To_G (X : F) return G is
89 Asm ("ldf %0,%1", T'Asm_Output ("=f", A), F'Asm_Input ("m", X),
91 Asm ("stg %1,%0", G'Asm_Output ("=m", B), T'Asm_Input ("f", A),
100 function F_To_S (X : F) return S is
105 -- Because converting to a wider FP format is a no-op, we say
106 -- A is 64-bit even though we are loading 32 bits into it.
108 Asm ("ldf %0,%1", T'Asm_Output ("=f", A), F'Asm_Input ("m", X),
111 B := S (Cvt_G_T (A));
119 function G_To_D (X : G) return D is
123 Asm ("ldg %0,%1", T'Asm_Output ("=f", A), G'Asm_Input ("m", X),
125 Asm ("cvtgd %1,%0", T'Asm_Output ("=f", B), T'Asm_Input ("f", A),
127 Asm ("stg %1,%0", D'Asm_Output ("=m", C), T'Asm_Input ("f", B),
136 function G_To_F (X : G) return F is
141 Asm ("ldg %0,%1", T'Asm_Output ("=f", A), G'Asm_Input ("m", X),
143 Asm ("cvtgf %1,%0", S'Asm_Output ("=f", B), T'Asm_Input ("f", A),
145 Asm ("stf %1,%0", F'Asm_Output ("=m", C), S'Asm_Input ("f", B),
154 function G_To_Q (X : G) return Q is
158 Asm ("ldg %0,%1", T'Asm_Output ("=f", A), G'Asm_Input ("m", X),
160 Asm ("cvtgq %1,%0", Q'Asm_Output ("=f", B), T'Asm_Input ("f", A),
169 function G_To_T (X : G) return T is
172 Asm ("ldg %0,%1", T'Asm_Output ("=f", A), G'Asm_Input ("m", X),
182 function F_To_Q (X : F) return Q is
184 return G_To_Q (F_To_G (X));
191 function Q_To_F (X : Q) return F is
195 Asm ("cvtqf %1,%0", S'Asm_Output ("=f", A), Q'Asm_Input ("f", X),
197 Asm ("stf %1,%0", F'Asm_Output ("=m", B), S'Asm_Input ("f", A),
206 function Q_To_G (X : Q) return G is
210 Asm ("cvtqg %1,%0", T'Asm_Output ("=f", A), Q'Asm_Input ("f", X),
212 Asm ("stg %1,%0", G'Asm_Output ("=m", B), T'Asm_Input ("f", A),
221 function S_To_F (X : S) return F is
225 A := Cvt_T_F (T (X));
226 Asm ("stf %1,%0", F'Asm_Output ("=m", B), S'Asm_Input ("f", A),
235 function T_To_D (X : T) return D is
237 return G_To_D (T_To_G (X));
244 function T_To_G (X : T) return G is
249 Asm ("stg %1,%0", G'Asm_Output ("=m", B), T'Asm_Input ("f", A),
258 function Abs_F (X : F) return F is
262 Asm ("ldf %0,%1", S'Asm_Output ("=f", A), F'Asm_Input ("m", X),
264 Asm ("cpys $f31,%1,%0", S'Asm_Output ("=f", B), S'Asm_Input ("f", A),
266 Asm ("stf %1,%0", F'Asm_Output ("=m", C), S'Asm_Input ("f", B),
275 function Abs_G (X : G) return G is
279 Asm ("ldg %0,%1", T'Asm_Output ("=f", A), G'Asm_Input ("m", X));
280 Asm ("cpys $f31,%1,%0", T'Asm_Output ("=f", B), T'Asm_Input ("f", A),
282 Asm ("stg %1,%0", G'Asm_Output ("=m", C), T'Asm_Input ("f", B),
291 function Add_F (X, Y : F) return F is
295 Asm ("ldf %0,%1", S'Asm_Output ("=f", X1), F'Asm_Input ("m", X));
296 Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y),
298 Asm ("addf %1,%2,%0", S'Asm_Output ("=f", R),
299 (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)),
301 Asm ("stf %1,%0", F'Asm_Output ("=m", R1), S'Asm_Input ("f", R),
310 function Add_G (X, Y : G) return G is
314 Asm ("ldg %0,%1", T'Asm_Output ("=f", X1), G'Asm_Input ("m", X));
315 Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y),
317 Asm ("addg %1,%2,%0", T'Asm_Output ("=f", R),
318 (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)),
320 Asm ("stg %1,%0", G'Asm_Output ("=m", R1), T'Asm_Input ("f", R),
329 procedure Debug_Output_D (Arg : D) is
331 System.IO.Put (D'Image (Arg));
338 procedure Debug_Output_F (Arg : F) is
340 System.IO.Put (F'Image (Arg));
347 procedure Debug_Output_G (Arg : G) is
349 System.IO.Put (G'Image (Arg));
356 function Debug_String_D (Arg : D) return System.Address is
357 Image_String : constant String := D'Image (Arg) & ASCII.NUL;
358 Image_Size : constant Integer := Image_String'Length;
360 Debug_String_Buffer (1 .. Image_Size) := Image_String;
361 return Debug_String_Buffer (1)'Address;
368 function Debug_String_F (Arg : F) return System.Address is
369 Image_String : constant String := F'Image (Arg) & ASCII.NUL;
370 Image_Size : constant Integer := Image_String'Length;
372 Debug_String_Buffer (1 .. Image_Size) := Image_String;
373 return Debug_String_Buffer (1)'Address;
380 function Debug_String_G (Arg : G) return System.Address is
381 Image_String : constant String := G'Image (Arg) & ASCII.NUL;
382 Image_Size : constant Integer := Image_String'Length;
384 Debug_String_Buffer (1 .. Image_Size) := Image_String;
385 return Debug_String_Buffer (1)'Address;
392 function Div_F (X, Y : F) return F is
396 Asm ("ldf %0,%1", S'Asm_Output ("=f", X1), F'Asm_Input ("m", X));
397 Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y),
399 Asm ("divf %1,%2,%0", S'Asm_Output ("=f", R),
400 (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)),
402 Asm ("stf %1,%0", F'Asm_Output ("=m", R1), S'Asm_Input ("f", R),
411 function Div_G (X, Y : G) return G is
415 Asm ("ldg %0,%1", T'Asm_Output ("=f", X1), G'Asm_Input ("m", X));
416 Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y),
418 Asm ("divg %1,%2,%0", T'Asm_Output ("=f", R),
419 (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)),
421 Asm ("stg %1,%0", G'Asm_Output ("=m", R1), T'Asm_Input ("f", R),
430 function Eq_F (X, Y : F) return Boolean is
433 Asm ("ldf %0,%1", S'Asm_Output ("=f", X1), F'Asm_Input ("m", X));
434 Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y),
436 Asm ("cmpgeq %1,%2,%0", S'Asm_Output ("=f", R),
437 (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)),
446 function Eq_G (X, Y : G) return Boolean is
449 Asm ("ldg %0,%1", T'Asm_Output ("=f", X1), G'Asm_Input ("m", X));
450 Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y),
452 Asm ("cmpgeq %1,%2,%0", T'Asm_Output ("=f", R),
453 (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)),
462 function Le_F (X, Y : F) return Boolean is
465 Asm ("ldf %0,%1", S'Asm_Output ("=f", X1), F'Asm_Input ("m", X));
466 Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y),
468 Asm ("cmpgle %1,%2,%0", S'Asm_Output ("=f", R),
469 (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)),
478 function Le_G (X, Y : G) return Boolean is
481 Asm ("ldg %0,%1", T'Asm_Output ("=f", X1), G'Asm_Input ("m", X));
482 Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y),
484 Asm ("cmpgle %1,%2,%0", T'Asm_Output ("=f", R),
485 (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)),
494 function Lt_F (X, Y : F) return Boolean is
497 Asm ("ldf %0,%1", S'Asm_Output ("=f", X1), F'Asm_Input ("m", X));
498 Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y),
500 Asm ("cmpglt %1,%2,%0", S'Asm_Output ("=f", R),
501 (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)),
510 function Lt_G (X, Y : G) return Boolean is
513 Asm ("ldg %0,%1", T'Asm_Output ("=f", X1), G'Asm_Input ("m", X));
514 Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y),
516 Asm ("cmpglt %1,%2,%0", T'Asm_Output ("=f", R),
517 (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)),
526 function Mul_F (X, Y : F) return F is
530 Asm ("ldf %0,%1", S'Asm_Output ("=f", X1), F'Asm_Input ("m", X));
531 Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y),
533 Asm ("mulf %1,%2,%0", S'Asm_Output ("=f", R),
534 (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)),
536 Asm ("stf %1,%0", F'Asm_Output ("=m", R1), S'Asm_Input ("f", R),
545 function Mul_G (X, Y : G) return G is
549 Asm ("ldg %0,%1", T'Asm_Output ("=f", X1), G'Asm_Input ("m", X));
550 Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y),
552 Asm ("mulg %1,%2,%0", T'Asm_Output ("=f", R),
553 (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)),
555 Asm ("stg %1,%0", G'Asm_Output ("=m", R1), T'Asm_Input ("f", R),
564 function Ne_F (X, Y : F) return Boolean is
567 Asm ("ldf %0,%1", S'Asm_Output ("=f", X1), F'Asm_Input ("m", X));
568 Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y),
570 Asm ("cmpgeq %1,%2,%0", S'Asm_Output ("=f", R),
571 (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)),
580 function Ne_G (X, Y : G) return Boolean is
583 Asm ("ldg %0,%1", T'Asm_Output ("=f", X1), G'Asm_Input ("m", X));
584 Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y),
586 Asm ("cmpgeq %1,%2,%0", T'Asm_Output ("=f", R),
587 (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)),
596 function Neg_F (X : F) return F is
600 Asm ("ldf %0,%1", S'Asm_Output ("=f", A), F'Asm_Input ("m", X));
601 Asm ("cpysn %1,%1,%0", S'Asm_Output ("=f", B), S'Asm_Input ("f", A),
603 Asm ("stf %1,%0", F'Asm_Output ("=m", C), S'Asm_Input ("f", B),
612 function Neg_G (X : G) return G is
616 Asm ("ldg %0,%1", T'Asm_Output ("=f", A), G'Asm_Input ("m", X));
617 Asm ("cpysn %1,%1,%0", T'Asm_Output ("=f", B), T'Asm_Input ("f", A),
619 Asm ("stg %1,%0", G'Asm_Output ("=m", C), T'Asm_Input ("f", B),
628 procedure pd (Arg : D) is
630 System.IO.Put_Line (D'Image (Arg));
637 procedure pf (Arg : F) is
639 System.IO.Put_Line (F'Image (Arg));
646 procedure pg (Arg : G) is
648 System.IO.Put_Line (G'Image (Arg));
655 function Return_D (X : D) return D is
659 -- The return value is already in $f0 so we need to trick the compiler
660 -- into thinking that we're moving X to $f0.
662 Asm ("cvtdg $f0,$f0", Inputs => D'Asm_Input ("g", X), Clobber => "$f0",
664 Asm ("stg $f0,%0", D'Asm_Output ("=m", R), Volatile => True);
672 function Return_F (X : F) return F is
676 -- The return value is already in $f0 so we need to trick the compiler
677 -- into thinking that we're moving X to $f0.
679 Asm ("stf $f0,%0", F'Asm_Output ("=m", R), F'Asm_Input ("g", X),
680 Clobber => "$f0", Volatile => True);
688 function Return_G (X : G) return G is
692 -- The return value is already in $f0 so we need to trick the compiler
693 -- into thinking that we're moving X to $f0.
695 Asm ("stg $f0,%0", G'Asm_Output ("=m", R), G'Asm_Input ("g", X),
696 Clobber => "$f0", Volatile => True);
704 function Sub_F (X, Y : F) return F is
709 Asm ("ldf %0,%1", S'Asm_Output ("=f", X1), F'Asm_Input ("m", X));
710 Asm ("ldf %0,%1", S'Asm_Output ("=f", Y1), F'Asm_Input ("m", Y),
712 Asm ("subf %1,%2,%0", S'Asm_Output ("=f", R),
713 (S'Asm_Input ("f", X1), S'Asm_Input ("f", Y1)),
715 Asm ("stf %1,%0", F'Asm_Output ("=m", R1), S'Asm_Input ("f", R),
724 function Sub_G (X, Y : G) return G is
728 Asm ("ldg %0,%1", T'Asm_Output ("=f", X1), G'Asm_Input ("m", X));
729 Asm ("ldg %0,%1", T'Asm_Output ("=f", Y1), G'Asm_Input ("m", Y),
731 Asm ("subg %1,%2,%0", T'Asm_Output ("=f", R),
732 (T'Asm_Input ("f", X1), T'Asm_Input ("f", Y1)),
734 Asm ("stg %1,%0", G'Asm_Output ("=m", R1), T'Asm_Input ("f", R),
743 -- For now, convert to IEEE and do Valid test on result. This is not quite
744 -- accurate, but is good enough in practice.
746 function Valid_D (Arg : D) return Boolean is
747 Val : constant T := G_To_T (D_To_G (Arg));
756 -- For now, convert to IEEE and do Valid test on result. This is not quite
757 -- accurate, but is good enough in practice.
759 function Valid_F (Arg : F) return Boolean is
760 Val : constant S := F_To_S (Arg);
769 -- For now, convert to IEEE and do Valid test on result. This is not quite
770 -- accurate, but is good enough in practice.
772 function Valid_G (Arg : G) return Boolean is
773 Val : constant T := G_To_T (Arg);
778 end System.Vax_Float_Operations;