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