src/openpower/test/cr/cr_cases.py

   1 import unittest
   2 from openpower.simulator.program import Program
   3 from openpower.endian import bigendian
   4
   5 from openpower.test.common import TestAccumulatorBase
   6 from openpower.util import mask_extend
   7 import random
   8
   9
  10 class CRTestCase(TestAccumulatorBase):
  11
  12     def case_crop(self):
  13         insns = ["crand", "cror", "crnand", "crnor", "crxor", "creqv",
  14                  "crandc", "crorc"]
  15         for i in range(40):
  16             choice = random.choice(insns)
  17             ba = random.randint(0, 31)
  18             bb = random.randint(0, 31)
  19             bt = random.randint(0, 31)
  20             lst = [f"{choice} {ba}, {bb}, {bt}"]
  21             cr = random.randint(0, (1 << 32)-1)
  22             self.add_case(Program(lst, bigendian), initial_cr=cr)
  23
  24     def case_crand(self):
  25         for i in range(20):
  26             lst = ["crand 0, 11, 13"]
  27             cr = random.randint(0, (1 << 32)-1)
  28             self.add_case(Program(lst, bigendian), initial_cr=cr)
  29
  30     def case_1_mcrf(self):
  31         for i in range(20):
  32             src = random.randint(0, 7)
  33             dst = random.randint(0, 7)
  34             lst = [f"mcrf {src}, {dst}"]
  35             cr = random.randint(0, (1 << 32)-1)
  36         self.add_case(Program(lst, bigendian), initial_cr=cr)
  37
  38     def case_0_mcrf(self):
  39         for i in range(8):
  40             lst = [f"mcrf 5, {i}"]
  41             cr = 0xfeff0001
  42             self.add_case(Program(lst, bigendian), initial_cr=cr)
  43
  44     def case_mtcrf(self):
  45         for i in range(1):
  46             mask = random.randint(0, 255)
  47             lst = [f"mtcrf {mask}, 2"]
  48             cr = random.randint(0, (1 << 32)-1)
  49             initial_regs = [0] * 32
  50             initial_regs[2] = random.randint(0, (1 << 32)-1)
  51             self.add_case(Program(lst, bigendian), initial_regs=initial_regs,
  52                           initial_cr=cr)
  53
  54     def case_mtocrf(self):
  55         for i in range(20):
  56             mask = 1 << random.randint(0, 7)
  57             lst = [f"mtocrf {mask}, 2"]
  58             cr = random.randint(0, (1 << 32)-1)
  59             initial_regs = [0] * 32
  60             initial_regs[2] = random.randint(0, (1 << 32)-1)
  61             self.add_case(Program(lst, bigendian), initial_regs=initial_regs,
  62                           initial_cr=cr)
  63
  64     def case_mfcr(self):
  65         for i in range(1):
  66             lst = ["mfcr 2"]
  67             cr = random.randint(0, (1 << 32)-1)
  68             self.add_case(Program(lst, bigendian), initial_cr=cr)
  69
  70     def case_cror_regression(self):
  71         """another bad hack!
  72         """
  73         dis = ["cror 28, 5, 11"]
  74         lst = bytes([0x83, 0x5b, 0x75, 0x4f]) # 4f855b83
  75         cr = 0x35055058
  76         p = Program(lst, bigendian)
  77         p.assembly = '\n'.join(dis)+'\n'
  78         self.add_case(p, initial_cr=cr)
  79
  80     def case_mfocrf_regression(self):
  81         """bit of a bad hack.  comes from microwatt 1.bin instruction 0x106d0
  82         as the mask is non-standard, gnu-as barfs.  so we fake it up directly
  83         from the binary
  84         """
  85         mask = 0b10000111
  86         dis = [f"mfocrf 2, {mask}"]
  87         lst = bytes([0x26, 0x78, 0xb8, 0x7c]) # 0x7cb87826
  88         cr = 0x5F9E080E
  89         p = Program(lst, bigendian)
  90         p.assembly = '\n'.join(dis)+'\n'
  91         self.add_case(p, initial_cr=cr)
  92
  93     def case_mtocrf_regression(self):
  94         """microwatt 1.bin regression, same hack as above.
  95            106b4:   21 d9 96 7d     .long 0x7d96d921   # mtocrf 12, 0b01101101
  96         """
  97         mask = 0b01101101
  98         dis = [f"mtocrf 12, {mask}"]
  99         lst = bytes([0x21, 0xd9, 0x96, 0x7d]) # 0x7d96d921
 100         cr = 0x529e08fe
 101         initial_regs = [0] * 32
 102         initial_regs[12] = 0xffffffffffffffff
 103         p = Program(lst, bigendian)
 104         p.assembly = '\n'.join(dis)+'\n'
 105         self.add_case(p, initial_regs=initial_regs, initial_cr=cr)
 106
 107     def case_mtocrf_regression_2(self):
 108         """microwatt 1.bin regression, zero fxm
 109            mtocrf 0,16     14928:   21 09 10 7e     .long 0x7e100921
 110         """
 111         dis = ["mtocrf 16, 0"]
 112         lst = bytes([0x21, 0x09, 0x10, 0x7e]) # 0x7e100921
 113         cr = 0x3F089F7F
 114         initial_regs = [0] * 32
 115         initial_regs[16] = 0x0001C020
 116         p = Program(lst, bigendian)
 117         p.assembly = '\n'.join(dis)+'\n'
 118         self.add_case(p, initial_regs=initial_regs, initial_cr=cr)
 119
 120     def case_mfocrf_1(self):
 121         lst = [f"mfocrf 2, 1"]
 122         cr = 0x1234
 123         self.add_case(Program(lst, bigendian), initial_cr=cr)
 124
 125     def case_mfocrf(self):
 126         for i in range(1):
 127             mask = 1 << random.randint(0, 7)
 128             lst = [f"mfocrf 2, {mask}"]
 129             cr = random.randint(0, (1 << 32)-1)
 130             self.add_case(Program(lst, bigendian), initial_cr=cr)
 131
 132     def case_isel_0(self):
 133         lst = [ "isel 4, 1, 2, 31"
 134                ]
 135         initial_regs = [0] * 32
 136         initial_regs[1] = 0x1004
 137         initial_regs[2] = 0x1008
 138         cr= 0x1ee
 139         self.add_case(Program(lst, bigendian),
 140                       initial_regs=initial_regs, initial_cr=cr)
 141
 142     def case_isel_1(self):
 143         lst = [ "isel 4, 1, 2, 30"
 144                ]
 145         initial_regs = [0] * 32
 146         initial_regs[1] = 0x1004
 147         initial_regs[2] = 0x1008
 148         cr= 0x1ee
 149         self.add_case(Program(lst, bigendian),
 150                       initial_regs=initial_regs, initial_cr=cr)
 151
 152     def case_isel_2(self):
 153         lst = [ "isel 4, 1, 2, 2"
 154                ]
 155         initial_regs = [0] * 32
 156         initial_regs[1] = 0x1004
 157         initial_regs[2] = 0x1008
 158         cr= 0x1ee
 159         self.add_case(Program(lst, bigendian),
 160                       initial_regs=initial_regs, initial_cr=cr)
 161
 162     def case_isel_3(self):
 163         lst = [ "isel 1, 2, 3, 13"
 164                ]
 165         initial_regs = [0] * 32
 166         initial_regs[2] = 0x1004
 167         initial_regs[3] = 0x1008
 168         cr= 0x5d677571b8229f1
 169         cr= 0x1b8229f1
 170         self.add_case(Program(lst, bigendian),
 171                       initial_regs=initial_regs, initial_cr=cr)
 172
 173     def case_isel(self):
 174         for i in range(20):
 175             bc = random.randint(0, 31)
 176             lst = [f"isel 1, 2, 3, {bc}"]
 177             cr = random.randint(0, (1 << 64)-1)
 178             initial_regs = [0] * 32
 179             #initial_regs[2] = random.randint(0, (1 << 64)-1)
 180             #initial_regs[3] = random.randint(0, (1 << 64)-1)
 181             initial_regs[2] = i*2+1
 182             initial_regs[3] = i*2+2
 183             self.add_case(Program(lst, bigendian),
 184                           initial_regs=initial_regs, initial_cr=cr)
 185
 186     def case_setb(self):
 187         for i in range(20):
 188             bfa = random.randint(0, 7)
 189             lst = [f"setb 1, {bfa}"]
 190             cr = random.randint(0, (1 << 32)-1)
 191             self.add_case(Program(lst, bigendian), initial_cr=cr)
 192
 193     def case_regression_setb(self):
 194         lst = [f"setb 1, 6"]
 195         cr = random.randint(0, 0x66f6b106)
 196         self.add_case(Program(lst, bigendian), initial_cr=cr)
 197