------------------------------------------------------------------------------ -- -- -- GNAT COMPILER COMPONENTS -- -- -- -- S Y S T E M . F A T _ G E N -- -- -- -- S p e c -- -- -- -- Copyright (C) 1992-2003 Free Software Foundation, Inc. -- -- -- -- 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- -- -- 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, 59 Temple Place - Suite 330, Boston, -- -- MA 02111-1307, USA. -- -- -- -- 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. -- -- -- -- GNAT was originally developed by the GNAT team at New York University. -- -- Extensive contributions were provided by Ada Core Technologies Inc. -- -- -- ------------------------------------------------------------------------------ -- This generic package provides a target independent implementation of the -- floating-point attributes that denote functions. The implementations here -- are portable, but very slow. The runtime contains a set of instantiations -- of this package for all predefined floating-point types, and these should -- be replaced by efficient assembly language code where possible. generic type T is digits <>; package System.Fat_Gen is pragma Pure (Fat_Gen); subtype UI is Integer; -- The runtime representation of universal integer for the purposes of -- this package is integer. The expander generates conversions for the -- actual type used. For functions returning universal integer, there -- is no problem, since the result always is in range of integer. For -- input arguments, the expander has to do some special casing to deal -- with the (very annoying!) cases of out of range values. If we used -- Long_Long_Integer to represent universal, then there would be no -- problem, but the resulting inefficiency would be annoying. function Adjacent (X, Towards : T) return T; function Ceiling (X : T) return T; function Compose (Fraction : T; Exponent : UI) return T; function Copy_Sign (Value, Sign : T) return T; function Exponent (X : T) return UI; function Floor (X : T) return T; function Fraction (X : T) return T; function Leading_Part (X : T; Radix_Digits : UI) return T; function Machine (X : T) return T; function Model (X : T) return T; function Pred (X : T) return T; function Remainder (X, Y : T) return T; function Rounding (X : T) return T; function Scaling (X : T; Adjustment : UI) return T; function Succ (X : T) return T; function Truncation (X : T) return T; function Unbiased_Rounding (X : T) return T; function Valid (X : access T) return Boolean; -- This function checks if the object of type T referenced by X -- is valid, and returns True/False accordingly. The parameter is -- passed by reference (access) here, as the object of type T may -- be an abnormal value that cannot be passed in a floating-point -- register, and the whole point of 'Valid is to prevent exceptions. -- Note that the object of type T must have the natural alignment -- for type T. See Unaligned_Valid for further discussion. function Unaligned_Valid (A : System.Address) return Boolean; -- This version of Valid is used if the floating-point value to -- be checked is not known to be aligned (for example it appears -- in a packed record). In this case, we cannot call Valid since -- Valid assumes proper full alignment. Instead Unaligned_Valid -- performs the same processing for a possibly unaligned float, -- by first doing a copy and then calling Valid. One might think -- that the front end could simply do a copy to an aligned temp, -- but remember that we may have an abnormal value that cannot -- be copied into a floating-point register, so things are a bit -- trickier than one might expect. -- -- Note: Unaligned_Valid is never called for a target which does -- not require strict alignment (e.g. the ia32/x86), since on a -- target not requiring strict alignment, it is fine to pass a -- non-aligned value to the standard Valid routine. private pragma Inline (Machine); pragma Inline (Model); pragma Inline_Always (Valid); pragma Inline_Always (Unaligned_Valid); end System.Fat_Gen;