src/openpower/test/mul/long_mul_cases.py

   1 import unittest
   2 from openpower.simulator.program import Program
   3 from openpower.endian import bigendian
   4 from openpower.test.common import TestAccumulatorBase
   5 import random
   6
   7
   8 class MulTestCases2Arg(TestAccumulatorBase):
   9     def case_all(self):
  10         instrs = ["mulhw",
  11                   "mulhw.", "mullw",
  12                   "mullw.", "mullwo",
  13                   "mullwo.", "mulhwu",
  14                   "mulhwu.", "mulld",
  15                   "mulld.", "mulldo",
  16                   "mulldo.", "mulhd",
  17                   "mulhd.", "mulhdu",
  18                   "mulhdu."]
  19
  20         test_values = [
  21             0x0,
  22             0x1,
  23             0x2,
  24             0xFFFF_FFFF_FFFF_FFFF,
  25             0xFFFF_FFFF_FFFF_FFFE,
  26             0x7FFF_FFFF_FFFF_FFFF,
  27             0x8000_0000_0000_0000,
  28             0x1234_5678_0000_0000,
  29             0x1234_5678_8000_0000,
  30             0x1234_5678_FFFF_FFFF,
  31             0x1234_5678_7FFF_FFFF,
  32             0xffffffff,
  33             0x7fffffff,
  34             0x80000000,
  35             0xfffffffe,
  36             0xfffffffd
  37         ]
  38
  39         for instr in instrs:
  40             l = [f"{instr} 3, 1, 2"]
  41             # use "with" so as to close the files used
  42             with Program(l, bigendian) as prog:
  43                 for ra in test_values:
  44                     for rb in test_values:
  45                         initial_regs = [0] * 32
  46                         initial_regs[1] = ra
  47                         initial_regs[2] = rb
  48                         self.add_case(prog, initial_regs)
  49
  50     def case_all_rb_randint(self):
  51         instrs = ["mulhw",
  52                   "mulhw.", "mullw",
  53                   "mullw.", "mullwo",
  54                   "mullwo.", "mulhwu",
  55                   "mulhwu.", "mulld",
  56                   "mulld.", "mulldo",
  57                   "mulldo.", "mulhd",
  58                   "mulhd.", "mulhdu",
  59                   "mulhdu."]
  60
  61         test_values = [
  62             0x0,
  63             0x1,
  64             0x2,
  65             0xFFFF_FFFF_FFFF_FFFF,
  66             0xFFFF_FFFF_FFFF_FFFE,
  67             0x7FFF_FFFF_FFFF_FFFF,
  68             0x8000_0000_0000_0000,
  69             0x1234_5678_0000_0000,
  70             0x1234_5678_8000_0000,
  71             0x1234_5678_FFFF_FFFF,
  72             0x1234_5678_7FFF_FFFF,
  73             0xffffffff,
  74             0x7fffffff,
  75             0x80000000,
  76             0xfffffffe,
  77             0xfffffffd
  78         ]
  79
  80         for instr in instrs:
  81             l = [f"{instr} 3, 1, 2"]
  82             # use "with" so as to close the files used
  83             with Program(l, bigendian) as prog:
  84                 for ra in test_values:
  85                     initial_regs = [0] * 32
  86                     initial_regs[1] = ra
  87                     initial_regs[2] = random.randint(0, (1 << 64)-1)
  88                     self.add_case(prog, initial_regs)
  89
  90     def case_all_rb_close_to_ov(self):
  91         instrs = ["mulhw",
  92                   "mulhw.", "mullw",
  93                   "mullw.", "mullwo",
  94                   "mullwo.", "mulhwu",
  95                   "mulhwu.", "mulld",
  96                   "mulld.", "mulldo",
  97                   "mulldo.", "mulhd",
  98                   "mulhd.", "mulhdu",
  99                   "mulhdu."]
 100
 101         test_values = [
 102             0x0,
 103             0x1,
 104             0x2,
 105             0xFFFF_FFFF_FFFF_FFFF,
 106             0xFFFF_FFFF_FFFF_FFFE,
 107             0x7FFF_FFFF_FFFF_FFFF,
 108             0x8000_0000_0000_0000,
 109             0x1234_5678_0000_0000,
 110             0x1234_5678_8000_0000,
 111             0x1234_5678_FFFF_FFFF,
 112             0x1234_5678_7FFF_FFFF,
 113             0xffffffff,
 114             0x7fffffff,
 115             0x80000000,
 116             0xfffffffe,
 117             0xfffffffd
 118         ]
 119
 120         for instr in instrs:
 121             l = [f"{instr} 3, 1, 2"]
 122             # use "with" so as to close the files used
 123             with Program(l, bigendian) as prog:
 124                 for i in range(20):
 125                     x = 0x7fffffff + random.randint((-1 << 31), (1 << 31) - 1)
 126                     ra = random.randint(0, (1 << 32)-1)
 127                     rb = x // ra
 128
 129                     initial_regs = [0] * 32
 130                     initial_regs[1] = ra
 131                     initial_regs[2] = rb
 132                     self.add_case(prog, initial_regs)
 133
 134     def case_mulli(self):
 135
 136         imm_values = [-32768, -32767, -32766, -2, -1, 0, 1, 2, 32766, 32767]
 137
 138         ra_values = [
 139             0x0,
 140             0x1,
 141             0x2,
 142             0xFFFF_FFFF_FFFF_FFFF,
 143             0xFFFF_FFFF_FFFF_FFFE,
 144             0x7FFF_FFFF_FFFF_FFFF,
 145             0x8000_0000_0000_0000,
 146             0x1234_5678_0000_0000,
 147             0x1234_5678_8000_0000,
 148             0x1234_5678_FFFF_FFFF,
 149             0x1234_5678_7FFF_FFFF,
 150             0xffffffff,
 151             0x7fffffff,
 152             0x80000000,
 153             0xfffffffe,
 154             0xfffffffd
 155         ]
 156
 157         for i in range(20):
 158             imm_values.append(random.randint(-1 << 15, (1 << 15) - 1))
 159
 160         for i in range(14):
 161             ra_values.append(random.randint(0, (1 << 64) - 1))
 162
 163         for imm in imm_values:
 164             l = [f"mulli 0, 1, {imm}"]
 165             # use "with" so as to close the files used
 166             with Program(l, bigendian) as prog:
 167                 for ra in ra_values:
 168                     initial_regs = [0] * 32
 169                     initial_regs[1] = ra
 170                     self.add_case(prog, initial_regs)
 171
 172
 173 MUL_3_ARG_TEST_VALUES = [
 174     0x0,
 175     0x1,
 176     0x2,
 177     0xFFFF_FFFF_FFFF_FFFF,
 178     0xFFFF_FFFF_FFFF_FFFE,
 179     0x7FFF_FFFF_FFFF_FFFF,
 180     0x8000_0000_0000_0000,
 181     0x1234_5678_0000_0000,
 182     0x1234_5678_8000_0000,
 183     0x1234_5678_FFFF_FFFF,
 184     0x1234_5678_7FFF_FFFF,
 185     0xffffffff,
 186     0x7fffffff,
 187     0x80000000,
 188     0xfffffffe,
 189     0xfffffffd
 190 ]
 191
 192
 193 class MulTestCases3Arg(TestAccumulatorBase):
 194     def __init__(self, subtest_index):
 195         self.subtest_index = subtest_index
 196         super().__init__()
 197
 198     def case_all(self):
 199         instrs = ["maddhd", "maddhdu", "maddld"]
 200
 201         for instr in instrs:
 202             l = [f"{instr} 1, 2, 3, 4"]
 203             ra = MUL_3_ARG_TEST_VALUES[self.subtest_index]
 204             for rb in MUL_3_ARG_TEST_VALUES:
 205                 for rc in MUL_3_ARG_TEST_VALUES:
 206                     initial_regs = [0] * 32
 207                     initial_regs[2] = ra
 208                     initial_regs[3] = rb
 209                     initial_regs[4] = rc
 210                     # use "with" so as to close the files used
 211                     with Program(l, bigendian) as prog:
 212                         self.add_case(prog, initial_regs)
 213
 214