1------------------------------------------------------------------------------ 2-- -- 3-- GNAT COMPILER COMPONENTS -- 4-- -- 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 -- 6-- -- 7-- S p e c -- 8-- -- 9-- Copyright (C) 1997-2009, Free Software Foundation, Inc. -- 10-- -- 11-- GNAT is free software; you can redistribute it and/or modify it under -- 12-- terms of the GNU General Public License as published by the Free Soft- -- 13-- ware Foundation; either version 3, or (at your option) any later ver- -- 14-- sion. GNAT is distributed in the hope that it will be useful, but WITH- -- 15-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -- 16-- or FITNESS FOR A PARTICULAR PURPOSE. -- 17-- -- 18-- As a special exception under Section 7 of GPL version 3, you are granted -- 19-- additional permissions described in the GCC Runtime Library Exception, -- 20-- version 3.1, as published by the Free Software Foundation. -- 21-- -- 22-- You should have received a copy of the GNU General Public License and -- 23-- a copy of the GCC Runtime Library Exception along with this program; -- 24-- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- 25-- <http://www.gnu.org/licenses/>. -- 26-- -- 27-- GNAT was originally developed by the GNAT team at New York University. -- 28-- Extensive contributions were provided by Ada Core Technologies Inc. -- 29-- -- 30------------------------------------------------------------------------------ 31 32-- This package contains runtime routines for handling the non-IEEE 33-- floating-point formats used on the Vax and the Alpha. 34 35package System.Vax_Float_Operations is 36 37 pragma Warnings (Off); 38 -- Suppress warnings if not on Alpha/VAX 39 40 type D is digits 9; 41 pragma Float_Representation (VAX_Float, D); 42 -- D Float type on Vax 43 44 type G is digits 15; 45 pragma Float_Representation (VAX_Float, G); 46 -- G Float type on Vax 47 48 type F is digits 6; 49 pragma Float_Representation (VAX_Float, F); 50 -- F Float type on Vax 51 52 type S is digits 6; 53 pragma Float_Representation (IEEE_Float, S); 54 -- IEEE short 55 56 type T is digits 15; 57 pragma Float_Representation (IEEE_Float, T); 58 -- IEEE long 59 60 pragma Warnings (On); 61 62 type Q is range -2 ** 63 .. +(2 ** 63 - 1); 63 -- 64-bit signed integer 64 65 -------------------------- 66 -- Conversion Functions -- 67 -------------------------- 68 69 function D_To_G (X : D) return G; 70 function G_To_D (X : G) return D; 71 -- Conversions between D float and G float 72 73 function G_To_F (X : G) return F; 74 function F_To_G (X : F) return G; 75 -- Conversions between F float and G float 76 77 function F_To_S (X : F) return S; 78 function S_To_F (X : S) return F; 79 -- Conversions between F float and IEEE short 80 81 function G_To_T (X : G) return T; 82 function T_To_G (X : T) return G; 83 -- Conversions between G float and IEEE long 84 85 function F_To_Q (X : F) return Q; 86 function Q_To_F (X : Q) return F; 87 -- Conversions between F float and 64-bit integer 88 89 function G_To_Q (X : G) return Q; 90 function Q_To_G (X : Q) return G; 91 -- Conversions between G float and 64-bit integer 92 93 function T_To_D (X : T) return D; 94 -- Conversion from IEEE long to D_Float (used for literals) 95 96 -------------------------- 97 -- Arithmetic Functions -- 98 -------------------------- 99 100 function Abs_F (X : F) return F; 101 function Abs_G (X : G) return G; 102 -- Absolute value of F/G float 103 104 function Add_F (X, Y : F) return F; 105 function Add_G (X, Y : G) return G; 106 -- Addition of F/G float 107 108 function Div_F (X, Y : F) return F; 109 function Div_G (X, Y : G) return G; 110 -- Division of F/G float 111 112 function Mul_F (X, Y : F) return F; 113 function Mul_G (X, Y : G) return G; 114 -- Multiplication of F/G float 115 116 function Neg_F (X : F) return F; 117 function Neg_G (X : G) return G; 118 -- Negation of F/G float 119 120 function Sub_F (X, Y : F) return F; 121 function Sub_G (X, Y : G) return G; 122 -- Subtraction of F/G float 123 124 -------------------------- 125 -- Comparison Functions -- 126 -------------------------- 127 128 function Eq_F (X, Y : F) return Boolean; 129 function Eq_G (X, Y : G) return Boolean; 130 -- Compares for X = Y 131 132 function Le_F (X, Y : F) return Boolean; 133 function Le_G (X, Y : G) return Boolean; 134 -- Compares for X <= Y 135 136 function Lt_F (X, Y : F) return Boolean; 137 function Lt_G (X, Y : G) return Boolean; 138 -- Compares for X < Y 139 140 function Ne_F (X, Y : F) return Boolean; 141 function Ne_G (X, Y : G) return Boolean; 142 -- Compares for X /= Y 143 144 ---------------------- 145 -- Return Functions -- 146 ---------------------- 147 148 function Return_D (X : D) return D; 149 function Return_F (X : F) return F; 150 function Return_G (X : G) return G; 151 -- Deal with returned value for an imported function where the function 152 -- result is of VAX Float type. Usually nothing needs to be done, and these 153 -- functions return their argument unchanged. But for the case of VMS Alpha 154 -- the return value is already in $f0, so we need to trick the compiler 155 -- into thinking that we are moving X to $f0. See bodies for this case 156 -- for the Asm sequence generated to achieve this. 157 158 ---------------------------------- 159 -- Routines for Valid Attribute -- 160 ---------------------------------- 161 162 function Valid_D (Arg : D) return Boolean; 163 function Valid_F (Arg : F) return Boolean; 164 function Valid_G (Arg : G) return Boolean; 165 -- Test whether Arg has a valid representation 166 167 ---------------------- 168 -- Debug Procedures -- 169 ---------------------- 170 171 procedure Debug_Output_D (Arg : D); 172 procedure Debug_Output_F (Arg : F); 173 procedure Debug_Output_G (Arg : G); 174 pragma Export (Ada, Debug_Output_D); 175 pragma Export (Ada, Debug_Output_F); 176 pragma Export (Ada, Debug_Output_G); 177 -- These routines output their argument in decimal string form, with 178 -- no terminating line return. They are provided for implicit use by 179 -- the pre gnat-3.12w GDB, and are retained for backwards compatibility. 180 181 function Debug_String_D (Arg : D) return System.Address; 182 function Debug_String_F (Arg : F) return System.Address; 183 function Debug_String_G (Arg : G) return System.Address; 184 pragma Export (Ada, Debug_String_D); 185 pragma Export (Ada, Debug_String_F); 186 pragma Export (Ada, Debug_String_G); 187 -- These routines return a decimal C string image of their argument. 188 -- They are provided for implicit use by the debugger, in response to 189 -- the special encoding used for Vax floating-point types (see Exp_Dbug 190 -- for details). They supersede the above Debug_Output_D/F/G routines 191 -- which didn't work properly with GDBTK. 192 193 procedure pd (Arg : D); 194 procedure pf (Arg : F); 195 procedure pg (Arg : G); 196 pragma Export (Ada, pd); 197 pragma Export (Ada, pf); 198 pragma Export (Ada, pg); 199 -- These are like the Debug_Output_D/F/G procedures except that they 200 -- output a line return after the output. They were originally present 201 -- for direct use in GDB before GDB recognized Vax floating-point 202 -- types, and are retained for backwards compatibility. 203 204private 205 pragma Inline_Always (D_To_G); 206 pragma Inline_Always (F_To_G); 207 pragma Inline_Always (F_To_Q); 208 pragma Inline_Always (F_To_S); 209 pragma Inline_Always (G_To_D); 210 pragma Inline_Always (G_To_F); 211 pragma Inline_Always (G_To_Q); 212 pragma Inline_Always (G_To_T); 213 pragma Inline_Always (Q_To_F); 214 pragma Inline_Always (Q_To_G); 215 pragma Inline_Always (S_To_F); 216 pragma Inline_Always (T_To_G); 217 218 pragma Inline_Always (Abs_F); 219 pragma Inline_Always (Abs_G); 220 pragma Inline_Always (Add_F); 221 pragma Inline_Always (Add_G); 222 pragma Inline_Always (Div_G); 223 pragma Inline_Always (Div_F); 224 pragma Inline_Always (Mul_F); 225 pragma Inline_Always (Mul_G); 226 pragma Inline_Always (Neg_G); 227 pragma Inline_Always (Neg_F); 228 pragma Inline_Always (Return_D); 229 pragma Inline_Always (Return_F); 230 pragma Inline_Always (Return_G); 231 pragma Inline_Always (Sub_F); 232 pragma Inline_Always (Sub_G); 233 234 pragma Inline_Always (Eq_F); 235 pragma Inline_Always (Eq_G); 236 pragma Inline_Always (Le_F); 237 pragma Inline_Always (Le_G); 238 pragma Inline_Always (Lt_F); 239 pragma Inline_Always (Lt_G); 240 pragma Inline_Always (Ne_F); 241 pragma Inline_Always (Ne_G); 242 243 pragma Inline_Always (Valid_D); 244 pragma Inline_Always (Valid_F); 245 pragma Inline_Always (Valid_G); 246 247end System.Vax_Float_Operations; 248