src/soc/fu/div/test/test_pipe_caller.py

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