Renaming of target specific files for clarity

        * Makefile.in: Rename GNAT target specific files.

	* 31soccon.ads, 31soliop.ads 35soccon.ads, 3asoccon.ads,
	3bsoccon.ads, 3gsoccon.ads, 3hsoccon.ads, 3psoccon.ads,
	3ssoccon.ads, 3ssoliop.ads, 3veacodu.adb, 3vexpect.adb,
	3vsoccon.ads, 3vsocthi.adb, 3vsocthi.ads, 3vtrasym.adb,
	3wsoccon.ads, 3wsocthi.adb, 3wsocthi.ads, 3wsoliop.ads,
	3zsoccon.ads, 3zsocthi.adb, 3zsocthi.ads, 41intnam.ads,
	42intnam.ads, 45intnam.ads, 4aintnam.ads, 4cintnam.ads,
	4gintnam.ads, 4hexcpol.adb, 4hintnam.ads, 4lintnam.ads,
	4nintnam.ads, 4ointnam.ads, 4onumaux.ads, 4pintnam.ads,
	4sintnam.ads, 4vcaldel.adb, 4vcalend.adb, 4vcalend.ads,
	4vintnam.ads, 4wcalend.adb, 4wexcpol.adb, 4wintnam.ads,
	4zintnam.ads, 4znumaux.ads, 4zsytaco.adb, 4zsytaco.ads,
	51osinte.adb, 51osinte.ads, 51system.ads,
	52osinte.adb, 52osinte.ads, 53osinte.ads, 54osinte.ads,
	55osinte.adb, 55osinte.ads, 55system.ads, 56osinte.adb,
	56osinte.ads, 56system.ads, 56taprop.adb, 56taspri.ads,
	56tpopsp.adb, 57system.ads, 58system.ads,
	5amastop.adb, 5aml-tgt.adb, 5aosinte.adb, 5aosinte.ads,
	5asystem.ads, 5ataprop.adb, 5atasinf.ads, 5ataspri.ads,
	5atpopsp.adb, 5avxwork.ads, 5bml-tgt.adb, 5bosinte.adb,
	5bosinte.ads, 5bsystem.ads, 5cosinte.ads, 5csystem.ads,
	5dsystem.ads, 5esystem.ads, 5fintman.adb, 5fosinte.adb,
	5fosinte.ads, 5fsystem.ads, 5ftaprop.adb, 5ftasinf.ads,
	5ginterr.adb, 5gintman.adb, 5gmastop.adb, 5gml-tgt.adb,
	5gosinte.ads, 5gproinf.adb, 5gproinf.ads, 5gsystem.ads,
	5gtaprop.adb, 5gtasinf.adb, 5gtasinf.ads, 5gtpgetc.adb,
	5hml-tgt.adb, 5hosinte.adb, 5hosinte.ads, 5hparame.ads,
	5hsystem.ads, 5htaprop.adb, 5htaspri.ads, 5htraceb.adb,
	5iosinte.adb, 5iosinte.ads, 5itaprop.adb, 5itaspri.ads,
	5ksystem.ads, 5kvxwork.ads, 5lml-tgt.adb, 5losinte.ads,
	5lparame.adb, 5lsystem.ads, 5msystem.ads, 5mvxwork.ads,
	5ninmaop.adb, 5nintman.adb, 5nosinte.ads, 5nsystem.ads,
	5ntaprop.adb, 5ntaspri.ads, 5ointerr.adb, 5omastop.adb,
	5oosinte.adb, 5oosinte.ads, 5oosprim.adb, 5oparame.adb,
	5osystem.ads, 5otaprop.adb, 5otaspri.ads, 5posinte.ads,
	5posprim.adb, 5psystem.ads, 5pvxwork.ads, 5sintman.adb,
	5sml-tgt.adb, 5sosinte.adb, 5sosinte.ads, 5sosprim.adb,
	5sparame.adb, 5ssystem.ads, 5staprop.adb, 5stasinf.adb,
	5stasinf.ads, 5staspri.ads, 5stpopsp.adb, 5svxwork.ads,
	5tosinte.ads, 5usystem.ads, 5vasthan.adb, 5vdirval.adb,
	5vinmaop.adb, 5vinterr.adb, 5vintman.adb, 5vintman.ads,
	5vmastop.adb, 5vml-tgt.adb, 5vosinte.adb, 5vosinte.ads,
	5vosprim.adb, 5vosprim.ads, 5vparame.ads, 5vsymbol.adb,
	5vsystem.ads, 5vtaprop.adb, 5vtaspri.ads, 5vtpopde.adb,
	5vtpopde.ads, 5vtraent.adb, 5vtraent.ads, 5vvaflop.adb,
	5wdirval.adb, 5wgloloc.adb, 5wintman.adb, 5wmemory.adb,
	5wml-tgt.adb, 5wosinte.ads, 5wosprim.adb, 5wsystem.ads,
	5wtaprop.adb, 5wtaspri.ads, 5xparame.ads, 5xsystem.ads,
	5xvxwork.ads, 5yparame.ads, 5ysystem.ads, 5zinterr.adb,
	5zintman.adb, 5zintman.ads, 5zml-tgt.adb, 5zosinte.adb,
	5zosinte.ads, 5zosprim.adb, 5zparame.ads, 5zstchop.adb,
	5zsystem.ads, 5ztaprop.adb, 5ztaspri.ads, 5ztfsetr.adb,
	5ztpopsp.adb, 6vcpp.adb, 6vcstrea.adb, 6vinterf.ads,
	7sinmaop.adb, 7sintman.adb, 7sosinte.adb, 7sosprim.adb,
	7staprop.adb, 7staspri.ads, 7stfsetr.adb, 7stpopsp.adb,
	7straceb.adb, 7straces.adb, 7strafor.adb, 7strafor.ads,
	7stratas.adb, 86numaux.adb, 86numaux.ads: Replaced by files below.

	* a-caldel-vms.adb, a-calend-mingw.adb, a-calend-vms.adb,
	a-calend-vms.ads, a-dirval-mingw.adb, a-dirval-vms.adb,
	a-excpol-abort.adb, a-excpol-interix.adb, a-intnam-aix.ads,
	a-intnam-dummy.ads, a-intnam-freebsd.ads, a-intnam-hpux.ads,
	a-intnam-interix.ads, a-intnam-irix.ads, a-intnam-linux.ads,
	a-intnam-lynxos.ads, a-intnam-mingw.ads, a-intnam-os2.ads,
	a-intnam-solaris.ads, a-intnam-tru64.ads, a-intnam-unixware.ads,
	a-intnam-vms.ads, a-intnam-vxworks.ads, a-numaux-libc-x86.ads,
	a-numaux-vxworks.ads, a-numaux-x86.adb, a-numaux-x86.ads,
	a-sytaco-vxworks.adb, a-sytaco-vxworks.ads, g-eacodu-vms.adb,
	g-expect-vms.adb, g-soccon-aix.ads, g-soccon-freebsd.ads,
	g-soccon-hpux.ads, g-soccon-interix.ads, g-soccon-irix.ads,
	g-soccon-mingw.ads, g-soccon-solaris.ads, g-soccon-tru64.ads,
	g-soccon-unixware.ads, g-soccon-vms.adb, g-soccon-vxworks.ads,
	g-socthi-mingw.adb, g-socthi-mingw.ads, g-socthi-vms.adb,
	g-socthi-vms.ads, g-socthi-vxworks.adb, g-socthi-vxworks.ads,
	g-soliop-mingw.ads, g-soliop-solaris.ads, g-soliop-unixware.ads,
	g-trasym-vms.adb, i-cpp-vms.adb, i-cstrea-vms.adb,
	interfac-vms.ads, mlib-tgt-aix.adb, mlib-tgt-hpux.adb,
	mlib-tgt-irix.adb, mlib-tgt-linux.adb, mlib-tgt-mingw.adb,
	mlib-tgt-solaris.adb, mlib-tgt-tru64.adb, mlib-tgt-vms.adb,
	mlib-tgt-vxworks.adb, s-asthan-vms.adb, s-gloloc-mingw.adb,
	s-inmaop-dummy.adb, s-inmaop-posix.adb, s-inmaop-vms.adb,
	s-interr-dummy.adb, s-interr-sigaction.adb, s-interr-vms.adb,
	s-interr-vxworks.adb, s-intman-dummy.adb, s-intman-irix.adb,
	s-intman-irix-athread.adb, s-intman-mingw.adb, s-intman-posix.adb,
	s-intman-solaris.adb, s-intman-vms.adb, s-intman-vms.ads,
	s-intman-vxworks.adb, s-intman-vxworks.ads, s-mastop-irix.adb,
	s-mastop-tru64.adb, s-mastop-vms.adb, s-mastop-x86.adb,
	s-memory-mingw.adb, s-osinte-aix.adb, s-osinte-aix.ads,
	s-osinte-aix-fsu.ads, s-osinte-dummy.ads, s-osinte-freebsd.adb,
	s-osinte-freebsd.ads, s-osinte-fsu.adb, s-osinte-hpux.ads,
	s-osinte-hpux-dce.adb, s-osinte-hpux-dce.ads, s-osinte-interix.ads,
	s-osinte-irix.adb, s-osinte-irix.ads, s-osinte-irix-athread.ads,
	s-osinte-linux.ads, s-osinte-linux-fsu.ads, s-osinte-linux-ia64.ads,
	s-osinte-lynxos-3.adb, s-osinte-lynxos-3.ads, s-osinte-lynxos.adb,
	s-osinte-lynxos.ads, s-osinte-mingw.ads, s-osinte-os2.adb,
	s-osinte-os2.ads, s-osinte-posix.adb, s-osinte-solaris.adb,
	s-osinte-solaris.ads, s-osinte-solaris-fsu.ads,
	s-osinte-solaris-posix.ads, s-osinte-tru64.adb, s-osinte-tru64.ads,
	s-osinte-unixware.adb, s-osinte-unixware.ads, s-osinte-vms.adb,
	s-osinte-vms.ads, s-osinte-vxworks.adb,
	s-osinte-vxworks.ads, s-osprim-mingw.adb,
	s-osprim-os2.adb, s-osprim-posix.adb, s-osprim-solaris.adb,
	s-osprim-unix.adb, s-osprim-vms.adb, s-osprim-vms.ads,
	s-osprim-vxworks.adb, s-parame-ae653.ads, s-parame-hpux.ads,
	s-parame-linux.adb, s-parame-os2.adb, s-parame-solaris.adb,
	s-parame-vms.ads, s-parame-vms-restrict.ads, s-parame-vxworks.ads,
	s-proinf-irix-athread.adb, s-proinf-irix-athread.ads,
	s-stchop-vxworks.adb, s-taprop-dummy.adb,
	s-taprop-hpux-dce.adb, s-taprop-irix.adb,
	s-taprop-irix-athread.adb, s-taprop-linux.adb, s-taprop-lynxos.adb,
	s-taprop-mingw.adb, s-taprop-os2.adb, s-taprop-posix.adb,
	s-taprop-solaris.adb, s-taprop-tru64.adb, s-taprop-vms.adb,
	s-taprop-vxworks.adb, s-tasinf-irix.ads, s-tasinf-irix-athread.adb,
	s-tasinf-irix-athread.ads, s-tasinf-solaris.adb, s-tasinf-solaris.ads,
	s-tasinf-tru64.ads, s-taspri-dummy.ads, s-taspri-hpux-dce.ads,
	s-taspri-linux.ads, s-taspri-lynxos.ads, s-taspri-mingw.ads,
	s-taspri-os2.ads, s-taspri-posix.ads, s-taspri-solaris.ads,
	s-taspri-tru64.ads, s-taspri-vms.ads, s-taspri-vxworks.ads,
	s-tfsetr-default.adb, s-tfsetr-vxworks.adb, s-tpopde-vms.adb,
	s-tpopde-vms.ads, s-tpopsp-lynxos.adb, s-tpopsp-posix.adb,
	s-tpopsp-posix-foreign.adb, s-tpopsp-solaris.adb, s-tpopsp-vxworks.adb,
	s-traceb-hpux.adb, s-traceb-mastop.adb, s-traces-default.adb,
	s-traent-vms.adb, s-traent-vms.ads, s-trafor-default.adb,
	s-trafor-default.ads, s-tratas-default.adb, s-vaflop-vms.adb,
	s-vxwork-alpha.ads, s-vxwork-m68k.ads, s-vxwork-mips.ads,
	s-vxwork-ppc.ads, s-vxwork-sparcv9.ads, s-vxwork-xscale.ads,
	symbols-vms.adb, system-aix.ads, system-freebsd-x86.ads,
	system-hpux.ads, system-interix.ads, system-irix-n32.ads,
	system-irix-o32.ads, system-linux-x86_64.ads,
	system-linux-x86.ads, system-lynxos-ppc.ads, system-lynxos-x86.ads,
	system-mingw.ads, system-os2.ads, system-solaris-sparc.ads,
	system-solaris-sparcv9.ads, system-solaris-x86.ads, system-tru64.ads,
	system-unixware.ads, system-vms.ads, system-vms-zcx.ads,
	system-vxworks-alpha.ads, system-vxworks-m68k.ads,
	system-vxworks-mips.ads, system-vxworks-ppc.ads,
	system-vxworks-sparcv9.ads, system-vxworks-xscale.ads: Replace files
	above.

