2007-04-06 Thomas Quinot <quinot@adacore.com>

	    Pat Rogers  <rogers@adacore.com>
	    Pascal Obry  <obry@adacore.com>

	* g-stsifd-sockets.adb: New file.

	* g-socthi.ads, g-socket.adb, g-socthi-vxworks.adb,
	g-socthi-vxworks.ads, g-socthi-mingw.ads, g-socthi-vms.ads,
	g-socthi-vms.adb: Move signalling
	fd management to a nested package, so that they can conveniently be
	moved to a subunit that is shared across Windows, VMS, and VxWorks
	(Ada implementation) or completed with imported bodies from socket.c
	(UNIX case).
	(Read_Signalling_Fd, Write_Signalling_Fd, Create_Signalling_Fds): New
	subprograms.
	(Check_Selector): Use Read_Signalling_Fd to read and discard data from
	the signalling file descriptor.
	(Abort_Selector): Use Write_Signalling_Fd to write dummy data to the
	signalling file descriptor.
	(Create_Selector): Use new C-imported subprogram Create_Signalling_Fds
	instead of creating a pair of sockets for signalling here.

	* g-socthi.adb: Ditto.
	Set the runtime process to ignore SIGPIPEs on platforms that support
	neither SO_NOSIGPIPE nor MSG_NOSIGNAL functionality.

	* g-socthi-mingw.adb: Ditto.
	(WS_Version): Use Windows 2.2.
	Use Winsock 2.2 (instead of 1.1) for the GNAT.Socket API.

	* g-soliop-mingw.ads: Link with ws2_32 for Windows 2.x support.
	Use Winsock 2.2 (instead of 1.1) for the GNAT.Socket API.

	* Makefile.in: New libgnat pair g-stsifd.adb<g-stsifd-sockets.adb.
	added GNAT byte swapping facility
	Update FreeBSD THREADSLIB from -lc_r to -lpthread, for FreeBSD 6.

	* g-bytswa.adb, g-bytswa-x86.adb, g-bytswa.ads: New files.

	* socket.c (__gnat_read_signalling_fd, __gnat_write_controlling_fd):
	New subprograms.
	(__gnat_create_signalling_fds): New subprogram.
	Set the runtime process to ignore SIGPIPEs on platforms that support
	neither SO_NOSIGPIPE nor MSG_NOSIGNAL functionality.



git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@123542 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 206 insertions, 0 deletions

