gcc/ada/s-bitops.adb

   1 ------------------------------------------------------------------------------
   2 --                                                                          --
   3 --                 GNAT RUN-TIME LIBRARY (GNARL) COMPONENTS                 --
   4 --                                                                          --
   5 --                       S Y S T E M . B I T _ O P S                        --
   6 --                                                                          --
   7 --                                 B o d y                                  --
   8 --                                                                          --
   9 --         Copyright (C) 1996-2005 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 2,  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.  See the GNU General Public License --
  17 -- for  more details.  You should have  received  a copy of the GNU General --
  18 -- Public License  distributed with GNAT;  see file COPYING.  If not, write --
  19 -- to  the  Free Software Foundation,  51  Franklin  Street,  Fifth  Floor, --
  20 -- Boston, MA 02110-1301, USA.                                              --
  21 --                                                                          --
  22 -- As a special exception,  if other files  instantiate  generics from this --
  23 -- unit, or you link  this unit with other files  to produce an executable, --
  24 -- this  unit  does not  by itself cause  the resulting  executable  to  be --
  25 -- covered  by the  GNU  General  Public  License.  This exception does not --
  26 -- however invalidate  any other reasons why  the executable file  might be --
  27 -- covered by the  GNU Public License.                                      --
  28 --                                                                          --
  29 -- GNAT was originally developed  by the GNAT team at  New York University. --
  30 -- Extensive contributions were provided by Ada Core Technologies Inc.      --
  31 --                                                                          --
  32 ------------------------------------------------------------------------------
  33
  34 with System;                 use System;
  35 with System.Pure_Exceptions; use System.Pure_Exceptions;
  36 with System.Unsigned_Types;  use System.Unsigned_Types;
  37
  38 with Unchecked_Conversion;
  39
  40 package body System.Bit_Ops is
  41
  42    subtype Bits_Array is System.Unsigned_Types.Packed_Bytes1 (Positive);
  43    --  Dummy array type used to interpret the address values. We use the
  44    --  unaligned version always, since this will handle both the aligned and
  45    --  unaligned cases, and we always do these operations by bytes anyway.
  46    --  Note: we use a ones origin array here so that the computations of the
  47    --  length in bytes work correctly (give a non-negative value) for the
  48    --  case of zero length bit strings). Note that we never allocate any
  49    --  objects of this type (we can't because they would be absurdly big).
  50
  51    type Bits is access Bits_Array;
  52    --  This is the actual type into which address values are converted
  53
  54    function To_Bits is new Unchecked_Conversion (Address, Bits);
  55
  56    LE : constant := Standard'Default_Bit_Order;
  57    --  Static constant set to 0 for big-endian, 1 for little-endian
  58
  59    --  The following is an array of masks used to mask the final byte, either
  60    --  at the high end (big-endian case) or the low end (little-endian case).
  61
  62    Masks : constant array (1 .. 7) of Packed_Byte := (
  63      (1 - LE) * 2#1000_0000# + LE * 2#0000_0001#,
  64      (1 - LE) * 2#1100_0000# + LE * 2#0000_0011#,
  65      (1 - LE) * 2#1110_0000# + LE * 2#0000_0111#,
  66      (1 - LE) * 2#1111_0000# + LE * 2#0000_1111#,
  67      (1 - LE) * 2#1111_1000# + LE * 2#0001_1111#,
  68      (1 - LE) * 2#1111_1100# + LE * 2#0011_1111#,
  69      (1 - LE) * 2#1111_1110# + LE * 2#0111_1111#);
  70
  71    -----------------------
  72    -- Local Subprograms --
  73    -----------------------
  74
  75    procedure Raise_Error;
  76    --  Raise Constraint_Error, complaining about unequal lengths
  77
  78    -------------
  79    -- Bit_And --
  80    -------------
  81
  82    procedure Bit_And
  83      (Left   : Address;
  84       Llen   : Natural;
  85       Right  : Address;
  86       Rlen   : Natural;
  87       Result : Address)
  88    is
  89       LeftB   : constant Bits := To_Bits (Left);
  90       RightB  : constant Bits := To_Bits (Right);
  91       ResultB : constant Bits := To_Bits (Result);
  92
  93    begin
  94       if Llen /= Rlen then
  95          Raise_Error;
  96       end if;
  97
  98       for J in 1 .. (Rlen + 7) / 8 loop
  99          ResultB (J) := LeftB (J) and RightB (J);
 100       end loop;
 101    end Bit_And;
 102
 103    ------------
 104    -- Bit_Eq --
 105    ------------
 106
 107    function Bit_Eq
 108      (Left  : Address;
 109       Llen  : Natural;
 110       Right : Address;
 111       Rlen  : Natural) return Boolean
 112    is
 113       LeftB  : constant Bits := To_Bits (Left);
 114       RightB : constant Bits := To_Bits (Right);
 115
 116    begin
 117       if Llen /= Rlen then
 118          return False;
 119
 120       else
 121          declare
 122             BLen : constant Natural := Llen / 8;
 123             Bitc : constant Natural := Llen mod 8;
 124
 125          begin
 126             if LeftB (1 .. BLen) /= RightB (1 .. BLen) then
 127                return False;
 128
 129             elsif Bitc /= 0 then
 130                return
 131                  ((LeftB (BLen + 1) xor RightB (BLen + 1))
 132                    and Masks (Bitc)) = 0;
 133
 134             else -- Bitc = 0
 135                return True;
 136             end if;
 137          end;
 138       end if;
 139    end Bit_Eq;
 140
 141    -------------
 142    -- Bit_Not --
 143    -------------
 144
 145    procedure Bit_Not
 146      (Opnd   : System.Address;
 147       Len    : Natural;
 148       Result : System.Address)
 149    is
 150       OpndB   : constant Bits := To_Bits (Opnd);
 151       ResultB : constant Bits := To_Bits (Result);
 152
 153    begin
 154       for J in 1 .. (Len + 7) / 8 loop
 155          ResultB (J) := not OpndB (J);
 156       end loop;
 157    end Bit_Not;
 158
 159    ------------
 160    -- Bit_Or --
 161    ------------
 162
 163    procedure Bit_Or
 164      (Left   : Address;
 165       Llen   : Natural;
 166       Right  : Address;
 167       Rlen   : Natural;
 168       Result : Address)
 169    is
 170       LeftB   : constant Bits := To_Bits (Left);
 171       RightB  : constant Bits := To_Bits (Right);
 172       ResultB : constant Bits := To_Bits (Result);
 173
 174    begin
 175       if Llen /= Rlen then
 176          Raise_Error;
 177       end if;
 178
 179       for J in 1 .. (Rlen + 7) / 8 loop
 180          ResultB (J) := LeftB (J) or RightB (J);
 181       end loop;
 182    end Bit_Or;
 183
 184    -------------
 185    -- Bit_Xor --
 186    -------------
 187
 188    procedure Bit_Xor
 189      (Left   : Address;
 190       Llen   : Natural;
 191       Right  : Address;
 192       Rlen   : Natural;
 193       Result : Address)
 194    is
 195       LeftB   : constant Bits := To_Bits (Left);
 196       RightB  : constant Bits := To_Bits (Right);
 197       ResultB : constant Bits := To_Bits (Result);
 198
 199    begin
 200       if Llen /= Rlen then
 201          Raise_Error;
 202       end if;
 203
 204       for J in 1 .. (Rlen + 7) / 8 loop
 205          ResultB (J) := LeftB (J) xor RightB (J);
 206       end loop;
 207    end Bit_Xor;
 208
 209    -----------------
 210    -- Raise_Error --
 211    -----------------
 212
 213    procedure Raise_Error is
 214    begin
 215       Raise_Exception (CE, "unequal lengths in logical operation");
 216    end Raise_Error;
 217
 218 end System.Bit_Ops;