3 from openpower
.simulator
.program
import Program
4 from openpower
.endian
import bigendian
5 from openpower
.test
.common
import TestAccumulatorBase
, skip_case
7 from openpower
.util
import log_rand
10 class DivTestCases(TestAccumulatorBase
):
11 def case_divdeu_regression(self
):
12 lst
= ["divdeu 3, 1, 2"]
13 initial_regs
= [0] * 32
16 with
Program(lst
, bigendian
) as prog
:
17 self
.add_case(prog
, initial_regs
)
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
)
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
)
35 def case_divde_regression2(self
):
36 lst
= ["divde 3, 1, 2"]
37 initial_regs
= [0] * 32
39 initial_regs
[2] = 0xfffffffffffffffe
40 with
Program(lst
, bigendian
) as prog
:
41 self
.add_case(prog
, initial_regs
)
43 def case_divde_regression(self
):
44 lst
= ["divde 3, 1, 2"]
45 initial_regs
= [0] * 32
47 with
Program(lst
, bigendian
) as prog
:
48 self
.add_case(prog
, initial_regs
)
50 def case_moduw_regression(self
):
51 lst
= ["moduw 3, 1, 2"]
52 initial_regs
= [0] * 32
54 initial_regs
[2] = 0xffffffffffffffff
55 with
Program(lst
, bigendian
) as prog
:
56 self
.add_case(prog
, initial_regs
)
58 def case_modsw_regression(self
):
59 lst
= ["modsw 3, 1, 2"]
60 initial_regs
= [0] * 32
61 initial_regs
[1] = 0xffffffffffffffff
63 with
Program(lst
, bigendian
) as prog
:
64 self
.add_case(prog
, initial_regs
)
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
71 initial_regs
[2] = 0xffffffffffffffff
72 with
Program(lst
, bigendian
) as prog
:
73 self
.add_case(prog
, initial_regs
)
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
84 with
Program(lst
, bigendian
) as prog
:
85 self
.add_case(prog
, initial_regs
)
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
)
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
98 initial_regs
[1] = 0x80000000
99 with
Program(lst
, bigendian
) as prog
:
100 self
.add_case(prog
, initial_regs
)
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
)
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
)
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
)
131 def case_0_regression(self
):
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
)
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
)
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
)
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
)
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
)
172 def case_5_regression(self
):
173 lst
= ["divw 3, 1, 2",
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
)
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
)
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
)
204 def case_8_fsm_regression(self
): # FSM result is "36" not 6
205 lst
= ["divwu. 3, 1, 2"]
206 initial_regs
= [0] * 32
209 with
Program(lst
, bigendian
) as prog
:
210 self
.add_case(prog
, initial_regs
)
212 def case_9_regression(self
): # CR0 fails: expected 0b10, actual 0b11
213 lst
= ["divw. 3, 1, 2"]
214 initial_regs
= [0] * 32
217 with
Program(lst
, bigendian
) as prog
:
218 self
.add_case(prog
, initial_regs
)
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
)
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
)
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
)
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
)
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
)
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
)
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
)
276 def case_rand_divwu(self
):
277 insns
= ["divwu", "divwu.", "divwuo", "divwuo."]
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
)
287 def case_rand_divw(self
):
288 insns
= ["divw", "divw.", "divwo", "divwo."]
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
)