src/openpower/test/shift_rot/shift_rot_cases.py

   1 from openpower.test.common import TestAccumulatorBase, TestCase
   2 from openpower.endian import bigendian
   3 from openpower.simulator.program import Program
   4 import random
   5
   6
   7 class ShiftRotTestCase(TestAccumulatorBase):
   8
   9     def case_0_proof_regression_rlwnm(self):
  10         lst = ["rlwnm 3, 1, 2, 16, 20"]
  11         initial_regs = [0] * 32
  12         initial_regs[1] = 0x7ffdbffb91b906b9
  13         initial_regs[2] = 31
  14         print(initial_regs[1], initial_regs[2])
  15         self.add_case(Program(lst, bigendian), initial_regs)
  16
  17     def case_regression_rldicr_0(self):
  18         lst = ["rldicr. 29, 19, 1, 21"]
  19         initial_regs = [0] * 32
  20         initial_regs[1] = 0x3f
  21         initial_regs[19] = 0x00000000ffff8000
  22
  23         initial_sprs = {'XER': 0xe00c0000}
  24
  25         self.add_case(Program(lst, bigendian), initial_regs,
  26                                 initial_sprs=initial_sprs)
  27
  28     def case_regression_rldicr_1(self):
  29         lst = ["rldicr. 29, 19, 1, 21"]
  30         initial_regs = [0] * 32
  31         initial_regs[1] = 0x3f
  32         initial_regs[19] = 0x00000000ffff8000
  33
  34         self.add_case(Program(lst, bigendian), initial_regs)
  35
  36     def case_shift(self):
  37         insns = ["slw", "sld", "srw", "srd", "sraw", "srad"]
  38         for i in range(20):
  39             choice = random.choice(insns)
  40             lst = [f"{choice} 3, 1, 2"]
  41             initial_regs = [0] * 32
  42             initial_regs[1] = random.randint(0, (1 << 64)-1)
  43             initial_regs[2] = random.randint(0, 63)
  44             print(initial_regs[1], initial_regs[2])
  45             self.add_case(Program(lst, bigendian), initial_regs)
  46
  47     def case_shift_arith(self):
  48         lst = ["sraw 3, 1, 2"]
  49         initial_regs = [0] * 32
  50         initial_regs[1] = random.randint(0, (1 << 64)-1)
  51         initial_regs[2] = random.randint(0, 63)
  52         print(initial_regs[1], initial_regs[2])
  53         self.add_case(Program(lst, bigendian), initial_regs)
  54
  55     def case_sld_rb_too_big(self):
  56         lst = ["sld 3, 1, 4",
  57                ]
  58         initial_regs = [0] * 32
  59         initial_regs[1] = 0xffffffffffffffff
  60         initial_regs[4] = 64 # too big, output should be zero
  61         self.add_case(Program(lst, bigendian), initial_regs)
  62
  63     def case_sld_rb_is_zero(self):
  64         lst = ["sld 3, 1, 4",
  65                ]
  66         initial_regs = [0] * 32
  67         initial_regs[1] = 0x8000000000000000
  68         initial_regs[4] = 0 # no shift; output should equal input
  69         self.add_case(Program(lst, bigendian), initial_regs)
  70
  71     def case_shift_once(self):
  72         lst = ["slw 3, 1, 4",
  73                "slw 3, 1, 2"]
  74         initial_regs = [0] * 32
  75         initial_regs[1] = 0x80000000
  76         initial_regs[2] = 0x40
  77         initial_regs[4] = 0x00
  78         self.add_case(Program(lst, bigendian), initial_regs)
  79
  80     def case_rlwinm(self):
  81         for i in range(10):
  82             mb = random.randint(0, 31)
  83             me = random.randint(0, 31)
  84             sh = random.randint(0, 31)
  85             lst = [f"rlwinm 3, 1, {mb}, {me}, {sh}",
  86                    #f"rlwinm. 3, 1, {mb}, {me}, {sh}"
  87                    ]
  88             initial_regs = [0] * 32
  89             initial_regs[1] = random.randint(0, (1 << 64)-1)
  90             self.add_case(Program(lst, bigendian), initial_regs)
  91
  92     def case_rlwimi(self):
  93         lst = ["rlwimi 3, 1, 5, 20, 6"]
  94         initial_regs = [0] * 32
  95         initial_regs[1] = 0xdeadbeef
  96         initial_regs[3] = 0x12345678
  97         self.add_case(Program(lst, bigendian), initial_regs)
  98
  99     def case_rlwnm(self):
 100         lst = ["rlwnm 3, 1, 2, 20, 6"]
 101         initial_regs = [0] * 32
 102         initial_regs[1] = random.randint(0, (1 << 64)-1)
 103         initial_regs[2] = random.randint(0, 63)
 104         self.add_case(Program(lst, bigendian), initial_regs)
 105
 106     def case_rldicl(self):
 107         lst = ["rldicl 3, 1, 5, 20"]
 108         initial_regs = [0] * 32
 109         initial_regs[1] = random.randint(0, (1 << 64)-1)
 110         self.add_case(Program(lst, bigendian), initial_regs)
 111
 112     def case_rldicr(self):
 113         lst = ["rldicr 3, 1, 5, 20"]
 114         initial_regs = [0] * 32
 115         initial_regs[1] = random.randint(0, (1 << 64)-1)
 116         self.add_case(Program(lst, bigendian), initial_regs)
 117
 118     def case_regression_extswsli(self):
 119         lst = [f"extswsli 3, 1, 34"]
 120         initial_regs = [0] * 32
 121         initial_regs[1] = 0x5678
 122         self.add_case(Program(lst, bigendian), initial_regs)
 123
 124     def case_regression_extswsli_2(self):
 125         lst = [f"extswsli 3, 1, 7"]
 126         initial_regs = [0] * 32
 127         initial_regs[1] = 0x3ffffd7377f19fdd
 128         self.add_case(Program(lst, bigendian), initial_regs)
 129
 130     def case_regression_extswsli_3(self):
 131         lst = [f"extswsli 3, 1, 0"]
 132         initial_regs = [0] * 32
 133         #initial_regs[1] = 0x80000000fb4013e2
 134         #initial_regs[1] = 0xffffffffffffffff
 135         #initial_regs[1] = 0x00000000ffffffff
 136         initial_regs[1] = 0x0000010180122900
 137         #initial_regs[1] = 0x3ffffd73f7f19fdd
 138         self.add_case(Program(lst, bigendian), initial_regs)
 139
 140     def case_extswsli(self):
 141         for i in range(40):
 142             sh = random.randint(0, 63)
 143             lst = [f"extswsli 3, 1, {sh}"]
 144             initial_regs = [0] * 32
 145             initial_regs[1] = random.randint(0, (1 << 64)-1)
 146             self.add_case(Program(lst, bigendian), initial_regs)
 147
 148     def case_rlc(self):
 149         insns = ["rldic", "rldicl", "rldicr"]
 150         for i in range(20):
 151             choice = random.choice(insns)
 152             sh = random.randint(0, 63)
 153             m = random.randint(0, 63)
 154             lst = [f"{choice} 3, 1, {sh}, {m}"]
 155             initial_regs = [0] * 32
 156             initial_regs[1] = random.randint(0, (1 << 64)-1)
 157             self.add_case(Program(lst, bigendian), initial_regs)