[thirdparty/gcc.git] / gcc / ada / libgnat / s-scaval.adb

------------------------------------------------------------------------------
--                                                                          --
--                          GNAT RUN-TIME COMPONENTS                        --
--                                                                          --
--                  S Y S T E M . S C A L A R _ V A L U E S                 --
--                                                                          --
--                                 B o d y                                  --
--                                                                          --
--          Copyright (C) 2003-2020, 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 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 Ada.Unchecked_Conversion;

package body System.Scalar_Values is

   ----------------
   -- Initialize --
   ----------------

   procedure Initialize (Mode1 : Character; Mode2 : Character) is
      C1 : Character := Mode1;
      C2 : Character := Mode2;

      procedure Get_Env_Value_Ptr (Name, Length, Ptr : Address);
      pragma Import (C, Get_Env_Value_Ptr, "__gnat_getenv");

      subtype String2 is String (1 .. 2);
      type String2_Ptr is access all String2;

      Env_Value_Ptr    : aliased String2_Ptr;
      Env_Value_Length : aliased Integer;

      EV_Val : aliased constant String :=
                 "GNAT_INIT_SCALARS" & ASCII.NUL;

      B : Byte1;

      EFloat : constant Boolean := Long_Long_Float'Size > Long_Float'Size;
      --  Set True if we are on an x86 with 96-bit floats for extended

      AFloat : constant Boolean :=
                 Long_Float'Size = 48 and then Long_Long_Float'Size = 48;
      --  Set True if we are on an AAMP with 48-bit extended floating point

      type ByteLF is array (0 .. 7 - 2 * Boolean'Pos (AFloat)) of Byte1;

      for ByteLF'Component_Size use 8;

      --  Type used to hold Long_Float values on all targets and to initialize
      --  48-bit Long_Float values used on AAMP. On AAMP, this type is 6 bytes.
      --  On other targets the type is 8 bytes, and type Byte8 is used for
      --  values that are then converted to ByteLF.

      pragma Warnings (Off); --  why ???
      function To_ByteLF is new Ada.Unchecked_Conversion (Byte8, ByteLF);
      pragma Warnings (On);

      type ByteLLF is
        array (0 .. 7 + 4 * Boolean'Pos (EFloat) - 2 * Boolean'Pos (AFloat))
          of Byte1;

      for ByteLLF'Component_Size use 8;

      --  Type used to initialize Long_Long_Float values used on x86 and
      --  any other target with the same 80-bit floating-point values that
      --  GCC always stores in 96-bits. Note that we are assuming Intel
      --  format little-endian addressing for this type. On non-Intel
      --  architectures, this is the same length as Byte8 and holds
      --  a Long_Float value.

      --  The following variables are used to initialize the float values
      --  by overlay. We can't assign directly to the float values, since
      --  we may be assigning signalling Nan's that will cause a trap if
      --  loaded into a floating-point register.

      IV_Isf : aliased Byte4;     -- Initialize short float
      IV_Ifl : aliased Byte4;     -- Initialize float
      IV_Ilf : aliased ByteLF;    -- Initialize long float
      IV_Ill : aliased ByteLLF;   -- Initialize long long float

      for IV_Isf'Address use IS_Isf'Address;
      for IV_Ifl'Address use IS_Ifl'Address;
      for IV_Ilf'Address use IS_Ilf'Address;
      for IV_Ill'Address use IS_Ill'Address;

      --  The following pragmas are used to suppress initialization

      pragma Import (Ada, IV_Isf);
      pragma Import (Ada, IV_Ifl);
      pragma Import (Ada, IV_Ilf);
      pragma Import (Ada, IV_Ill);

   begin
      --  Acquire environment variable value if necessary

      if C1 = 'E' and then C2 = 'V' then
         Get_Env_Value_Ptr
           (EV_Val'Address, Env_Value_Length'Address, Env_Value_Ptr'Address);

         --  Ignore if length is not 2

         if Env_Value_Length /= 2 then
            C1 := 'I';
            C2 := 'N';

         --  Length is 2, see if it is a valid value

         else
            --  Acquire two characters and fold to upper case

            C1 := Env_Value_Ptr (1);
            C2 := Env_Value_Ptr (2);

            if C1 in 'a' .. 'z' then
               C1 := Character'Val (Character'Pos (C1) - 32);
            end if;

            if C2 in 'a' .. 'z' then
               C2 := Character'Val (Character'Pos (C2) - 32);
            end if;

            --  IN/LO/HI are ok values

            if (C1 = 'I' and then C2 = 'N')
                  or else
               (C1 = 'L' and then C2 = 'O')
                  or else
               (C1 = 'H' and then C2 = 'I')
            then
               null;

            --  Try for valid hex digits

            elsif (C1 in '0' .. '9' or else C1 in 'A' .. 'Z')
                     or else
                  (C2 in '0' .. '9' or else C2 in 'A' .. 'Z')
            then
               null;

            --  Otherwise environment value is bad, ignore and use IN (invalid)

            else
               C1 := 'I';
               C2 := 'N';
            end if;
         end if;
      end if;

      --  IN (invalid value)

      if C1 = 'I' and then C2 = 'N' then
         IS_Is1 := 16#80#;
         IS_Is2 := 16#8000#;
         IS_Is4 := 16#8000_0000#;
         IS_Is8 := 16#8000_0000_0000_0000#;

         IS_Iu1 := 16#FF#;
         IS_Iu2 := 16#FFFF#;
         IS_Iu4 := 16#FFFF_FFFF#;
         IS_Iu8 := 16#FFFF_FFFF_FFFF_FFFF#;

         IS_Iz1 := 16#00#;
         IS_Iz2 := 16#0000#;
         IS_Iz4 := 16#0000_0000#;
         IS_Iz8 := 16#0000_0000_0000_0000#;

         if AFloat then
            IV_Isf := 16#FFFF_FF00#;
            IV_Ifl := 16#FFFF_FF00#;
            IV_Ilf := (0, 16#FF#, 16#FF#, 16#FF#, 16#FF#, 16#FF#);

         else
            IV_Isf := IS_Iu4;
            IV_Ifl := IS_Iu4;
            IV_Ilf := To_ByteLF (IS_Iu8);
         end if;

         if EFloat then
            IV_Ill := (0, 0, 0, 0, 0, 0, 0, 16#C0#, 16#FF#, 16#FF#, 0, 0);
         end if;

      --  LO (Low values)

      elsif C1 = 'L' and then C2 = 'O' then
         IS_Is1 := 16#80#;
         IS_Is2 := 16#8000#;
         IS_Is4 := 16#8000_0000#;
         IS_Is8 := 16#8000_0000_0000_0000#;

         IS_Iu1 := 16#00#;
         IS_Iu2 := 16#0000#;
         IS_Iu4 := 16#0000_0000#;
         IS_Iu8 := 16#0000_0000_0000_0000#;

         IS_Iz1 := 16#00#;
         IS_Iz2 := 16#0000#;
         IS_Iz4 := 16#0000_0000#;
         IS_Iz8 := 16#0000_0000_0000_0000#;

         if AFloat then
            IV_Isf := 16#0000_0001#;
            IV_Ifl := 16#0000_0001#;
            IV_Ilf := (1, 0, 0, 0, 0, 0);

         else
            IV_Isf := 16#FF80_0000#;
            IV_Ifl := 16#FF80_0000#;
            IV_Ilf := To_ByteLF (16#FFF0_0000_0000_0000#);
         end if;

         if EFloat then
            IV_Ill := (0, 0, 0, 0, 0, 0, 0, 16#80#, 16#FF#, 16#FF#, 0, 0);
         end if;

      --  HI (High values)

      elsif C1 = 'H' and then C2 = 'I' then
         IS_Is1 := 16#7F#;
         IS_Is2 := 16#7FFF#;
         IS_Is4 := 16#7FFF_FFFF#;
         IS_Is8 := 16#7FFF_FFFF_FFFF_FFFF#;

         IS_Iu1 := 16#FF#;
         IS_Iu2 := 16#FFFF#;
         IS_Iu4 := 16#FFFF_FFFF#;
         IS_Iu8 := 16#FFFF_FFFF_FFFF_FFFF#;

         IS_Iz1 := 16#FF#;
         IS_Iz2 := 16#FFFF#;
         IS_Iz4 := 16#FFFF_FFFF#;
         IS_Iz8 := 16#FFFF_FFFF_FFFF_FFFF#;

         if AFloat then
            IV_Isf := 16#7FFF_FFFF#;
            IV_Ifl := 16#7FFF_FFFF#;
            IV_Ilf := (16#FF#, 16#FF#, 16#FF#, 16#FF#, 16#FF#, 16#7F#);

         else
            IV_Isf := 16#7F80_0000#;
            IV_Ifl := 16#7F80_0000#;
            IV_Ilf := To_ByteLF (16#7FF0_0000_0000_0000#);
         end if;

         if EFloat then
            IV_Ill := (0, 0, 0, 0, 0, 0, 0, 16#80#, 16#FF#, 16#7F#, 0, 0);
         end if;

      --  -Shh (hex byte)

      else
         --  Convert the two hex digits (we know they are valid here)

         B := 16 * (Character'Pos (C1)
                     - (if C1 in '0' .. '9'
                        then Character'Pos ('0')
                        else Character'Pos ('A') - 10))
                 + (Character'Pos (C2)
                     - (if C2 in '0' .. '9'
                        then Character'Pos ('0')
                        else Character'Pos ('A') - 10));

         --  Initialize data values from the hex value

         IS_Is1 := B;
         IS_Is2 := 2**8  * Byte2 (IS_Is1) + Byte2 (IS_Is1);
         IS_Is4 := 2**16 * Byte4 (IS_Is2) + Byte4 (IS_Is2);
         IS_Is8 := 2**32 * Byte8 (IS_Is4) + Byte8 (IS_Is4);

         IS_Iu1 := IS_Is1;
         IS_Iu2 := IS_Is2;
         IS_Iu4 := IS_Is4;
         IS_Iu8 := IS_Is8;

         IS_Iz1 := IS_Is1;
         IS_Iz2 := IS_Is2;
         IS_Iz4 := IS_Is4;
         IS_Iz8 := IS_Is8;

         IV_Isf := IS_Is4;
         IV_Ifl := IS_Is4;

         if AFloat then
            IV_Ill := (B, B, B, B, B, B);
         else
            IV_Ilf := To_ByteLF (IS_Is8);
         end if;

         if EFloat then
            IV_Ill := (B, B, B, B, B, B, B, B, B, B, B, B);
         end if;
      end if;

      --  If no separate Long_Long_Float, then use Long_Float value as
      --  Long_Long_Float initial value.

      if not EFloat then
         declare
            pragma Warnings (Off);  -- why???
            function To_ByteLLF is
              new Ada.Unchecked_Conversion (ByteLF, ByteLLF);
            pragma Warnings (On);
         begin
            IV_Ill := To_ByteLLF (IV_Ilf);
         end;
      end if;
   end Initialize;

end System.Scalar_Values;
Commit	Line	Data
fbf5a39b AC	1	------------------------------------------------------------------------------
fbf5a39b AC	2	-- --
3084fecd	3	-- GNAT RUN-TIME COMPONENTS --
fbf5a39b AC	4	-- --
	5	-- S Y S T E M . S C A L A R _ V A L U E S --
	6	-- --
	7	-- B o d y --
	8	-- --
4b490c1e	9	-- Copyright (C) 2003-2020, Free Software Foundation, Inc. --
fbf5a39b AC	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- --
748086b7	13	-- ware Foundation; either version 3, or (at your option) any later ver- --
fbf5a39b AC	14	-- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
fbf5a39b AC	15	-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
748086b7 JJ	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/>. --
fbf5a39b AC	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
cecaf88a	32	with Ada.Unchecked_Conversion;
fbf5a39b AC	33
	34	package body System.Scalar_Values is
	35
	36	----------------
	37	-- Initialize --
	38	----------------
	39
	40	procedure Initialize (Mode1 : Character; Mode2 : Character) is
	41	C1 : Character := Mode1;
	42	C2 : Character := Mode2;
	43
	44	procedure Get_Env_Value_Ptr (Name, Length, Ptr : Address);
0022d9e3	45	pragma Import (C, Get_Env_Value_Ptr, "__gnat_getenv");
fbf5a39b AC	46
	47	subtype String2 is String (1 .. 2);
	48	type String2_Ptr is access all String2;
	49
	50	Env_Value_Ptr : aliased String2_Ptr;
	51	Env_Value_Length : aliased Integer;
	52
	53	EV_Val : aliased constant String :=
	54	"GNAT_INIT_SCALARS" & ASCII.NUL;
	55
	56	B : Byte1;
	57
	58	EFloat : constant Boolean := Long_Long_Float'Size > Long_Float'Size;
	59	-- Set True if we are on an x86 with 96-bit floats for extended
	60
d5ef47fb	61	AFloat : constant Boolean :=
d1ced162	62	Long_Float'Size = 48 and then Long_Long_Float'Size = 48;
d5ef47fb GD	63	-- Set True if we are on an AAMP with 48-bit extended floating point
	64
	65	type ByteLF is array (0 .. 7 - 2 * Boolean'Pos (AFloat)) of Byte1;
	66
	67	for ByteLF'Component_Size use 8;
	68
	69	-- Type used to hold Long_Float values on all targets and to initialize
	70	-- 48-bit Long_Float values used on AAMP. On AAMP, this type is 6 bytes.
	71	-- On other targets the type is 8 bytes, and type Byte8 is used for
	72	-- values that are then converted to ByteLF.
	73
74e63df1	74	pragma Warnings (Off); -- why ???
cecaf88a	75	function To_ByteLF is new Ada.Unchecked_Conversion (Byte8, ByteLF);
d5ef47fb GD	76	pragma Warnings (On);
	77
	78	type ByteLLF is
	79	array (0 .. 7 + 4 * Boolean'Pos (EFloat) - 2 * Boolean'Pos (AFloat))
	80	of Byte1;
	81
	82	for ByteLLF'Component_Size use 8;
	83
fbf5a39b AC	84	-- Type used to initialize Long_Long_Float values used on x86 and
	85	-- any other target with the same 80-bit floating-point values that
	86	-- GCC always stores in 96-bits. Note that we are assuming Intel
	87	-- format little-endian addressing for this type. On non-Intel
	88	-- architectures, this is the same length as Byte8 and holds
	89	-- a Long_Float value.
	90
	91	-- The following variables are used to initialize the float values
	92	-- by overlay. We can't assign directly to the float values, since
	93	-- we may be assigning signalling Nan's that will cause a trap if
	94	-- loaded into a floating-point register.
	95
	96	IV_Isf : aliased Byte4; -- Initialize short float
	97	IV_Ifl : aliased Byte4; -- Initialize float
d5ef47fb GD	98	IV_Ilf : aliased ByteLF; -- Initialize long float
d5ef47fb GD	99	IV_Ill : aliased ByteLLF; -- Initialize long long float
fbf5a39b AC	100
	101	for IV_Isf'Address use IS_Isf'Address;
	102	for IV_Ifl'Address use IS_Ifl'Address;
	103	for IV_Ilf'Address use IS_Ilf'Address;
	104	for IV_Ill'Address use IS_Ill'Address;
	105
	106	-- The following pragmas are used to suppress initialization
	107
	108	pragma Import (Ada, IV_Isf);
	109	pragma Import (Ada, IV_Ifl);
	110	pragma Import (Ada, IV_Ilf);
	111	pragma Import (Ada, IV_Ill);
	112
	113	begin
	114	-- Acquire environment variable value if necessary
	115
	116	if C1 = 'E' and then C2 = 'V' then
	117	Get_Env_Value_Ptr
	118	(EV_Val'Address, Env_Value_Length'Address, Env_Value_Ptr'Address);
	119
	120	-- Ignore if length is not 2
	121
	122	if Env_Value_Length /= 2 then
	123	C1 := 'I';
	124	C2 := 'N';
	125
	126	-- Length is 2, see if it is a valid value
	127
	128	else
	129	-- Acquire two characters and fold to upper case
	130
	131	C1 := Env_Value_Ptr (1);
	132	C2 := Env_Value_Ptr (2);
	133
	134	if C1 in 'a' .. 'z' then
	135	C1 := Character'Val (Character'Pos (C1) - 32);
	136	end if;
	137
	138	if C2 in 'a' .. 'z' then
	139	C2 := Character'Val (Character'Pos (C2) - 32);
	140	end if;
	141
	142	-- IN/LO/HI are ok values
	143
	144	if (C1 = 'I' and then C2 = 'N')
	145	or else
	146	(C1 = 'L' and then C2 = 'O')
	147	or else
	148	(C1 = 'H' and then C2 = 'I')
	149	then
	150	null;
	151
	152	-- Try for valid hex digits
	153
	154	elsif (C1 in '0' .. '9' or else C1 in 'A' .. 'Z')
	155	or else
	156	(C2 in '0' .. '9' or else C2 in 'A' .. 'Z')
	157	then
	158	null;
	159
	160	-- Otherwise environment value is bad, ignore and use IN (invalid)
	161
	162	else
	163	C1 := 'I';
164	C2 := 'N';
165	end if;
166	end if;
167	end if;
168
169	-- IN (invalid value)
170
171	if C1 = 'I' and then C2 = 'N' then
172	IS_Is1 := 16#80#;
173	IS_Is2 := 16#8000#;
174	IS_Is4 := 16#8000_0000#;
175	IS_Is8 := 16#8000_0000_0000_0000#;
176
177	IS_Iu1 := 16#FF#;
178	IS_Iu2 := 16#FFFF#;
179	IS_Iu4 := 16#FFFF_FFFF#;
180	IS_Iu8 := 16#FFFF_FFFF_FFFF_FFFF#;
181
82c80734 RD	182	IS_Iz1 := 16#00#;
	183	IS_Iz2 := 16#0000#;
	184	IS_Iz4 := 16#0000_0000#;
	185	IS_Iz8 := 16#0000_0000_0000_0000#;
	186
d5ef47fb GD	187	if AFloat then
	188	IV_Isf := 16#FFFF_FF00#;
	189	IV_Ifl := 16#FFFF_FF00#;
	190	IV_Ilf := (0, 16#FF#, 16#FF#, 16#FF#, 16#FF#, 16#FF#);
	191
	192	else
	193	IV_Isf := IS_Iu4;
	194	IV_Ifl := IS_Iu4;
	195	IV_Ilf := To_ByteLF (IS_Iu8);
	196	end if;
fbf5a39b AC	197
	198	if EFloat then
	199	IV_Ill := (0, 0, 0, 0, 0, 0, 0, 16#C0#, 16#FF#, 16#FF#, 0, 0);
	200	end if;
	201
	202	-- LO (Low values)
	203
	204	elsif C1 = 'L' and then C2 = 'O' then
	205	IS_Is1 := 16#80#;
	206	IS_Is2 := 16#8000#;
	207	IS_Is4 := 16#8000_0000#;
	208	IS_Is8 := 16#8000_0000_0000_0000#;
	209
	210	IS_Iu1 := 16#00#;
	211	IS_Iu2 := 16#0000#;
	212	IS_Iu4 := 16#0000_0000#;
	213	IS_Iu8 := 16#0000_0000_0000_0000#;
	214
82c80734 RD	215	IS_Iz1 := 16#00#;
	216	IS_Iz2 := 16#0000#;
	217	IS_Iz4 := 16#0000_0000#;
	218	IS_Iz8 := 16#0000_0000_0000_0000#;
	219
d5ef47fb GD	220	if AFloat then
	221	IV_Isf := 16#0000_0001#;
	222	IV_Ifl := 16#0000_0001#;
	223	IV_Ilf := (1, 0, 0, 0, 0, 0);
	224
	225	else
	226	IV_Isf := 16#FF80_0000#;
	227	IV_Ifl := 16#FF80_0000#;
	228	IV_Ilf := To_ByteLF (16#FFF0_0000_0000_0000#);
	229	end if;
fbf5a39b AC	230
	231	if EFloat then
	232	IV_Ill := (0, 0, 0, 0, 0, 0, 0, 16#80#, 16#FF#, 16#FF#, 0, 0);
	233	end if;
	234
	235	-- HI (High values)
	236
	237	elsif C1 = 'H' and then C2 = 'I' then
	238	IS_Is1 := 16#7F#;
	239	IS_Is2 := 16#7FFF#;
	240	IS_Is4 := 16#7FFF_FFFF#;
	241	IS_Is8 := 16#7FFF_FFFF_FFFF_FFFF#;
	242
	243	IS_Iu1 := 16#FF#;
	244	IS_Iu2 := 16#FFFF#;
	245	IS_Iu4 := 16#FFFF_FFFF#;
	246	IS_Iu8 := 16#FFFF_FFFF_FFFF_FFFF#;
	247
82c80734 RD	248	IS_Iz1 := 16#FF#;
	249	IS_Iz2 := 16#FFFF#;
	250	IS_Iz4 := 16#FFFF_FFFF#;
	251	IS_Iz8 := 16#FFFF_FFFF_FFFF_FFFF#;
	252
d5ef47fb GD	253	if AFloat then
	254	IV_Isf := 16#7FFF_FFFF#;
	255	IV_Ifl := 16#7FFF_FFFF#;
	256	IV_Ilf := (16#FF#, 16#FF#, 16#FF#, 16#FF#, 16#FF#, 16#7F#);
	257
	258	else
	259	IV_Isf := 16#7F80_0000#;
	260	IV_Ifl := 16#7F80_0000#;
	261	IV_Ilf := To_ByteLF (16#7FF0_0000_0000_0000#);
	262	end if;
fbf5a39b AC	263
	264	if EFloat then
	265	IV_Ill := (0, 0, 0, 0, 0, 0, 0, 16#80#, 16#FF#, 16#7F#, 0, 0);
	266	end if;
	267
	268	-- -Shh (hex byte)
	269
	270	else
	271	-- Convert the two hex digits (we know they are valid here)
	272
01957849 AC	273	B := 16 * (Character'Pos (C1)
	274	- (if C1 in '0' .. '9'
	275	then Character'Pos ('0')
	276	else Character'Pos ('A') - 10))
	277	+ (Character'Pos (C2)
	278	- (if C2 in '0' .. '9'
	279	then Character'Pos ('0')
	280	else Character'Pos ('A') - 10));
fbf5a39b AC	281
	282	-- Initialize data values from the hex value
	283
	284	IS_Is1 := B;
	285	IS_Is2 := 2*8 Byte2 (IS_Is1) + Byte2 (IS_Is1);
	286	IS_Is4 := 2*16 Byte4 (IS_Is2) + Byte4 (IS_Is2);
	287	IS_Is8 := 2*32 Byte8 (IS_Is4) + Byte8 (IS_Is4);
	288
	289	IS_Iu1 := IS_Is1;
	290	IS_Iu2 := IS_Is2;
	291	IS_Iu4 := IS_Is4;
	292	IS_Iu8 := IS_Is8;
	293
82c80734 RD	294	IS_Iz1 := IS_Is1;
	295	IS_Iz2 := IS_Is2;
	296	IS_Iz4 := IS_Is4;
	297	IS_Iz8 := IS_Is8;
	298
fbf5a39b AC	299	IV_Isf := IS_Is4;
fbf5a39b AC	300	IV_Ifl := IS_Is4;
d5ef47fb GD	301
	302	if AFloat then
	303	IV_Ill := (B, B, B, B, B, B);
	304	else
	305	IV_Ilf := To_ByteLF (IS_Is8);
	306	end if;
fbf5a39b AC	307
	308	if EFloat then
	309	IV_Ill := (B, B, B, B, B, B, B, B, B, B, B, B);
	310	end if;
	311	end if;
	312
	313	-- If no separate Long_Long_Float, then use Long_Float value as
	314	-- Long_Long_Float initial value.
	315
	316	if not EFloat then
	317	declare
cecaf88a RD	318	pragma Warnings (Off); -- why???
	319	function To_ByteLLF is
	320	new Ada.Unchecked_Conversion (ByteLF, ByteLLF);
fbf5a39b AC	321	pragma Warnings (On);
fbf5a39b AC	322	begin
d5ef47fb	323	IV_Ill := To_ByteLLF (IV_Ilf);
fbf5a39b AC	324	end;
fbf5a39b AC	325	end if;
fbf5a39b AC	326	end Initialize;
	327
	328	end System.Scalar_Values;