diff --git a/gcc/ada/g-bytswa.ads b/gcc/ada/g-bytswa.ads
new file mode 100644
index 00000000000..5c9741482ea
--- /dev/null
+++ b/gcc/ada/g-bytswa.ads
@@ -0,0 +1,206 @@
+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT RUN-TIME COMPONENTS                         --
+--                                                                          --
+--                    G N A T . B Y T E _ S W A P P I N G                   --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+--                      Copyright (C) 2006, AdaCore                         --
+--                                                                          --
+-- 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,  51  Franklin  Street,  Fifth  Floor, --
+-- Boston, MA 02110-1301, 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.      --
+--                                                                          --
+------------------------------------------------------------------------------
+
+--  Simple routines for swapping the bytes of 16-, 32-, and 64-bit objects.
+
+--  The generic functions should be instantiated with types that
+--  are of a size in bytes corresponding to the name of the generic. For
+--  example, a 2-byte integer type would be compatible with Swapped2, 4-byte
+--  integer with Swapped4, and so on. Failure to do so will result in a
+--  warning when compiling the instantiation; this warning should be heeded.
+--  Ignoring this warning can result in unexpected results.
+
+--  An example of proper usage follows:
+
+--     declare
+--        type Short_Integer is range -32768 .. 32767;
+--        for Short_Integer'Size use 16; -- for confirmation
+
+--        X : Short_Integer := 16#7FFF#;
+
+--        function Swapped is new Byte_Swapping.Swapped2 (Short_Integer);
+
+--     begin
+--        Put_Line (X'Img);
+--        X := Swapped (X);
+--        Put_Line (X'Img);
+--     end;
+
+--  Note that the generic actual types need not be scalars, but must be
+--  'definite' types. They can, for example, be constrained subtypes of
+--  unconstrained array types as long as the size is correct. For instance,
+--  a subtype of String with length of 4 would be compatible with the
+--  Swapped4 generic:
+
+--     declare
+--        subtype String4 is String (1 .. 4);
+--        function Swapped is new Byte_Swapping.Swapped4 (String4);
+--        S : String4 := "ABCD";
+--     begin
+--        Put_Line (S);
+--        S := Swapped (S);
+--        Put_Line (S);
+--     end;
+
+--  Similarly, a constrained array type is also acceptable:
+
+--     declare
+--        type Mask is array (0 .. 15) of Boolean;
+--        for Mask'Component_Size use Boolean'Size;
+--        X : Mask := (0 .. 7 => True, others => False);
+--        function Swapped is new Byte_Swapping.Swapped2 (Mask);
+--     begin
+--        ...
+--        X := Swapped (X);
+--        ...
+--     end;
+
+--  A properly-sized record type will also be acceptable, and so forth.
+
+--  However, as described, a size mismatch must be avoided. In the following
+--  we instantiate one of the generics with a type that is too large. The
+--  result of the function call is undefined, such that assignment to an
+--  object can result in garbage values.
+
+--     Wrong: declare
+--        subtype String16 is String (1 .. 16);
+
+--        function Swapped is new Byte_Swapping.Swapped8 (String16);
+--        --  Instantiation generates a compiler warning about
+--        --  mismatched sizes
+
+--        S : String16;
+
+--     begin
+--        S := "ABCDEFGHDEADBEEF";
+--
+--        Put_Line (S);
+--
+--        --  the following assignment results in garbage in S after the
+--        --  first 8 bytes
+--
+--        S := Swapped (S);
+--
+--        Put_Line (S);
+--     end Wrong;
+
+--  When the size of the type is larger than 8 bytes, the use of the
+--  non-generic procedures is an alternative because no function result is
+--  involved; manipulation of the object is direct.
+
+--  The procedures are passed the address of an object to manipulate. They will
+--  swap the first N bytes of that object corresponding to the name of the
+--  procedure.  For example:
+
+--     declare
+--        S2 : String := "AB";
+--        for S2'Alignment use 2;
+--        S4 : String := "ABCD";
+--        for S4'Alignment use 4;
+--        S8 : String := "ABCDEFGH";
+--        for S8'Alignment use 8;
+
+--     begin
+--        Swap2 (S2'Address);
+--        Put_Line (S2);
+
+--        Swap4 (S4'Address);
+--        Put_Line (S4);
+
+--        Swap8 (S8'Address);
+--        Put_Line (S8);
+--     end;
+
+--  If an object of a type larger than N is passed, the remaining
+--  bytes of the object are undisturbed.  For example:
+
+--     declare
+--        subtype String16 is String (1 .. 16);
+
+--        S : String16;
+--        for S'Alignment use 8;
+
+--     begin
+--        S  := "ABCDEFGHDEADBEEF";
+--        Put_Line (S);
+--        Swap8 (S'Address);
+--        Put_Line (S);
+--     end;
+
+with System;
+
+package GNAT.Byte_Swapping is
+   pragma Pure;
+
+   --  NB: all the routines in this package treat the application objects as
+   --  unsigned (modular) types of a size in bytes corresponding to the routine
+   --  name. For example, the generic function Swapped2 manipulates the object
+   --  passed to the formal parameter Input as a value of an unsigned type that
+   --  is 2 bytes long. Therefore clients are responsible for the compatibility
+   --  of application types manipulated by these routines and these modular
+   --  types, in terms of both size and alignment. This requirement applies to
+   --  the generic actual type passed to the generic formal type Item in the
+   --  generic functions, as well as to the type of the object implicitly
+   --  designated by the address passed to the non-generic procedures. Use of
+   --  incompatible types can result in implementation- defined effects.
+
+   generic
+      type Item is limited private;
+   function Swapped2 (Input : Item) return Item;
+   --  Return the 2-byte value of Input with the bytes swapped
+
+   generic
+      type Item is limited private;
+   function Swapped4 (Input : Item) return Item;
+   --  Return the 4-byte value of Input with the bytes swapped
+
+   generic
+      type Item is limited private;
+   function Swapped8 (Input : Item) return Item;
+   --  Return the 8-byte value of Input with the bytes swapped
+
+   procedure Swap2 (Location : System.Address);
+   --  Swap the first 2 bytes of the object starting at the address specified
+   --  by Location.
+
+   procedure Swap4 (Location : System.Address);
+   --  Swap the first 4 bytes of the object starting at the address specified
+   --  by Location.
+
+   procedure Swap8 (Location : System.Address);
+   --  Swap the first 8 bytes of the object starting at the address specified
+   --  by Location.
+
+   pragma Inline (Swap2, Swap4, Swap8, Swapped2, Swapped4, Swapped8);
+
+end GNAT.Byte_Swapping;