Maintainer | Iago Abal <iago.abal@gmail.com> |
---|---|
Safe Haskell | None |
Implementation of bit-vectors as wrappers over Integer
.
- Bit-vectors are interpreted as unsigned integers (i.e. natural numbers) except for some very specific cases.
- Bit-vectors are size-polymorphic insofar as most operations treat a bit-vector of size n as of size m for m >= n if required.
For documentation purposes we will write [n]k
to denote a bit-vector
of size n
representing the natural number k
.
- type BitVector = BV
- data BV
- size :: BV -> Int
- width :: BV -> Int
- nat :: BV -> Integer
- uint :: BV -> Integer
- int :: BV -> Integer
- bitVec :: Integral a => Int -> a -> BV
- ones :: Int -> BV
- zeros :: Int -> BV
- (==.) :: BV -> BV -> Bool
- (/=.) :: BV -> BV -> Bool
- (<.) :: BV -> BV -> Bool
- (<=.) :: BV -> BV -> Bool
- (>.) :: BV -> BV -> Bool
- (>=.) :: BV -> BV -> Bool
- slt :: BV -> BV -> Bool
- sle :: BV -> BV -> Bool
- sgt :: BV -> BV -> Bool
- sge :: BV -> BV -> Bool
- (@.) :: Integral ix => BV -> ix -> Bool
- index :: Integral ix => ix -> BV -> Bool
- (@@) :: Integral ix => BV -> (ix, ix) -> BV
- extract :: Integral ix => ix -> ix -> BV -> BV
- (!.) :: Integral ix => BV -> ix -> Bool
- least :: Integral ix => ix -> BV -> BV
- most :: Integral ix => ix -> BV -> BV
- msb :: BV -> Bool
- lsb :: BV -> Bool
- msb1 :: BV -> Int
- sdiv :: BV -> BV -> BV
- srem :: BV -> BV -> BV
- smod :: BV -> BV -> BV
- lg2 :: BV -> BV
- (#) :: BV -> BV -> BV
- cat :: BV -> BV -> BV
- zeroExtend :: Integral size => size -> BV -> BV
- signExtend :: Integral size => size -> BV -> BV
- foldl_ :: (a -> Bool -> a) -> a -> BV -> a
- foldr_ :: (Bool -> a -> a) -> a -> BV -> a
- reverse_ :: BV -> BV
- replicate_ :: Integral size => size -> BV -> BV
- and_ :: [BV] -> BV
- or_ :: [BV] -> BV
- split :: Integral times => times -> BV -> [BV]
- group_ :: Integral size => size -> BV -> [BV]
- join :: [BV] -> BV
- module Data.Bits
- not_ :: BV -> BV
- nand :: BV -> BV -> BV
- nor :: BV -> BV -> BV
- xnor :: BV -> BV -> BV
- (<<.) :: BV -> BV -> BV
- shl :: BV -> BV -> BV
- (>>.) :: BV -> BV -> BV
- shr :: BV -> BV -> BV
- ashr :: BV -> BV -> BV
- (<<<.) :: BV -> BV -> BV
- rol :: BV -> BV -> BV
- (>>>.) :: BV -> BV -> BV
- ror :: BV -> BV -> BV
- fromBool :: Bool -> BV
- fromBits :: [Bool] -> BV
- toBits :: BV -> [Bool]
- showBin :: BV -> String
- showOct :: BV -> String
- showHex :: BV -> String
- maxNat :: (Integral a, Integral b) => a -> b
- integerWidth :: Integer -> Int
Bit-vectors
Big-endian pseudo size-polymorphic bit-vectors.
Creation
bitVec :: Integral a => Int -> a -> BVSource
Create a bit-vector given a size and an integer value.
>>>
bitVec 4 3
[4]3
This function also handles negative values.
>>>
bitVec 4 (-1)
[4]15
Comparison
(==.) :: BV -> BV -> BoolSource
Fixed-size equality.
In contrast with ==
, which is size-polymorphic, this equality
requires both bit-vectors to be of equal size.
>>>
[n]k ==. [m]k
False
>>>
[n]k ==. [n]k
True
Indexing
(@.) :: Integral ix => BV -> ix -> BoolSource
Bit indexing.
u @. i
stands for the i-th bit of u.
>>>
[4]2 @. 0
False
>>>
[4]2 @. 1
True
(@@) :: Integral ix => BV -> (ix, ix) -> BVSource
Bit-string extraction.
u @@ (j,i) == fromBits (map (u @.) [j,j-1..i])
>>>
[4]7 @@ (3,1)
[3]3
(!.) :: Integral ix => BV -> ix -> BoolSource
Reverse bit-indexing.
Index starting from the most significant bit.
u !. i == u @. (size u - i - 1)
>>>
[3]3 !. 0
False
Most significant 1-bit.
Pre: input must be non-zero.
>>>
msb1 [4]2
1
>>>
msb1 [4]4
2
Arithmetic
List-like operations
zeroExtend :: Integral size => size -> BV -> BVSource
Logical extension.
>>>
zeroExtend 3 [1]1
[4]1
signExtend :: Integral size => size -> BV -> BVSource
Arithmetic extension.
>>>
signExtend 2 [2]1
[4]1
>>>
signExtend 2 [2]3
[4]15
foldl_ :: (a -> Bool -> a) -> a -> BV -> aSource
foldl_ f z (fromBits [un, ..., u1, u0]) == ((((z `f` un) `f` ...) `f` u1) `f` u0)
foldl_ f e = fromBits . foldl f e . toBits
foldr_ :: (Bool -> a -> a) -> a -> BV -> aSource
foldr_ f z (fromBits [un, ..., u1, u0]) == un `f` (... `f` (u1 `f` (u0 `f` z)))
foldr_ f e = fromBits . foldr f e . toBits
replicate_ :: Integral size => size -> BV -> BVSource
Pre: if replicate_ n u
then n > 0
must hold.
replicate_ n == fromBits . concat . replicate n . toBits
split :: Integral times => times -> BV -> [BV]Source
Split a bit-vector k times.
>>>
split 3 [4]15
[[2]0,[2]3,[2]3]
group_ :: Integral size => size -> BV -> [BV]Source
Split a bit-vector into n-wide pieces.
>>>
group_ 3 [4]15
[[3]1,[3]7]
Bitwise operations
module Data.Bits
An alias for complement
.
Conversion
fromBits :: [Bool] -> BVSource
Create a bit-vector from a big-endian list of bits.
>>>
fromBits [False, False, True]
[3]1
Create a big-endian list of bits from a bit-vector.
>>>
toBits [4]11
[True, False, True, True]
Pretty-printing
Utilities
maxNat :: (Integral a, Integral b) => a -> bSource
Greatest natural number representable with n bits.
integerWidth :: Integer -> IntSource
Minimum width of a bit-vector to represent a given integer number.
>>>
integerWith 4
3
>>>
integerWith (-4)
4