src/openpower/decoder/helpers.py

   1 import unittest
   2 import struct
   3 import sys
   4 from openpower.decoder.selectable_int import (SelectableInt, onebit,
   5                                               selectconcat)
   6 from nmutil.divmod import trunc_divs, trunc_rems
   7 from operator import floordiv, mod
   8 from openpower.decoder.selectable_int import selectltu as ltu
   9 from openpower.decoder.selectable_int import selectgtu as gtu
  10 from openpower.decoder.selectable_int import check_extsign
  11
  12 from openpower.util import log
  13 import math
  14
  15 trunc_div = floordiv
  16 trunc_rem = mod
  17 DIVS = trunc_divs
  18 MODS = trunc_rems
  19
  20 """
  21 Links:
  22 * https://bugs.libre-soc.org/show_bug.cgi?id=324 - add trunc_div and trunc_rem
  23 * https://bugs.libre-soc.org/show_bug.cgi?id=671#c38 - RANGE (and bugfixes)
  24 """
  25
  26
  27 def RANGE(start, end):
  28     if start > end:
  29         # reverse direction
  30         # auto-subtract-one (sigh) due to python range
  31         return range(start, end-1, -1)
  32     # auto-add-one (sigh) due to python range
  33     return range(start, end+1)
  34
  35
  36 def exts(value, bits):
  37     sign = 1 << (bits - 1)
  38     return (value & (sign - 1)) - (value & sign)
  39
  40
  41 def EXTS(value):
  42     """ extends sign bit out from current MSB to all 256 bits
  43     """
  44     log("EXTS", value, type(value))
  45     assert isinstance(value, SelectableInt)
  46     return SelectableInt(exts(value.value, value.bits) & ((1 << 256)-1), 256)
  47
  48
  49 def EXTS64(value):
  50     """ extends sign bit out from current MSB to 64 bits
  51     """
  52     assert isinstance(value, SelectableInt)
  53     return SelectableInt(exts(value.value, value.bits) & ((1 << 64)-1), 64)
  54
  55
  56 def EXTS128(value):
  57     """ extends sign bit out from current MSB to 128 bits
  58     """
  59     assert isinstance(value, SelectableInt)
  60     return SelectableInt(exts(value.value, value.bits) & ((1 << 128)-1), 128)
  61
  62
  63 # signed version of MUL
  64 def MULS(a, b):
  65     if isinstance(b, int):
  66         b = SelectableInt(b, self.bits)
  67     b = check_extsign(a, b)
  68     a_s = a.value & (1 << (a.bits-1)) != 0
  69     b_s = b.value & (1 << (b.bits-1)) != 0
  70     result = abs(a) * abs(b)
  71     log("MULS", result, a_s, b_s)
  72     if a_s == b_s:
  73         return result
  74     return -result
  75
  76
  77 # XXX should this explicitly extend from 32 to 64?
  78 def EXTZ64(value):
  79     if isinstance(value, SelectableInt):
  80         value = value.value
  81     return SelectableInt(value & ((1 << 32)-1), 64)
  82
  83
  84 def rotl(value, bits, wordlen):
  85     if isinstance(bits, SelectableInt):
  86         bits = bits.value
  87     mask = (1 << wordlen) - 1
  88     bits = bits & (wordlen - 1)
  89     return ((value << bits) | (value >> (wordlen-bits))) & mask
  90
  91
  92 def SHL64(value, bits, wordlen=64):
  93     if isinstance(bits, SelectableInt):
  94         bits = bits.value
  95     mask = (1 << wordlen) - 1
  96     bits = bits & (wordlen - 1)
  97     return SelectableInt((value << bits) & mask, 64)
  98
  99
 100 def ne(a, b):
 101     return onebit(a != b)
 102
 103
 104 def eq(a, b):
 105     return onebit(a == b)
 106
 107
 108 def gt(a, b):
 109     return onebit(a > b)
 110
 111
 112 def ge(a, b):
 113     return onebit(a >= b)
 114
 115
 116 def lt(a, b):
 117     return onebit(a < b)
 118
 119
 120 def le(a, b):
 121     return onebit(a <= b)
 122
 123
 124 def length(a):
 125     return len(a)
 126
 127
 128 def undefined(v):
 129     """ function that, for Power spec purposes, returns undefined bits of
 130         the same shape as the input bits.  however, for purposes of matching
 131         POWER9's behavior returns the input bits unchanged.  this effectively
 132         "marks" (tags) locations in the v3.0B spec that need to be submitted
 133         for clarification.
 134     """
 135     return v
 136
 137
 138 def SINGLE(FRS):
 139     """convert incoming FRS into 32-bit word.  v3.0B p144 section 4.6.3
 140     """
 141     # result - WORD - start off all zeros
 142     WORD = SelectableInt(0, 32)
 143
 144     e = FRS[1:12]
 145     m = FRS[12:64]
 146     s = FRS[0]
 147
 148     log("SINGLE", FRS)
 149     log("s e m", s.value, e.value, m.value)
 150
 151     # No Denormalization Required (includes Zero / Infinity / NaN)
 152     if e.value > 896 or FRS[1:64].value == 0:
 153         log("nodenorm", FRS[0:2].value, hex(FRS[5:35].value))
 154         WORD[0:2] = FRS[0:2]
 155         WORD[2:32] = FRS[5:35]
 156
 157     # Denormalization Required
 158     if e.value >= 874 and e.value <= 896:
 159         sign = FRS[0]
 160         exp = e.value - 1023
 161         frac = selectconcat(SelectableInt(1, 1), FRS[12:64])
 162         log("exp, fract", exp, hex(frac.value))
 163         # denormalize operand
 164         while exp < -126:
 165             frac[0:53] = selectconcat(SelectableInt(0, 1), frac[0:52])
 166             exp = exp + 1
 167         WORD[0] = sign
 168         WORD[1:9] = SelectableInt(0, 8)
 169         WORD[9:32] = frac[1:24]
 170     # else WORD = undefined # return zeros
 171
 172     log("WORD", WORD)
 173
 174     return WORD
 175
 176 # XXX NOTE: these are very quick hacked functions for utterly basic
 177 # FP support
 178
 179
 180 def signinv(res, sign):
 181     if sign == 1:
 182         return res
 183     if sign == 0:
 184         return 0.0
 185     if sign == -1:
 186         return -res
 187
 188
 189 def fp32toselectable(flt):
 190     """convert FP number to 32 bit SelectableInt
 191     """
 192     b = struct.pack("<f", flt)
 193     val = int.from_bytes(b, byteorder='little', signed=False)
 194     return SelectableInt(val, 32)
 195
 196
 197 def fp64toselectable(flt):
 198     """convert FP number to 64 bit SelectableInt
 199     """
 200     b = struct.pack("<d", flt)
 201     val = int.from_bytes(b, byteorder='little', signed=False)
 202     return SelectableInt(val, 64)
 203
 204
 205 def _minmag(a, b):
 206     if abs(a) < abs(b):
 207         return a
 208     if abs(a) > abs(b):
 209         return b
 210     return min(a, b)
 211
 212
 213 def _maxmag(a, b):
 214     if abs(a) < abs(b):
 215         return b
 216     if abs(a) > abs(b):
 217         return a
 218     return max(a, b)
 219
 220
 221 class ISAFPHelpers:
 222     # bfp32/64_OP naming mirrors that in the Power ISA spec.
 223
 224     def bfp64_ATAN2PI(self, a, b):
 225         # FIXME: use proper implementation
 226         return fp64toselectable(math.atan2(float(a), float(b)) / math.pi)
 227
 228     def bfp32_ATAN2PI(self, a, b):
 229         # FIXME: use proper implementation
 230         return fp32toselectable(math.atan2(float(a), float(b)) / math.pi)
 231
 232     def bfp64_ATAN2(self, a, b):
 233         # FIXME: use proper implementation
 234         return fp64toselectable(math.atan2(float(a), float(b)))
 235
 236     def bfp32_ATAN2(self, a, b):
 237         # FIXME: use proper implementation
 238         return fp32toselectable(math.atan2(float(a), float(b)))
 239
 240     def bfp64_HYPOT(self, a, b):
 241         # FIXME: use proper implementation
 242         return fp64toselectable(math.hypot(float(a), float(b)))
 243
 244     def bfp32_HYPOT(self, a, b):
 245         # FIXME: use proper implementation
 246         return fp32toselectable(math.hypot(float(a), float(b)))
 247
 248     def bfp64_MINNUM08(self, a, b):
 249         # FIXME: use proper implementation
 250         return fp64toselectable(min(float(a), float(b)))
 251
 252     def bfp32_MINNUM08(self, a, b):
 253         # FIXME: use proper implementation
 254         return fp32toselectable(min(float(a), float(b)))
 255
 256     def bfp64_MIN19(self, a, b):
 257         # FIXME: use proper implementation
 258         return fp64toselectable(min(float(a), float(b)))
 259
 260     def bfp32_MIN19(self, a, b):
 261         # FIXME: use proper implementation
 262         return fp32toselectable(min(float(a), float(b)))
 263
 264     def bfp64_MINNUM19(self, a, b):
 265         # FIXME: use proper implementation
 266         return fp64toselectable(min(float(a), float(b)))
 267
 268     def bfp32_MINNUM19(self, a, b):
 269         # FIXME: use proper implementation
 270         return fp32toselectable(min(float(a), float(b)))
 271
 272     def bfp64_MINC(self, a, b):
 273         # FIXME: use proper implementation
 274         return fp64toselectable(min(float(a), float(b)))
 275
 276     def bfp32_MINC(self, a, b):
 277         # FIXME: use proper implementation
 278         return fp32toselectable(min(float(a), float(b)))
 279
 280     def bfp64_MAXNUM08(self, a, b):
 281         # FIXME: use proper implementation
 282         return fp64toselectable(max(float(a), float(b)))
 283
 284     def bfp32_MAXNUM08(self, a, b):
 285         # FIXME: use proper implementation
 286         return fp32toselectable(max(float(a), float(b)))
 287
 288     def bfp64_MAX19(self, a, b):
 289         # FIXME: use proper implementation
 290         return fp64toselectable(max(float(a), float(b)))
 291
 292     def bfp32_MAX19(self, a, b):
 293         # FIXME: use proper implementation
 294         return fp32toselectable(max(float(a), float(b)))
 295
 296     def bfp64_MAXNUM19(self, a, b):
 297         # FIXME: use proper implementation
 298         return fp64toselectable(max(float(a), float(b)))
 299
 300     def bfp32_MAXNUM19(self, a, b):
 301         # FIXME: use proper implementation
 302         return fp32toselectable(max(float(a), float(b)))
 303
 304     def bfp64_MAXC(self, a, b):
 305         # FIXME: use proper implementation
 306         return fp64toselectable(max(float(a), float(b)))
 307
 308     def bfp32_MAXC(self, a, b):
 309         # FIXME: use proper implementation
 310         return fp32toselectable(max(float(a), float(b)))
 311
 312     def bfp64_MINMAGNUM08(self, a, b):
 313         # FIXME: use proper implementation
 314         return fp64toselectable(_minmag(float(a), float(b)))
 315
 316     def bfp32_MINMAGNUM08(self, a, b):
 317         # FIXME: use proper implementation
 318         return fp32toselectable(_minmag(float(a), float(b)))
 319
 320     def bfp64_MAXMAGNUM08(self, a, b):
 321         # FIXME: use proper implementation
 322         return fp64toselectable(_maxmag(float(a), float(b)))
 323
 324     def bfp32_MAXMAGNUM08(self, a, b):
 325         # FIXME: use proper implementation
 326         return fp32toselectable(_maxmag(float(a), float(b)))
 327
 328     def bfp64_MOD(self, a, b):
 329         # FIXME: use proper implementation
 330         return fp64toselectable(math.fmod(float(a), float(b)))
 331
 332     def bfp32_MOD(self, a, b):
 333         # FIXME: use proper implementation
 334         return fp32toselectable(math.fmod(float(a), float(b)))
 335
 336     def bfp64_MINMAG19(self, a, b):
 337         # FIXME: use proper implementation
 338         return fp64toselectable(_minmag(float(a), float(b)))
 339
 340     def bfp32_MINMAG19(self, a, b):
 341         # FIXME: use proper implementation
 342         return fp32toselectable(_minmag(float(a), float(b)))
 343
 344     def bfp64_MAXMAG19(self, a, b):
 345         # FIXME: use proper implementation
 346         return fp64toselectable(_maxmag(float(a), float(b)))
 347
 348     def bfp32_MAXMAG19(self, a, b):
 349         # FIXME: use proper implementation
 350         return fp32toselectable(_maxmag(float(a), float(b)))
 351
 352     def bfp64_MINMAGNUM19(self, a, b):
 353         # FIXME: use proper implementation
 354         return fp64toselectable(_minmag(float(a), float(b)))
 355
 356     def bfp32_MINMAGNUM19(self, a, b):
 357         # FIXME: use proper implementation
 358         return fp32toselectable(_minmag(float(a), float(b)))
 359
 360     def bfp64_MAXMAGNUM19(self, a, b):
 361         # FIXME: use proper implementation
 362         return fp64toselectable(_maxmag(float(a), float(b)))
 363
 364     def bfp32_MAXMAGNUM19(self, a, b):
 365         # FIXME: use proper implementation
 366         return fp32toselectable(_maxmag(float(a), float(b)))
 367
 368     def bfp64_REMAINDER(self, a, b):
 369         # FIXME: use proper implementation
 370         return fp64toselectable(math.remainder(float(a), float(b)))
 371
 372     def bfp32_REMAINDER(self, a, b):
 373         # FIXME: use proper implementation
 374         return fp32toselectable(math.remainder(float(a), float(b)))
 375
 376     def bfp64_POWR(self, a, b):
 377         # FIXME: use proper implementation
 378         return fp64toselectable(pow(float(a), float(b)))
 379
 380     def bfp32_POWR(self, a, b):
 381         # FIXME: use proper implementation
 382         return fp32toselectable(pow(float(a), float(b)))
 383
 384     def bfp64_POW(self, a, b):
 385         # FIXME: use proper implementation
 386         return fp64toselectable(pow(float(a), float(b)))
 387
 388     def bfp32_POW(self, a, b):
 389         # FIXME: use proper implementation
 390         return fp32toselectable(pow(float(a), float(b)))
 391
 392     def bfp64_MINMAGC(self, a, b):
 393         # FIXME: use proper implementation
 394         return fp64toselectable(_minmag(float(a), float(b)))
 395
 396     def bfp32_MINMAGC(self, a, b):
 397         # FIXME: use proper implementation
 398         return fp32toselectable(_minmag(float(a), float(b)))
 399
 400     def bfp64_MAXMAGC(self, a, b):
 401         # FIXME: use proper implementation
 402         return fp64toselectable(_maxmag(float(a), float(b)))
 403
 404     def bfp32_MAXMAGC(self, a, b):
 405         # FIXME: use proper implementation
 406         return fp32toselectable(_maxmag(float(a), float(b)))
 407
 408     def bfp64_POWN(self, a, b):
 409         # FIXME: use proper implementation
 410         return fp64toselectable(pow(float(a), int(b)))
 411
 412     def bfp32_POWN(self, a, b):
 413         # FIXME: use proper implementation
 414         return fp32toselectable(pow(float(a), int(b)))
 415
 416     def bfp64_ROOTN(self, a, b):
 417         # FIXME: use proper implementation
 418         return fp64toselectable(pow(float(a), 1 / int(b)))
 419
 420     def bfp32_ROOTN(self, a, b):
 421         # FIXME: use proper implementation
 422         return fp32toselectable(pow(float(a), 1 / int(b)))
 423
 424     def bfp64_CBRT(self, v):
 425         # FIXME: use proper implementation
 426         return fp64toselectable(pow(float(v), 1 / 3))
 427
 428     def bfp32_CBRT(self, v):
 429         # FIXME: use proper implementation
 430         return fp32toselectable(pow(float(v), 1 / 3))
 431
 432     def bfp64_SINPI(self, v):
 433         # FIXME: use proper implementation
 434         return fp64toselectable(math.sin(float(v) * math.pi))
 435
 436     def bfp32_SINPI(self, v):
 437         # FIXME: use proper implementation
 438         return fp32toselectable(math.sin(float(v) * math.pi))
 439
 440     def bfp64_ASINPI(self, v):
 441         # FIXME: use proper implementation
 442         return fp64toselectable(math.asin(float(v)) / math.pi)
 443
 444     def bfp32_ASINPI(self, v):
 445         # FIXME: use proper implementation
 446         return fp32toselectable(math.asin(float(v)) / math.pi)
 447
 448     def bfp64_COSPI(self, v):
 449         # FIXME: use proper implementation
 450         return fp64toselectable(math.cos(float(v) * math.pi))
 451
 452     def bfp32_COSPI(self, v):
 453         # FIXME: use proper implementation
 454         return fp32toselectable(math.cos(float(v) * math.pi))
 455
 456     def bfp64_TANPI(self, v):
 457         # FIXME: use proper implementation
 458         return fp64toselectable(math.tan(float(v) * math.pi))
 459
 460     def bfp32_TANPI(self, v):
 461         # FIXME: use proper implementation
 462         return fp32toselectable(math.tan(float(v) * math.pi))
 463
 464     def bfp64_ACOSPI(self, v):
 465         # FIXME: use proper implementation
 466         return fp64toselectable(math.acos(float(v)) / math.pi)
 467
 468     def bfp32_ACOSPI(self, v):
 469         # FIXME: use proper implementation
 470         return fp32toselectable(math.acos(float(v)) / math.pi)
 471
 472     def bfp64_ATANPI(self, v):
 473         # FIXME: use proper implementation
 474         return fp64toselectable(math.atan(float(v)) / math.pi)
 475
 476     def bfp32_ATANPI(self, v):
 477         # FIXME: use proper implementation
 478         return fp32toselectable(math.atan(float(v)) / math.pi)
 479
 480     def bfp64_RSQRT(self, v):
 481         # FIXME: use proper implementation
 482         return fp64toselectable(1 / math.sqrt(float(v)))
 483
 484     def bfp32_RSQRT(self, v):
 485         # FIXME: use proper implementation
 486         return fp32toselectable(1 / math.sqrt(float(v)))
 487
 488     def bfp64_SIN(self, v):
 489         # FIXME: use proper implementation
 490         return fp64toselectable(math.sin(float(v)))
 491
 492     def bfp32_SIN(self, v):
 493         # FIXME: use proper implementation
 494         return fp32toselectable(math.sin(float(v)))
 495
 496     def bfp64_ASIN(self, v):
 497         # FIXME: use proper implementation
 498         return fp64toselectable(math.asin(float(v)))
 499
 500     def bfp32_ASIN(self, v):
 501         # FIXME: use proper implementation
 502         return fp32toselectable(math.asin(float(v)))
 503
 504     def bfp64_COS(self, v):
 505         # FIXME: use proper implementation
 506         return fp64toselectable(math.cos(float(v)))
 507
 508     def bfp32_COS(self, v):
 509         # FIXME: use proper implementation
 510         return fp32toselectable(math.cos(float(v)))
 511
 512     def bfp64_TAN(self, v):
 513         # FIXME: use proper implementation
 514         return fp64toselectable(math.tan(float(v)))
 515
 516     def bfp32_TAN(self, v):
 517         # FIXME: use proper implementation
 518         return fp32toselectable(math.tan(float(v)))
 519
 520     def bfp64_ACOS(self, v):
 521         # FIXME: use proper implementation
 522         return fp64toselectable(math.acos(float(v)))
 523
 524     def bfp32_ACOS(self, v):
 525         # FIXME: use proper implementation
 526         return fp32toselectable(math.acos(float(v)))
 527
 528     def bfp64_ATAN(self, v):
 529         # FIXME: use proper implementation
 530         return fp64toselectable(math.atan(float(v)))
 531
 532     def bfp32_ATAN(self, v):
 533         # FIXME: use proper implementation
 534         return fp32toselectable(math.atan(float(v)))
 535
 536     def bfp64_RECIP(self, v):
 537         # FIXME: use proper implementation
 538         return fp64toselectable(1 / float(v))
 539
 540     def bfp32_RECIP(self, v):
 541         # FIXME: use proper implementation
 542         return fp32toselectable(1 / float(v))
 543
 544     def bfp64_SINH(self, v):
 545         # FIXME: use proper implementation
 546         return fp64toselectable(math.sinh(float(v)))
 547
 548     def bfp32_SINH(self, v):
 549         # FIXME: use proper implementation
 550         return fp32toselectable(math.sinh(float(v)))
 551
 552     def bfp64_ASINH(self, v):
 553         # FIXME: use proper implementation
 554         return fp64toselectable(math.asinh(float(v)))
 555
 556     def bfp32_ASINH(self, v):
 557         # FIXME: use proper implementation
 558         return fp32toselectable(math.asinh(float(v)))
 559
 560     def bfp64_COSH(self, v):
 561         # FIXME: use proper implementation
 562         return fp64toselectable(math.cosh(float(v)))
 563
 564     def bfp32_COSH(self, v):
 565         # FIXME: use proper implementation
 566         return fp32toselectable(math.cosh(float(v)))
 567
 568     def bfp64_TANH(self, v):
 569         # FIXME: use proper implementation
 570         return fp64toselectable(math.tanh(float(v)))
 571
 572     def bfp32_TANH(self, v):
 573         # FIXME: use proper implementation
 574         return fp32toselectable(math.tanh(float(v)))
 575
 576     def bfp64_ACOSH(self, v):
 577         # FIXME: use proper implementation
 578         return fp64toselectable(math.acosh(float(v)))
 579
 580     def bfp32_ACOSH(self, v):
 581         # FIXME: use proper implementation
 582         return fp32toselectable(math.acosh(float(v)))
 583
 584     def bfp64_ATANH(self, v):
 585         # FIXME: use proper implementation
 586         return fp64toselectable(math.atanh(float(v)))
 587
 588     def bfp32_ATANH(self, v):
 589         # FIXME: use proper implementation
 590         return fp32toselectable(math.atanh(float(v)))
 591
 592     def bfp64_EXP2M1(self, v):
 593         # FIXME: use proper implementation
 594         return fp64toselectable(pow(2, float(v)) - 1)
 595
 596     def bfp32_EXP2M1(self, v):
 597         # FIXME: use proper implementation
 598         return fp32toselectable(pow(2, float(v)) - 1)
 599
 600     def bfp64_LOG2P1(self, v):
 601         # FIXME: use proper implementation
 602         return fp64toselectable(math.log2(float(v) + 1))
 603
 604     def bfp32_LOG2P1(self, v):
 605         # FIXME: use proper implementation
 606         return fp32toselectable(math.log2(float(v) + 1))
 607
 608     def bfp64_EXPM1(self, v):
 609         # FIXME: use proper implementation
 610         return fp64toselectable(math.expm1(float(v)))
 611
 612     def bfp32_EXPM1(self, v):
 613         # FIXME: use proper implementation
 614         return fp32toselectable(math.expm1(float(v)))
 615
 616     def bfp64_LOGP1(self, v):
 617         # FIXME: use proper implementation
 618         return fp64toselectable(math.log1p(float(v)))
 619
 620     def bfp32_LOGP1(self, v):
 621         # FIXME: use proper implementation
 622         return fp32toselectable(math.log1p(float(v)))
 623
 624     def bfp64_EXP10M1(self, v):
 625         # FIXME: use proper implementation
 626         return fp64toselectable(pow(10, float(v)) - 1)
 627
 628     def bfp32_EXP10M1(self, v):
 629         # FIXME: use proper implementation
 630         return fp32toselectable(pow(10, float(v)) - 1)
 631
 632     def bfp64_LOG10P1(self, v):
 633         # FIXME: use proper implementation
 634         return fp64toselectable(math.log10(float(v) + 1))
 635
 636     def bfp32_LOG10P1(self, v):
 637         # FIXME: use proper implementation
 638         return fp32toselectable(math.log10(float(v) + 1))
 639
 640     def bfp64_EXP2(self, v):
 641         # FIXME: use proper implementation
 642         return fp64toselectable(pow(2, float(v)))
 643
 644     def bfp32_EXP2(self, v):
 645         # FIXME: use proper implementation
 646         return fp32toselectable(pow(2, float(v)))
 647
 648     def bfp64_LOG2(self, v):
 649         # FIXME: use proper implementation
 650         return fp64toselectable(math.log2(float(v)))
 651
 652     def bfp32_LOG2(self, v):
 653         # FIXME: use proper implementation
 654         return fp32toselectable(math.log2(float(v)))
 655
 656     def bfp64_EXP(self, v):
 657         # FIXME: use proper implementation
 658         return fp64toselectable(math.exp(float(v)))
 659
 660     def bfp32_EXP(self, v):
 661         # FIXME: use proper implementation
 662         return fp32toselectable(math.exp(float(v)))
 663
 664     def bfp64_LOG(self, v):
 665         # FIXME: use proper implementation
 666         return fp64toselectable(math.log(float(v)))
 667
 668     def bfp32_LOG(self, v):
 669         # FIXME: use proper implementation
 670         return fp32toselectable(math.log(float(v)))
 671
 672     def bfp64_EXP10(self, v):
 673         # FIXME: use proper implementation
 674         return fp64toselectable(pow(10, float(v)))
 675
 676     def bfp32_EXP10(self, v):
 677         # FIXME: use proper implementation
 678         return fp32toselectable(pow(10, float(v)))
 679
 680     def bfp64_LOG10(self, v):
 681         # FIXME: use proper implementation
 682         return fp64toselectable(math.log10(float(v)))
 683
 684     def bfp32_LOG10(self, v):
 685         # FIXME: use proper implementation
 686         return fp32toselectable(math.log10(float(v)))
 687
 688     def FPADD32(self, FRA, FRB):
 689         # return FPADD64(FRA, FRB)
 690         #FRA = DOUBLE(SINGLE(FRA))
 691         #FRB = DOUBLE(SINGLE(FRB))
 692         result = float(FRA) + float(FRB)
 693         cvt = fp64toselectable(result)
 694         cvt = self.DOUBLE2SINGLE(cvt)
 695         log("FPADD32", FRA, FRB, float(FRA), "+", float(FRB), "=", result, cvt)
 696         return cvt
 697
 698     def FPSUB32(self, FRA, FRB):
 699         # return FPSUB64(FRA, FRB)
 700         #FRA = DOUBLE(SINGLE(FRA))
 701         #FRB = DOUBLE(SINGLE(FRB))
 702         result = float(FRA) - float(FRB)
 703         cvt = fp64toselectable(result)
 704         cvt = self.DOUBLE2SINGLE(cvt)
 705         log("FPSUB32", FRA, FRB, float(FRA), "-", float(FRB), "=", result, cvt)
 706         return cvt
 707
 708     def FPMUL32(self, FRA, FRB, sign=1):
 709         # return FPMUL64(FRA, FRB)
 710         FRA = self.DOUBLE(SINGLE(FRA))
 711         FRB = self.DOUBLE(SINGLE(FRB))
 712         result = signinv(float(FRA) * float(FRB), sign)
 713         log("FPMUL32", FRA, FRB, float(FRA), float(FRB), result, sign)
 714         cvt = fp64toselectable(result)
 715         cvt = self.DOUBLE2SINGLE(cvt)
 716         log("      cvt", cvt)
 717         return cvt
 718
 719     def FPMULADD32(self, FRA, FRC, FRB, mulsign, addsign):
 720         # return FPMUL64(FRA, FRB)
 721         #FRA = DOUBLE(SINGLE(FRA))
 722         #FRB = DOUBLE(SINGLE(FRB))
 723         if addsign == 1:
 724             if mulsign == 1:
 725                 result = float(FRA) * float(FRC) + float(FRB)  # fmadds
 726             elif mulsign == -1:
 727                 result = -(float(FRA) * float(FRC) - float(FRB))  # fnmsubs
 728         elif addsign == -1:
 729             if mulsign == 1:
 730                 result = float(FRA) * float(FRC) - float(FRB)  # fmsubs
 731             elif mulsign == -1:
 732                 result = -(float(FRA) * float(FRC) + float(FRB))  # fnmadds
 733         elif addsign == 0:
 734             result = 0.0
 735         log("FPMULADD32 FRA FRC FRB", FRA, FRC, FRB)
 736         log("      FRA", float(FRA))
 737         log("      FRC", float(FRC))
 738         log("      FRB", float(FRB))
 739         log("      (FRA*FRC)+FRB=", mulsign, addsign, result)
 740         cvt = fp64toselectable(result)
 741         cvt = self.DOUBLE2SINGLE(cvt)
 742         log("      cvt", cvt)
 743         return cvt
 744
 745     def FPDIV32(self, FRA, FRB, sign=1):
 746         # return FPDIV64(FRA, FRB)
 747         #FRA = DOUBLE(SINGLE(FRA))
 748         #FRB = DOUBLE(SINGLE(FRB))
 749         result = signinv(float(FRA) / float(FRB), sign)
 750         cvt = fp64toselectable(result)
 751         cvt = self.DOUBLE2SINGLE(cvt)
 752         log("FPDIV32", FRA, FRB, result, cvt)
 753         return cvt
 754
 755
 756 def FPADD64(FRA, FRB):
 757     result = float(FRA) + float(FRB)
 758     cvt = fp64toselectable(result)
 759     log("FPADD64", FRA, FRB, result, cvt)
 760     return cvt
 761
 762
 763 def FPSUB64(FRA, FRB):
 764     result = float(FRA) - float(FRB)
 765     cvt = fp64toselectable(result)
 766     log("FPSUB64", FRA, FRB, result, cvt)
 767     return cvt
 768
 769
 770 def FPMUL64(FRA, FRB, sign=1):
 771     result = signinv(float(FRA) * float(FRB), sign)
 772     cvt = fp64toselectable(result)
 773     log("FPMUL64", FRA, FRB, result, cvt, sign)
 774     return cvt
 775
 776
 777 def FPDIV64(FRA, FRB, sign=1):
 778     result = signinv(float(FRA) / float(FRB), sign)
 779     cvt = fp64toselectable(result)
 780     log("FPDIV64", FRA, FRB, result, cvt, sign)
 781     return cvt
 782
 783
 784 def bitrev(val, VL):
 785     """Returns the integer whose value is the reverse of the lowest
 786     'width' bits of the integer 'val'
 787     """
 788     result = 0
 789     width = VL.bit_length()-1
 790     for _ in range(width):
 791         result = (result << 1) | (val & 1)
 792         val >>= 1
 793     return result
 794
 795
 796 def log2(val):
 797     """return the base-2 logarithm of `val`. Only works for powers of 2."""
 798     if isinstance(val, SelectableInt):
 799         val = val.value
 800     retval = val.bit_length() - 1
 801     assert val == 2 ** retval, "value is not a power of 2"
 802     return retval
 803
 804
 805 class ISACallerHelper:
 806     def __init__(self, XLEN):
 807         self.__XLEN = XLEN
 808
 809     @property
 810     def XLEN(self):
 811         return self.__XLEN
 812
 813     def XLCASTS(self, value):
 814         return SelectableInt(exts(value.value, self.XLEN), self.XLEN)
 815
 816     def XLCASTU(self, value):
 817         # SelectableInt already takes care of masking out the bits
 818         return SelectableInt(value.value, self.XLEN)
 819
 820     def EXTSXL(self, value, bits):
 821         return SelectableInt(exts(value.value, bits), self.XLEN)
 822
 823     def DOUBLE2SINGLE(self, FRS):
 824         """ DOUBLE2SINGLE has been renamed to FRSP since it is the
 825             implementation of the frsp instruction.
 826             use SINGLE() or FRSP() instead, or just use struct.pack/unpack
 827         """
 828         FPSCR = {
 829             'UE': SelectableInt(0, 1),
 830             'OE': SelectableInt(0, 1),
 831             'RN': SelectableInt(0, 2),  # round to nearest, ties to even
 832             'XX': SelectableInt(0, 1),
 833         }
 834         FRT, FPSCR = self.FRSP(FRS, FPSCR)
 835         return FRT
 836
 837     def ROTL32(self, value, bits):
 838         if isinstance(bits, SelectableInt):
 839             bits = bits.value
 840         if isinstance(value, SelectableInt):
 841             value = SelectableInt(value.value, self.XLEN)
 842         value = value | (value << (self.XLEN//2))
 843         value = rotl(value, bits, self.XLEN)
 844         return value
 845
 846     def ROTL128(self, value, bits):
 847         return rotl(value, bits, self.XLEN*2)
 848
 849     def ROTL64(self, value, bits):
 850         return rotl(value, bits, self.XLEN)
 851
 852     def MASK32(self, x, y):
 853         if isinstance(x, SelectableInt):
 854             x = x.value
 855         if isinstance(y, SelectableInt):
 856             y = y.value
 857         return self.MASK(x+(self.XLEN//2), y+(self.XLEN//2))
 858
 859     def MASK(self, x, y, lim=None):
 860         if lim is None:
 861             lim = self.XLEN
 862         if isinstance(x, SelectableInt):
 863             x = x.value
 864         if isinstance(y, SelectableInt):
 865             y = y.value
 866         if x < y:
 867             x = lim-x
 868             y = (lim-1)-y
 869             mask_a = ((1 << x) - 1) & ((1 << lim) - 1)
 870             mask_b = ((1 << y) - 1) & ((1 << lim) - 1)
 871         elif x == y:
 872             return 1 << ((lim-1)-x)
 873         else:
 874             x = lim-x
 875             y = (lim-1)-y
 876             mask_a = ((1 << x) - 1) & ((1 << lim) - 1)
 877             mask_b = (~((1 << y) - 1)) & ((1 << lim) - 1)
 878         return mask_a ^ mask_b
 879
 880     def __getattr__(self, attr):
 881         """workaround for getting function out of the global namespace
 882         within this module, as a way to get functions being transitioned
 883         to Helper classes within ISACaller (and therefore pseudocode)
 884         """
 885         try:
 886             return globals()[attr]
 887         except KeyError:
 888             raise AttributeError(attr)
 889
 890
 891 # For these tests I tried to find power instructions that would let me
 892 # isolate each of these helper operations. So for instance, when I was
 893 # testing the MASK() function, I chose rlwinm and rldicl because if I
 894 # set the shift equal to 0 and passed in a value of all ones, the
 895 # result I got would be exactly the same as the output of MASK()
 896
 897 class HelperTests(unittest.TestCase, ISACallerHelper):
 898     def __init__(self, *args, **kwargs):
 899         ISACallerHelper.__init__(self, 64) # TODO: dynamic (64/32/16/8)
 900         unittest.TestCase.__init__(self, *args, **kwargs)
 901
 902     def test_MASK(self):
 903         # Verified using rlwinm, rldicl, rldicr in qemu
 904         # li 1, -1
 905         # rlwinm reg, 1, 0, 5, 15
 906         self.assertHex(self.MASK(5+32, 15+32), 0x7ff0000)
 907         # rlwinm reg, 1, 0, 15, 5
 908         self.assertHex(self.MASK(15+32, 5+32), 0xfffffffffc01ffff)
 909         self.assertHex(self.MASK(30+32, 2+32), 0xffffffffe0000003)
 910         # rldicl reg, 1, 0, 37
 911         self.assertHex(self.MASK(37, 63), 0x7ffffff)
 912         self.assertHex(self.MASK(10, 63), 0x3fffffffffffff)
 913         self.assertHex(self.MASK(58, 63), 0x3f)
 914         # rldicr reg, 1, 0, 37
 915         self.assertHex(self.MASK(0, 37), 0xfffffffffc000000)
 916         self.assertHex(self.MASK(0, 10), 0xffe0000000000000)
 917         self.assertHex(self.MASK(0, 58), 0xffffffffffffffe0)
 918
 919         # li 2, 5
 920         # slw 1, 1, 2
 921         self.assertHex(self.MASK(32, 63-5), 0xffffffe0)
 922
 923         self.assertHex(self.MASK(32, 33), 0xc0000000)
 924         self.assertHex(self.MASK(32, 32), 0x80000000)
 925         self.assertHex(self.MASK(33, 33), 0x40000000)
 926
 927     def test_ROTL64(self):
 928         # r1 = 0xdeadbeef12345678
 929         value = 0xdeadbeef12345678
 930
 931         # rldicl reg, 1, 10, 0
 932         self.assertHex(self.ROTL64(value, 10), 0xb6fbbc48d159e37a)
 933         # rldicl reg, 1, 35, 0
 934         self.assertHex(self.ROTL64(value, 35), 0x91a2b3c6f56df778)
 935         self.assertHex(self.ROTL64(value, 58), 0xe37ab6fbbc48d159)
 936         self.assertHex(self.ROTL64(value, 22), 0xbbc48d159e37ab6f)
 937
 938     def test_ROTL32(self):
 939         # r1 = 0xdeadbeef
 940         value = SelectableInt(0xdeadbeef, self.XLEN)
 941
 942         # rlwinm reg, 1, 10, 0, 31
 943         self.assertHex(self.ROTL32(value, 10), 0xb6fbbf7a)
 944         # rlwinm reg, 1, 17, 0, 31
 945         self.assertHex(self.ROTL32(value, 17), 0x7ddfbd5b)
 946         self.assertHex(self.ROTL32(value, 25), 0xdfbd5b7d)
 947         self.assertHex(self.ROTL32(value, 30), 0xf7ab6fbb)
 948
 949     def test_EXTS64(self):
 950         value_a = SelectableInt(0xdeadbeef, 32)  # r1
 951         value_b = SelectableInt(0x73123456, 32)  # r2
 952         value_c = SelectableInt(0x80000000, 32)  # r3
 953
 954         # extswsli reg, 1, 0
 955         self.assertHex(self.EXTS64(value_a), 0xffffffffdeadbeef)
 956         # extswsli reg, 2, 0
 957         self.assertHex(self.EXTS64(value_b), SelectableInt(value_b.value, 64))
 958         # extswsli reg, 3, 0
 959         self.assertHex(self.EXTS64(value_c), 0xffffffff80000000)
 960
 961     def test_FPADD32(self):
 962         value_a = SelectableInt(0x4014000000000000, 64)  # 5.0
 963         value_b = SelectableInt(0x403B4CCCCCCCCCCD, 64)  # 27.3
 964         result = FPADD32(value_a, value_b)
 965         self.assertHex(0x4040266666666666, result)
 966
 967     def assertHex(self, a, b):
 968         a_val = a
 969         if isinstance(a, SelectableInt):
 970             a_val = a.value
 971         b_val = b
 972         if isinstance(b, SelectableInt):
 973             b_val = b.value
 974         msg = "{:x} != {:x}".format(a_val, b_val)
 975         return self.assertEqual(a, b, msg)
 976
 977
 978
 979 if __name__ == '__main__':
 980     log(SelectableInt.__bases__)
 981     unittest.main()