import struct
import sys
from openpower.decoder.selectable_int import (SelectableInt, onebit,
- selectconcat)
+ selectconcat, FieldSelectableInt)
+from openpower.decoder.selectable_int import EFFECTIVELY_UNLIMITED as EU
from nmutil.divmod import trunc_divs, trunc_rems
-from operator import floordiv, mod
+from operator import floordiv, mod, truediv # truediv used by bfp_* functions
from openpower.decoder.selectable_int import selectltu as ltu
from openpower.decoder.selectable_int import selectgtu as gtu
from openpower.decoder.selectable_int import check_extsign
+from openpower.fpscr import FPSCRState
+from openpower.xer import XERState
+from openpower.decoder.isa.svshape import SVSHAPE
+from openpower.decoder.isa.svstate import SVP64State
+from openpower.decoder.fp_working_format import (
+ BFPState, SelectableMSB0Fraction)
from openpower.util import log
import math
def EXTS(value):
- """ extends sign bit out from current MSB to all 256 bits
+ """ extends sign bit out from current MSB to MAX limit bits
"""
log("EXTS", value, type(value))
assert isinstance(value, SelectableInt)
- return SelectableInt(exts(value.value, value.bits) & ((1 << 256)-1), 256)
+ return SelectableInt(exts(value.value, value.bits) & ((1 << EU)-1), EU)
+
+
+def EXTZ(value):
+ """ zero extend to EFFECTIVELY_UNLIMITED bits
+ """
+ if isinstance(value, SelectableInt):
+ value = value.value
+ return SelectableInt(value & ((1 << EU) - 1), EU)
def EXTS64(value):
return SelectableInt(exts(value.value, value.bits) & ((1 << 128)-1), 128)
+def copy_assign_rhs(inp):
+ """ implicitly added function call to all assignment RHSes.
+ This copies the passed-in value so later assignments to parts of the
+ LHS don't modify the RHS if it's a SelectableInt.
+
+ Example:
+ ```
+ # this needs to copy the SelectableInt instance in RA
+ # not just assign a reference to it to A
+ A <- RA
+ A[0] <- 1 # if the copy wasn't performed, we just modified RA too!
+ ```
+ """
+ if isinstance(inp, (str, int)):
+ return inp
+ if isinstance(inp, FPSCRState):
+ return FPSCRState(inp)
+ if isinstance(inp, XERState):
+ return XERState(inp)
+ if isinstance(inp, SVSHAPE):
+ return SVSHAPE(inp)
+ if isinstance(inp, SVP64State):
+ return SVP64State(inp)
+ if isinstance(inp, (SelectableInt, FieldSelectableInt)):
+ return SelectableInt(inp)
+ if isinstance(inp, BFPState):
+ return BFPState(inp)
+ if isinstance(inp, SelectableMSB0Fraction):
+ return SelectableMSB0Fraction(inp)
+ if isinstance(inp, tuple):
+ return tuple(map(copy_assign_rhs, inp))
+ if isinstance(inp, dict):
+ return {copy_assign_rhs(k): copy_assign_rhs(v) for k, v in inp.items()}
+ raise TypeError("tried to assign an unsupported type in pseudo-code",
+ repr(type(inp)))
+
+
# signed version of MUL
def MULS(a, b):
if isinstance(b, int):
return SelectableInt((value << bits) & mask, 64)
-def ROTL64(value, bits):
- return rotl(value, bits, 64)
-
-
-def ROTL32(value, bits):
- if isinstance(bits, SelectableInt):
- bits = bits.value
- if isinstance(value, SelectableInt):
- value = SelectableInt(value.value, 64)
- return rotl(value | (value << 32), bits, 64)
-
-
-def MASK32(x, y):
- if isinstance(x, SelectableInt):
- x = x.value
- if isinstance(y, SelectableInt):
- y = y.value
- return MASK(x+32, y+32)
-
-
-def MASK(x, y):
- if isinstance(x, SelectableInt):
- x = x.value
- if isinstance(y, SelectableInt):
- y = y.value
- if x < y:
- x = 64-x
- y = 63-y
- mask_a = ((1 << x) - 1) & ((1 << 64) - 1)
- mask_b = ((1 << y) - 1) & ((1 << 64) - 1)
- elif x == y:
- return 1 << (63-x)
- else:
- x = 64-x
- y = 63-y
- mask_a = ((1 << x) - 1) & ((1 << 64) - 1)
- mask_b = (~((1 << y) - 1)) & ((1 << 64) - 1)
- return mask_a ^ mask_b
-
-
def ne(a, b):
return onebit(a != b)
return retval
+# BFP classification predicates
+# these need to be implemented in python because they work with multiple
+# input types
+def IsInf(v):
+ if isinstance(v, BFPState):
+ return onebit(v.class_.Infinity)
+ # TODO: implement for SelectableInt/int
+ raise NotImplementedError("not yet implemented for non-BFPState values")
+
+
+def IsNaN(v):
+ if isinstance(v, BFPState):
+ return onebit(v.class_.SNaN or v.class_.QNaN)
+ # TODO: implement for SelectableInt/int
+ raise NotImplementedError("not yet implemented for non-BFPState values")
+
+
+def IsNeg(v):
+ if isinstance(v, BFPState):
+ if v.class_.SNaN or v.class_.QNaN or v.class_.Zero:
+ return onebit(0)
+ return onebit(v.sign)
+ # TODO: implement for SelectableInt/int
+ raise NotImplementedError("not yet implemented for non-BFPState values")
+
+
+def IsSNaN(v):
+ if isinstance(v, BFPState):
+ return onebit(v.class_.SNaN)
+ # TODO: implement for SelectableInt/int
+ raise NotImplementedError("not yet implemented for non-BFPState values")
+
+
+def IsZero(v):
+ if isinstance(v, BFPState):
+ return onebit(v.class_.Zero)
+ # TODO: implement for SelectableInt/int
+ raise NotImplementedError("not yet implemented for non-BFPState values")
+
+
+def SetFX(fpscr, field):
+ assert isinstance(fpscr, FPSCRState), "SetFX only works on FPSCR fields"
+ if eq(getattr(fpscr, field), SelectableInt(0, 1)):
+ setattr(fpscr, field, SelectableInt(1, 1))
+ fpscr.FX = SelectableInt(1, 1)
+
+
+class ISACallerHelper:
+ def __init__(self, XLEN, FPSCR):
+ self.__XLEN = XLEN
+ if FPSCR is None:
+ FPSCR = FPSCRState()
+ self.__FPSCR = FPSCR
+
+ @property
+ def XLEN(self):
+ return self.__XLEN
+
+ @property
+ def FPSCR(self):
+ return self.__FPSCR
+
+ def EXTZXL(self, value, bits=None):
+ if bits is None:
+ bits = self.XLEN
+ elif isinstance(bits, SelectableInt):
+ bits = bits.value
+ if isinstance(value, SelectableInt):
+ value = value.value
+ return SelectableInt(value & ((1 << bits) - 1), self.XLEN)
+
+ def EXTSXL(self, value, bits=None):
+ if isinstance(value, SelectableInt):
+ value = value.value
+ if bits is None:
+ bits = self.XLEN
+ elif isinstance(bits, SelectableInt):
+ bits = bits.value
+ return SelectableInt(exts(value, bits), self.XLEN)
+
+ def DOUBLE2SINGLE(self, FRS):
+ """ DOUBLE2SINGLE has been renamed to FRSP since it is the
+ implementation of the frsp instruction.
+ use SINGLE() or FRSP() instead, or just use struct.pack/unpack
+ """
+ return self.FRSP(FRS)
+
+ def ROTL32(self, value, bits):
+ if isinstance(bits, SelectableInt):
+ bits = bits.value
+ if isinstance(value, SelectableInt):
+ value = SelectableInt(value.value, self.XLEN)
+ value = value | (value << (self.XLEN//2))
+ value = rotl(value, bits, self.XLEN)
+ return value
+
+ def ROTL128(self, value, bits):
+ return rotl(value, bits, self.XLEN*2)
+
+ def ROTL64(self, value, bits):
+ return rotl(value, bits, self.XLEN)
+
+ def MASK32(self, x, y):
+ if isinstance(x, SelectableInt):
+ x = x.value
+ if isinstance(y, SelectableInt):
+ y = y.value
+ return self.MASK(x+(self.XLEN//2), y+(self.XLEN//2))
+
+ def MASK(self, x, y, lim=None):
+ if lim is None:
+ lim = self.XLEN
+ if isinstance(x, SelectableInt):
+ x = x.value
+ if isinstance(y, SelectableInt):
+ y = y.value
+ if x < y:
+ x = lim-x
+ y = (lim-1)-y
+ mask_a = ((1 << x) - 1) & ((1 << lim) - 1)
+ mask_b = ((1 << y) - 1) & ((1 << lim) - 1)
+ elif x == y:
+ return 1 << ((lim-1)-x)
+ else:
+ x = lim-x
+ y = (lim-1)-y
+ mask_a = ((1 << x) - 1) & ((1 << lim) - 1)
+ mask_b = (~((1 << y) - 1)) & ((1 << lim) - 1)
+ return mask_a ^ mask_b
+
+ def __getattr__(self, attr):
+ """workaround for getting function out of the global namespace
+ within this module, as a way to get functions being transitioned
+ to Helper classes within ISACaller (and therefore pseudocode)
+ """
+ try:
+ return globals()[attr]
+ except KeyError:
+ raise AttributeError(attr)
+
+
# For these tests I tried to find power instructions that would let me
# isolate each of these helper operations. So for instance, when I was
# testing the MASK() function, I chose rlwinm and rldicl because if I
# set the shift equal to 0 and passed in a value of all ones, the
# result I got would be exactly the same as the output of MASK()
+class HelperTests(unittest.TestCase, ISACallerHelper):
+ def __init__(self, *args, **kwargs):
+ # TODO: dynamic (64/32/16/8)
+ ISACallerHelper.__init__(self, 64, FPSCR=None)
+ unittest.TestCase.__init__(self, *args, **kwargs)
-class HelperTests(unittest.TestCase):
def test_MASK(self):
# Verified using rlwinm, rldicl, rldicr in qemu
# li 1, -1
# rlwinm reg, 1, 0, 5, 15
- self.assertHex(MASK(5+32, 15+32), 0x7ff0000)
+ self.assertHex(self.MASK(5+32, 15+32), 0x7ff0000)
# rlwinm reg, 1, 0, 15, 5
- self.assertHex(MASK(15+32, 5+32), 0xfffffffffc01ffff)
- self.assertHex(MASK(30+32, 2+32), 0xffffffffe0000003)
+ self.assertHex(self.MASK(15+32, 5+32), 0xfffffffffc01ffff)
+ self.assertHex(self.MASK(30+32, 2+32), 0xffffffffe0000003)
# rldicl reg, 1, 0, 37
- self.assertHex(MASK(37, 63), 0x7ffffff)
- self.assertHex(MASK(10, 63), 0x3fffffffffffff)
- self.assertHex(MASK(58, 63), 0x3f)
+ self.assertHex(self.MASK(37, 63), 0x7ffffff)
+ self.assertHex(self.MASK(10, 63), 0x3fffffffffffff)
+ self.assertHex(self.MASK(58, 63), 0x3f)
# rldicr reg, 1, 0, 37
- self.assertHex(MASK(0, 37), 0xfffffffffc000000)
- self.assertHex(MASK(0, 10), 0xffe0000000000000)
- self.assertHex(MASK(0, 58), 0xffffffffffffffe0)
+ self.assertHex(self.MASK(0, 37), 0xfffffffffc000000)
+ self.assertHex(self.MASK(0, 10), 0xffe0000000000000)
+ self.assertHex(self.MASK(0, 58), 0xffffffffffffffe0)
# li 2, 5
# slw 1, 1, 2
- self.assertHex(MASK(32, 63-5), 0xffffffe0)
+ self.assertHex(self.MASK(32, 63-5), 0xffffffe0)
- self.assertHex(MASK(32, 33), 0xc0000000)
- self.assertHex(MASK(32, 32), 0x80000000)
- self.assertHex(MASK(33, 33), 0x40000000)
+ self.assertHex(self.MASK(32, 33), 0xc0000000)
+ self.assertHex(self.MASK(32, 32), 0x80000000)
+ self.assertHex(self.MASK(33, 33), 0x40000000)
def test_ROTL64(self):
# r1 = 0xdeadbeef12345678
value = 0xdeadbeef12345678
# rldicl reg, 1, 10, 0
- self.assertHex(ROTL64(value, 10), 0xb6fbbc48d159e37a)
+ self.assertHex(self.ROTL64(value, 10), 0xb6fbbc48d159e37a)
# rldicl reg, 1, 35, 0
- self.assertHex(ROTL64(value, 35), 0x91a2b3c6f56df778)
- self.assertHex(ROTL64(value, 58), 0xe37ab6fbbc48d159)
- self.assertHex(ROTL64(value, 22), 0xbbc48d159e37ab6f)
+ self.assertHex(self.ROTL64(value, 35), 0x91a2b3c6f56df778)
+ self.assertHex(self.ROTL64(value, 58), 0xe37ab6fbbc48d159)
+ self.assertHex(self.ROTL64(value, 22), 0xbbc48d159e37ab6f)
def test_ROTL32(self):
# r1 = 0xdeadbeef
- value = 0xdeadbeef
+ value = SelectableInt(0xdeadbeef, self.XLEN)
# rlwinm reg, 1, 10, 0, 31
- self.assertHex(ROTL32(value, 10), 0xb6fbbf7a)
+ self.assertHex(self.ROTL32(value, 10), 0xb6fbbf7a)
# rlwinm reg, 1, 17, 0, 31
- self.assertHex(ROTL32(value, 17), 0x7ddfbd5b)
- self.assertHex(ROTL32(value, 25), 0xdfbd5b7d)
- self.assertHex(ROTL32(value, 30), 0xf7ab6fbb)
+ self.assertHex(self.ROTL32(value, 17), 0x7ddfbd5b)
+ self.assertHex(self.ROTL32(value, 25), 0xdfbd5b7d)
+ self.assertHex(self.ROTL32(value, 30), 0xf7ab6fbb)
def test_EXTS64(self):
value_a = SelectableInt(0xdeadbeef, 32) # r1
value_c = SelectableInt(0x80000000, 32) # r3
# extswsli reg, 1, 0
- self.assertHex(EXTS64(value_a), 0xffffffffdeadbeef)
+ self.assertHex(self.EXTS64(value_a), 0xffffffffdeadbeef)
# extswsli reg, 2, 0
- self.assertHex(EXTS64(value_b), SelectableInt(value_b.value, 64))
+ self.assertHex(self.EXTS64(value_b), SelectableInt(value_b.value, 64))
# extswsli reg, 3, 0
- self.assertHex(EXTS64(value_c), 0xffffffff80000000)
+ self.assertHex(self.EXTS64(value_c), 0xffffffff80000000)
def test_FPADD32(self):
value_a = SelectableInt(0x4014000000000000, 64) # 5.0
return self.assertEqual(a, b, msg)
-class ISACallerHelper:
- def __init__(self, XLEN):
- self.__XLEN = XLEN
-
- @property
- def XLEN(self):
- return self.__XLEN
-
- def XLCASTS(self, value):
- return SelectableInt(exts(value.value, self.XLEN), self.XLEN)
-
- def XLCASTU(self, value):
- # SelectableInt already takes care of masking out the bits
- return SelectableInt(value.value, self.XLEN)
-
- def EXTSXL(self, value, bits):
- return SelectableInt(exts(value.value, bits), self.XLEN)
-
- def DOUBLE2SINGLE(self, FRS):
- """ DOUBLE2SINGLE has been renamed to FRSP since it is the
- implementation of the frsp instruction.
- use SINGLE() or FRSP() instead, or just use struct.pack/unpack
- """
- FPSCR = {
- 'UE': SelectableInt(0, 1),
- 'OE': SelectableInt(0, 1),
- 'RN': SelectableInt(0, 2), # round to nearest, ties to even
- 'XX': SelectableInt(0, 1),
- }
- FRT, FPSCR = self.FRSP(FRS, FPSCR)
- return FRT
-
- def __getattr__(self, attr):
- try:
- return globals()[attr]
- except KeyError:
- raise AttributeError(attr)
-
if __name__ == '__main__':
log(SelectableInt.__bases__)
projects / openpower-isa.git / blobdiff