src/openpower/decoder/isa/test_caller_fp.py

   1 import unittest
   2
   3 from nmutil.formaltest import FHDLTestCase
   4 from openpower.decoder.isa.test_caller import run_tst
   5 from openpower.decoder.selectable_int import SelectableInt
   6 from openpower.simulator.program import Program
   7
   8
   9 class DecoderTestCase(FHDLTestCase):
  10
  11     def _check_regs(self, sim, expected_int, expected_fpr):
  12         for i in range(32):
  13             self.assertEqual(sim.gpr(i), SelectableInt(expected[i], 64))
  14         for i in range(32):
  15             self.assertEqual(sim.fpr(i), SelectableInt(expected_fpr[i], 64))
  16
  17     def test_fpload(self):
  18         """>>> lst = ["lfsx 1, 0, 0",
  19                      ]
  20         """
  21         lst = ["lfsx 1, 0, 0",
  22                ]
  23         initial_mem = {0x0000: (0x42013333, 8),
  24                        0x0008: (0x42026666, 8),
  25                        0x0020: (0x1828384822324252, 8),
  26                        }
  27
  28         with Program(lst, bigendian=False) as program:
  29             sim = self.run_tst_program(program, initial_mem=initial_mem)
  30             print("FPR 1", sim.fpr(1))
  31             self.assertEqual(sim.fpr(1), SelectableInt(0x4040266660000000, 64))
  32
  33     def test_fpload_imm(self):
  34         """>>> lst = ["lfs 1, 8(1)",
  35                      ]
  36         """
  37         lst = ["lfs 1, 8(1)",
  38                ]
  39         initial_mem = {0x0000: (0x42013333, 8),
  40                        0x0008: (0x42026666, 8),
  41                        0x0020: (0x1828384822324252, 8),
  42                        }
  43
  44         with Program(lst, bigendian=False) as program:
  45             sim = self.run_tst_program(program, initial_mem=initial_mem)
  46             print("FPR 1", sim.fpr(1))
  47             self.assertEqual(sim.fpr(1), SelectableInt(0x40404cccc0000000, 64))
  48
  49     def test_fpload2(self):
  50         """>>> lst = ["lfsx 1, 0, 0",
  51                      ]
  52         """
  53         lst = ["lfsx 1, 0, 0",
  54                ]
  55         initial_mem = {0x0000: (0xac000000, 8),
  56                        0x0020: (0x1828384822324252, 8),
  57                        }
  58
  59         with Program(lst, bigendian=False) as program:
  60             sim = self.run_tst_program(program, initial_mem=initial_mem)
  61             print("FPR 1", sim.fpr(1))
  62             self.assertEqual(sim.fpr(1), SelectableInt(0xbd80000000000000, 64))
  63
  64     def test_fp_single_ldst(self):
  65         """>>> lst = ["lfsx 1, 1, 0",   # load fp 1 from mem location 0
  66                       "stfsu 1, 16(1)", # store fp 1 into mem 0x10, update RA
  67                       "lfs 2, 0(1)",   # re-load from UPDATED r1
  68                      ]
  69         """
  70         lst = ["lfsx 1, 1, 0",
  71                "stfsu 1, 16(1)",
  72                "lfs 2, 0(1)",
  73                ]
  74         initial_mem = {0x0000: (0x42013333, 8),
  75                        0x0008: (0x42026666, 8),
  76                        0x0020: (0x1828384822324252, 8),
  77                        }
  78
  79         with Program(lst, bigendian=False) as program:
  80             sim = self.run_tst_program(program, initial_mem=initial_mem)
  81             print("FPR 1", sim.fpr(1))
  82             print("FPR 2", sim.fpr(2))
  83             print("GPR 1", sim.gpr(1))  # should be 0x10 due to update
  84             self.assertEqual(sim.gpr(1), SelectableInt(0x10, 64))
  85             self.assertEqual(sim.fpr(1), SelectableInt(0x4040266660000000, 64))
  86             self.assertEqual(sim.fpr(2), SelectableInt(0x4040266660000000, 64))
  87
  88     def test_fp_single_ldst_update_idx(self):
  89         """>>> lst = ["lfsx 1, 0, 0",   # load fp 1 from mem location 0
  90                       "stfsux 1, 2, 1", # store fp 1 into mem 0x10, update RA
  91                       "lfs 2, 0(2)",   # re-load from UPDATED r2
  92                      ]
  93         """
  94         lst = ["lfsx 1, 0, 0",
  95                "stfsux 1, 2, 1",
  96                "lfs 2, 0(2)",
  97                ]
  98         initial_mem = {0x0000: (0x42013333, 8),
  99                        0x0008: (0x42026666, 8),
 100                        0x0020: (0x1828384822324252, 8),
 101                        }
 102         # create an offset of 0x10 (2+3)
 103         initial_regs = [0]*32
 104         initial_regs[1] = 0x4
 105         initial_regs[2] = 0xc
 106
 107         with Program(lst, bigendian=False) as program:
 108             sim = self.run_tst_program(program, initial_regs=initial_regs,
 109                                        initial_mem=initial_mem)
 110             print("FPR 1", sim.fpr(1))
 111             print("FPR 2", sim.fpr(2))
 112             print("GPR 1", sim.gpr(1))  # should be 0x4
 113             print("GPR 2", sim.gpr(2))  # should be 0x10 due to update
 114             print("mem dump")
 115             print(sim.mem.dump())
 116             self.assertEqual(sim.gpr(1), SelectableInt(0x4, 64))
 117             self.assertEqual(sim.gpr(2), SelectableInt(0x10, 64))
 118             self.assertEqual(sim.fpr(1), SelectableInt(0x4040266660000000, 64))
 119             self.assertEqual(sim.fpr(2), SelectableInt(0x4040266660000000, 64))
 120
 121     def test_fp_single_ldst_idx(self):
 122         """>>> lst = ["lfsx 1, 0, 0",   # load fp 1 from mem location 0
 123                       "stfsx 1, 2, 1", # store fp 1 into mem 0x10, no update
 124                       "lfs 2, 4(2)",   # re-load from NOT updated r2
 125                      ]
 126         """
 127         lst = ["lfsx 1, 0, 0",
 128                "stfsx 1, 2, 1",
 129                "lfs 2, 4(2)",
 130                ]
 131         initial_mem = {0x0000: (0x42013333, 8),
 132                        0x0008: (0x42026666, 8),
 133                        0x0020: (0x1828384822324252, 8),
 134                        }
 135         # create an offset of 0x10 (2+3)
 136         initial_regs = [0]*32
 137         initial_regs[1] = 0x4
 138         initial_regs[2] = 0xc
 139
 140         with Program(lst, bigendian=False) as program:
 141             sim = self.run_tst_program(program, initial_regs=initial_regs,
 142                                        initial_mem=initial_mem)
 143             print("FPR 1", sim.fpr(1))
 144             print("FPR 2", sim.fpr(2))
 145             print("GPR 1", sim.gpr(1))  # should be 0x4
 146             print("GPR 2", sim.gpr(2))  # should be 0xc (no update)
 147             print("mem dump")
 148             print(sim.mem.dump())
 149             self.assertEqual(sim.gpr(1), SelectableInt(0x4, 64))
 150             self.assertEqual(sim.gpr(2), SelectableInt(0xc, 64))
 151             self.assertEqual(sim.fpr(1), SelectableInt(0x4040266660000000, 64))
 152             self.assertEqual(sim.fpr(2), SelectableInt(0x4040266660000000, 64))
 153
 154     def test_fp_single_ldst_2(self):
 155         """>>> lst = ["lfsx 1, 0, 0",   # load fp 1 from mem location 0
 156                       "stfs 1, 4(2)", # store fp 1 into mem 0x10, no update
 157                       "lfs 2, 4(2)",   # re-load from NOT updated r2
 158                      ]
 159         """
 160         lst = ["lfsx 1, 0, 0",
 161                "stfs 1, 4(2)",
 162                "lfs 2, 4(2)",
 163                ]
 164         initial_mem = {0x0000: (0x42013333, 8),
 165                        0x0008: (0x42026666, 8),
 166                        0x0020: (0x1828384822324252, 8),
 167                        }
 168         # create an offset of 0x10 (2+3)
 169         initial_regs = [0]*32
 170         initial_regs[1] = 0x4
 171         initial_regs[2] = 0xc
 172
 173         with Program(lst, bigendian=False) as program:
 174             sim = self.run_tst_program(program, initial_regs=initial_regs,
 175                                        initial_mem=initial_mem)
 176             print("FPR 1", sim.fpr(1))
 177             print("FPR 2", sim.fpr(2))
 178             print("GPR 1", sim.gpr(1))  # should be 0x4
 179             print("GPR 2", sim.gpr(2))  # should be 0xc (no update)
 180             print("mem dump")
 181             print(sim.mem.dump())
 182             self.assertEqual(sim.gpr(1), SelectableInt(0x4, 64))
 183             self.assertEqual(sim.gpr(2), SelectableInt(0xc, 64))
 184             self.assertEqual(sim.fpr(1), SelectableInt(0x4040266660000000, 64))
 185             self.assertEqual(sim.fpr(2), SelectableInt(0x4040266660000000, 64))
 186
 187     def test_fp_mv(self):
 188         """>>> lst = ["fmr 1, 2",
 189                      ]
 190         """
 191         lst = ["fmr 1, 2",
 192                ]
 193
 194         fprs = [0] * 32
 195         fprs[2] = 0x4040266660000000
 196
 197         with Program(lst, bigendian=False) as program:
 198             sim = self.run_tst_program(program, initial_fprs=fprs)
 199             print("FPR 1", sim.fpr(1))
 200             print("FPR 2", sim.fpr(2))
 201             self.assertEqual(sim.fpr(1), SelectableInt(0x4040266660000000, 64))
 202             self.assertEqual(sim.fpr(2), SelectableInt(0x4040266660000000, 64))
 203
 204     def test_fp_neg(self):
 205         """>>> lst = ["fneg 1, 2",
 206                      ]
 207         """
 208         lst = ["fneg 1, 2",
 209                ]
 210
 211         fprs = [0] * 32
 212         fprs[2] = 0x4040266660000000
 213
 214         with Program(lst, bigendian=False) as program:
 215             sim = self.run_tst_program(program, initial_fprs=fprs)
 216             print("FPR 1", sim.fpr(1))
 217             print("FPR 2", sim.fpr(2))
 218             self.assertEqual(sim.fpr(1), SelectableInt(0xC040266660000000, 64))
 219             self.assertEqual(sim.fpr(2), SelectableInt(0x4040266660000000, 64))
 220
 221     def test_fp_abs(self):
 222         """>>> lst = ["fabs 3, 1",
 223                       "fabs 4, 2",
 224                       "fnabs 5, 1",
 225                       "fnabs 6, 2",
 226                      ]
 227         """
 228         lst = ["fabs 3, 1",
 229                "fabs 4, 2",
 230                "fnabs 5, 1",
 231                "fnabs 6, 2",
 232                ]
 233
 234         fprs = [0] * 32
 235         fprs[1] = 0xC040266660000000
 236         fprs[2] = 0x4040266660000000
 237
 238         with Program(lst, bigendian=False) as program:
 239             sim = self.run_tst_program(program, initial_fprs=fprs)
 240             self.assertEqual(sim.fpr(1), SelectableInt(0xC040266660000000, 64))
 241             self.assertEqual(sim.fpr(2), SelectableInt(0x4040266660000000, 64))
 242             self.assertEqual(sim.fpr(3), SelectableInt(0x4040266660000000, 64))
 243             self.assertEqual(sim.fpr(4), SelectableInt(0x4040266660000000, 64))
 244             self.assertEqual(sim.fpr(5), SelectableInt(0xC040266660000000, 64))
 245             self.assertEqual(sim.fpr(6), SelectableInt(0xC040266660000000, 64))
 246
 247     def test_fp_sgn(self):
 248         """>>> lst = ["fcpsgn 3, 1, 2",
 249                       "fcpsgn 4, 2, 1",
 250                      ]
 251         """
 252         lst = ["fcpsgn 3, 1, 2",
 253                "fcpsgn 4, 2, 1",
 254                ]
 255
 256         fprs = [0] * 32
 257         fprs[1] = 0xC040266660000001  # 1 in LSB, 1 in MSB
 258         fprs[2] = 0x4040266660000000  # 0 in LSB, 0 in MSB
 259
 260         with Program(lst, bigendian=False) as program:
 261             sim = self.run_tst_program(program, initial_fprs=fprs)
 262             self.assertEqual(sim.fpr(1), SelectableInt(0xC040266660000001, 64))
 263             self.assertEqual(sim.fpr(2), SelectableInt(0x4040266660000000, 64))
 264             # 1 in MSB comes from reg 1, 0 in LSB comes from reg 2
 265             self.assertEqual(sim.fpr(3), SelectableInt(0xC040266660000000, 64))
 266             # 0 in MSB comes from reg 2, 1 in LSB comes from reg 1
 267             self.assertEqual(sim.fpr(4), SelectableInt(0x4040266660000001, 64))
 268
 269     def test_fp_adds(self):
 270         """>>> lst = ["fadds 3, 1, 2",
 271                      ]
 272         """
 273         lst = ["fadds 3, 1, 2",  # -32.3 + 32.3 = 0
 274                ]
 275
 276         fprs = [0] * 32
 277         fprs[1] = 0xC040266660000000
 278         fprs[2] = 0x4040266660000000
 279
 280         with Program(lst, bigendian=False) as program:
 281             sim = self.run_tst_program(program, initial_fprs=fprs)
 282             self.assertEqual(sim.fpr(1), SelectableInt(0xC040266660000000, 64))
 283             self.assertEqual(sim.fpr(2), SelectableInt(0x4040266660000000, 64))
 284             self.assertEqual(sim.fpr(3), SelectableInt(0, 64))
 285
 286     def test_fp_subs(self):
 287         """>>> lst = ["fsubs 3, 1, 2",
 288                      ]
 289         """
 290         lst = ["fsubs 3, 1, 2",  # 0 - -32.3 = 32.3
 291                ]
 292
 293         fprs = [0] * 32
 294         fprs[1] = 0x0
 295         fprs[2] = 0xC040266660000000
 296
 297         with Program(lst, bigendian=False) as program:
 298             sim = self.run_tst_program(program, initial_fprs=fprs)
 299             self.assertEqual(sim.fpr(1), SelectableInt(0x0, 64))
 300             self.assertEqual(sim.fpr(2), SelectableInt(0xC040266660000000, 64))
 301             self.assertEqual(sim.fpr(3), SelectableInt(0x4040266660000000, 64))
 302
 303     def test_fp_add(self):
 304         """>>> lst = ["fadd 3, 1, 2",
 305                      ]
 306         """
 307         lst = ["fadd 3, 1, 2",  # 7.0 + -9.8 = -2.8
 308                ]
 309
 310         fprs = [0] * 32
 311         fprs[1] = 0x401C000000000000  # 7.0
 312         fprs[2] = 0xC02399999999999A  # -9.8
 313
 314         with Program(lst, bigendian=False) as program:
 315             sim = self.run_tst_program(program, initial_fprs=fprs)
 316             self.assertEqual(sim.fpr(1), SelectableInt(0x401C000000000000, 64))
 317             self.assertEqual(sim.fpr(2), SelectableInt(0xC02399999999999A, 64))
 318             self.assertEqual(sim.fpr(3), SelectableInt(0xC006666666666668, 64))
 319
 320     def test_fp_muls(self):
 321         """>>> lst = ["fmuls 3, 1, 2",
 322                      ]
 323         """
 324         lst = ["fmuls 3, 1, 2",  # 7.0 * -9.8 = -68.6
 325                "fmuls 29,12,8",  # test
 326                ]
 327
 328         fprs = [0] * 32
 329         fprs[1] = 0x401C000000000000  # 7.0
 330         fprs[2] = 0xC02399999999999A  # -9.8
 331
 332         with Program(lst, bigendian=False) as program:
 333             sim = self.run_tst_program(program, initial_fprs=fprs)
 334             self.assertEqual(sim.fpr(1), SelectableInt(0x401C000000000000, 64))
 335             self.assertEqual(sim.fpr(2), SelectableInt(0xC02399999999999A, 64))
 336             self.assertEqual(sim.fpr(3), SelectableInt(0xc051266640000000, 64))
 337
 338     def test_fp_muls3(self):
 339         """>>> lst = ["fmuls 3, 1, 2",
 340                      ]
 341         """
 342         lst = ["fmuls 3, 1, 2",
 343                ]
 344
 345         fprs = [0] * 32
 346         fprs[1] = 0xbfb0ab5100000000
 347         fprs[2] = 0xbdca000000000000
 348
 349         with Program(lst, bigendian=False) as program:
 350             sim = self.run_tst_program(program, initial_fprs=fprs)
 351             self.assertEqual(sim.fpr(3), SelectableInt(0x3d8b1663a0000000, 64))
 352
 353     def test_fp_muls4(self):
 354         """>>> lst = ["fmuls 3, 1, 2",
 355                      ]
 356         """
 357         lst = ["fmuls 3, 1, 2",
 358                ]
 359
 360         fprs = [0] * 32
 361         fprs[1] = 0xbe724e2000000000  # negative number
 362         fprs[2] = 0x0                # times zero
 363
 364         with Program(lst, bigendian=False) as program:
 365             sim = self.run_tst_program(program, initial_fprs=fprs)
 366             # result should be -ve zero not +ve zero
 367             self.assertEqual(sim.fpr(3), SelectableInt(0x8000000000000000, 64))
 368
 369     def test_fp_muls5(self):
 370         """>>> lst = ["fmuls 3, 1, 2",
 371                      ]
 372         """
 373         lst = ["fmuls 3, 1, 2",
 374                ]
 375
 376         fprs = [0] * 32
 377         fprs[1] = 0xbfb0ab5100000000
 378         fprs[2] = 0xbdca000000000000
 379
 380         with Program(lst, bigendian=False) as program:
 381             sim = self.run_tst_program(program, initial_fprs=fprs)
 382             self.assertEqual(sim.fpr(3), SelectableInt(0x3d8b1663a0000000, 64))
 383
 384     def test_fp_mul(self):
 385         """>>> lst = ["fmul 3, 1, 2",
 386                      ]
 387         """
 388         lst = ["fmul 3, 1, 2",  # 7.0 * -9.8 = -68.6
 389                ]
 390
 391         fprs = [0] * 32
 392         fprs[1] = 0x401C000000000000  # 7.0
 393         fprs[2] = 0xC02399999999999A  # -9.8
 394
 395         with Program(lst, bigendian=False) as program:
 396             sim = self.run_tst_program(program, initial_fprs=fprs)
 397             self.assertEqual(sim.fpr(1), SelectableInt(0x401C000000000000, 64))
 398             self.assertEqual(sim.fpr(2), SelectableInt(0xC02399999999999A, 64))
 399             self.assertEqual(sim.fpr(3), SelectableInt(0xC051266666666667, 64))
 400
 401     def test_fp_madd1(self):
 402         """>>> lst = ["fmadds 3, 1, 2, 4",
 403                      ]
 404         """
 405         lst = ["fmadds 3, 1, 2, 4",  # 7.0 * -9.8 + 2 = -66.6
 406                ]
 407
 408         fprs = [0] * 32
 409         fprs[1] = 0x401C000000000000  # 7.0
 410         fprs[2] = 0xC02399999999999A  # -9.8
 411         fprs[4] = 0x4000000000000000  # 2.0
 412
 413         with Program(lst, bigendian=False) as program:
 414             sim = self.run_tst_program(program, initial_fprs=fprs)
 415             self.assertEqual(sim.fpr(3), SelectableInt(0xC050A66660000000, 64))
 416
 417     def test_fp_msub1(self):
 418         """>>> lst = ["fmsubs 3, 1, 2, 4",
 419                      ]
 420         """
 421         lst = ["fmsubs 3, 1, 2, 4",  # 7.0 * -9.8 + 2 = -70.6
 422                ]
 423
 424         fprs = [0] * 32
 425         fprs[1] = 0x401C000000000000  # 7.0
 426         fprs[2] = 0xC02399999999999A  # -9.8
 427         fprs[4] = 0x4000000000000000  # 2.0
 428
 429         with Program(lst, bigendian=False) as program:
 430             sim = self.run_tst_program(program, initial_fprs=fprs)
 431             self.assertEqual(sim.fpr(3), SelectableInt(0xc051a66660000000, 64))
 432
 433     def test_fp_fcfids(self):
 434         """>>> lst = ["fcfids 1, 2",
 435                lst = ["fcfids 3, 4",
 436                      ]
 437         """
 438         lst = ["fcfids 1, 2",
 439                "fcfids 3, 4",
 440                ]
 441
 442         fprs = [0] * 32
 443         fprs[2] = 7
 444         fprs[4] = -32
 445
 446         with Program(lst, bigendian=False) as program:
 447             sim = self.run_tst_program(program, initial_fprs=fprs)
 448             self.assertEqual(sim.fpr(1), SelectableInt(0x401C000000000000, 64))
 449             self.assertEqual(sim.fpr(2), SelectableInt(7, 64))
 450             self.assertEqual(sim.fpr(3), SelectableInt(0xC040000000000000, 64))
 451             self.assertEqual(sim.fpr(4), SelectableInt(-32, 64))
 452
 453     def run_tst_program(self, prog, initial_regs=None,
 454                         initial_mem=None,
 455                         initial_fprs=None):
 456         if initial_regs is None:
 457             initial_regs = [0] * 32
 458         simulator = run_tst(prog, initial_regs, mem=initial_mem,
 459                             initial_fprs=initial_fprs)
 460         print("GPRs")
 461         simulator.gpr.dump()
 462         print("FPRs")
 463         simulator.fpr.dump()
 464         return simulator
 465
 466
 467 if __name__ == "__main__":
 468     unittest.main()