src/soc/decoder/helpers.py

   1 import unittest
   2 from soc.decoder.selectable_int import SelectableInt
   3
   4
   5 def exts(value, bits):
   6     sign = 1 << (bits - 1)
   7     return (value & (sign - 1)) - (value & sign)
   8
   9
  10 def EXTS(value):
  11     """ extends sign bit out from current MSB to all 256 bits
  12     """
  13     assert isinstance(value, SelectableInt)
  14     return SelectableInt(exts(value.value, value.bits) & ((1 << 256)-1), 256)
  15
  16 def EXTS64(value):
  17     """ extends sign bit out from current MSB to 64 bits
  18     """
  19     assert isinstance(value, SelectableInt)
  20     return SelectableInt(exts(value.value, value.bits) & ((1 << 64)-1), 64)
  21
  22
  23 # XXX should this explicitly extend from 32 to 64?
  24 def EXTZ64(value):
  25     if isinstance(value, SelectableInt):
  26         value = value.value
  27     return SelectableInt(value & ((1<<32)-1), 64)
  28
  29
  30 def rotl(value, bits, wordlen):
  31     if isinstance(bits, SelectableInt):
  32         bits = bits.value
  33     mask = (1 << wordlen) - 1
  34     bits = bits & (wordlen - 1)
  35     return ((value << bits) | (value >> (wordlen-bits))) & mask
  36
  37
  38 def ROTL64(value, bits):
  39     return rotl(value, bits, 64)
  40
  41
  42 def ROTL32(value, bits):
  43     return rotl(value, bits, 32)
  44
  45
  46 def MASK(x, y):
  47     if isinstance(x, SelectableInt):
  48         x = x.value
  49     if isinstance(y, SelectableInt):
  50         y = y.value
  51     if x < y:
  52         x = 64-x
  53         y = 63-y
  54         mask_a = ((1 << x) - 1) & ((1 << 64) - 1)
  55         mask_b = ((1 << y) - 1) & ((1 << 64) - 1)
  56     else:
  57         x = 64-x
  58         y = 63-y
  59         mask_a = ((1 << x) - 1) & ((1 << 64) - 1)
  60         mask_b = (~((1 << y) - 1)) & ((1 << 64) - 1)
  61     return mask_a ^ mask_b
  62
  63 def ne(a, b):
  64     return SelectableInt((a != b), bits=1)
  65
  66 def eq(a, b):
  67     return SelectableInt((a == b), bits=1)
  68
  69 def gt(a, b):
  70     return SelectableInt((a > b), bits=1)
  71
  72 def ge(a, b):
  73     return SelectableInt((a >= b), bits=1)
  74
  75 def lt(a, b):
  76     return SelectableInt((a < b), bits=1)
  77
  78 def le(a, b):
  79     return SelectableInt((a <= b), bits=1)
  80
  81 def length(a):
  82     return len(a)
  83
  84 # For these tests I tried to find power instructions that would let me
  85 # isolate each of these helper operations. So for instance, when I was
  86 # testing the MASK() function, I chose rlwinm and rldicl because if I
  87 # set the shift equal to 0 and passed in a value of all ones, the
  88 # result I got would be exactly the same as the output of MASK()
  89
  90 class HelperTests(unittest.TestCase):
  91     def test_MASK(self):
  92         # Verified using rlwinm, rldicl, rldicr in qemu
  93         # li 1, -1
  94         # rlwinm reg, 1, 0, 5, 15
  95         self.assertHex(MASK(5+32, 15+32), 0x7ff0000)
  96         # rlwinm reg, 1, 0, 15, 5
  97         self.assertHex(MASK(15+32, 5+32), 0xfffffffffc01ffff)
  98         self.assertHex(MASK(30+32, 2+32), 0xffffffffe0000003)
  99         # rldicl reg, 1, 0, 37
 100         self.assertHex(MASK(37, 63), 0x7ffffff)
 101         self.assertHex(MASK(10, 63), 0x3fffffffffffff)
 102         self.assertHex(MASK(58, 63), 0x3f)
 103         # rldicr reg, 1, 0, 37
 104         self.assertHex(MASK(0, 37), 0xfffffffffc000000)
 105         self.assertHex(MASK(0, 10), 0xffe0000000000000)
 106         self.assertHex(MASK(0, 58), 0xffffffffffffffe0)
 107
 108         # li 2, 5
 109         # slw 1, 1, 2
 110         self.assertHex(MASK(32, 63-5), 0xffffffe0)
 111
 112     def test_ROTL64(self):
 113         # r1 = 0xdeadbeef12345678
 114         value = 0xdeadbeef12345678
 115
 116         # rldicl reg, 1, 10, 0
 117         self.assertHex(ROTL64(value, 10), 0xb6fbbc48d159e37a)
 118         # rldicl reg, 1, 35, 0
 119         self.assertHex(ROTL64(value, 35), 0x91a2b3c6f56df778)
 120         self.assertHex(ROTL64(value, 58), 0xe37ab6fbbc48d159)
 121         self.assertHex(ROTL64(value, 22), 0xbbc48d159e37ab6f)
 122
 123     def test_ROTL32(self):
 124         # r1 = 0xdeadbeef
 125         value = 0xdeadbeef
 126
 127         # rlwinm reg, 1, 10, 0, 31
 128         self.assertHex(ROTL32(value, 10), 0xb6fbbf7a)
 129         # rlwinm reg, 1, 17, 0, 31
 130         self.assertHex(ROTL32(value, 17), 0x7ddfbd5b)
 131         self.assertHex(ROTL32(value, 25), 0xdfbd5b7d)
 132         self.assertHex(ROTL32(value, 30), 0xf7ab6fbb)
 133
 134     def test_EXTS64(self):
 135         value_a = SelectableInt(0xdeadbeef, 32)  # r1
 136         value_b = SelectableInt(0x73123456, 32)  # r2
 137         value_c = SelectableInt(0x80000000, 32)  # r3
 138
 139         # extswsli reg, 1, 0
 140         self.assertHex(EXTS64(value_a), 0xffffffffdeadbeef)
 141         # extswsli reg, 2, 0
 142         self.assertHex(EXTS64(value_b), SelectableInt(value_b.value, 64))
 143         # extswsli reg, 3, 0
 144         self.assertHex(EXTS64(value_c), 0xffffffff80000000)
 145
 146     def assertHex(self, a, b):
 147         a_val = a
 148         if isinstance(a, SelectableInt):
 149             a_val = a.value
 150         b_val = b
 151         if isinstance(b, SelectableInt):
 152             b_val = b.value
 153         msg = "{:x} != {:x}".format(a_val, b_val)
 154         return self.assertEqual(a, b, msg)
 155
 156
 157 if __name__ == '__main__':
 158     print (SelectableInt.__bases__)
 159     unittest.main()