src/openpower/test/logical/logical_cases.py

   1 from nmutil.sim_util import hash_256
   2 from openpower.test.state import ExpectedState
   3 from openpower.simulator.program import Program
   4 from openpower.endian import bigendian
   5 from openpower.insndb.asm import SVP64Asm
   6 from openpower.test.common import TestAccumulatorBase, skip_case
   7 import random
   8
   9
  10 class LogicalTestCase(TestAccumulatorBase):
  11     def case_complement(self):
  12         insns = ["andc", "orc", "nand", "nor"]
  13         for i in range(40):
  14             choice = random.choice(insns)
  15             lst = [f"{choice} 3, 1, 2"]
  16             initial_regs = [0] * 32
  17             initial_regs[1] = random.randint(0, (1 << 64)-1)
  18             initial_regs[2] = random.randint(0, (1 << 64)-1)
  19             self.add_case(Program(lst, bigendian), initial_regs)
  20
  21     def case_rand(self):
  22         insns = ["and", "or", "xor", "eqv"]
  23         for i in range(40):
  24             choice = random.choice(insns)
  25             lst = [f"{choice} 3, 1, 2"]
  26             initial_regs = [0] * 32
  27             initial_regs[1] = random.randint(0, (1 << 64)-1)
  28             initial_regs[2] = random.randint(0, (1 << 64)-1)
  29             self.add_case(Program(lst, bigendian), initial_regs)
  30
  31     def case_rand_(self):
  32         insns = ["and.", "or.", "xor.", "eqv.", "andc.",
  33                  "orc.", "nand.", "nor."]
  34         for XER in [0, 0xe00c0000]:
  35             for i in range(40):
  36                 choice = random.choice(insns)
  37                 lst = [f"{choice} 3, 1, 2"]
  38                 initial_regs = [0] * 32
  39                 initial_regs[1] = random.randint(0, (1 << 64)-1)
  40                 initial_regs[2] = random.randint(0, (1 << 64)-1)
  41                 self.add_case(Program(lst, bigendian), initial_regs,
  42                               initial_sprs={'XER': XER})
  43
  44     def case_rand_imm_so(self):
  45         insns = ["andi.", "andis."]
  46         for i in range(1):
  47             choice = random.choice(insns)
  48             imm = random.randint(0, (1 << 16)-1)
  49             lst = [f"{choice} 3, 1, {imm}"]
  50             print(lst)
  51             initial_regs = [0] * 32
  52             initial_regs[1] = random.randint(0, (1 << 64)-1)
  53             initial_sprs = {'XER': 0xe00c0000}
  54
  55             self.add_case(Program(lst, bigendian), initial_regs,
  56                           initial_sprs=initial_sprs)
  57
  58     def case_rand_imm_logical(self):
  59         insns = ["andi.", "andis.", "ori", "oris", "xori", "xoris"]
  60         for i in range(10):
  61             choice = random.choice(insns)
  62             imm = random.randint(0, (1 << 16)-1)
  63             lst = [f"{choice} 3, 1, {imm}"]
  64             print(lst)
  65             initial_regs = [0] * 32
  66             initial_regs[1] = random.randint(0, (1 << 64)-1)
  67             self.add_case(Program(lst, bigendian), initial_regs)
  68
  69     def case_cntz(self):
  70         insns = ["cntlzd", "cnttzd", "cntlzw", "cnttzw"]
  71         for i in range(100):
  72             choice = random.choice(insns)
  73             lst = [f"{choice} 3, 1"]
  74             print(lst)
  75             initial_regs = [0] * 32
  76             initial_regs[1] = random.randint(0, (1 << 64)-1)
  77             self.add_case(Program(lst, bigendian), initial_regs)
  78
  79     def case_parity(self):
  80         insns = ["prtyw", "prtyd"]
  81         for i in range(10):
  82             choice = random.choice(insns)
  83             lst = [f"{choice} 3, 1"]
  84             print(lst)
  85             initial_regs = [0] * 32
  86             initial_regs[1] = random.randint(0, (1 << 64)-1)
  87             self.add_case(Program(lst, bigendian), initial_regs)
  88
  89     def case_popcnt(self):
  90         insns = ["popcntb", "popcntw", "popcntd"]
  91         for i in range(10):
  92             choice = random.choice(insns)
  93             lst = [f"{choice} 3, 1"]
  94             print(lst)
  95             initial_regs = [0] * 32
  96             initial_regs[1] = random.randint(0, (1 << 64)-1)
  97             self.add_case(Program(lst, bigendian), initial_regs)
  98
  99     def case_popcnt_edge(self):
 100         insns = ["popcntb", "popcntw", "popcntd"]
 101         for choice in insns:
 102             lst = [f"{choice} 3, 1"]
 103             initial_regs = [0] * 32
 104             initial_regs[1] = -1
 105             self.add_case(Program(lst, bigendian), initial_regs)
 106
 107     def case_cmpb(self):
 108         lst = ["cmpb 3, 1, 2"]
 109         initial_regs = [0] * 32
 110         initial_regs[1] = 0xdeadbeefcafec0de
 111         initial_regs[2] = 0xd0adb0000afec1de
 112         self.add_case(Program(lst, bigendian), initial_regs)
 113
 114     def case_bpermd(self):
 115         lst = ["bpermd 3, 1, 2"]
 116         for i in range(20):
 117             initial_regs = [0] * 32
 118             initial_regs[1] = 1 << random.randint(0, 63)
 119             initial_regs[2] = 0xdeadbeefcafec0de
 120             self.add_case(Program(lst, bigendian), initial_regs)
 121
 122     def case_bpermd_morerandom(self):
 123         lst = ["bpermd 3, 1, 2"]
 124         for i in range(100):
 125             initial_regs = [0] * 32
 126             initial_regs[1] = random.randint(0, (1 << 64)-1)
 127             initial_regs[2] = random.randint(0, (1 << 64)-1)
 128             self.add_case(Program(lst, bigendian), initial_regs)
 129
 130     def case_cfuged(self):
 131         prog = Program(list(SVP64Asm(["cfuged 3,4,5"])), bigendian)
 132         for case_idx in range(200):
 133             gprs = [0] * 32
 134             gprs[4] = hash_256(f"cfuged {case_idx} r4") % 2**64
 135             gprs[5] = hash_256(f"cfuged {case_idx} r5") % 2**64
 136             e = ExpectedState(pc=4, int_regs=gprs)
 137             zeros = []
 138             ones = []
 139             for i in range(64):
 140                 bit = 1 << i
 141                 if gprs[5] & bit:
 142                     ones.append(bool(gprs[4] & bit))
 143                 else:
 144                     zeros.append(bool(gprs[4] & bit))
 145             bits = ones + zeros
 146             e.intregs[3] = 0
 147             for i, v in enumerate(bits):
 148                 e.intregs[3] |= v << i
 149             with self.subTest(
 150                     case_idx=case_idx, RS_in=hex(gprs[4]),
 151                     RB_in=hex(gprs[5]), expected_RA=hex(e.intregs[3])):
 152                 self.add_case(prog, gprs, expected=e)
 153
 154     def case_cntlzdm(self):
 155         prog = Program(list(SVP64Asm(["cntlzdm 3,4,5"])), bigendian)
 156         for case_idx in range(200):
 157             gprs = [0] * 32
 158             gprs[4] = hash_256(f"cntlzdm {case_idx} r4") % 2**64
 159             gprs[5] = hash_256(f"cntlzdm {case_idx} r5") % 2**64
 160             e = ExpectedState(pc=4, int_regs=gprs)
 161             count = 0
 162             for i in reversed(range(64)):
 163                 bit = 1 << i
 164                 if gprs[5] & bit:
 165                     if gprs[4] & bit:
 166                         break
 167                     count += 1
 168             e.intregs[3] = count
 169             with self.subTest(
 170                     case_idx=case_idx, RS_in=hex(gprs[4]),
 171                     RB_in=hex(gprs[5]), expected_RA=hex(e.intregs[3])):
 172                 self.add_case(prog, gprs, expected=e)
 173
 174     def case_cnttzdm(self):
 175         prog = Program(list(SVP64Asm(["cnttzdm 3,4,5"])), bigendian)
 176         for case_idx in range(200):
 177             gprs = [0] * 32
 178             gprs[4] = hash_256(f"cnttzdm {case_idx} r4") % 2**64
 179             gprs[5] = hash_256(f"cnttzdm {case_idx} r5") % 2**64
 180             e = ExpectedState(pc=4, int_regs=gprs)
 181             count = 0
 182             for i in range(64):
 183                 bit = 1 << i
 184                 if gprs[5] & bit:
 185                     if gprs[4] & bit:
 186                         break
 187                     count += 1
 188             e.intregs[3] = count
 189             with self.subTest(
 190                     case_idx=case_idx, RS_in=hex(gprs[4]),
 191                     RB_in=hex(gprs[5]), expected_RA=hex(e.intregs[3])):
 192                 self.add_case(prog, gprs, expected=e)
 193
 194     def case_pdepd(self):
 195         prog = Program(list(SVP64Asm(["pdepd 3,4,5"])), bigendian)
 196         for case_idx in range(200):
 197             gprs = [0] * 32
 198             gprs[4] = hash_256(f"pdepd {case_idx} r4") % 2**64
 199             gprs[5] = hash_256(f"pdepd {case_idx} r5") % 2**64
 200             e = ExpectedState(pc=4, int_regs=gprs)
 201             e.intregs[3] = 0
 202             j = 0
 203             for i in range(64):
 204                 bit = 1 << i
 205                 if gprs[5] & bit:
 206                     if gprs[4] & (1 << j):
 207                         e.intregs[3] |= bit
 208                     j += 1
 209             with self.subTest(
 210                     case_idx=case_idx, RS_in=hex(gprs[4]),
 211                     RB_in=hex(gprs[5]), expected_RA=hex(e.intregs[3])):
 212                 self.add_case(prog, gprs, expected=e)
 213
 214     def case_pextd(self):
 215         prog = Program(list(SVP64Asm(["pextd 3,4,5"])), bigendian)
 216         for case_idx in range(200):
 217             gprs = [0] * 32
 218             gprs[4] = hash_256(f"pextd {case_idx} r4") % 2**64
 219             gprs[5] = hash_256(f"pextd {case_idx} r5") % 2**64
 220             e = ExpectedState(pc=4, int_regs=gprs)
 221             e.intregs[3] = 0
 222             j = 0
 223             for i in range(64):
 224                 bit = 1 << i
 225                 if gprs[5] & bit:
 226                     if gprs[4] & bit:
 227                         e.intregs[3] |= 1 << j
 228                     j += 1
 229             with self.subTest(
 230                     case_idx=case_idx, RS_in=hex(gprs[4]),
 231                     RB_in=hex(gprs[5]), expected_RA=hex(e.intregs[3])):
 232                 self.add_case(prog, gprs, expected=e)