From-SVN: r81834

1 files changed, 1106 insertions, 0 deletions

diff --git a/gcc/ada/s-taprop-mingw.adb b/gcc/ada/s-taprop-mingw.adb
new file mode 100644
index 0000000..1e24de0
--- /dev/null
+++ b/gcc/ada/s-taprop-mingw.adb
@@ -0,0 +1,1106 @@
+------------------------------------------------------------------------------
+--                                                                          --
+--                GNU ADA RUN-TIME LIBRARY (GNARL) COMPONENTS               --
+--                                                                          --
+--     S Y S T E M . T A S K _ P R I M I T I V E S . O P E R A T I O N S    --
+--                                                                          --
+--                                  B o d y                                 --
+--                                                                          --
+--         Copyright (C) 1992-2004, Free Software Foundation, Inc.          --
+--                                                                          --
+-- GNARL 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. GNARL 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 GNARL; 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.                                      --
+--                                                                          --
+-- GNARL was developed by the GNARL team at Florida State University.       --
+-- Extensive contributions were provided by Ada Core Technologies, Inc.     --
+--                                                                          --
+------------------------------------------------------------------------------
+
+--  This is a NT (native) version of this package
+
+--  This package contains all the GNULL primitives that interface directly
+--  with the underlying OS.
+
+pragma Polling (Off);
+--  Turn off polling, we do not want ATC polling to take place during
+--  tasking operations. It causes infinite loops and other problems.
+
+with System.Tasking.Debug;
+--  used for Known_Tasks
+
+with Interfaces.C;
+--  used for int
+--           size_t
+
+with Interfaces.C.Strings;
+--  used for Null_Ptr
+
+with System.OS_Interface;
+--  used for various type, constant, and operations
+
+with System.Parameters;
+--  used for Size_Type
+
+with System.Tasking;
+--  used for Ada_Task_Control_Block
+--           Task_ID
+
+with System.Soft_Links;
+--  used for Defer/Undefer_Abort
+--       to initialize TSD for a C thread, in function Self
+
+--  Note that we do not use System.Tasking.Initialization directly since
+--  this is a higher level package that we shouldn't depend on. For example
+--  when using the restricted run time, it is replaced by
+--  System.Tasking.Restricted.Initialization
+
+with System.OS_Primitives;
+--  used for Delay_Modes
+
+with System.Task_Info;
+--  used for Unspecified_Task_Info
+
+with Unchecked_Deallocation;
+
+package body System.Task_Primitives.Operations is
+
+   use System.Tasking.Debug;
+   use System.Tasking;
+   use Interfaces.C;
+   use Interfaces.C.Strings;
+   use System.OS_Interface;
+   use System.Parameters;
+   use System.OS_Primitives;
+
+   pragma Link_With ("-Xlinker --stack=0x800000,0x1000");
+   --  Change the stack size (8 MB) for tasking programs on Windows. This
+   --  permit to have more than 30 tasks running at the same time. Note that
+   --  we set the stack size for non tasking programs on System unit.
+
+   package SSL renames System.Soft_Links;
+
+   ----------------
+   -- Local Data --
+   ----------------
+
+   Environment_Task_ID : Task_ID;
+   --  A variable to hold Task_ID for the environment task.
+
+   Single_RTS_Lock : aliased RTS_Lock;
+   --  This is a lock to allow only one thread of control in the RTS at
+   --  a time; it is used to execute in mutual exclusion from all other tasks.
+   --  Used mainly in Single_Lock mode, but also to protect All_Tasks_List
+
+   Time_Slice_Val : Integer;
+   pragma Import (C, Time_Slice_Val, "__gl_time_slice_val");
+
+   Dispatching_Policy : Character;
+   pragma Import (C, Dispatching_Policy, "__gl_task_dispatching_policy");
+
+   FIFO_Within_Priorities : constant Boolean := Dispatching_Policy = 'F';
+   --  Indicates whether FIFO_Within_Priorities is set.
+
+   Foreign_Task_Elaborated : aliased Boolean := True;
+   --  Used to identified fake tasks (i.e., non-Ada Threads).
+
+   ------------------------------------
+   -- The thread local storage index --
+   ------------------------------------
+
+   TlsIndex : DWORD;
+   pragma Export (Ada, TlsIndex);
+   --  To ensure that this variable won't be local to this package, since
+   --  in some cases, inlining forces this variable to be global anyway.
+
+   --------------------
+   -- Local Packages --
+   --------------------
+
+   package Specific is
+
+      function Is_Valid_Task return Boolean;
+      pragma Inline (Is_Valid_Task);
+      --  Does executing thread have a TCB?
+
+      procedure Set (Self_Id : Task_ID);
+      pragma Inline (Set);
+      --  Set the self id for the current task.
+
+   end Specific;
+
+   package body Specific is
+
+      function Is_Valid_Task return Boolean is
+      begin
+         return TlsGetValue (TlsIndex) /= System.Null_Address;
+      end Is_Valid_Task;
+
+      procedure Set (Self_Id : Task_ID) is
+         Succeeded : BOOL;
+      begin
+         Succeeded := TlsSetValue (TlsIndex, To_Address (Self_Id));
+         pragma Assert (Succeeded = True);
+      end Set;
+
+   end Specific;
+
+   ---------------------------------
+   -- Support for foreign threads --
+   ---------------------------------
+
+   function Register_Foreign_Thread (Thread : Thread_Id) return Task_ID;
+   --  Allocate and Initialize a new ATCB for the current Thread.
+
+   function Register_Foreign_Thread
+     (Thread : Thread_Id) return Task_ID is separate;
+
+   ----------------------------------
+   -- Condition Variable Functions --
+   ----------------------------------
+
+   procedure Initialize_Cond (Cond : access Condition_Variable);
+   --  Initialize given condition variable Cond
+
+   procedure Finalize_Cond (Cond : access Condition_Variable);
+   --  Finalize given condition variable Cond.
+
+   procedure Cond_Signal (Cond : access Condition_Variable);
+   --  Signal condition variable Cond
+
+   procedure Cond_Wait
+     (Cond : access Condition_Variable;
+      L    : access RTS_Lock);
+   --  Wait on conditional variable Cond, using lock L
+
+   procedure Cond_Timed_Wait
+     (Cond      : access Condition_Variable;
+      L         : access RTS_Lock;
+      Rel_Time  : Duration;
+      Timed_Out : out Boolean;
+      Status    : out Integer);
+   --  Do timed wait on condition variable Cond using lock L. The duration
+   --  of the timed wait is given by Rel_Time. When the condition is
+   --  signalled, Timed_Out shows whether or not a time out occurred.
+   --  Status is only valid if Timed_Out is False, in which case it
+   --  shows whether Cond_Timed_Wait completed successfully.
+
+   ---------------------
+   -- Initialize_Cond --
+   ---------------------
+
+   procedure Initialize_Cond (Cond : access Condition_Variable) is
+      hEvent : HANDLE;
+
+   begin
+      hEvent := CreateEvent (null, True, False, Null_Ptr);
+      pragma Assert (hEvent /= 0);
+      Cond.all := Condition_Variable (hEvent);
+   end Initialize_Cond;
+
+   -------------------
+   -- Finalize_Cond --
+   -------------------
+
+   --  No such problem here, DosCloseEventSem has been derived.
+   --  What does such refer to in above comment???
+
+   procedure Finalize_Cond (Cond : access Condition_Variable) is
+      Result : BOOL;
+   begin
+      Result := CloseHandle (HANDLE (Cond.all));
+      pragma Assert (Result = True);
+   end Finalize_Cond;
+
+   -----------------
+   -- Cond_Signal --
+   -----------------
+
+   procedure Cond_Signal (Cond : access Condition_Variable) is
+      Result : BOOL;
+   begin
+      Result := SetEvent (HANDLE (Cond.all));
+      pragma Assert (Result = True);
+   end Cond_Signal;
+
+   ---------------
+   -- Cond_Wait --
+   ---------------
+
+   --  Pre-assertion: Cond is posted
+   --                 L is locked.
+
+   --  Post-assertion: Cond is posted
+   --                  L is locked.
+
+   procedure Cond_Wait
+     (Cond : access Condition_Variable;
+      L    : access RTS_Lock)
+   is
+      Result      : DWORD;
+      Result_Bool : BOOL;
+
+   begin
+      --  Must reset Cond BEFORE L is unlocked.
+
+      Result_Bool := ResetEvent (HANDLE (Cond.all));
+      pragma Assert (Result_Bool = True);
+      Unlock (L);
+
+      --  No problem if we are interrupted here: if the condition is signaled,
+      --  WaitForSingleObject will simply not block
+
+      Result := WaitForSingleObject (HANDLE (Cond.all), Wait_Infinite);
+      pragma Assert (Result = 0);
+
+      Write_Lock (L);
+   end Cond_Wait;
+
+   ---------------------
+   -- Cond_Timed_Wait --
+   ---------------------
+
+   --  Pre-assertion: Cond is posted
+   --                 L is locked.
+
+   --  Post-assertion: Cond is posted
+   --                  L is locked.
+
+   procedure Cond_Timed_Wait
+     (Cond      : access Condition_Variable;
+      L         : access RTS_Lock;
+      Rel_Time  : Duration;
+      Timed_Out : out Boolean;
+      Status    : out Integer)
+   is
+      Time_Out_Max : constant DWORD := 16#FFFF0000#;
+      --  NT 4 cannot handle timeout values that are too large,
+      --  e.g. DWORD'Last - 1
+
+      Time_Out     : DWORD;
+      Result       : BOOL;
+      Wait_Result  : DWORD;
+
+   begin
+      --  Must reset Cond BEFORE L is unlocked.
+
+      Result := ResetEvent (HANDLE (Cond.all));
+      pragma Assert (Result = True);
+      Unlock (L);
+
+      --  No problem if we are interrupted here: if the condition is signaled,
+      --  WaitForSingleObject will simply not block
+
+      if Rel_Time <= 0.0 then
+         Timed_Out := True;
+         Wait_Result := 0;
+
+      else
+         if Rel_Time >= Duration (Time_Out_Max) / 1000 then
+            Time_Out := Time_Out_Max;
+         else
+            Time_Out := DWORD (Rel_Time * 1000);
+         end if;
+
+         Wait_Result := WaitForSingleObject (HANDLE (Cond.all), Time_Out);
+
+         if Wait_Result = WAIT_TIMEOUT then
+            Timed_Out := True;
+            Wait_Result := 0;
+         else
+            Timed_Out := False;
+         end if;
+      end if;
+
+      Write_Lock (L);
+
+      --  Ensure post-condition
+
+      if Timed_Out then
+         Result := SetEvent (HANDLE (Cond.all));
+         pragma Assert (Result = True);
+      end if;
+
+      Status := Integer (Wait_Result);
+   end Cond_Timed_Wait;
+
+   ------------------
+   -- Stack_Guard  --
+   ------------------
+
+   --  The underlying thread system sets a guard page at the
+   --  bottom of a thread stack, so nothing is needed.
+   --  ??? Check the comment above
+
+   procedure Stack_Guard (T : ST.Task_ID; On : Boolean) is
+      pragma Warnings (Off, T);
+      pragma Warnings (Off, On);
+
+   begin
+      null;
+   end Stack_Guard;
+
+   --------------------
+   -- Get_Thread_Id  --
+   --------------------
+
+   function Get_Thread_Id (T : ST.Task_ID) return OSI.Thread_Id is
+   begin
+      return T.Common.LL.Thread;
+   end Get_Thread_Id;
+
+   ----------
+   -- Self --
+   ----------
+
+   function Self return Task_ID is
+      Self_Id : constant Task_ID := To_Task_ID (TlsGetValue (TlsIndex));
+   begin
+      if Self_Id = null then
+         return Register_Foreign_Thread (GetCurrentThread);
+      else
+         return Self_Id;
+      end if;
+   end Self;
+
+   ---------------------
+   -- Initialize_Lock --
+   ---------------------
+
+   --  Note: mutexes and cond_variables needed per-task basis are
+   --  initialized in Intialize_TCB and the Storage_Error is handled.
+   --  Other mutexes (such as RTS_Lock, Memory_Lock...) used in
+   --  the RTS is initialized before any status change of RTS.
+   --  Therefore raising Storage_Error in the following routines
+   --  should be able to be handled safely.
+
+   procedure Initialize_Lock
+     (Prio : System.Any_Priority;
+      L    : access Lock)
+   is
+   begin
+      InitializeCriticalSection (L.Mutex'Access);
+      L.Owner_Priority := 0;
+      L.Priority := Prio;
+   end Initialize_Lock;
+
+   procedure Initialize_Lock (L : access RTS_Lock; Level : Lock_Level) is
+      pragma Unreferenced (Level);
+
+   begin
+      InitializeCriticalSection (CRITICAL_SECTION (L.all)'Unrestricted_Access);
+   end Initialize_Lock;
+
+   -------------------
+   -- Finalize_Lock --
+   -------------------
+
+   procedure Finalize_Lock (L : access Lock) is
+   begin
+      DeleteCriticalSection (L.Mutex'Access);
+   end Finalize_Lock;
+
+   procedure Finalize_Lock (L : access RTS_Lock) is
+   begin
+      DeleteCriticalSection (CRITICAL_SECTION (L.all)'Unrestricted_Access);
+   end Finalize_Lock;
+
+   ----------------
+   -- Write_Lock --
+   ----------------
+
+   procedure Write_Lock (L : access Lock; Ceiling_Violation : out Boolean) is
+   begin
+      L.Owner_Priority := Get_Priority (Self);
+
+      if L.Priority < L.Owner_Priority then
+         Ceiling_Violation := True;
+         return;
+      end if;
+
+      EnterCriticalSection (L.Mutex'Access);
+
+      Ceiling_Violation := False;
+   end Write_Lock;
+
+   procedure Write_Lock
+     (L           : access RTS_Lock;
+      Global_Lock : Boolean := False)
+   is
+   begin
+      if not Single_Lock or else Global_Lock then
+         EnterCriticalSection (CRITICAL_SECTION (L.all)'Unrestricted_Access);
+      end if;
+   end Write_Lock;
+
+   procedure Write_Lock (T : Task_ID) is
+   begin
+      if not Single_Lock then
+         EnterCriticalSection
+           (CRITICAL_SECTION (T.Common.LL.L)'Unrestricted_Access);
+      end if;
+   end Write_Lock;
+
+   ---------------
+   -- Read_Lock --
+   ---------------
+
+   procedure Read_Lock (L : access Lock; Ceiling_Violation : out Boolean) is
+   begin
+      Write_Lock (L, Ceiling_Violation);
+   end Read_Lock;
+
+   ------------
+   -- Unlock --
+   ------------
+
+   procedure Unlock (L : access Lock) is
+   begin
+      LeaveCriticalSection (L.Mutex'Access);
+   end Unlock;
+
+   procedure Unlock (L : access RTS_Lock; Global_Lock : Boolean := False) is
+   begin
+      if not Single_Lock or else Global_Lock then
+         LeaveCriticalSection (CRITICAL_SECTION (L.all)'Unrestricted_Access);
+      end if;
+   end Unlock;
+
+   procedure Unlock (T : Task_ID) is
+   begin
+      if not Single_Lock then
+         LeaveCriticalSection
+           (CRITICAL_SECTION (T.Common.LL.L)'Unrestricted_Access);
+      end if;
+   end Unlock;
+
+   -----------
+   -- Sleep --
+   -----------
+
+   procedure Sleep
+     (Self_ID : Task_ID;
+      Reason  : System.Tasking.Task_States)
+   is
+      pragma Unreferenced (Reason);
+
+   begin
+      pragma Assert (Self_ID = Self);
+
+      if Single_Lock then
+         Cond_Wait (Self_ID.Common.LL.CV'Access, Single_RTS_Lock'Access);
+      else
+         Cond_Wait (Self_ID.Common.LL.CV'Access, Self_ID.Common.LL.L'Access);
+      end if;
+
+      if Self_ID.Deferral_Level = 0
+        and then Self_ID.Pending_ATC_Level < Self_ID.ATC_Nesting_Level
+      then
+         Unlock (Self_ID);
+         raise Standard'Abort_Signal;
+      end if;
+   end Sleep;
+
+   -----------------
+   -- Timed_Sleep --
+   -----------------
+
+   --  This is for use within the run-time system, so abort is
+   --  assumed to be already deferred, and the caller should be
+   --  holding its own ATCB lock.
+
+   procedure Timed_Sleep
+     (Self_ID  : Task_ID;
+      Time     : Duration;
+      Mode     : ST.Delay_Modes;
+      Reason   : System.Tasking.Task_States;
+      Timedout : out Boolean;
+      Yielded  : out Boolean)
+   is
+      pragma Unreferenced (Reason);
+      Check_Time : Duration := Monotonic_Clock;
+      Rel_Time   : Duration;
+      Abs_Time   : Duration;
+      Result     : Integer;
+
+      Local_Timedout : Boolean;
+
+   begin
+      Timedout := True;
+      Yielded  := False;
+
+      if Mode = Relative then
+         Rel_Time := Time;
+         Abs_Time := Duration'Min (Time, Max_Sensible_Delay) + Check_Time;
+      else
+         Rel_Time := Time - Check_Time;
+         Abs_Time := Time;
+      end if;
+
+      if Rel_Time > 0.0 then
+         loop
+            exit when Self_ID.Pending_ATC_Level < Self_ID.ATC_Nesting_Level
+              or else Self_ID.Pending_Priority_Change;
+
+            if Single_Lock then
+               Cond_Timed_Wait (Self_ID.Common.LL.CV'Access,
+                 Single_RTS_Lock'Access, Rel_Time, Local_Timedout, Result);
+            else
+               Cond_Timed_Wait (Self_ID.Common.LL.CV'Access,
+                 Self_ID.Common.LL.L'Access, Rel_Time, Local_Timedout, Result);
+            end if;
+
+            Check_Time := Monotonic_Clock;
+            exit when Abs_Time <= Check_Time;
+
+            if not Local_Timedout then
+
+               --  Somebody may have called Wakeup for us
+
+               Timedout := False;
+               exit;
+            end if;
+
+            Rel_Time := Abs_Time - Check_Time;
+         end loop;
+      end if;
+   end Timed_Sleep;
+
+   -----------------
+   -- Timed_Delay --
+   -----------------
+
+   procedure Timed_Delay
+     (Self_ID  : Task_ID;
+      Time     : Duration;
+      Mode     : ST.Delay_Modes)
+   is
+      Check_Time : Duration := Monotonic_Clock;
+      Rel_Time   : Duration;
+      Abs_Time   : Duration;
+      Result     : Integer;
+      Timedout   : Boolean;
+
+   begin
+      --  Only the little window between deferring abort and
+      --  locking Self_ID is the reason we need to
+      --  check for pending abort and priority change below!
+
+      SSL.Abort_Defer.all;
+
+      if Single_Lock then
+         Lock_RTS;
+      end if;
+
+      Write_Lock (Self_ID);
+
+      if Mode = Relative then
+         Rel_Time := Time;
+         Abs_Time := Time + Check_Time;
+      else
+         Rel_Time := Time - Check_Time;
+         Abs_Time := Time;
+      end if;
+
+      if Rel_Time > 0.0 then
+         Self_ID.Common.State := Delay_Sleep;
+
+         loop
+            if Self_ID.Pending_Priority_Change then
+               Self_ID.Pending_Priority_Change := False;
+               Self_ID.Common.Base_Priority := Self_ID.New_Base_Priority;
+               Set_Priority (Self_ID, Self_ID.Common.Base_Priority);
+            end if;
+
+            exit when Self_ID.Pending_ATC_Level < Self_ID.ATC_Nesting_Level;
+
+            if Single_Lock then
+               Cond_Timed_Wait (Self_ID.Common.LL.CV'Access,
+                 Single_RTS_Lock'Access, Rel_Time, Timedout, Result);
+            else
+               Cond_Timed_Wait (Self_ID.Common.LL.CV'Access,
+                 Self_ID.Common.LL.L'Access, Rel_Time, Timedout, Result);
+            end if;
+
+            Check_Time := Monotonic_Clock;
+            exit when Abs_Time <= Check_Time;
+
+            Rel_Time := Abs_Time - Check_Time;
+         end loop;
+
+         Self_ID.Common.State := Runnable;
+      end if;
+
+      Unlock (Self_ID);
+
+      if Single_Lock then
+         Unlock_RTS;
+      end if;
+
+      Yield;
+      SSL.Abort_Undefer.all;
+   end Timed_Delay;
+
+   ------------
+   -- Wakeup --
+   ------------
+
+   procedure Wakeup (T : Task_ID; Reason : System.Tasking.Task_States) is
+      pragma Unreferenced (Reason);
+
+   begin
+      Cond_Signal (T.Common.LL.CV'Access);
+   end Wakeup;
+
+   -----------
+   -- Yield --
+   -----------
+
+   procedure Yield (Do_Yield : Boolean := True) is
+   begin
+      if Do_Yield then
+         Sleep (0);
+      end if;
+   end Yield;
+
+   ------------------
+   -- Set_Priority --
+   ------------------
+
+   type Prio_Array_Type is array (System.Any_Priority) of Integer;
+   pragma Atomic_Components (Prio_Array_Type);
+
+   Prio_Array : Prio_Array_Type;
+   --  Global array containing the id of the currently running task for
+   --  each priority.
+   --
+   --  Note: we assume that we are on a single processor with run-til-blocked
+   --  scheduling.
+
+   procedure Set_Priority
+     (T                   : Task_ID;
+      Prio                : System.Any_Priority;
+      Loss_Of_Inheritance : Boolean := False)
+   is
+      Res        : BOOL;
+      Array_Item : Integer;
+
+   begin
+      Res := SetThreadPriority
+        (T.Common.LL.Thread, Interfaces.C.int (Underlying_Priorities (Prio)));
+      pragma Assert (Res = True);
+
+      if FIFO_Within_Priorities then
+
+         --  Annex D requirement [RM D.2.2 par. 9]:
+         --    If the task drops its priority due to the loss of inherited
+         --    priority, it is added at the head of the ready queue for its
+         --    new active priority.
+
+         if Loss_Of_Inheritance
+           and then Prio < T.Common.Current_Priority
+         then
+            Array_Item := Prio_Array (T.Common.Base_Priority) + 1;
+            Prio_Array (T.Common.Base_Priority) := Array_Item;
+
+            loop
+               --  Let some processes a chance to arrive
+
+               Yield;
+
+               --  Then wait for our turn to proceed
+
+               exit when Array_Item = Prio_Array (T.Common.Base_Priority)
+                 or else Prio_Array (T.Common.Base_Priority) = 1;
+            end loop;
+
+            Prio_Array (T.Common.Base_Priority) :=
+              Prio_Array (T.Common.Base_Priority) - 1;
+         end if;
+      end if;
+
+      T.Common.Current_Priority := Prio;
+   end Set_Priority;
+
+   ------------------
+   -- Get_Priority --
+   ------------------
+
+   function Get_Priority (T : Task_ID) return System.Any_Priority is
+   begin
+      return T.Common.Current_Priority;
+   end Get_Priority;
+
+   ----------------
+   -- Enter_Task --
+   ----------------
+
+   --  There were two paths were we needed to call Enter_Task :
+   --  1) from System.Task_Primitives.Operations.Initialize
+   --  2) from System.Tasking.Stages.Task_Wrapper
+   --
+   --  The thread initialisation has to be done only for the first case.
+   --
+   --  This is because the GetCurrentThread NT call does not return the
+   --  real thread handler but only a "pseudo" one. It is not possible to
+   --  release the thread handle and free the system ressources from this
+   --  "pseudo" handle. So we really want to keep the real thread handle
+   --  set in System.Task_Primitives.Operations.Create_Task during the
+   --  thread creation.
+
+   procedure Enter_Task (Self_ID : Task_ID) is
+      procedure Init_Float;
+      pragma Import (C, Init_Float, "__gnat_init_float");
+      --  Properly initializes the FPU for x86 systems.
+
+   begin
+      Specific.Set (Self_ID);
+      Init_Float;
+
+      Self_ID.Common.LL.Thread_Id := GetCurrentThreadId;
+
+      Lock_RTS;
+
+      for J in Known_Tasks'Range loop
+         if Known_Tasks (J) = null then
+            Known_Tasks (J) := Self_ID;
+            Self_ID.Known_Tasks_Index := J;
+            exit;
+         end if;
+      end loop;
+
+      Unlock_RTS;
+   end Enter_Task;
+
+   --------------
+   -- New_ATCB --
+   --------------
+
+   function New_ATCB (Entry_Num : Task_Entry_Index) return Task_ID is
+   begin
+      return new Ada_Task_Control_Block (Entry_Num);
+   end New_ATCB;
+
+   -------------------
+   -- Is_Valid_Task --
+   -------------------
+
+   function Is_Valid_Task return Boolean renames Specific.Is_Valid_Task;
+
+   -----------------------------
+   -- Register_Foreign_Thread --
+   -----------------------------
+
+   function Register_Foreign_Thread return Task_ID is
+   begin
+      if Is_Valid_Task then
+         return Self;
+      else
+         return Register_Foreign_Thread (GetCurrentThread);
+      end if;
+   end Register_Foreign_Thread;
+
+   --------------------
+   -- Initialize_TCB --
+   --------------------
+
+   procedure Initialize_TCB (Self_ID : Task_ID; Succeeded : out Boolean) is
+   begin
+      --  Initialize thread ID to 0, this is needed to detect threads that
+      --  are not yet activated.
+
+      Self_ID.Common.LL.Thread := 0;
+
+      Initialize_Cond (Self_ID.Common.LL.CV'Access);
+
+      if not Single_Lock then
+         Initialize_Lock (Self_ID.Common.LL.L'Access, ATCB_Level);
+      end if;
+
+      Succeeded := True;
+   end Initialize_TCB;
+
+   -----------------
+   -- Create_Task --
+   -----------------
+
+   procedure Create_Task
+     (T          : Task_ID;
+      Wrapper    : System.Address;
+      Stack_Size : System.Parameters.Size_Type;
+      Priority   : System.Any_Priority;
+      Succeeded  : out Boolean)
+   is
+      hTask          : HANDLE;
+      TaskId         : aliased DWORD;
+      pTaskParameter : System.OS_Interface.PVOID;
+      dwStackSize    : DWORD;
+      Result         : DWORD;
+      Entry_Point    : PTHREAD_START_ROUTINE;
+
+   begin
+      pTaskParameter := To_Address (T);
+
+      if Stack_Size = Unspecified_Size then
+         dwStackSize := DWORD (Default_Stack_Size);
+
+      elsif Stack_Size < Minimum_Stack_Size then
+         dwStackSize := DWORD (Minimum_Stack_Size);
+
+      else
+         dwStackSize := DWORD (Stack_Size);
+      end if;
+
+      Entry_Point := To_PTHREAD_START_ROUTINE (Wrapper);
+
+      hTask := CreateThread
+         (null,
+          dwStackSize,
+          Entry_Point,
+          pTaskParameter,
+          DWORD (Create_Suspended),
+          TaskId'Unchecked_Access);
+
+      --  Step 1: Create the thread in blocked mode
+
+      if hTask = 0 then
+         raise Storage_Error;
+      end if;
+
+      --  Step 2: set its TCB
+
+      T.Common.LL.Thread := hTask;
+
+      --  Step 3: set its priority (child has inherited priority from parent)
+
+      Set_Priority (T, Priority);
+
+      if Time_Slice_Val = 0 or else FIFO_Within_Priorities then
+         --  Here we need Annex E semantics so we disable the NT priority
+         --  boost. A priority boost is temporarily given by the system to a
+         --  thread when it is taken out of a wait state.
+
+         SetThreadPriorityBoost (hTask, DisablePriorityBoost => True);
+      end if;
+
+      --  Step 4: Now, start it for good:
+
+      Result := ResumeThread (hTask);
+      pragma Assert (Result = 1);
+
+      Succeeded := Result = 1;
+   end Create_Task;
+
+   ------------------
+   -- Finalize_TCB --
+   ------------------
+
+   procedure Finalize_TCB (T : Task_ID) is
+      Self_ID   : Task_ID := T;
+      Result    : DWORD;
+      Succeeded : BOOL;
+      Is_Self   : constant Boolean := T = Self;
+
+      procedure Free is new
+        Unchecked_Deallocation (Ada_Task_Control_Block, Task_ID);
+
+   begin
+      if not Single_Lock then
+         Finalize_Lock (T.Common.LL.L'Access);
+      end if;
+
+      Finalize_Cond (T.Common.LL.CV'Access);
+
+      if T.Known_Tasks_Index /= -1 then
+         Known_Tasks (T.Known_Tasks_Index) := null;
+      end if;
+
+      if Self_ID.Common.LL.Thread /= 0 then
+
+         --  This task has been activated. Wait for the thread to terminate
+         --  then close it. this is needed to release system ressources.
+
+         Result := WaitForSingleObject (T.Common.LL.Thread, Wait_Infinite);
+         pragma Assert (Result /= WAIT_FAILED);
+         Succeeded := CloseHandle (T.Common.LL.Thread);
+         pragma Assert (Succeeded = True);
+      end if;
+
+      Free (Self_ID);
+
+      if Is_Self then
+         Specific.Set (null);
+      end if;
+   end Finalize_TCB;
+
+   ---------------
+   -- Exit_Task --
+   ---------------
+
+   procedure Exit_Task is
+   begin
+      Specific.Set (null);
+   end Exit_Task;
+
+   ----------------
+   -- Abort_Task --
+   ----------------
+
+   procedure Abort_Task (T : Task_ID) is
+   pragma Unreferenced (T);
+   begin
+      null;
+   end Abort_Task;
+
+   ----------------------
+   -- Environment_Task --
+   ----------------------
+
+   function Environment_Task return Task_ID is
+   begin
+      return Environment_Task_ID;
+   end Environment_Task;
+
+   --------------
+   -- Lock_RTS --
+   --------------
+
+   procedure Lock_RTS is
+   begin
+      Write_Lock (Single_RTS_Lock'Access, Global_Lock => True);
+   end Lock_RTS;
+
+   ----------------
+   -- Unlock_RTS --
+   ----------------
+
+   procedure Unlock_RTS is
+   begin
+      Unlock (Single_RTS_Lock'Access, Global_Lock => True);
+   end Unlock_RTS;
+
+   ----------------
+   -- Initialize --
+   ----------------
+
+   procedure Initialize (Environment_Task : Task_ID) is
+      Discard : BOOL;
+      pragma Unreferenced (Discard);
+
+   begin
+      Environment_Task_ID := Environment_Task;
+
+      if Time_Slice_Val = 0 or else FIFO_Within_Priorities then
+
+         --  Here we need Annex E semantics, switch the current process to the
+         --  High_Priority_Class.
+
+         Discard :=
+           OS_Interface.SetPriorityClass
+             (GetCurrentProcess, High_Priority_Class);
+
+         --  ??? In theory it should be possible to use the priority class
+         --  Realtime_Prioriry_Class but we suspect a bug in the NT scheduler
+         --  which prevents (in some obscure cases) a thread to get on top of
+         --  the running queue by another thread of lower priority. For
+         --  example cxd8002 ACATS test freeze.
+      end if;
+
+      TlsIndex := TlsAlloc;
+
+      --  Initialize the lock used to synchronize chain of all ATCBs.
+
+      Initialize_Lock (Single_RTS_Lock'Access, RTS_Lock_Level);
+
+      Environment_Task.Common.LL.Thread := GetCurrentThread;
+      Enter_Task (Environment_Task);
+   end Initialize;
+
+   ---------------------
+   -- Monotonic_Clock --
+   ---------------------
+
+   function Monotonic_Clock return Duration
+     renames System.OS_Primitives.Monotonic_Clock;
+
+   -------------------
+   -- RT_Resolution --
+   -------------------
+
+   function RT_Resolution return Duration is
+   begin
+      return 0.000_001; --  1 micro-second
+   end RT_Resolution;
+
+   ----------------
+   -- Check_Exit --
+   ----------------
+
+   --  Dummy versions.  The only currently working versions is for solaris
+   --  (native).
+
+   function Check_Exit (Self_ID : ST.Task_ID) return Boolean is
+      pragma Unreferenced (Self_ID);
+
+   begin
+      return True;
+   end Check_Exit;
+
+   --------------------
+   -- Check_No_Locks --
+   --------------------
+
+   function Check_No_Locks (Self_ID : ST.Task_ID) return Boolean is
+      pragma Unreferenced (Self_ID);
+
+   begin
+      return True;
+   end Check_No_Locks;
+
+   ------------------
+   -- Suspend_Task --
+   ------------------
+
+   function Suspend_Task
+     (T           : ST.Task_ID;
+      Thread_Self : Thread_Id) return Boolean
+   is
+   begin
+      if T.Common.LL.Thread /= Thread_Self then
+         return SuspendThread (T.Common.LL.Thread) = NO_ERROR;
+      else
+         return True;
+      end if;
+   end Suspend_Task;
+
+   -----------------
+   -- Resume_Task --
+   -----------------
+
+   function Resume_Task
+     (T           : ST.Task_ID;
+      Thread_Self : Thread_Id) return Boolean
+   is
+   begin
+      if T.Common.LL.Thread /= Thread_Self then
+         return ResumeThread (T.Common.LL.Thread) = NO_ERROR;
+      else
+         return True;
+      end if;
+   end Resume_Task;
+
+end System.Task_Primitives.Operations;