src/soc/decoder/selectable_int.py

   1 import unittest
   2 from copy import copy
   3 from soc.decoder.power_fields import BitRange
   4 from operator import (add, sub, mul, truediv, mod, or_, and_, xor, neg, inv)
   5
   6
   7 def check_extsign(a, b):
   8     if b.bits != 256:
   9         return b
  10     return SelectableInt(b.value, a.bits)
  11
  12
  13 class FieldSelectableInt:
  14     """FieldSelectableInt: allows bit-range selection onto another target
  15     """
  16     def __init__(self, si, br):
  17         self.si = si # target selectable int
  18         if isinstance(br, list) or isinstance(br, tuple):
  19             _br = BitRange()
  20             for i, v in enumerate(br):
  21                 _br[i] = v
  22             br = _br
  23         self.br = br # map of indices.
  24
  25     def _op(self, op, b):
  26         vi = self.get_range()
  27         vi = op(vi + b)
  28         return self.merge(vi)
  29
  30     def _op1(self, op):
  31         vi = self.get_range()
  32         vi = op(vi)
  33         return self.merge(vi)
  34
  35     def __getitem__(self, key):
  36         key = self.br[key]
  37         return self.si[key]
  38
  39     def __setitem__(self, key, value):
  40         key = self.br[key]
  41         return self.si__setitem__(key, value)
  42
  43     def __negate__(self):
  44         return self._op1(negate)
  45     def __invert__(self):
  46         return self._op1(inv)
  47     def __add__(self, b):
  48         return self._op(add, b)
  49     def __sub__(self, b):
  50         return self._op(sub, b)
  51     def __mul__(self, b):
  52         return self._op(mul, b)
  53     def __div__(self, b):
  54         return self._op(truediv, b)
  55     def __mod__(self, b):
  56         return self._op(mod, b)
  57     def __and__(self, b):
  58         return self._op(and_, b)
  59     def __or__(self, b):
  60         return self._op(or_, b)
  61     def __xor__(self, b):
  62         return self._op(xor, b)
  63
  64     def get_range(self):
  65         print ("get_range", self.si)
  66         vi = SelectableInt(0, len(self.br))
  67         for k, v in self.br.items():
  68             print ("get_range", k, v, self.si[v])
  69             vi[k] = self.si[v]
  70         print ("get_range", vi)
  71         return vi
  72
  73     def merge(self, vi):
  74         fi = copy(self)
  75         for i, v in fi.br.items():
  76             fi.si[v] = vi[i]
  77         return fi
  78
  79     def __repr__(self):
  80         return "FieldSelectableInt(si=%s, br=%s)" % (self.si, self.br)
  81
  82
  83 class FieldSelectableIntTestCase(unittest.TestCase):
  84     def test_arith(self):
  85         a = SelectableInt(0b10101, 5)
  86         b = SelectableInt(0b011, 3)
  87         br = BitRange()
  88         br[0] = 0
  89         br[1] = 2
  90         br[2] = 3
  91         fs = FieldSelectableInt(a, br)
  92         c = fs + b
  93         print (c)
  94         #self.assertEqual(c.value, a.value + b.value)
  95
  96
  97 class SelectableInt:
  98     def __init__(self, value, bits):
  99         mask = (1 << bits) - 1
 100         self.value = value & mask
 101         self.bits = bits
 102
 103     def __add__(self, b):
 104         if isinstance(b, int):
 105             b = SelectableInt(b, self.bits)
 106         b = check_extsign(self, b)
 107         assert b.bits == self.bits
 108         return SelectableInt(self.value + b.value, self.bits)
 109
 110     def __sub__(self, b):
 111         if isinstance(b, int):
 112             b = SelectableInt(b, self.bits)
 113         b = check_extsign(self, b)
 114         assert b.bits == self.bits
 115         return SelectableInt(self.value - b.value, self.bits)
 116
 117     def __mul__(self, b):
 118         b = check_extsign(self, b)
 119         assert b.bits == self.bits
 120         return SelectableInt(self.value * b.value, self.bits)
 121
 122     def __div__(self, b):
 123         b = check_extsign(self, b)
 124         assert b.bits == self.bits
 125         return SelectableInt(self.value / b.value, self.bits)
 126
 127     def __mod__(self, b):
 128         b = check_extsign(self, b)
 129         assert b.bits == self.bits
 130         return SelectableInt(self.value % b.value, self.bits)
 131
 132     def __or__(self, b):
 133         b = check_extsign(self, b)
 134         assert b.bits == self.bits
 135         return SelectableInt(self.value | b.value, self.bits)
 136
 137     def __and__(self, b):
 138         b = check_extsign(self, b)
 139         assert b.bits == self.bits
 140         return SelectableInt(self.value & b.value, self.bits)
 141
 142     def __xor__(self, b):
 143         b = check_extsign(self, b)
 144         assert b.bits == self.bits
 145         return SelectableInt(self.value ^ b.value, self.bits)
 146
 147     def __invert__(self):
 148         return SelectableInt(~self.value, self.bits)
 149
 150     def __neg__(self):
 151         return SelectableInt(~self.value + 1, self.bits)
 152
 153     def __getitem__(self, key):
 154         if isinstance(key, int):
 155             assert key < self.bits, "key %d accessing %d" % (key, self.bits)
 156             assert key >= 0
 157             # NOTE: POWER 3.0B annotation order!  see p4 1.3.2
 158             # MSB is indexed **LOWEST** (sigh)
 159             key = self.bits - (key + 1)
 160
 161             value = (self.value >> key) & 1
 162             return SelectableInt(value, 1)
 163         elif isinstance(key, slice):
 164             assert key.step is None or key.step == 1
 165             assert key.start < key.stop
 166             assert key.start >= 0
 167             assert key.stop <= self.bits
 168
 169             stop = self.bits - key.start
 170             start = self.bits - key.stop
 171
 172             bits = stop - start + 1
 173             mask = (1 << bits) - 1
 174             value = (self.value >> start) & mask
 175             return SelectableInt(value, bits)
 176
 177     def __setitem__(self, key, value):
 178         if isinstance(key, int):
 179             assert key < self.bits
 180             assert key >= 0
 181             key = self.bits - (key + 1)
 182             if isinstance(value, SelectableInt):
 183                 assert value.bits == 1
 184                 value = value.value
 185
 186             value = value << key
 187             mask = 1 << key
 188             self.value = (self.value & ~mask) | (value & mask)
 189         elif isinstance(key, slice):
 190             assert key.step is None or key.step == 1
 191             assert key.start < key.stop
 192             assert key.start >= 0
 193             assert key.stop <= self.bits
 194
 195             stop = self.bits - key.start
 196             start = self.bits - key.stop
 197
 198             bits = stop - start + 1
 199             if isinstance(value, SelectableInt):
 200                 assert value.bits == bits, "%d into %d" % (value.bits, bits)
 201                 value = value.value
 202             mask = ((1 << bits) - 1) << start
 203             value = value << start
 204             self.value = (self.value & ~mask) | (value & mask)
 205
 206     def __ge__(self, other):
 207         if isinstance(other, SelectableInt):
 208             other = check_extsign(self, other)
 209             assert other.bits == self.bits
 210             other = other.value
 211         if isinstance(other, int):
 212             return other >= self.value
 213         assert False
 214
 215     def __le__(self, other):
 216         if isinstance(other, SelectableInt):
 217             other = check_extsign(self, other)
 218             assert other.bits == self.bits
 219             other = other.value
 220         if isinstance(other, int):
 221             return onebit(other <= self.value)
 222         assert False
 223
 224     def __gt__(self, other):
 225         if isinstance(other, SelectableInt):
 226             other = check_extsign(self, other)
 227             assert other.bits == self.bits
 228             other = other.value
 229         if isinstance(other, int):
 230             return onebit(other > self.value)
 231         assert False
 232
 233     def __lt__(self, other):
 234         if isinstance(other, SelectableInt):
 235             other = check_extsign(self, other)
 236             assert other.bits == self.bits
 237             other = other.value
 238         if isinstance(other, int):
 239             return onebit(other < self.value)
 240         assert False
 241
 242     def __eq__(self, other):
 243         if isinstance(other, SelectableInt):
 244             other = check_extsign(self, other)
 245             assert other.bits == self.bits
 246             other = other.value
 247         if isinstance(other, int):
 248             return onebit(other == self.value)
 249         assert False
 250
 251     def narrow(self, bits):
 252         assert bits <= self.bits
 253         return SelectableInt(self.value, bits)
 254
 255     def __bool__(self):
 256         return self.value != 0
 257
 258     def __repr__(self):
 259         return "SelectableInt(value=0x{:x}, bits={})".format(self.value,
 260                                                            self.bits)
 261
 262 def onebit(bit):
 263     return SelectableInt(1 if bit else 0, 1)
 264
 265 def selectltu(lhs, rhs):
 266     """ less-than (unsigned)
 267     """
 268     if isinstance(rhs, SelectableInt):
 269         rhs = rhs.value
 270     return onebit(lhs.value < rhs)
 271
 272 def selectgtu(lhs, rhs):
 273     """ greater-than (unsigned)
 274     """
 275     if isinstance(rhs, SelectableInt):
 276         rhs = rhs.value
 277     return onebit(lhs.value > rhs)
 278
 279
 280 # XXX this probably isn't needed...
 281 def selectassign(lhs, idx, rhs):
 282     if isinstance(idx, tuple):
 283         if len(idx) == 2:
 284             lower, upper = idx
 285             step = None
 286         else:
 287             lower, upper, step = idx
 288         toidx = range(lower, upper, step)
 289         fromidx = range(0, upper-lower, step) # XXX eurgh...
 290     else:
 291         toidx = [idx]
 292         fromidx = [0]
 293     for t, f in zip(toidx, fromidx):
 294         lhs[t] = rhs[f]
 295
 296
 297 def selectconcat(*args, repeat=1):
 298     if repeat != 1 and len(args) == 1 and isinstance(args[0], int):
 299         args = [SelectableInt(args[0], 1)]
 300     if repeat != 1: # multiplies the incoming arguments
 301         tmp = []
 302         for i in range(repeat):
 303             tmp += args
 304         args = tmp
 305     res = copy(args[0])
 306     for i in args[1:]:
 307         assert isinstance(i, SelectableInt), "can only concat SIs, sorry"
 308         res.bits += i.bits
 309         res.value = (res.value << i.bits) | i.value
 310     print ("concat", repeat, res)
 311     return res
 312
 313
 314 class SelectableIntTestCase(unittest.TestCase):
 315     def test_arith(self):
 316         a = SelectableInt(5, 8)
 317         b = SelectableInt(9, 8)
 318         c = a + b
 319         d = a - b
 320         e = a * b
 321         f = -a
 322         self.assertEqual(c.value, a.value + b.value)
 323         self.assertEqual(d.value, (a.value - b.value) & 0xFF)
 324         self.assertEqual(e.value, (a.value * b.value) & 0xFF)
 325         self.assertEqual(f.value, (-a.value) & 0xFF)
 326         self.assertEqual(c.bits, a.bits)
 327         self.assertEqual(d.bits, a.bits)
 328         self.assertEqual(e.bits, a.bits)
 329
 330     def test_logic(self):
 331         a = SelectableInt(0x0F, 8)
 332         b = SelectableInt(0xA5, 8)
 333         c = a & b
 334         d = a | b
 335         e = a ^ b
 336         f = ~a
 337         self.assertEqual(c.value, a.value & b.value)
 338         self.assertEqual(d.value, a.value | b.value)
 339         self.assertEqual(e.value, a.value ^ b.value)
 340         self.assertEqual(f.value, 0xF0)
 341
 342     def test_get(self):
 343         a = SelectableInt(0xa2, 8)
 344         # These should be big endian
 345         self.assertEqual(a[7], 0)
 346         self.assertEqual(a[0:4], 10)
 347         self.assertEqual(a[4:8], 2)
 348
 349     def test_set(self):
 350         a = SelectableInt(0x5, 8)
 351         a[7] = SelectableInt(0, 1)
 352         self.assertEqual(a, 4)
 353         a[4:8] = 9
 354         self.assertEqual(a, 9)
 355         a[0:4] = 3
 356         self.assertEqual(a, 0x39)
 357         a[0:4] = a[4:8]
 358         self.assertEqual(a, 0x199)
 359
 360     def test_concat(self):
 361         a = SelectableInt(0x1, 1)
 362         c = selectconcat(a, repeat=8)
 363         self.assertEqual(c, 0xff)
 364         self.assertEqual(c.bits, 8)
 365         a = SelectableInt(0x0, 1)
 366         c = selectconcat(a, repeat=8)
 367         self.assertEqual(c, 0x00)
 368         self.assertEqual(c.bits, 8)
 369
 370     def test_repr(self):
 371         for i in range(65536):
 372             a = SelectableInt(i, 16)
 373             b = eval(repr(a))
 374             self.assertEqual(a, b)
 375
 376 if __name__ == "__main__":
 377     unittest.main()