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 isinstance(b, FieldSelectableInt):
   9         b = b.get_range()
  10     if isinstance(b, int):
  11         return SelectableInt(b, a.bits)
  12     if b.bits != 256:
  13         return b
  14     return SelectableInt(b.value, a.bits)
  15
  16
  17 class FieldSelectableInt:
  18     """FieldSelectableInt: allows bit-range selection onto another target
  19     """
  20     def __init__(self, si, br):
  21         self.si = si # target selectable int
  22         if isinstance(br, list) or isinstance(br, tuple):
  23             _br = BitRange()
  24             for i, v in enumerate(br):
  25                 _br[i] = v
  26             br = _br
  27         self.br = br # map of indices.
  28
  29     def eq(self, b):
  30         if isinstance(b, SelectableInt):
  31             for i in range(b.bits):
  32                 self[i] = b[i]
  33         else:
  34             self.si = copy(b.si)
  35             self.br = copy(b.br)
  36
  37     def _op(self, op, b):
  38         vi = self.get_range()
  39         vi = op(vi, b)
  40         return self.merge(vi)
  41
  42     def _op1(self, op):
  43         vi = self.get_range()
  44         vi = op(vi)
  45         return self.merge(vi)
  46
  47     def __getitem__(self, key):
  48         print ("getitem", key, self.br)
  49         if isinstance(key, SelectableInt):
  50             key = key.value
  51         if isinstance(key, int):
  52             key = self.br[key] # don't do POWER 1.3.4 bit-inversion
  53             return self.si[key]
  54         if isinstance(key, slice):
  55             key = self.br[key]
  56             return selectconcat(*[self.si[x] for x in key])
  57
  58     def __setitem__(self, key, value):
  59         if isinstance(key, SelectableInt):
  60             key = key.value
  61         key = self.br[key] # don't do POWER 1.3.4 bit-inversion
  62         if isinstance(key, int):
  63             return self.si.__setitem__(key, value)
  64         else:
  65             if not isinstance(value, SelectableInt):
  66                 value = SelectableInt(value, bits=len(key))
  67             for i, k in enumerate(key):
  68                 self.si[k] = value[i]
  69
  70     def __negate__(self):
  71         return self._op1(negate)
  72     def __invert__(self):
  73         return self._op1(inv)
  74     def __add__(self, b):
  75         return self._op(add, b)
  76     def __sub__(self, b):
  77         return self._op(sub, b)
  78     def __mul__(self, b):
  79         return self._op(mul, b)
  80     def __div__(self, b):
  81         return self._op(truediv, b)
  82     def __mod__(self, b):
  83         return self._op(mod, b)
  84     def __and__(self, b):
  85         return self._op(and_, b)
  86     def __or__(self, b):
  87         return self._op(or_, b)
  88     def __xor__(self, b):
  89         return self._op(xor, b)
  90
  91     def get_range(self):
  92         print ("get_range", self.si)
  93         vi = SelectableInt(0, len(self.br))
  94         for k, v in self.br.items():
  95             print ("get_range", k, v, self.si[v])
  96             vi[k] = self.si[v]
  97         print ("get_range", vi)
  98         return vi
  99
 100     def merge(self, vi):
 101         fi = copy(self)
 102         for i, v in fi.br.items():
 103             fi.si[v] = vi[i]
 104         return fi
 105
 106     def __repr__(self):
 107         return "FieldSelectableInt(si=%s, br=%s)" % (self.si, self.br)
 108
 109
 110 class FieldSelectableIntTestCase(unittest.TestCase):
 111     def test_arith(self):
 112         a = SelectableInt(0b10101, 5)
 113         b = SelectableInt(0b011, 3)
 114         br = BitRange()
 115         br[0] = 0
 116         br[1] = 2
 117         br[2] = 3
 118         fs = FieldSelectableInt(a, br)
 119         c = fs + b
 120         print (c)
 121         #self.assertEqual(c.value, a.value + b.value)
 122
 123     def test_select(self):
 124         a = SelectableInt(0b00001111, 8)
 125         br = BitRange()
 126         br[0] = 0
 127         br[1] = 1
 128         br[2] = 4
 129         br[3] = 5
 130         fs = FieldSelectableInt(a, br)
 131
 132         self.assertEqual(fs.get_range(), 0b0011)
 133
 134     def test_select_range(self):
 135         a = SelectableInt(0b00001111, 8)
 136         br = BitRange()
 137         br[0] = 0
 138         br[1] = 1
 139         br[2] = 4
 140         br[3] = 5
 141         fs = FieldSelectableInt(a, br)
 142
 143         self.assertEqual(fs[2:4], 0b11)
 144
 145         fs[0:2] = 0b10
 146         self.assertEqual(fs.get_range(), 0b1011)
 147
 148
 149
 150 class SelectableInt:
 151     def __init__(self, value, bits):
 152         mask = (1 << bits) - 1
 153         self.value = value & mask
 154         self.bits = bits
 155
 156     def eq(self, b):
 157         self.value = b.value
 158         self.bits = b.bits
 159
 160     def __add__(self, b):
 161         if isinstance(b, int):
 162             b = SelectableInt(b, self.bits)
 163         b = check_extsign(self, b)
 164         assert b.bits == self.bits
 165         return SelectableInt(self.value + b.value, self.bits)
 166
 167     def __sub__(self, b):
 168         if isinstance(b, int):
 169             b = SelectableInt(b, self.bits)
 170         b = check_extsign(self, b)
 171         assert b.bits == self.bits
 172         return SelectableInt(self.value - b.value, self.bits)
 173
 174     def __rsub__(self, b):
 175         if isinstance(b, int):
 176             b = SelectableInt(b, self.bits)
 177         b = check_extsign(self, b)
 178         assert b.bits == self.bits
 179         return SelectableInt(b.value - self.value, self.bits)
 180
 181     def __radd__(self, b):
 182         if isinstance(b, int):
 183             b = SelectableInt(b, self.bits)
 184         b = check_extsign(self, b)
 185         assert b.bits == self.bits
 186         return SelectableInt(b.value + self.value, self.bits)
 187
 188     def __mul__(self, b):
 189         b = check_extsign(self, b)
 190         assert b.bits == self.bits
 191         return SelectableInt(self.value * b.value, self.bits)
 192
 193     def __div__(self, b):
 194         b = check_extsign(self, b)
 195         assert b.bits == self.bits
 196         return SelectableInt(self.value / b.value, self.bits)
 197
 198     def __mod__(self, b):
 199         b = check_extsign(self, b)
 200         assert b.bits == self.bits
 201         return SelectableInt(self.value % b.value, self.bits)
 202
 203     def __or__(self, b):
 204         b = check_extsign(self, b)
 205         assert b.bits == self.bits
 206         return SelectableInt(self.value | b.value, self.bits)
 207
 208     def __and__(self, b):
 209         print ("__and__", self, b)
 210         b = check_extsign(self, b)
 211         assert b.bits == self.bits
 212         return SelectableInt(self.value & b.value, self.bits)
 213
 214     def __xor__(self, b):
 215         b = check_extsign(self, b)
 216         assert b.bits == self.bits
 217         return SelectableInt(self.value ^ b.value, self.bits)
 218
 219     def __rxor__(self, b):
 220         b = check_extsign(self, b)
 221         assert b.bits == self.bits
 222         return SelectableInt(self.value ^ b.value, self.bits)
 223
 224     def __invert__(self):
 225         return SelectableInt(~self.value, self.bits)
 226
 227     def __neg__(self):
 228         return SelectableInt(~self.value + 1, self.bits)
 229
 230     def __lshift__(self, b):
 231         b = check_extsign(self, b)
 232         return SelectableInt(self.value << b.value, self.bits)
 233
 234     def __rshift__(self, b):
 235         b = check_extsign(self, b)
 236         return SelectableInt(self.value >> b.value, self.bits)
 237
 238     def __getitem__(self, key):
 239         if isinstance(key, int):
 240             assert key < self.bits, "key %d accessing %d" % (key, self.bits)
 241             assert key >= 0
 242             # NOTE: POWER 3.0B annotation order!  see p4 1.3.2
 243             # MSB is indexed **LOWEST** (sigh)
 244             key = self.bits - (key + 1)
 245
 246             value = (self.value >> key) & 1
 247             return SelectableInt(value, 1)
 248         elif isinstance(key, slice):
 249             assert key.step is None or key.step == 1
 250             assert key.start < key.stop
 251             assert key.start >= 0
 252             assert key.stop <= self.bits
 253
 254             stop = self.bits - key.start
 255             start = self.bits - key.stop
 256
 257             bits = stop - start
 258             #print ("__getitem__ slice num bits", bits)
 259             mask = (1 << bits) - 1
 260             value = (self.value >> start) & mask
 261             return SelectableInt(value, bits)
 262
 263     def __setitem__(self, key, value):
 264         if isinstance(key, int):
 265             assert key < self.bits
 266             assert key >= 0
 267             key = self.bits - (key + 1)
 268             if isinstance(value, SelectableInt):
 269                 assert value.bits == 1
 270                 value = value.value
 271
 272             value = value << key
 273             mask = 1 << key
 274             self.value = (self.value & ~mask) | (value & mask)
 275         elif isinstance(key, slice):
 276             assert key.step is None or key.step == 1
 277             assert key.start < key.stop
 278             assert key.start >= 0
 279             assert key.stop <= self.bits
 280
 281             stop = self.bits - key.start
 282             start = self.bits - key.stop
 283
 284             bits = stop - start
 285             #print ("__setitem__ slice num bits", bits)
 286             if isinstance(value, SelectableInt):
 287                 assert value.bits == bits, "%d into %d" % (value.bits, bits)
 288                 value = value.value
 289             mask = ((1 << bits) - 1) << start
 290             value = value << start
 291             self.value = (self.value & ~mask) | (value & mask)
 292
 293     def __ge__(self, other):
 294         if isinstance(other, FieldSelectableInt):
 295             other = other.get_range()
 296         if isinstance(other, SelectableInt):
 297             other = check_extsign(self, other)
 298             assert other.bits == self.bits
 299             other = other.value
 300         if isinstance(other, int):
 301             return onebit(self.value >= other.value)
 302         assert False
 303
 304     def __le__(self, other):
 305         if isinstance(other, FieldSelectableInt):
 306             other = other.get_range()
 307         if isinstance(other, SelectableInt):
 308             other = check_extsign(self, other)
 309             assert other.bits == self.bits
 310             other = other.value
 311         if isinstance(other, int):
 312             return onebit(self.value <= other)
 313         assert False
 314
 315     def __gt__(self, other):
 316         if isinstance(other, FieldSelectableInt):
 317             other = other.get_range()
 318         if isinstance(other, SelectableInt):
 319             other = check_extsign(self, other)
 320             assert other.bits == self.bits
 321             other = other.value
 322         if isinstance(other, int):
 323             return onebit(self.value > other)
 324         assert False
 325
 326     def __lt__(self, other):
 327         if isinstance(other, FieldSelectableInt):
 328             other = other.get_range()
 329         if isinstance(other, SelectableInt):
 330             other = check_extsign(self, other)
 331             assert other.bits == self.bits
 332             other = other.value
 333         if isinstance(other, int):
 334             return onebit(self.value < other)
 335         assert False
 336
 337     def __eq__(self, other):
 338         print ("__eq__", self, other)
 339         if isinstance(other, FieldSelectableInt):
 340             other = other.get_range()
 341         if isinstance(other, SelectableInt):
 342             other = check_extsign(self, other)
 343             assert other.bits == self.bits
 344             other = other.value
 345         if isinstance(other, int):
 346             return onebit(other == self.value)
 347         assert False
 348
 349     def narrow(self, bits):
 350         assert bits <= self.bits
 351         return SelectableInt(self.value, bits)
 352
 353     def __bool__(self):
 354         return self.value != 0
 355
 356     def __repr__(self):
 357         return "SelectableInt(value=0x{:x}, bits={})".format(self.value,
 358                                                            self.bits)
 359
 360     def __len__(self):
 361         return self.bits
 362
 363 def onebit(bit):
 364     return SelectableInt(1 if bit else 0, 1)
 365
 366 def selectltu(lhs, rhs):
 367     """ less-than (unsigned)
 368     """
 369     if isinstance(rhs, SelectableInt):
 370         rhs = rhs.value
 371     return onebit(lhs.value < rhs)
 372
 373 def selectgtu(lhs, rhs):
 374     """ greater-than (unsigned)
 375     """
 376     if isinstance(rhs, SelectableInt):
 377         rhs = rhs.value
 378     return onebit(lhs.value > rhs)
 379
 380
 381 # XXX this probably isn't needed...
 382 def selectassign(lhs, idx, rhs):
 383     if isinstance(idx, tuple):
 384         if len(idx) == 2:
 385             lower, upper = idx
 386             step = None
 387         else:
 388             lower, upper, step = idx
 389         toidx = range(lower, upper, step)
 390         fromidx = range(0, upper-lower, step) # XXX eurgh...
 391     else:
 392         toidx = [idx]
 393         fromidx = [0]
 394     for t, f in zip(toidx, fromidx):
 395         lhs[t] = rhs[f]
 396
 397
 398 def selectconcat(*args, repeat=1):
 399     if repeat != 1 and len(args) == 1 and isinstance(args[0], int):
 400         args = [SelectableInt(args[0], 1)]
 401     if repeat != 1: # multiplies the incoming arguments
 402         tmp = []
 403         for i in range(repeat):
 404             tmp += args
 405         args = tmp
 406     res = copy(args[0])
 407     for i in args[1:]:
 408         if isinstance(i, FieldSelectableInt):
 409             i = i.si
 410         assert isinstance(i, SelectableInt), "can only concat SIs, sorry"
 411         res.bits += i.bits
 412         res.value = (res.value << i.bits) | i.value
 413     print ("concat", repeat, res)
 414     return res
 415
 416
 417 class SelectableIntTestCase(unittest.TestCase):
 418     def test_arith(self):
 419         a = SelectableInt(5, 8)
 420         b = SelectableInt(9, 8)
 421         c = a + b
 422         d = a - b
 423         e = a * b
 424         f = -a
 425         self.assertEqual(c.value, a.value + b.value)
 426         self.assertEqual(d.value, (a.value - b.value) & 0xFF)
 427         self.assertEqual(e.value, (a.value * b.value) & 0xFF)
 428         self.assertEqual(f.value, (-a.value) & 0xFF)
 429         self.assertEqual(c.bits, a.bits)
 430         self.assertEqual(d.bits, a.bits)
 431         self.assertEqual(e.bits, a.bits)
 432
 433     def test_logic(self):
 434         a = SelectableInt(0x0F, 8)
 435         b = SelectableInt(0xA5, 8)
 436         c = a & b
 437         d = a | b
 438         e = a ^ b
 439         f = ~a
 440         self.assertEqual(c.value, a.value & b.value)
 441         self.assertEqual(d.value, a.value | b.value)
 442         self.assertEqual(e.value, a.value ^ b.value)
 443         self.assertEqual(f.value, 0xF0)
 444
 445     def test_get(self):
 446         a = SelectableInt(0xa2, 8)
 447         # These should be big endian
 448         self.assertEqual(a[7], 0)
 449         self.assertEqual(a[0:4], 10)
 450         self.assertEqual(a[4:8], 2)
 451
 452     def test_set(self):
 453         a = SelectableInt(0x5, 8)
 454         a[7] = SelectableInt(0, 1)
 455         self.assertEqual(a, 4)
 456         a[4:8] = 9
 457         self.assertEqual(a, 9)
 458         a[0:4] = 3
 459         self.assertEqual(a, 0x39)
 460         a[0:4] = a[4:8]
 461         self.assertEqual(a, 0x99)
 462
 463     def test_concat(self):
 464         a = SelectableInt(0x1, 1)
 465         c = selectconcat(a, repeat=8)
 466         self.assertEqual(c, 0xff)
 467         self.assertEqual(c.bits, 8)
 468         a = SelectableInt(0x0, 1)
 469         c = selectconcat(a, repeat=8)
 470         self.assertEqual(c, 0x00)
 471         self.assertEqual(c.bits, 8)
 472
 473     def test_repr(self):
 474         for i in range(65536):
 475             a = SelectableInt(i, 16)
 476             b = eval(repr(a))
 477             self.assertEqual(a, b)
 478
 479     def test_cmp(self):
 480         a = SelectableInt(10, bits=8)
 481         b = SelectableInt(5, bits=8)
 482         self.assertTrue(a > b)
 483         self.assertFalse(a < b)
 484         self.assertTrue(a != b)
 485         self.assertFalse(a == b)
 486
 487     def test_unsigned(self):
 488         a = SelectableInt(0x80, bits=8)
 489         b = SelectableInt(0x7f, bits=8)
 490         self.assertTrue(a > b)
 491         self.assertFalse(a < b)
 492         self.assertTrue(a != b)
 493         self.assertFalse(a == b)
 494
 495 if __name__ == "__main__":
 496     unittest.main()