src/openpower/test/div/div_cases.py

   1 import random
   2 import unittest
   3 from openpower.simulator.program import Program
   4 from openpower.endian import bigendian
   5 from openpower.test.common import TestAccumulatorBase, skip_case
   6
   7 from openpower.util import log_rand
   8
   9
  10 class DivTestCases(TestAccumulatorBase):
  11     def case_divdeu_regression(self):
  12         lst = ["divdeu 3, 1, 2"]
  13         initial_regs = [0] * 32
  14         initial_regs[1] = 0x1
  15         initial_regs[2] = 0x2
  16         with Program(lst, bigendian) as prog:
  17             self.add_case(prog, initial_regs)
  18
  19     def case_divde_regression3(self):
  20         lst = ["divde 3, 1, 2"]
  21         initial_regs = [0] * 32
  22         initial_regs[1] = 0x8000000000000000
  23         initial_regs[2] = 0xFFFFFFFFFFFFFFFF
  24         with Program(lst, bigendian) as prog:
  25             self.add_case(prog, initial_regs)
  26
  27     def case_divwe_regression2(self):
  28         lst = ["divwe 3, 1, 2"]
  29         initial_regs = [0] * 32
  30         initial_regs[1] = 0x80000000
  31         initial_regs[2] = 0xFFFFFFFF
  32         with Program(lst, bigendian) as prog:
  33             self.add_case(prog, initial_regs)
  34
  35     def case_divde_regression2(self):
  36         lst = ["divde 3, 1, 2"]
  37         initial_regs = [0] * 32
  38         initial_regs[1] = 0x1
  39         initial_regs[2] = 0xfffffffffffffffe
  40         with Program(lst, bigendian) as prog:
  41             self.add_case(prog, initial_regs)
  42
  43     def case_divde_regression(self):
  44         lst = ["divde 3, 1, 2"]
  45         initial_regs = [0] * 32
  46         initial_regs[2] = 0x1
  47         with Program(lst, bigendian) as prog:
  48             self.add_case(prog, initial_regs)
  49
  50     def case_moduw_regression(self):
  51         lst = ["moduw 3, 1, 2"]
  52         initial_regs = [0] * 32
  53         initial_regs[1] = 0x1
  54         initial_regs[2] = 0xffffffffffffffff
  55         with Program(lst, bigendian) as prog:
  56             self.add_case(prog, initial_regs)
  57
  58     def case_modsw_regression(self):
  59         lst = ["modsw 3, 1, 2"]
  60         initial_regs = [0] * 32
  61         initial_regs[1] = 0xffffffffffffffff
  62         initial_regs[2] = 0x2
  63         with Program(lst, bigendian) as prog:
  64             self.add_case(prog, initial_regs)
  65
  66     def case_divweu_regression(self):
  67         # simulator is wrong, FSM and power-instruction-analyzer both correct
  68         lst = ["divweu 3, 1, 2"]
  69         initial_regs = [0] * 32
  70         initial_regs[1] = 0x1
  71         initial_regs[2] = 0xffffffffffffffff
  72         with Program(lst, bigendian) as prog:
  73             self.add_case(prog, initial_regs)
  74
  75     def case_divwe_regression(self):
  76         # div FU and power-instruction-analyzer both correctly return 0
  77         # hitting behavior undefined by Power v3.1 spec, need to adjust
  78         # simulator API to tell tests that the simulator's output doesn't
  79         # need to completely match
  80         lst = [f"divwe 3, 1, 2"]
  81         initial_regs = [0] * 32
  82         initial_regs[1] = 1
  83         initial_regs[2] = 1
  84         with Program(lst, bigendian) as prog:
  85             self.add_case(prog, initial_regs)
  86
  87     def case_divwe__regression(self):
  88         lst = ["divwe. 3, 1, 2"]
  89         initial_regs = [0] * 32
  90         with Program(lst, bigendian) as prog:
  91             self.add_case(prog, initial_regs)
  92
  93     def case_divw_regression(self):
  94         # simulator is wrong, FSM and power-instruction-analyzer both correct
  95         lst = [f"divw 0, 1, 2"]
  96         initial_regs = [0] * 32
  97         initial_regs[2] = 0x2
  98         initial_regs[1] = 0x80000000
  99         with Program(lst, bigendian) as prog:
 100             self.add_case(prog, initial_regs)
 101
 102     # modulo
 103     def case_modsd_regression2(self):
 104         lst = [f"modsd 0, 1, 2"]
 105         initial_regs = [0] * 32
 106         initial_regs[2] = 0xff
 107         initial_regs[1] = 0x7fffffffffffffff
 108         with Program(lst, bigendian) as prog:
 109             self.add_case(prog, initial_regs)
 110
 111     # modulo
 112     def case_modsd_regression(self):
 113         lst = [f"modsd 17, 27, 0"]
 114         initial_regs = [0] * 32
 115         initial_regs[0] = 0xff
 116         initial_regs[27] = 0x7fffffffffffffff
 117         with Program(lst, bigendian) as prog:
 118             self.add_case(prog, initial_regs)
 119
 120     def case_divduo_regression(self):
 121         lst = [f"divduo. 11, 20, 6"]
 122         initial_regs = [0] * 32
 123         # gpr: 00ff00ff00ff0080 <- r6
 124         # gpr: 000000000000007f <- r11
 125         # gpr: 7f6e5d4c3b2a1908 <- r20
 126         initial_regs[6] = 0x00ff00ff00ff0080
 127         initial_regs[20] = 0x7f6e5d4c3b2a1908
 128         with Program(lst, bigendian) as prog:
 129             self.add_case(prog, initial_regs)
 130
 131     def case_0_regression(self):
 132         for i in range(40):
 133             lst = ["divwo 3, 1, 2"]
 134             initial_regs = [0] * 32
 135             initial_regs[1] = 0xbc716835f32ac00c
 136             initial_regs[2] = 0xcdf69a7f7042db66
 137             with Program(lst, bigendian) as prog:
 138                 self.add_case(prog, initial_regs)
 139
 140     def case_1_regression(self):
 141         lst = ["divwo 3, 1, 2"]
 142         initial_regs = [0] * 32
 143         initial_regs[1] = 0x10000000000000000-4
 144         initial_regs[2] = 0x10000000000000000-2
 145         with Program(lst, bigendian) as prog:
 146             self.add_case(prog, initial_regs)
 147
 148     def case_2_regression(self):
 149         lst = ["divwo 3, 1, 2"]
 150         initial_regs = [0] * 32
 151         initial_regs[1] = 0xffffffffffff9321
 152         initial_regs[2] = 0xffffffffffff7012
 153         with Program(lst, bigendian) as prog:
 154             self.add_case(prog, initial_regs)
 155
 156     def case_3_regression(self):
 157         lst = ["divwo. 3, 1, 2"]
 158         initial_regs = [0] * 32
 159         initial_regs[1] = 0x1b8e32f2458746af
 160         initial_regs[2] = 0x6b8aee2ccf7d62e9
 161         with Program(lst, bigendian) as prog:
 162             self.add_case(prog, initial_regs)
 163
 164     def case_4_regression(self):
 165         lst = ["divw 3, 1, 2"]
 166         initial_regs = [0] * 32
 167         initial_regs[1] = 0x1c4e6c2f3aa4a05c
 168         initial_regs[2] = 0xe730c2eed6cc8dd7
 169         with Program(lst, bigendian) as prog:
 170             self.add_case(prog, initial_regs)
 171
 172     def case_5_regression(self):
 173         lst = ["divw 3, 1, 2",
 174                "divwo. 6, 4, 5"]
 175         initial_regs = [0] * 32
 176         initial_regs[1] = 0x1c4e6c2f3aa4a05c
 177         initial_regs[2] = 0xe730c2eed6cc8dd7
 178         initial_regs[4] = 0x1b8e32f2458746af
 179         initial_regs[5] = 0x6b8aee2ccf7d62e9
 180         with Program(lst, bigendian) as prog:
 181             self.add_case(prog, initial_regs)
 182
 183     def case_6_regression(self):
 184         # CR0 not getting set properly for this one
 185         # turns out that overflow is not set correctly in
 186         # fu/div/output_stage.py calc_overflow
 187         # https://bugs.libre-soc.org/show_bug.cgi?id=425
 188         lst = ["divw. 3, 1, 2"]
 189         initial_regs = [0] * 32
 190         initial_regs[1] = 0x61c1cc3b80f2a6af
 191         initial_regs[2] = 0x9dc66a7622c32bc0
 192         with Program(lst, bigendian) as prog:
 193             self.add_case(prog, initial_regs)
 194
 195     def case_7_regression(self):
 196         # https://bugs.libre-soc.org/show_bug.cgi?id=425
 197         lst = ["divw. 3, 1, 2"]
 198         initial_regs = [0] * 32
 199         initial_regs[1] = 0xf1791627e05e8096
 200         initial_regs[2] = 0xffc868bf4573da0b
 201         with Program(lst, bigendian) as prog:
 202             self.add_case(prog, initial_regs)
 203
 204     def case_8_fsm_regression(self):  # FSM result is "36" not 6
 205         lst = ["divwu. 3, 1, 2"]
 206         initial_regs = [0] * 32
 207         initial_regs[1] = 18
 208         initial_regs[2] = 3
 209         with Program(lst, bigendian) as prog:
 210             self.add_case(prog, initial_regs)
 211
 212     def case_9_regression(self):  # CR0 fails: expected 0b10, actual 0b11
 213         lst = ["divw. 3, 1, 2"]
 214         initial_regs = [0] * 32
 215         initial_regs[1] = 1
 216         initial_regs[2] = 0
 217         with Program(lst, bigendian) as prog:
 218             self.add_case(prog, initial_regs)
 219
 220     def case_10_regression(self):  # overflow fails
 221         lst = ["divwo 3, 1, 2"]
 222         initial_regs = [0] * 32
 223         initial_regs[1] = 0xbc716835f32ac00c
 224         initial_regs[2] = 0xcdf69a7f7042db66
 225         with Program(lst, bigendian) as prog:
 226             self.add_case(prog, initial_regs)
 227
 228     def case_11_regression(self):
 229         lst = ["divwo. 3, 1, 2"]
 230         initial_regs = [0] * 32
 231         initial_regs[1] = 0xffffffffffffffff
 232         initial_regs[2] = 0xffffffffffffffff
 233         with Program(lst, bigendian) as prog:
 234             self.add_case(prog, initial_regs)
 235
 236     def case_divw_by_zero_1(self):
 237         lst = ["divw. 3, 1, 2"]
 238         initial_regs = [0] * 32
 239         initial_regs[1] = 0x1
 240         initial_regs[2] = 0x0
 241         with Program(lst, bigendian) as prog:
 242             self.add_case(prog, initial_regs)
 243
 244     def case_divw_overflow2(self):
 245         lst = ["divw. 3, 1, 2"]
 246         initial_regs = [0] * 32
 247         initial_regs[1] = 0x80000000
 248         initial_regs[2] = 0xffffffffffffffff  # top bits don't seem to matter
 249         with Program(lst, bigendian) as prog:
 250             self.add_case(prog, initial_regs)
 251
 252     def case_divw_overflow3(self):
 253         lst = ["divw. 3, 1, 2"]
 254         initial_regs = [0] * 32
 255         initial_regs[1] = 0x80000000
 256         initial_regs[2] = 0xffffffff
 257         with Program(lst, bigendian) as prog:
 258             self.add_case(prog, initial_regs)
 259
 260     def case_divwuo_regression_1(self):
 261         lst = ["divwuo. 3, 1, 2"]
 262         initial_regs = [0] * 32
 263         initial_regs[1] = 0x7591a398c4e32b68
 264         initial_regs[2] = 0x48674ab432867d69
 265         with Program(lst, bigendian) as prog:
 266             self.add_case(prog, initial_regs)
 267
 268     def case_divwuo_1(self):
 269         lst = ["divwuo. 3, 1, 2"]
 270         initial_regs = [0] * 32
 271         initial_regs[1] = 0x50
 272         initial_regs[2] = 0x2
 273         with Program(lst, bigendian) as prog:
 274             self.add_case(prog, initial_regs)
 275
 276     def case_rand_divwu(self):
 277         insns = ["divwu", "divwu.", "divwuo", "divwuo."]
 278         for i in range(40):
 279             choice = random.choice(insns)
 280             lst = [f"{choice} 3, 1, 2"]
 281             initial_regs = [0] * 32
 282             initial_regs[1] = log_rand(32)
 283             initial_regs[2] = log_rand(32)
 284             with Program(lst, bigendian) as prog:
 285                 self.add_case(prog, initial_regs)
 286
 287     def case_rand_divw(self):
 288         insns = ["divw", "divw.", "divwo", "divwo."]
 289         for i in range(40):
 290             choice = random.choice(insns)
 291             lst = [f"{choice} 3, 1, 2"]
 292             initial_regs = [0] * 32
 293             initial_regs[1] = log_rand(32)
 294             initial_regs[2] = log_rand(32)
 295             with Program(lst, bigendian) as prog:
 296                 self.add_case(prog, initial_regs)
 297