projects / openpower-isa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
add comment that fptrans test cases output values are probably not all correct
[openpower-isa.git] / src / openpower / test / fptrans / fptrans_cases.py
1 from openpower.test.common import TestAccumulatorBase
2 from openpower.sv.trans.svp64 import SVP64Asm
3 from openpower.test.state import ExpectedState
4 from openpower.simulator.program import Program
5
6
7 # FIXME: output values are just what my computer produces for the current
8 # simulator, they are probably not all correct.
9
10
11 class FPTransCases(TestAccumulatorBase):
12 def case_fatan2s(self):
13 lst = list(SVP64Asm(["fatan2s 3,4,5"]))
14 gprs = [0] * 32
15 fprs = [0] * 32
16 fprs[4] = 0x3ff0000000000000 # 1.0
17 fprs[5] = 0x3ff0000000000000 # 1.0
18 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
19 e.fpregs[3] = 0x3fe921fb60000000 # pi/4 as f32 as f64
20 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
21
22 def case_fatan2s_(self):
23 lst = list(SVP64Asm(["fatan2s. 3,4,5"]))
24 gprs = [0] * 32
25 fprs = [0] * 32
26 fprs[4] = 0x3ff0000000000000 # 1.0
27 fprs[5] = 0x3ff0000000000000 # 1.0
28 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
29 e.fpregs[3] = 0x3fe921fb60000000 # pi/4 as f32 as f64
30 e.crregs[1] = 0x4
31 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
32
33 def case_fatan2(self):
34 lst = list(SVP64Asm(["fatan2 3,4,5"]))
35 gprs = [0] * 32
36 fprs = [0] * 32
37 fprs[4] = 0x3ff0000000000000 # 1.0
38 fprs[5] = 0x3ff0000000000000 # 1.0
39 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
40 e.fpregs[3] = 0x3fe921fb54442d18
41 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
42
43 def case_fatan2_(self):
44 lst = list(SVP64Asm(["fatan2. 3,4,5"]))
45 gprs = [0] * 32
46 fprs = [0] * 32
47 fprs[4] = 0x3ff0000000000000 # 1.0
48 fprs[5] = 0x3ff0000000000000 # 1.0
49 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
50 e.fpregs[3] = 0x3fe921fb54442d18
51 e.crregs[1] = 0x4
52 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
53
54 def case_fatan2pis(self):
55 lst = list(SVP64Asm(["fatan2pis 3,4,5"]))
56 gprs = [0] * 32
57 fprs = [0] * 32
58 fprs[4] = 0x3ff0000000000000 # 1.0
59 fprs[5] = 0x3ff0000000000000 # 1.0
60 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
61 e.fpregs[3] = 0x3fd0000000000000
62 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
63
64 def case_fatan2pis_(self):
65 lst = list(SVP64Asm(["fatan2pis. 3,4,5"]))
66 gprs = [0] * 32
67 fprs = [0] * 32
68 fprs[4] = 0x3ff0000000000000 # 1.0
69 fprs[5] = 0x3ff0000000000000 # 1.0
70 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
71 e.fpregs[3] = 0x3fd0000000000000
72 e.crregs[1] = 0x4
73 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
74
75 def case_fatan2pi(self):
76 lst = list(SVP64Asm(["fatan2pi 3,4,5"]))
77 gprs = [0] * 32
78 fprs = [0] * 32
79 fprs[4] = 0x3ff0000000000000 # 1.0
80 fprs[5] = 0x3ff0000000000000 # 1.0
81 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
82 e.fpregs[3] = 0x3fd0000000000000
83 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
84
85 def case_fatan2pi_(self):
86 lst = list(SVP64Asm(["fatan2pi. 3,4,5"]))
87 gprs = [0] * 32
88 fprs = [0] * 32
89 fprs[4] = 0x3ff0000000000000 # 1.0
90 fprs[5] = 0x3ff0000000000000 # 1.0
91 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
92 e.fpregs[3] = 0x3fd0000000000000
93 e.crregs[1] = 0x4
94 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
95
96 def case_fpows(self):
97 lst = list(SVP64Asm(["fpows 3,4,5"]))
98 gprs = [0] * 32
99 fprs = [0] * 32
100 fprs[4] = 0x3ff0000000000000 # 1.0
101 fprs[5] = 0x3ff0000000000000 # 1.0
102 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
103 e.fpregs[3] = 0x3ff0000000000000
104 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
105
106 def case_fpows_(self):
107 lst = list(SVP64Asm(["fpows. 3,4,5"]))
108 gprs = [0] * 32
109 fprs = [0] * 32
110 fprs[4] = 0x3ff0000000000000 # 1.0
111 fprs[5] = 0x3ff0000000000000 # 1.0
112 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
113 e.fpregs[3] = 0x3ff0000000000000
114 e.crregs[1] = 0x4
115 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
116
117 def case_fpow(self):
118 lst = list(SVP64Asm(["fpow 3,4,5"]))
119 gprs = [0] * 32
120 fprs = [0] * 32
121 fprs[4] = 0x3ff0000000000000 # 1.0
122 fprs[5] = 0x3ff0000000000000 # 1.0
123 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
124 e.fpregs[3] = 0x3ff0000000000000
125 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
126
127 def case_fpow_(self):
128 lst = list(SVP64Asm(["fpow. 3,4,5"]))
129 gprs = [0] * 32
130 fprs = [0] * 32
131 fprs[4] = 0x3ff0000000000000 # 1.0
132 fprs[5] = 0x3ff0000000000000 # 1.0
133 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
134 e.fpregs[3] = 0x3ff0000000000000
135 e.crregs[1] = 0x4
136 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
137
138 def case_fpowns(self):
139 lst = list(SVP64Asm(["fpowns 3,4,5"]))
140 gprs = [0] * 32
141 fprs = [0] * 32
142 fprs[4] = 0x3ff0000000000000 # 1.0
143 gprs[5] = 3
144 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
145 e.fpregs[3] = 0x3ff0000000000000
146 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
147
148 def case_fpowns_(self):
149 lst = list(SVP64Asm(["fpowns. 3,4,5"]))
150 gprs = [0] * 32
151 fprs = [0] * 32
152 fprs[4] = 0x3ff0000000000000 # 1.0
153 gprs[5] = 3
154 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
155 e.fpregs[3] = 0x3ff0000000000000
156 e.crregs[1] = 0x4
157 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
158
159 def case_fpown(self):
160 lst = list(SVP64Asm(["fpown 3,4,5"]))
161 gprs = [0] * 32
162 fprs = [0] * 32
163 fprs[4] = 0x3ff0000000000000 # 1.0
164 gprs[5] = 3
165 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
166 e.fpregs[3] = 0x3ff0000000000000
167 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
168
169 def case_fpown_(self):
170 lst = list(SVP64Asm(["fpown. 3,4,5"]))
171 gprs = [0] * 32
172 fprs = [0] * 32
173 fprs[4] = 0x3ff0000000000000 # 1.0
174 gprs[5] = 3
175 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
176 e.fpregs[3] = 0x3ff0000000000000
177 e.crregs[1] = 0x4
178 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
179
180 def case_fpowrs(self):
181 lst = list(SVP64Asm(["fpowrs 3,4,5"]))
182 gprs = [0] * 32
183 fprs = [0] * 32
184 fprs[4] = 0x3ff0000000000000 # 1.0
185 fprs[5] = 0x3ff0000000000000 # 1.0
186 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
187 e.fpregs[3] = 0x3ff0000000000000
188 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
189
190 def case_fpowrs_(self):
191 lst = list(SVP64Asm(["fpowrs. 3,4,5"]))
192 gprs = [0] * 32
193 fprs = [0] * 32
194 fprs[4] = 0x3ff0000000000000 # 1.0
195 fprs[5] = 0x3ff0000000000000 # 1.0
196 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
197 e.fpregs[3] = 0x3ff0000000000000
198 e.crregs[1] = 0x4
199 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
200
201 def case_fpowr(self):
202 lst = list(SVP64Asm(["fpowr 3,4,5"]))
203 gprs = [0] * 32
204 fprs = [0] * 32
205 fprs[4] = 0x3ff0000000000000 # 1.0
206 fprs[5] = 0x3ff0000000000000 # 1.0
207 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
208 e.fpregs[3] = 0x3ff0000000000000
209 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
210
211 def case_fpowr_(self):
212 lst = list(SVP64Asm(["fpowr. 3,4,5"]))
213 gprs = [0] * 32
214 fprs = [0] * 32
215 fprs[4] = 0x3ff0000000000000 # 1.0
216 fprs[5] = 0x3ff0000000000000 # 1.0
217 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
218 e.fpregs[3] = 0x3ff0000000000000
219 e.crregs[1] = 0x4
220 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
221
222 def case_frootns(self):
223 lst = list(SVP64Asm(["frootns 3,4,5"]))
224 gprs = [0] * 32
225 fprs = [0] * 32
226 fprs[4] = 0x3ff0000000000000 # 1.0
227 gprs[5] = 3
228 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
229 e.fpregs[3] = 0x3ff0000000000000
230 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
231
232 def case_frootns_(self):
233 lst = list(SVP64Asm(["frootns. 3,4,5"]))
234 gprs = [0] * 32
235 fprs = [0] * 32
236 fprs[4] = 0x3ff0000000000000 # 1.0
237 gprs[5] = 3
238 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
239 e.fpregs[3] = 0x3ff0000000000000
240 e.crregs[1] = 0x4
241 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
242
243 def case_frootn(self):
244 lst = list(SVP64Asm(["frootn 3,4,5"]))
245 gprs = [0] * 32
246 fprs = [0] * 32
247 fprs[4] = 0x3ff0000000000000 # 1.0
248 gprs[5] = 3
249 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
250 e.fpregs[3] = 0x3ff0000000000000
251 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
252
253 def case_frootn_(self):
254 lst = list(SVP64Asm(["frootn. 3,4,5"]))
255 gprs = [0] * 32
256 fprs = [0] * 32
257 fprs[4] = 0x3ff0000000000000 # 1.0
258 gprs[5] = 3
259 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
260 e.fpregs[3] = 0x3ff0000000000000
261 e.crregs[1] = 0x4
262 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
263
264 def case_fhypots(self):
265 lst = list(SVP64Asm(["fhypots 3,4,5"]))
266 gprs = [0] * 32
267 fprs = [0] * 32
268 fprs[4] = 0x3ff0000000000000 # 1.0
269 fprs[5] = 0x3ff0000000000000 # 1.0
270 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
271 e.fpregs[3] = 0x3ff6a09e60000000
272 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
273
274 def case_fhypots_(self):
275 lst = list(SVP64Asm(["fhypots. 3,4,5"]))
276 gprs = [0] * 32
277 fprs = [0] * 32
278 fprs[4] = 0x3ff0000000000000 # 1.0
279 fprs[5] = 0x3ff0000000000000 # 1.0
280 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
281 e.fpregs[3] = 0x3ff6a09e60000000
282 e.crregs[1] = 0x4
283 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
284
285 def case_fhypot(self):
286 lst = list(SVP64Asm(["fhypot 3,4,5"]))
287 gprs = [0] * 32
288 fprs = [0] * 32
289 fprs[4] = 0x3ff0000000000000 # 1.0
290 fprs[5] = 0x3ff0000000000000 # 1.0
291 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
292 e.fpregs[3] = 0x3ff6a09e667f3bcd
293 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
294
295 def case_fhypot_(self):
296 lst = list(SVP64Asm(["fhypot. 3,4,5"]))
297 gprs = [0] * 32
298 fprs = [0] * 32
299 fprs[4] = 0x3ff0000000000000 # 1.0
300 fprs[5] = 0x3ff0000000000000 # 1.0
301 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
302 e.fpregs[3] = 0x3ff6a09e667f3bcd
303 e.crregs[1] = 0x4
304 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
305
306 def case_frsqrts(self):
307 lst = list(SVP64Asm(["frsqrts 3,4"]))
308 gprs = [0] * 32
309 fprs = [0] * 32
310 fprs[4] = 0x3ff0000000000000 # 1.0
311 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
312 e.fpregs[3] = 0x3ff0000000000000
313 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
314
315 def case_frsqrts_(self):
316 lst = list(SVP64Asm(["frsqrts. 3,4"]))
317 gprs = [0] * 32
318 fprs = [0] * 32
319 fprs[4] = 0x3ff0000000000000 # 1.0
320 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
321 e.fpregs[3] = 0x3ff0000000000000
322 e.crregs[1] = 0x4
323 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
324
325 def case_frsqrt(self):
326 lst = list(SVP64Asm(["frsqrt 3,4"]))
327 gprs = [0] * 32
328 fprs = [0] * 32
329 fprs[4] = 0x3ff0000000000000 # 1.0
330 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
331 e.fpregs[3] = 0x3ff0000000000000
332 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
333
334 def case_frsqrt_(self):
335 lst = list(SVP64Asm(["frsqrt. 3,4"]))
336 gprs = [0] * 32
337 fprs = [0] * 32
338 fprs[4] = 0x3ff0000000000000 # 1.0
339 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
340 e.fpregs[3] = 0x3ff0000000000000
341 e.crregs[1] = 0x4
342 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
343
344 def case_fcbrts(self):
345 lst = list(SVP64Asm(["fcbrts 3,4"]))
346 gprs = [0] * 32
347 fprs = [0] * 32
348 fprs[4] = 0x3ff0000000000000 # 1.0
349 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
350 e.fpregs[3] = 0x3ff0000000000000
351 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
352
353 def case_fcbrts_(self):
354 lst = list(SVP64Asm(["fcbrts. 3,4"]))
355 gprs = [0] * 32
356 fprs = [0] * 32
357 fprs[4] = 0x3ff0000000000000 # 1.0
358 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
359 e.fpregs[3] = 0x3ff0000000000000
360 e.crregs[1] = 0x4
361 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
362
363 def case_fcbrt(self):
364 lst = list(SVP64Asm(["fcbrt 3,4"]))
365 gprs = [0] * 32
366 fprs = [0] * 32
367 fprs[4] = 0x3ff0000000000000 # 1.0
368 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
369 e.fpregs[3] = 0x3ff0000000000000
370 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
371
372 def case_fcbrt_(self):
373 lst = list(SVP64Asm(["fcbrt. 3,4"]))
374 gprs = [0] * 32
375 fprs = [0] * 32
376 fprs[4] = 0x3ff0000000000000 # 1.0
377 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
378 e.fpregs[3] = 0x3ff0000000000000
379 e.crregs[1] = 0x4
380 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
381
382 def case_frecips(self):
383 lst = list(SVP64Asm(["frecips 3,4"]))
384 gprs = [0] * 32
385 fprs = [0] * 32
386 fprs[4] = 0x3ff0000000000000 # 1.0
387 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
388 e.fpregs[3] = 0x3ff0000000000000
389 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
390
391 def case_frecips_(self):
392 lst = list(SVP64Asm(["frecips. 3,4"]))
393 gprs = [0] * 32
394 fprs = [0] * 32
395 fprs[4] = 0x3ff0000000000000 # 1.0
396 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
397 e.fpregs[3] = 0x3ff0000000000000
398 e.crregs[1] = 0x4
399 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
400
401 def case_frecip(self):
402 lst = list(SVP64Asm(["frecip 3,4"]))
403 gprs = [0] * 32
404 fprs = [0] * 32
405 fprs[4] = 0x3ff0000000000000 # 1.0
406 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
407 e.fpregs[3] = 0x3ff0000000000000
408 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
409
410 def case_frecip_(self):
411 lst = list(SVP64Asm(["frecip. 3,4"]))
412 gprs = [0] * 32
413 fprs = [0] * 32
414 fprs[4] = 0x3ff0000000000000 # 1.0
415 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
416 e.fpregs[3] = 0x3ff0000000000000
417 e.crregs[1] = 0x4
418 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
419
420 def case_fexp2m1s(self):
421 lst = list(SVP64Asm(["fexp2m1s 3,4"]))
422 gprs = [0] * 32
423 fprs = [0] * 32
424 fprs[4] = 0x3ff0000000000000 # 1.0
425 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
426 e.fpregs[3] = 0x3ff0000000000000
427 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
428
429 def case_fexp2m1s_(self):
430 lst = list(SVP64Asm(["fexp2m1s. 3,4"]))
431 gprs = [0] * 32
432 fprs = [0] * 32
433 fprs[4] = 0x3ff0000000000000 # 1.0
434 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
435 e.fpregs[3] = 0x3ff0000000000000
436 e.crregs[1] = 0x4
437 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
438
439 def case_fexp2m1(self):
440 lst = list(SVP64Asm(["fexp2m1 3,4"]))
441 gprs = [0] * 32
442 fprs = [0] * 32
443 fprs[4] = 0x3ff0000000000000 # 1.0
444 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
445 e.fpregs[3] = 0x3ff0000000000000
446 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
447
448 def case_fexp2m1_(self):
449 lst = list(SVP64Asm(["fexp2m1. 3,4"]))
450 gprs = [0] * 32
451 fprs = [0] * 32
452 fprs[4] = 0x3ff0000000000000 # 1.0
453 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
454 e.fpregs[3] = 0x3ff0000000000000
455 e.crregs[1] = 0x4
456 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
457
458 def case_flog2p1s(self):
459 lst = list(SVP64Asm(["flog2p1s 3,4"]))
460 gprs = [0] * 32
461 fprs = [0] * 32
462 fprs[4] = 0x3ff0000000000000 # 1.0
463 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
464 e.fpregs[3] = 0x3ff0000000000000
465 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
466
467 def case_flog2p1s_(self):
468 lst = list(SVP64Asm(["flog2p1s. 3,4"]))
469 gprs = [0] * 32
470 fprs = [0] * 32
471 fprs[4] = 0x3ff0000000000000 # 1.0
472 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
473 e.fpregs[3] = 0x3ff0000000000000
474 e.crregs[1] = 0x4
475 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
476
477 def case_flog2p1(self):
478 lst = list(SVP64Asm(["flog2p1 3,4"]))
479 gprs = [0] * 32
480 fprs = [0] * 32
481 fprs[4] = 0x3ff0000000000000 # 1.0
482 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
483 e.fpregs[3] = 0x3ff0000000000000
484 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
485
486 def case_flog2p1_(self):
487 lst = list(SVP64Asm(["flog2p1. 3,4"]))
488 gprs = [0] * 32
489 fprs = [0] * 32
490 fprs[4] = 0x3ff0000000000000 # 1.0
491 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
492 e.fpregs[3] = 0x3ff0000000000000
493 e.crregs[1] = 0x4
494 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
495
496 def case_fexp2s(self):
497 lst = list(SVP64Asm(["fexp2s 3,4"]))
498 gprs = [0] * 32
499 fprs = [0] * 32
500 fprs[4] = 0x3ff0000000000000 # 1.0
501 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
502 e.fpregs[3] = 0x4000000000000000
503 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
504
505 def case_fexp2s_(self):
506 lst = list(SVP64Asm(["fexp2s. 3,4"]))
507 gprs = [0] * 32
508 fprs = [0] * 32
509 fprs[4] = 0x3ff0000000000000 # 1.0
510 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
511 e.fpregs[3] = 0x4000000000000000
512 e.crregs[1] = 0x4
513 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
514
515 def case_fexp2(self):
516 lst = list(SVP64Asm(["fexp2 3,4"]))
517 gprs = [0] * 32
518 fprs = [0] * 32
519 fprs[4] = 0x3ff0000000000000 # 1.0
520 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
521 e.fpregs[3] = 0x4000000000000000
522 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
523
524 def case_fexp2_(self):
525 lst = list(SVP64Asm(["fexp2. 3,4"]))
526 gprs = [0] * 32
527 fprs = [0] * 32
528 fprs[4] = 0x3ff0000000000000 # 1.0
529 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
530 e.fpregs[3] = 0x4000000000000000
531 e.crregs[1] = 0x4
532 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
533
534 def case_flog2s(self):
535 lst = list(SVP64Asm(["flog2s 3,4"]))
536 gprs = [0] * 32
537 fprs = [0] * 32
538 fprs[4] = 0x3ff0000000000000 # 1.0
539 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
540 e.fpregs[3] = 0x0
541 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
542
543 def case_flog2s_(self):
544 lst = list(SVP64Asm(["flog2s. 3,4"]))
545 gprs = [0] * 32
546 fprs = [0] * 32
547 fprs[4] = 0x3ff0000000000000 # 1.0
548 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
549 e.fpregs[3] = 0x0
550 e.crregs[1] = 0x2
551 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
552
553 def case_flog2(self):
554 lst = list(SVP64Asm(["flog2 3,4"]))
555 gprs = [0] * 32
556 fprs = [0] * 32
557 fprs[4] = 0x3ff0000000000000 # 1.0
558 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
559 e.fpregs[3] = 0x0
560 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
561
562 def case_flog2_(self):
563 lst = list(SVP64Asm(["flog2. 3,4"]))
564 gprs = [0] * 32
565 fprs = [0] * 32
566 fprs[4] = 0x3ff0000000000000 # 1.0
567 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
568 e.fpregs[3] = 0x0
569 e.crregs[1] = 0x2
570 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
571
572 def case_fexpm1s(self):
573 lst = list(SVP64Asm(["fexpm1s 3,4"]))
574 gprs = [0] * 32
575 fprs = [0] * 32
576 fprs[4] = 0x3ff0000000000000 # 1.0
577 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
578 e.fpregs[3] = 0x3ffb7e1520000000
579 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
580
581 def case_fexpm1s_(self):
582 lst = list(SVP64Asm(["fexpm1s. 3,4"]))
583 gprs = [0] * 32
584 fprs = [0] * 32
585 fprs[4] = 0x3ff0000000000000 # 1.0
586 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
587 e.fpregs[3] = 0x3ffb7e1520000000
588 e.crregs[1] = 0x4
589 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
590
591 def case_fexpm1(self):
592 lst = list(SVP64Asm(["fexpm1 3,4"]))
593 gprs = [0] * 32
594 fprs = [0] * 32
595 fprs[4] = 0x3ff0000000000000 # 1.0
596 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
597 e.fpregs[3] = 0x3ffb7e151628aed2
598 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
599
600 def case_fexpm1_(self):
601 lst = list(SVP64Asm(["fexpm1. 3,4"]))
602 gprs = [0] * 32
603 fprs = [0] * 32
604 fprs[4] = 0x3ff0000000000000 # 1.0
605 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
606 e.fpregs[3] = 0x3ffb7e151628aed2
607 e.crregs[1] = 0x4
608 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
609
610 def case_flogp1s(self):
611 lst = list(SVP64Asm(["flogp1s 3,4"]))
612 gprs = [0] * 32
613 fprs = [0] * 32
614 fprs[4] = 0x3ff0000000000000 # 1.0
615 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
616 e.fpregs[3] = 0x3fe62e4300000000
617 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
618
619 def case_flogp1s_(self):
620 lst = list(SVP64Asm(["flogp1s. 3,4"]))
621 gprs = [0] * 32
622 fprs = [0] * 32
623 fprs[4] = 0x3ff0000000000000 # 1.0
624 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
625 e.fpregs[3] = 0x3fe62e4300000000
626 e.crregs[1] = 0x4
627 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
628
629 def case_flogp1(self):
630 lst = list(SVP64Asm(["flogp1 3,4"]))
631 gprs = [0] * 32
632 fprs = [0] * 32
633 fprs[4] = 0x3ff0000000000000 # 1.0
634 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
635 e.fpregs[3] = 0x3fe62e42fefa39ef
636 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
637
638 def case_flogp1_(self):
639 lst = list(SVP64Asm(["flogp1. 3,4"]))
640 gprs = [0] * 32
641 fprs = [0] * 32
642 fprs[4] = 0x3ff0000000000000 # 1.0
643 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
644 e.fpregs[3] = 0x3fe62e42fefa39ef
645 e.crregs[1] = 0x4
646 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
647
648 def case_fexps(self):
649 lst = list(SVP64Asm(["fexps 3,4"]))
650 gprs = [0] * 32
651 fprs = [0] * 32
652 fprs[4] = 0x3ff0000000000000 # 1.0
653 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
654 e.fpregs[3] = 0x4005bf0a80000000
655 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
656
657 def case_fexps_(self):
658 lst = list(SVP64Asm(["fexps. 3,4"]))
659 gprs = [0] * 32
660 fprs = [0] * 32
661 fprs[4] = 0x3ff0000000000000 # 1.0
662 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
663 e.fpregs[3] = 0x4005bf0a80000000
664 e.crregs[1] = 0x4
665 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
666
667 def case_fexp(self):
668 lst = list(SVP64Asm(["fexp 3,4"]))
669 gprs = [0] * 32
670 fprs = [0] * 32
671 fprs[4] = 0x3ff0000000000000 # 1.0
672 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
673 e.fpregs[3] = 0x4005bf0a8b145769
674 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
675
676 def case_fexp_(self):
677 lst = list(SVP64Asm(["fexp. 3,4"]))
678 gprs = [0] * 32
679 fprs = [0] * 32
680 fprs[4] = 0x3ff0000000000000 # 1.0
681 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
682 e.fpregs[3] = 0x4005bf0a8b145769
683 e.crregs[1] = 0x4
684 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
685
686 def case_flogs(self):
687 lst = list(SVP64Asm(["flogs 3,4"]))
688 gprs = [0] * 32
689 fprs = [0] * 32
690 fprs[4] = 0x3ff0000000000000 # 1.0
691 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
692 e.fpregs[3] = 0x0
693 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
694
695 def case_flogs_(self):
696 lst = list(SVP64Asm(["flogs. 3,4"]))
697 gprs = [0] * 32
698 fprs = [0] * 32
699 fprs[4] = 0x3ff0000000000000 # 1.0
700 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
701 e.fpregs[3] = 0x0
702 e.crregs[1] = 0x2
703 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
704
705 def case_flog(self):
706 lst = list(SVP64Asm(["flog 3,4"]))
707 gprs = [0] * 32
708 fprs = [0] * 32
709 fprs[4] = 0x3ff0000000000000 # 1.0
710 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
711 e.fpregs[3] = 0x0
712 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
713
714 def case_flog_(self):
715 lst = list(SVP64Asm(["flog. 3,4"]))
716 gprs = [0] * 32
717 fprs = [0] * 32
718 fprs[4] = 0x3ff0000000000000 # 1.0
719 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
720 e.fpregs[3] = 0x0
721 e.crregs[1] = 0x2
722 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
723
724 def case_fexp10m1s(self):
725 lst = list(SVP64Asm(["fexp10m1s 3,4"]))
726 gprs = [0] * 32
727 fprs = [0] * 32
728 fprs[4] = 0x3ff0000000000000 # 1.0
729 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
730 e.fpregs[3] = 0x4022000000000000
731 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
732
733 def case_fexp10m1s_(self):
734 lst = list(SVP64Asm(["fexp10m1s. 3,4"]))
735 gprs = [0] * 32
736 fprs = [0] * 32
737 fprs[4] = 0x3ff0000000000000 # 1.0
738 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
739 e.fpregs[3] = 0x4022000000000000
740 e.crregs[1] = 0x4
741 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
742
743 def case_fexp10m1(self):
744 lst = list(SVP64Asm(["fexp10m1 3,4"]))
745 gprs = [0] * 32
746 fprs = [0] * 32
747 fprs[4] = 0x3ff0000000000000 # 1.0
748 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
749 e.fpregs[3] = 0x4022000000000000
750 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
751
752 def case_fexp10m1_(self):
753 lst = list(SVP64Asm(["fexp10m1. 3,4"]))
754 gprs = [0] * 32
755 fprs = [0] * 32
756 fprs[4] = 0x3ff0000000000000 # 1.0
757 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
758 e.fpregs[3] = 0x4022000000000000
759 e.crregs[1] = 0x4
760 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
761
762 def case_flog10p1s(self):
763 lst = list(SVP64Asm(["flog10p1s 3,4"]))
764 gprs = [0] * 32
765 fprs = [0] * 32
766 fprs[4] = 0x3ff0000000000000 # 1.0
767 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
768 e.fpregs[3] = 0x3fd3441360000000
769 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
770
771 def case_flog10p1s_(self):
772 lst = list(SVP64Asm(["flog10p1s. 3,4"]))
773 gprs = [0] * 32
774 fprs = [0] * 32
775 fprs[4] = 0x3ff0000000000000 # 1.0
776 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
777 e.fpregs[3] = 0x3fd3441360000000
778 e.crregs[1] = 0x4
779 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
780
781 def case_flog10p1(self):
782 lst = list(SVP64Asm(["flog10p1 3,4"]))
783 gprs = [0] * 32
784 fprs = [0] * 32
785 fprs[4] = 0x3ff0000000000000 # 1.0
786 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
787 e.fpregs[3] = 0x3fd34413509f79ff
788 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
789
790 def case_flog10p1_(self):
791 lst = list(SVP64Asm(["flog10p1. 3,4"]))
792 gprs = [0] * 32
793 fprs = [0] * 32
794 fprs[4] = 0x3ff0000000000000 # 1.0
795 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
796 e.fpregs[3] = 0x3fd34413509f79ff
797 e.crregs[1] = 0x4
798 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
799
800 def case_fexp10s(self):
801 lst = list(SVP64Asm(["fexp10s 3,4"]))
802 gprs = [0] * 32
803 fprs = [0] * 32
804 fprs[4] = 0x3ff0000000000000 # 1.0
805 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
806 e.fpregs[3] = 0x4024000000000000
807 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
808
809 def case_fexp10s_(self):
810 lst = list(SVP64Asm(["fexp10s. 3,4"]))
811 gprs = [0] * 32
812 fprs = [0] * 32
813 fprs[4] = 0x3ff0000000000000 # 1.0
814 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
815 e.fpregs[3] = 0x4024000000000000
816 e.crregs[1] = 0x4
817 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
818
819 def case_fexp10(self):
820 lst = list(SVP64Asm(["fexp10 3,4"]))
821 gprs = [0] * 32
822 fprs = [0] * 32
823 fprs[4] = 0x3ff0000000000000 # 1.0
824 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
825 e.fpregs[3] = 0x4024000000000000
826 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
827
828 def case_fexp10_(self):
829 lst = list(SVP64Asm(["fexp10. 3,4"]))
830 gprs = [0] * 32
831 fprs = [0] * 32
832 fprs[4] = 0x3ff0000000000000 # 1.0
833 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
834 e.fpregs[3] = 0x4024000000000000
835 e.crregs[1] = 0x4
836 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
837
838 def case_flog10s(self):
839 lst = list(SVP64Asm(["flog10s 3,4"]))
840 gprs = [0] * 32
841 fprs = [0] * 32
842 fprs[4] = 0x3ff0000000000000 # 1.0
843 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
844 e.fpregs[3] = 0x0
845 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
846
847 def case_flog10s_(self):
848 lst = list(SVP64Asm(["flog10s. 3,4"]))
849 gprs = [0] * 32
850 fprs = [0] * 32
851 fprs[4] = 0x3ff0000000000000 # 1.0
852 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
853 e.fpregs[3] = 0x0
854 e.crregs[1] = 0x2
855 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
856
857 def case_flog10(self):
858 lst = list(SVP64Asm(["flog10 3,4"]))
859 gprs = [0] * 32
860 fprs = [0] * 32
861 fprs[4] = 0x3ff0000000000000 # 1.0
862 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
863 e.fpregs[3] = 0x0
864 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
865
866 def case_flog10_(self):
867 lst = list(SVP64Asm(["flog10. 3,4"]))
868 gprs = [0] * 32
869 fprs = [0] * 32
870 fprs[4] = 0x3ff0000000000000 # 1.0
871 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
872 e.fpregs[3] = 0x0
873 e.crregs[1] = 0x2
874 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
875
876 def case_fsins(self):
877 lst = list(SVP64Asm(["fsins 3,4"]))
878 gprs = [0] * 32
879 fprs = [0] * 32
880 fprs[4] = 0x3ff0000000000000 # 1.0
881 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
882 e.fpregs[3] = 0x3feaed5480000000
883 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
884
885 def case_fsins_(self):
886 lst = list(SVP64Asm(["fsins. 3,4"]))
887 gprs = [0] * 32
888 fprs = [0] * 32
889 fprs[4] = 0x3ff0000000000000 # 1.0
890 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
891 e.fpregs[3] = 0x3feaed5480000000
892 e.crregs[1] = 0x4
893 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
894
895 def case_fsin(self):
896 lst = list(SVP64Asm(["fsin 3,4"]))
897 gprs = [0] * 32
898 fprs = [0] * 32
899 fprs[4] = 0x3ff0000000000000 # 1.0
900 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
901 e.fpregs[3] = 0x3feaed548f090cee
902 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
903
904 def case_fsin_(self):
905 lst = list(SVP64Asm(["fsin. 3,4"]))
906 gprs = [0] * 32
907 fprs = [0] * 32
908 fprs[4] = 0x3ff0000000000000 # 1.0
909 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
910 e.fpregs[3] = 0x3feaed548f090cee
911 e.crregs[1] = 0x4
912 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
913
914 def case_fcoss(self):
915 lst = list(SVP64Asm(["fcoss 3,4"]))
916 gprs = [0] * 32
917 fprs = [0] * 32
918 fprs[4] = 0x3ff0000000000000 # 1.0
919 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
920 e.fpregs[3] = 0x3fe14a2800000000
921 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
922
923 def case_fcoss_(self):
924 lst = list(SVP64Asm(["fcoss. 3,4"]))
925 gprs = [0] * 32
926 fprs = [0] * 32
927 fprs[4] = 0x3ff0000000000000 # 1.0
928 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
929 e.fpregs[3] = 0x3fe14a2800000000
930 e.crregs[1] = 0x4
931 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
932
933 def case_fcos(self):
934 lst = list(SVP64Asm(["fcos 3,4"]))
935 gprs = [0] * 32
936 fprs = [0] * 32
937 fprs[4] = 0x3ff0000000000000 # 1.0
938 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
939 e.fpregs[3] = 0x3fe14a280fb5068c
940 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
941
942 def case_fcos_(self):
943 lst = list(SVP64Asm(["fcos. 3,4"]))
944 gprs = [0] * 32
945 fprs = [0] * 32
946 fprs[4] = 0x3ff0000000000000 # 1.0
947 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
948 e.fpregs[3] = 0x3fe14a280fb5068c
949 e.crregs[1] = 0x4
950 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
951
952 def case_ftans(self):
953 lst = list(SVP64Asm(["ftans 3,4"]))
954 gprs = [0] * 32
955 fprs = [0] * 32
956 fprs[4] = 0x3ff0000000000000 # 1.0
957 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
958 e.fpregs[3] = 0x3ff8eb2460000000
959 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
960
961 def case_ftans_(self):
962 lst = list(SVP64Asm(["ftans. 3,4"]))
963 gprs = [0] * 32
964 fprs = [0] * 32
965 fprs[4] = 0x3ff0000000000000 # 1.0
966 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
967 e.fpregs[3] = 0x3ff8eb2460000000
968 e.crregs[1] = 0x4
969 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
970
971 def case_ftan(self):
972 lst = list(SVP64Asm(["ftan 3,4"]))
973 gprs = [0] * 32
974 fprs = [0] * 32
975 fprs[4] = 0x3ff0000000000000 # 1.0
976 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
977 e.fpregs[3] = 0x3ff8eb245cbee3a6
978 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
979
980 def case_ftan_(self):
981 lst = list(SVP64Asm(["ftan. 3,4"]))
982 gprs = [0] * 32
983 fprs = [0] * 32
984 fprs[4] = 0x3ff0000000000000 # 1.0
985 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
986 e.fpregs[3] = 0x3ff8eb245cbee3a6
987 e.crregs[1] = 0x4
988 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
989
990 def case_fasins(self):
991 lst = list(SVP64Asm(["fasins 3,4"]))
992 gprs = [0] * 32
993 fprs = [0] * 32
994 fprs[4] = 0x3ff0000000000000 # 1.0
995 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
996 e.fpregs[3] = 0x3ff921fb60000000
997 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
998
999 def case_fasins_(self):
1000 lst = list(SVP64Asm(["fasins. 3,4"]))
1001 gprs = [0] * 32
1002 fprs = [0] * 32
1003 fprs[4] = 0x3ff0000000000000 # 1.0
1004 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1005 e.fpregs[3] = 0x3ff921fb60000000
1006 e.crregs[1] = 0x4
1007 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1008
1009 def case_fasin(self):
1010 lst = list(SVP64Asm(["fasin 3,4"]))
1011 gprs = [0] * 32
1012 fprs = [0] * 32
1013 fprs[4] = 0x3ff0000000000000 # 1.0
1014 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1015 e.fpregs[3] = 0x3ff921fb54442d18
1016 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1017
1018 def case_fasin_(self):
1019 lst = list(SVP64Asm(["fasin. 3,4"]))
1020 gprs = [0] * 32
1021 fprs = [0] * 32
1022 fprs[4] = 0x3ff0000000000000 # 1.0
1023 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1024 e.fpregs[3] = 0x3ff921fb54442d18
1025 e.crregs[1] = 0x4
1026 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1027
1028 def case_facoss(self):
1029 lst = list(SVP64Asm(["facoss 3,4"]))
1030 gprs = [0] * 32
1031 fprs = [0] * 32
1032 fprs[4] = 0x3ff0000000000000 # 1.0
1033 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1034 e.fpregs[3] = 0x0
1035 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1036
1037 def case_facoss_(self):
1038 lst = list(SVP64Asm(["facoss. 3,4"]))
1039 gprs = [0] * 32
1040 fprs = [0] * 32
1041 fprs[4] = 0x3ff0000000000000 # 1.0
1042 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1043 e.fpregs[3] = 0x0
1044 e.crregs[1] = 0x2
1045 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1046
1047 def case_facos(self):
1048 lst = list(SVP64Asm(["facos 3,4"]))
1049 gprs = [0] * 32
1050 fprs = [0] * 32
1051 fprs[4] = 0x3ff0000000000000 # 1.0
1052 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1053 e.fpregs[3] = 0x0
1054 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1055
1056 def case_facos_(self):
1057 lst = list(SVP64Asm(["facos. 3,4"]))
1058 gprs = [0] * 32
1059 fprs = [0] * 32
1060 fprs[4] = 0x3ff0000000000000 # 1.0
1061 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1062 e.fpregs[3] = 0x0
1063 e.crregs[1] = 0x2
1064 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1065
1066 def case_fatans(self):
1067 lst = list(SVP64Asm(["fatans 3,4"]))
1068 gprs = [0] * 32
1069 fprs = [0] * 32
1070 fprs[4] = 0x3ff0000000000000 # 1.0
1071 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1072 e.fpregs[3] = 0x3fe921fb60000000
1073 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1074
1075 def case_fatans_(self):
1076 lst = list(SVP64Asm(["fatans. 3,4"]))
1077 gprs = [0] * 32
1078 fprs = [0] * 32
1079 fprs[4] = 0x3ff0000000000000 # 1.0
1080 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1081 e.fpregs[3] = 0x3fe921fb60000000
1082 e.crregs[1] = 0x4
1083 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1084
1085 def case_fatan(self):
1086 lst = list(SVP64Asm(["fatan 3,4"]))
1087 gprs = [0] * 32
1088 fprs = [0] * 32
1089 fprs[4] = 0x3ff0000000000000 # 1.0
1090 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1091 e.fpregs[3] = 0x3fe921fb54442d18
1092 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1093
1094 def case_fatan_(self):
1095 lst = list(SVP64Asm(["fatan. 3,4"]))
1096 gprs = [0] * 32
1097 fprs = [0] * 32
1098 fprs[4] = 0x3ff0000000000000 # 1.0
1099 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1100 e.fpregs[3] = 0x3fe921fb54442d18
1101 e.crregs[1] = 0x4
1102 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1103
1104 def case_fsinpis(self):
1105 lst = list(SVP64Asm(["fsinpis 3,4"]))
1106 gprs = [0] * 32
1107 fprs = [0] * 32
1108 fprs[4] = 0x3fe0000000000000 # 0.5
1109 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1110 e.fpregs[3] = 0x3ff0000000000000
1111 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1112
1113 def case_fsinpis_(self):
1114 lst = list(SVP64Asm(["fsinpis. 3,4"]))
1115 gprs = [0] * 32
1116 fprs = [0] * 32
1117 fprs[4] = 0x3fe0000000000000 # 0.5
1118 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1119 e.fpregs[3] = 0x3ff0000000000000
1120 e.crregs[1] = 0x4
1121 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1122
1123 def case_fsinpi(self):
1124 lst = list(SVP64Asm(["fsinpi 3,4"]))
1125 gprs = [0] * 32
1126 fprs = [0] * 32
1127 fprs[4] = 0x3fe0000000000000 # 0.5
1128 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1129 e.fpregs[3] = 0x3ff0000000000000
1130 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1131
1132 def case_fsinpi_(self):
1133 lst = list(SVP64Asm(["fsinpi. 3,4"]))
1134 gprs = [0] * 32
1135 fprs = [0] * 32
1136 fprs[4] = 0x3fe0000000000000 # 0.5
1137 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1138 e.fpregs[3] = 0x3ff0000000000000
1139 e.crregs[1] = 0x4
1140 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1141
1142 def case_fcospis(self):
1143 lst = list(SVP64Asm(["fcospis 3,4"]))
1144 gprs = [0] * 32
1145 fprs = [0] * 32
1146 fprs[4] = 0x3ff0000000000000 # 1.0
1147 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1148 e.fpregs[3] = 0xbff0000000000000
1149 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1150
1151 def case_fcospis_(self):
1152 lst = list(SVP64Asm(["fcospis. 3,4"]))
1153 gprs = [0] * 32
1154 fprs = [0] * 32
1155 fprs[4] = 0x3ff0000000000000 # 1.0
1156 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1157 e.fpregs[3] = 0xbff0000000000000
1158 e.crregs[1] = 0x8
1159 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1160
1161 def case_fcospi(self):
1162 lst = list(SVP64Asm(["fcospi 3,4"]))
1163 gprs = [0] * 32
1164 fprs = [0] * 32
1165 fprs[4] = 0x3ff0000000000000 # 1.0
1166 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1167 e.fpregs[3] = 0xbff0000000000000
1168 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1169
1170 def case_fcospi_(self):
1171 lst = list(SVP64Asm(["fcospi. 3,4"]))
1172 gprs = [0] * 32
1173 fprs = [0] * 32
1174 fprs[4] = 0x3ff0000000000000 # 1.0
1175 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1176 e.fpregs[3] = 0xbff0000000000000
1177 e.crregs[1] = 0x8
1178 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1179
1180 def case_ftanpis(self):
1181 lst = list(SVP64Asm(["ftanpis 3,4"]))
1182 gprs = [0] * 32
1183 fprs = [0] * 32
1184 fprs[4] = 0x3fc0000000000000 # 0.125
1185 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1186 e.fpregs[3] = 0x3fda8279a0000000
1187 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1188
1189 def case_ftanpis_(self):
1190 lst = list(SVP64Asm(["ftanpis. 3,4"]))
1191 gprs = [0] * 32
1192 fprs = [0] * 32
1193 fprs[4] = 0x3fc0000000000000 # 0.125
1194 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1195 e.fpregs[3] = 0x3fda8279a0000000
1196 e.crregs[1] = 0x4
1197 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1198
1199 def case_ftanpi(self):
1200 lst = list(SVP64Asm(["ftanpi 3,4"]))
1201 gprs = [0] * 32
1202 fprs = [0] * 32
1203 fprs[4] = 0x3fc0000000000000 # 0.125
1204 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1205 e.fpregs[3] = 0x3fda827999fcef32
1206 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1207
1208 def case_ftanpi_(self):
1209 lst = list(SVP64Asm(["ftanpi. 3,4"]))
1210 gprs = [0] * 32
1211 fprs = [0] * 32
1212 fprs[4] = 0x3fc0000000000000 # 0.125
1213 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1214 e.fpregs[3] = 0x3fda827999fcef32
1215 e.crregs[1] = 0x4
1216 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1217
1218 def case_fasinpis(self):
1219 lst = list(SVP64Asm(["fasinpis 3,4"]))
1220 gprs = [0] * 32
1221 fprs = [0] * 32
1222 fprs[4] = 0x3ff0000000000000 # 1.0
1223 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1224 e.fpregs[3] = 0x3fe0000000000000
1225 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1226
1227 def case_fasinpis_(self):
1228 lst = list(SVP64Asm(["fasinpis. 3,4"]))
1229 gprs = [0] * 32
1230 fprs = [0] * 32
1231 fprs[4] = 0x3ff0000000000000 # 1.0
1232 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1233 e.fpregs[3] = 0x3fe0000000000000
1234 e.crregs[1] = 0x4
1235 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1236
1237 def case_fasinpi(self):
1238 lst = list(SVP64Asm(["fasinpi 3,4"]))
1239 gprs = [0] * 32
1240 fprs = [0] * 32
1241 fprs[4] = 0x3ff0000000000000 # 1.0
1242 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1243 e.fpregs[3] = 0x3fe0000000000000
1244 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1245
1246 def case_fasinpi_(self):
1247 lst = list(SVP64Asm(["fasinpi. 3,4"]))
1248 gprs = [0] * 32
1249 fprs = [0] * 32
1250 fprs[4] = 0x3ff0000000000000 # 1.0
1251 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1252 e.fpregs[3] = 0x3fe0000000000000
1253 e.crregs[1] = 0x4
1254 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1255
1256 def case_facospis(self):
1257 lst = list(SVP64Asm(["facospis 3,4"]))
1258 gprs = [0] * 32
1259 fprs = [0] * 32
1260 fprs[4] = 0x3ff0000000000000 # 1.0
1261 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1262 e.fpregs[3] = 0x0
1263 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1264
1265 def case_facospis_(self):
1266 lst = list(SVP64Asm(["facospis. 3,4"]))
1267 gprs = [0] * 32
1268 fprs = [0] * 32
1269 fprs[4] = 0x3ff0000000000000 # 1.0
1270 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1271 e.fpregs[3] = 0x0
1272 e.crregs[1] = 0x2
1273 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1274
1275 def case_facospi(self):
1276 lst = list(SVP64Asm(["facospi 3,4"]))
1277 gprs = [0] * 32
1278 fprs = [0] * 32
1279 fprs[4] = 0x3ff0000000000000 # 1.0
1280 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1281 e.fpregs[3] = 0x0
1282 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1283
1284 def case_facospi_(self):
1285 lst = list(SVP64Asm(["facospi. 3,4"]))
1286 gprs = [0] * 32
1287 fprs = [0] * 32
1288 fprs[4] = 0x3ff0000000000000 # 1.0
1289 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1290 e.fpregs[3] = 0x0
1291 e.crregs[1] = 0x2
1292 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1293
1294 def case_fatanpis(self):
1295 lst = list(SVP64Asm(["fatanpis 3,4"]))
1296 gprs = [0] * 32
1297 fprs = [0] * 32
1298 fprs[4] = 0x3ff0000000000000 # 1.0
1299 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1300 e.fpregs[3] = 0x3fd0000000000000
1301 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1302
1303 def case_fatanpis_(self):
1304 lst = list(SVP64Asm(["fatanpis. 3,4"]))
1305 gprs = [0] * 32
1306 fprs = [0] * 32
1307 fprs[4] = 0x3ff0000000000000 # 1.0
1308 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1309 e.fpregs[3] = 0x3fd0000000000000
1310 e.crregs[1] = 0x4
1311 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1312
1313 def case_fatanpi(self):
1314 lst = list(SVP64Asm(["fatanpi 3,4"]))
1315 gprs = [0] * 32
1316 fprs = [0] * 32
1317 fprs[4] = 0x3ff0000000000000 # 1.0
1318 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1319 e.fpregs[3] = 0x3fd0000000000000
1320 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1321
1322 def case_fatanpi_(self):
1323 lst = list(SVP64Asm(["fatanpi. 3,4"]))
1324 gprs = [0] * 32
1325 fprs = [0] * 32
1326 fprs[4] = 0x3ff0000000000000 # 1.0
1327 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1328 e.fpregs[3] = 0x3fd0000000000000
1329 e.crregs[1] = 0x4
1330 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1331
1332 def case_fsinhs(self):
1333 lst = list(SVP64Asm(["fsinhs 3,4"]))
1334 gprs = [0] * 32
1335 fprs = [0] * 32
1336 fprs[4] = 0x3ff0000000000000 # 1.0
1337 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1338 e.fpregs[3] = 0x3ff2cd9fc0000000
1339 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1340
1341 def case_fsinhs_(self):
1342 lst = list(SVP64Asm(["fsinhs. 3,4"]))
1343 gprs = [0] * 32
1344 fprs = [0] * 32
1345 fprs[4] = 0x3ff0000000000000 # 1.0
1346 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1347 e.fpregs[3] = 0x3ff2cd9fc0000000
1348 e.crregs[1] = 0x4
1349 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1350
1351 def case_fsinh(self):
1352 lst = list(SVP64Asm(["fsinh 3,4"]))
1353 gprs = [0] * 32
1354 fprs = [0] * 32
1355 fprs[4] = 0x3ff0000000000000 # 1.0
1356 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1357 e.fpregs[3] = 0x3ff2cd9fc44eb982
1358 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1359
1360 def case_fsinh_(self):
1361 lst = list(SVP64Asm(["fsinh. 3,4"]))
1362 gprs = [0] * 32
1363 fprs = [0] * 32
1364 fprs[4] = 0x3ff0000000000000 # 1.0
1365 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1366 e.fpregs[3] = 0x3ff2cd9fc44eb982
1367 e.crregs[1] = 0x4
1368 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1369
1370 def case_fcoshs(self):
1371 lst = list(SVP64Asm(["fcoshs 3,4"]))
1372 gprs = [0] * 32
1373 fprs = [0] * 32
1374 fprs[4] = 0x3ff0000000000000 # 1.0
1375 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1376 e.fpregs[3] = 0x3ff8b07560000000
1377 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1378
1379 def case_fcoshs_(self):
1380 lst = list(SVP64Asm(["fcoshs. 3,4"]))
1381 gprs = [0] * 32
1382 fprs = [0] * 32
1383 fprs[4] = 0x3ff0000000000000 # 1.0
1384 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1385 e.fpregs[3] = 0x3ff8b07560000000
1386 e.crregs[1] = 0x4
1387 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1388
1389 def case_fcosh(self):
1390 lst = list(SVP64Asm(["fcosh 3,4"]))
1391 gprs = [0] * 32
1392 fprs = [0] * 32
1393 fprs[4] = 0x3ff0000000000000 # 1.0
1394 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1395 e.fpregs[3] = 0x3ff8b07551d9f550
1396 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1397
1398 def case_fcosh_(self):
1399 lst = list(SVP64Asm(["fcosh. 3,4"]))
1400 gprs = [0] * 32
1401 fprs = [0] * 32
1402 fprs[4] = 0x3ff0000000000000 # 1.0
1403 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1404 e.fpregs[3] = 0x3ff8b07551d9f550
1405 e.crregs[1] = 0x4
1406 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1407
1408 def case_ftanhs(self):
1409 lst = list(SVP64Asm(["ftanhs 3,4"]))
1410 gprs = [0] * 32
1411 fprs = [0] * 32
1412 fprs[4] = 0x3ff0000000000000 # 1.0
1413 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1414 e.fpregs[3] = 0x3fe85efac0000000
1415 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1416
1417 def case_ftanhs_(self):
1418 lst = list(SVP64Asm(["ftanhs. 3,4"]))
1419 gprs = [0] * 32
1420 fprs = [0] * 32
1421 fprs[4] = 0x3ff0000000000000 # 1.0
1422 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1423 e.fpregs[3] = 0x3fe85efac0000000
1424 e.crregs[1] = 0x4
1425 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1426
1427 def case_ftanh(self):
1428 lst = list(SVP64Asm(["ftanh 3,4"]))
1429 gprs = [0] * 32
1430 fprs = [0] * 32
1431 fprs[4] = 0x3ff0000000000000 # 1.0
1432 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1433 e.fpregs[3] = 0x3fe85efab514f394
1434 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1435
1436 def case_ftanh_(self):
1437 lst = list(SVP64Asm(["ftanh. 3,4"]))
1438 gprs = [0] * 32
1439 fprs = [0] * 32
1440 fprs[4] = 0x3ff0000000000000 # 1.0
1441 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1442 e.fpregs[3] = 0x3fe85efab514f394
1443 e.crregs[1] = 0x4
1444 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1445
1446 def case_fasinhs(self):
1447 lst = list(SVP64Asm(["fasinhs 3,4"]))
1448 gprs = [0] * 32
1449 fprs = [0] * 32
1450 fprs[4] = 0x3ff0000000000000 # 1.0
1451 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1452 e.fpregs[3] = 0x3fec343660000000
1453 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1454
1455 def case_fasinhs_(self):
1456 lst = list(SVP64Asm(["fasinhs. 3,4"]))
1457 gprs = [0] * 32
1458 fprs = [0] * 32
1459 fprs[4] = 0x3ff0000000000000 # 1.0
1460 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1461 e.fpregs[3] = 0x3fec343660000000
1462 e.crregs[1] = 0x4
1463 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1464
1465 def case_fasinh(self):
1466 lst = list(SVP64Asm(["fasinh 3,4"]))
1467 gprs = [0] * 32
1468 fprs = [0] * 32
1469 fprs[4] = 0x3ff0000000000000 # 1.0
1470 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1471 e.fpregs[3] = 0x3fec34366179d427
1472 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1473
1474 def case_fasinh_(self):
1475 lst = list(SVP64Asm(["fasinh. 3,4"]))
1476 gprs = [0] * 32
1477 fprs = [0] * 32
1478 fprs[4] = 0x3ff0000000000000 # 1.0
1479 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1480 e.fpregs[3] = 0x3fec34366179d427
1481 e.crregs[1] = 0x4
1482 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1483
1484 def case_facoshs(self):
1485 lst = list(SVP64Asm(["facoshs 3,4"]))
1486 gprs = [0] * 32
1487 fprs = [0] * 32
1488 fprs[4] = 0x3ff0000000000000 # 1.0
1489 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1490 e.fpregs[3] = 0x0
1491 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1492
1493 def case_facoshs_(self):
1494 lst = list(SVP64Asm(["facoshs. 3,4"]))
1495 gprs = [0] * 32
1496 fprs = [0] * 32
1497 fprs[4] = 0x3ff0000000000000 # 1.0
1498 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1499 e.fpregs[3] = 0x0
1500 e.crregs[1] = 0x2
1501 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1502
1503 def case_facosh(self):
1504 lst = list(SVP64Asm(["facosh 3,4"]))
1505 gprs = [0] * 32
1506 fprs = [0] * 32
1507 fprs[4] = 0x3ff0000000000000 # 1.0
1508 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1509 e.fpregs[3] = 0x0
1510 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1511
1512 def case_facosh_(self):
1513 lst = list(SVP64Asm(["facosh. 3,4"]))
1514 gprs = [0] * 32
1515 fprs = [0] * 32
1516 fprs[4] = 0x3ff0000000000000 # 1.0
1517 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1518 e.fpregs[3] = 0x0
1519 e.crregs[1] = 0x2
1520 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1521
1522 def case_fatanhs(self):
1523 lst = list(SVP64Asm(["fatanhs 3,4"]))
1524 gprs = [0] * 32
1525 fprs = [0] * 32
1526 fprs[4] = 0x3fe0000000000000 # 0.5
1527 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1528 e.fpregs[3] = 0x3fe193ea80000000
1529 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1530
1531 def case_fatanhs_(self):
1532 lst = list(SVP64Asm(["fatanhs. 3,4"]))
1533 gprs = [0] * 32
1534 fprs = [0] * 32
1535 fprs[4] = 0x3fe0000000000000 # 0.5
1536 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1537 e.fpregs[3] = 0x3fe193ea80000000
1538 e.crregs[1] = 0x4
1539 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1540
1541 def case_fatanh(self):
1542 lst = list(SVP64Asm(["fatanh 3,4"]))
1543 gprs = [0] * 32
1544 fprs = [0] * 32
1545 fprs[4] = 0x3fe0000000000000 # 0.5
1546 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1547 e.fpregs[3] = 0x3fe193ea7aad030a
1548 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1549
1550 def case_fatanh_(self):
1551 lst = list(SVP64Asm(["fatanh. 3,4"]))
1552 gprs = [0] * 32
1553 fprs = [0] * 32
1554 fprs[4] = 0x3fe0000000000000 # 0.5
1555 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1556 e.fpregs[3] = 0x3fe193ea7aad030a
1557 e.crregs[1] = 0x4
1558 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1559
1560 def case_fminnum08s(self):
1561 lst = list(SVP64Asm(["fminnum08s 3,4,5"]))
1562 gprs = [0] * 32
1563 fprs = [0] * 32
1564 fprs[4] = 0x3ff0000000000000 # 1.0
1565 fprs[5] = 0x3ff0000000000000 # 1.0
1566 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1567 e.fpregs[3] = 0x3ff0000000000000
1568 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1569
1570 def case_fminnum08s_(self):
1571 lst = list(SVP64Asm(["fminnum08s. 3,4,5"]))
1572 gprs = [0] * 32
1573 fprs = [0] * 32
1574 fprs[4] = 0x3ff0000000000000 # 1.0
1575 fprs[5] = 0x3ff0000000000000 # 1.0
1576 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1577 e.fpregs[3] = 0x3ff0000000000000
1578 e.crregs[1] = 0x4
1579 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1580
1581 def case_fminnum08(self):
1582 lst = list(SVP64Asm(["fminnum08 3,4,5"]))
1583 gprs = [0] * 32
1584 fprs = [0] * 32
1585 fprs[4] = 0x3ff0000000000000 # 1.0
1586 fprs[5] = 0x3ff0000000000000 # 1.0
1587 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1588 e.fpregs[3] = 0x3ff0000000000000
1589 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1590
1591 def case_fminnum08_(self):
1592 lst = list(SVP64Asm(["fminnum08. 3,4,5"]))
1593 gprs = [0] * 32
1594 fprs = [0] * 32
1595 fprs[4] = 0x3ff0000000000000 # 1.0
1596 fprs[5] = 0x3ff0000000000000 # 1.0
1597 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1598 e.fpregs[3] = 0x3ff0000000000000
1599 e.crregs[1] = 0x4
1600 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1601
1602 def case_fmaxnum08s(self):
1603 lst = list(SVP64Asm(["fmaxnum08s 3,4,5"]))
1604 gprs = [0] * 32
1605 fprs = [0] * 32
1606 fprs[4] = 0x3ff0000000000000 # 1.0
1607 fprs[5] = 0x3ff0000000000000 # 1.0
1608 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1609 e.fpregs[3] = 0x3ff0000000000000
1610 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1611
1612 def case_fmaxnum08s_(self):
1613 lst = list(SVP64Asm(["fmaxnum08s. 3,4,5"]))
1614 gprs = [0] * 32
1615 fprs = [0] * 32
1616 fprs[4] = 0x3ff0000000000000 # 1.0
1617 fprs[5] = 0x3ff0000000000000 # 1.0
1618 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1619 e.fpregs[3] = 0x3ff0000000000000
1620 e.crregs[1] = 0x4
1621 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1622
1623 def case_fmaxnum08(self):
1624 lst = list(SVP64Asm(["fmaxnum08 3,4,5"]))
1625 gprs = [0] * 32
1626 fprs = [0] * 32
1627 fprs[4] = 0x3ff0000000000000 # 1.0
1628 fprs[5] = 0x3ff0000000000000 # 1.0
1629 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1630 e.fpregs[3] = 0x3ff0000000000000
1631 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1632
1633 def case_fmaxnum08_(self):
1634 lst = list(SVP64Asm(["fmaxnum08. 3,4,5"]))
1635 gprs = [0] * 32
1636 fprs = [0] * 32
1637 fprs[4] = 0x3ff0000000000000 # 1.0
1638 fprs[5] = 0x3ff0000000000000 # 1.0
1639 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1640 e.fpregs[3] = 0x3ff0000000000000
1641 e.crregs[1] = 0x4
1642 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1643
1644 def case_fmin19s(self):
1645 lst = list(SVP64Asm(["fmin19s 3,4,5"]))
1646 gprs = [0] * 32
1647 fprs = [0] * 32
1648 fprs[4] = 0x3ff0000000000000 # 1.0
1649 fprs[5] = 0x3ff0000000000000 # 1.0
1650 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1651 e.fpregs[3] = 0x3ff0000000000000
1652 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1653
1654 def case_fmin19s_(self):
1655 lst = list(SVP64Asm(["fmin19s. 3,4,5"]))
1656 gprs = [0] * 32
1657 fprs = [0] * 32
1658 fprs[4] = 0x3ff0000000000000 # 1.0
1659 fprs[5] = 0x3ff0000000000000 # 1.0
1660 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1661 e.fpregs[3] = 0x3ff0000000000000
1662 e.crregs[1] = 0x4
1663 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1664
1665 def case_fmin19(self):
1666 lst = list(SVP64Asm(["fmin19 3,4,5"]))
1667 gprs = [0] * 32
1668 fprs = [0] * 32
1669 fprs[4] = 0x3ff0000000000000 # 1.0
1670 fprs[5] = 0x3ff0000000000000 # 1.0
1671 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1672 e.fpregs[3] = 0x3ff0000000000000
1673 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1674
1675 def case_fmin19_(self):
1676 lst = list(SVP64Asm(["fmin19. 3,4,5"]))
1677 gprs = [0] * 32
1678 fprs = [0] * 32
1679 fprs[4] = 0x3ff0000000000000 # 1.0
1680 fprs[5] = 0x3ff0000000000000 # 1.0
1681 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1682 e.fpregs[3] = 0x3ff0000000000000
1683 e.crregs[1] = 0x4
1684 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1685
1686 def case_fmax19s(self):
1687 lst = list(SVP64Asm(["fmax19s 3,4,5"]))
1688 gprs = [0] * 32
1689 fprs = [0] * 32
1690 fprs[4] = 0x3ff0000000000000 # 1.0
1691 fprs[5] = 0x3ff0000000000000 # 1.0
1692 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1693 e.fpregs[3] = 0x3ff0000000000000
1694 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1695
1696 def case_fmax19s_(self):
1697 lst = list(SVP64Asm(["fmax19s. 3,4,5"]))
1698 gprs = [0] * 32
1699 fprs = [0] * 32
1700 fprs[4] = 0x3ff0000000000000 # 1.0
1701 fprs[5] = 0x3ff0000000000000 # 1.0
1702 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1703 e.fpregs[3] = 0x3ff0000000000000
1704 e.crregs[1] = 0x4
1705 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1706
1707 def case_fmax19(self):
1708 lst = list(SVP64Asm(["fmax19 3,4,5"]))
1709 gprs = [0] * 32
1710 fprs = [0] * 32
1711 fprs[4] = 0x3ff0000000000000 # 1.0
1712 fprs[5] = 0x3ff0000000000000 # 1.0
1713 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1714 e.fpregs[3] = 0x3ff0000000000000
1715 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1716
1717 def case_fmax19_(self):
1718 lst = list(SVP64Asm(["fmax19. 3,4,5"]))
1719 gprs = [0] * 32
1720 fprs = [0] * 32
1721 fprs[4] = 0x3ff0000000000000 # 1.0
1722 fprs[5] = 0x3ff0000000000000 # 1.0
1723 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1724 e.fpregs[3] = 0x3ff0000000000000
1725 e.crregs[1] = 0x4
1726 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1727
1728 def case_fminnum19s(self):
1729 lst = list(SVP64Asm(["fminnum19s 3,4,5"]))
1730 gprs = [0] * 32
1731 fprs = [0] * 32
1732 fprs[4] = 0x3ff0000000000000 # 1.0
1733 fprs[5] = 0x3ff0000000000000 # 1.0
1734 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1735 e.fpregs[3] = 0x3ff0000000000000
1736 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1737
1738 def case_fminnum19s_(self):
1739 lst = list(SVP64Asm(["fminnum19s. 3,4,5"]))
1740 gprs = [0] * 32
1741 fprs = [0] * 32
1742 fprs[4] = 0x3ff0000000000000 # 1.0
1743 fprs[5] = 0x3ff0000000000000 # 1.0
1744 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1745 e.fpregs[3] = 0x3ff0000000000000
1746 e.crregs[1] = 0x4
1747 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1748
1749 def case_fminnum19(self):
1750 lst = list(SVP64Asm(["fminnum19 3,4,5"]))
1751 gprs = [0] * 32
1752 fprs = [0] * 32
1753 fprs[4] = 0x3ff0000000000000 # 1.0
1754 fprs[5] = 0x3ff0000000000000 # 1.0
1755 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1756 e.fpregs[3] = 0x3ff0000000000000
1757 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1758
1759 def case_fminnum19_(self):
1760 lst = list(SVP64Asm(["fminnum19. 3,4,5"]))
1761 gprs = [0] * 32
1762 fprs = [0] * 32
1763 fprs[4] = 0x3ff0000000000000 # 1.0
1764 fprs[5] = 0x3ff0000000000000 # 1.0
1765 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1766 e.fpregs[3] = 0x3ff0000000000000
1767 e.crregs[1] = 0x4
1768 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1769
1770 def case_fmaxnum19s(self):
1771 lst = list(SVP64Asm(["fmaxnum19s 3,4,5"]))
1772 gprs = [0] * 32
1773 fprs = [0] * 32
1774 fprs[4] = 0x3ff0000000000000 # 1.0
1775 fprs[5] = 0x3ff0000000000000 # 1.0
1776 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1777 e.fpregs[3] = 0x3ff0000000000000
1778 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1779
1780 def case_fmaxnum19s_(self):
1781 lst = list(SVP64Asm(["fmaxnum19s. 3,4,5"]))
1782 gprs = [0] * 32
1783 fprs = [0] * 32
1784 fprs[4] = 0x3ff0000000000000 # 1.0
1785 fprs[5] = 0x3ff0000000000000 # 1.0
1786 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1787 e.fpregs[3] = 0x3ff0000000000000
1788 e.crregs[1] = 0x4
1789 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1790
1791 def case_fmaxnum19(self):
1792 lst = list(SVP64Asm(["fmaxnum19 3,4,5"]))
1793 gprs = [0] * 32
1794 fprs = [0] * 32
1795 fprs[4] = 0x3ff0000000000000 # 1.0
1796 fprs[5] = 0x3ff0000000000000 # 1.0
1797 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1798 e.fpregs[3] = 0x3ff0000000000000
1799 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1800
1801 def case_fmaxnum19_(self):
1802 lst = list(SVP64Asm(["fmaxnum19. 3,4,5"]))
1803 gprs = [0] * 32
1804 fprs = [0] * 32
1805 fprs[4] = 0x3ff0000000000000 # 1.0
1806 fprs[5] = 0x3ff0000000000000 # 1.0
1807 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1808 e.fpregs[3] = 0x3ff0000000000000
1809 e.crregs[1] = 0x4
1810 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1811
1812 def case_fmincs(self):
1813 lst = list(SVP64Asm(["fmincs 3,4,5"]))
1814 gprs = [0] * 32
1815 fprs = [0] * 32
1816 fprs[4] = 0x3ff0000000000000 # 1.0
1817 fprs[5] = 0x3ff0000000000000 # 1.0
1818 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1819 e.fpregs[3] = 0x3ff0000000000000
1820 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1821
1822 def case_fmincs_(self):
1823 lst = list(SVP64Asm(["fmincs. 3,4,5"]))
1824 gprs = [0] * 32
1825 fprs = [0] * 32
1826 fprs[4] = 0x3ff0000000000000 # 1.0
1827 fprs[5] = 0x3ff0000000000000 # 1.0
1828 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1829 e.fpregs[3] = 0x3ff0000000000000
1830 e.crregs[1] = 0x4
1831 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1832
1833 def case_fminc(self):
1834 lst = list(SVP64Asm(["fminc 3,4,5"]))
1835 gprs = [0] * 32
1836 fprs = [0] * 32
1837 fprs[4] = 0x3ff0000000000000 # 1.0
1838 fprs[5] = 0x3ff0000000000000 # 1.0
1839 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1840 e.fpregs[3] = 0x3ff0000000000000
1841 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1842
1843 def case_fminc_(self):
1844 lst = list(SVP64Asm(["fminc. 3,4,5"]))
1845 gprs = [0] * 32
1846 fprs = [0] * 32
1847 fprs[4] = 0x3ff0000000000000 # 1.0
1848 fprs[5] = 0x3ff0000000000000 # 1.0
1849 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1850 e.fpregs[3] = 0x3ff0000000000000
1851 e.crregs[1] = 0x4
1852 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1853
1854 def case_fmaxcs(self):
1855 lst = list(SVP64Asm(["fmaxcs 3,4,5"]))
1856 gprs = [0] * 32
1857 fprs = [0] * 32
1858 fprs[4] = 0x3ff0000000000000 # 1.0
1859 fprs[5] = 0x3ff0000000000000 # 1.0
1860 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1861 e.fpregs[3] = 0x3ff0000000000000
1862 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1863
1864 def case_fmaxcs_(self):
1865 lst = list(SVP64Asm(["fmaxcs. 3,4,5"]))
1866 gprs = [0] * 32
1867 fprs = [0] * 32
1868 fprs[4] = 0x3ff0000000000000 # 1.0
1869 fprs[5] = 0x3ff0000000000000 # 1.0
1870 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1871 e.fpregs[3] = 0x3ff0000000000000
1872 e.crregs[1] = 0x4
1873 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1874
1875 def case_fmaxc(self):
1876 lst = list(SVP64Asm(["fmaxc 3,4,5"]))
1877 gprs = [0] * 32
1878 fprs = [0] * 32
1879 fprs[4] = 0x3ff0000000000000 # 1.0
1880 fprs[5] = 0x3ff0000000000000 # 1.0
1881 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1882 e.fpregs[3] = 0x3ff0000000000000
1883 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1884
1885 def case_fmaxc_(self):
1886 lst = list(SVP64Asm(["fmaxc. 3,4,5"]))
1887 gprs = [0] * 32
1888 fprs = [0] * 32
1889 fprs[4] = 0x3ff0000000000000 # 1.0
1890 fprs[5] = 0x3ff0000000000000 # 1.0
1891 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1892 e.fpregs[3] = 0x3ff0000000000000
1893 e.crregs[1] = 0x4
1894 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1895
1896 def case_fminmagnum08s(self):
1897 lst = list(SVP64Asm(["fminmagnum08s 3,4,5"]))
1898 gprs = [0] * 32
1899 fprs = [0] * 32
1900 fprs[4] = 0x3ff0000000000000 # 1.0
1901 fprs[5] = 0x3ff0000000000000 # 1.0
1902 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1903 e.fpregs[3] = 0x3ff0000000000000
1904 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1905
1906 def case_fminmagnum08s_(self):
1907 lst = list(SVP64Asm(["fminmagnum08s. 3,4,5"]))
1908 gprs = [0] * 32
1909 fprs = [0] * 32
1910 fprs[4] = 0x3ff0000000000000 # 1.0
1911 fprs[5] = 0x3ff0000000000000 # 1.0
1912 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1913 e.fpregs[3] = 0x3ff0000000000000
1914 e.crregs[1] = 0x4
1915 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1916
1917 def case_fminmagnum08(self):
1918 lst = list(SVP64Asm(["fminmagnum08 3,4,5"]))
1919 gprs = [0] * 32
1920 fprs = [0] * 32
1921 fprs[4] = 0x3ff0000000000000 # 1.0
1922 fprs[5] = 0x3ff0000000000000 # 1.0
1923 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1924 e.fpregs[3] = 0x3ff0000000000000
1925 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1926
1927 def case_fminmagnum08_(self):
1928 lst = list(SVP64Asm(["fminmagnum08. 3,4,5"]))
1929 gprs = [0] * 32
1930 fprs = [0] * 32
1931 fprs[4] = 0x3ff0000000000000 # 1.0
1932 fprs[5] = 0x3ff0000000000000 # 1.0
1933 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1934 e.fpregs[3] = 0x3ff0000000000000
1935 e.crregs[1] = 0x4
1936 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1937
1938 def case_fmaxmagnum08s(self):
1939 lst = list(SVP64Asm(["fmaxmagnum08s 3,4,5"]))
1940 gprs = [0] * 32
1941 fprs = [0] * 32
1942 fprs[4] = 0x3ff0000000000000 # 1.0
1943 fprs[5] = 0x3ff0000000000000 # 1.0
1944 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1945 e.fpregs[3] = 0x3ff0000000000000
1946 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1947
1948 def case_fmaxmagnum08s_(self):
1949 lst = list(SVP64Asm(["fmaxmagnum08s. 3,4,5"]))
1950 gprs = [0] * 32
1951 fprs = [0] * 32
1952 fprs[4] = 0x3ff0000000000000 # 1.0
1953 fprs[5] = 0x3ff0000000000000 # 1.0
1954 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1955 e.fpregs[3] = 0x3ff0000000000000
1956 e.crregs[1] = 0x4
1957 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1958
1959 def case_fmaxmagnum08(self):
1960 lst = list(SVP64Asm(["fmaxmagnum08 3,4,5"]))
1961 gprs = [0] * 32
1962 fprs = [0] * 32
1963 fprs[4] = 0x3ff0000000000000 # 1.0
1964 fprs[5] = 0x3ff0000000000000 # 1.0
1965 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1966 e.fpregs[3] = 0x3ff0000000000000
1967 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1968
1969 def case_fmaxmagnum08_(self):
1970 lst = list(SVP64Asm(["fmaxmagnum08. 3,4,5"]))
1971 gprs = [0] * 32
1972 fprs = [0] * 32
1973 fprs[4] = 0x3ff0000000000000 # 1.0
1974 fprs[5] = 0x3ff0000000000000 # 1.0
1975 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1976 e.fpregs[3] = 0x3ff0000000000000
1977 e.crregs[1] = 0x4
1978 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1979
1980 def case_fminmag19s(self):
1981 lst = list(SVP64Asm(["fminmag19s 3,4,5"]))
1982 gprs = [0] * 32
1983 fprs = [0] * 32
1984 fprs[4] = 0x3ff0000000000000 # 1.0
1985 fprs[5] = 0x3ff0000000000000 # 1.0
1986 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1987 e.fpregs[3] = 0x3ff0000000000000
1988 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
1989
1990 def case_fminmag19s_(self):
1991 lst = list(SVP64Asm(["fminmag19s. 3,4,5"]))
1992 gprs = [0] * 32
1993 fprs = [0] * 32
1994 fprs[4] = 0x3ff0000000000000 # 1.0
1995 fprs[5] = 0x3ff0000000000000 # 1.0
1996 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
1997 e.fpregs[3] = 0x3ff0000000000000
1998 e.crregs[1] = 0x4
1999 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
2000
2001 def case_fminmag19(self):
2002 lst = list(SVP64Asm(["fminmag19 3,4,5"]))
2003 gprs = [0] * 32
2004 fprs = [0] * 32
2005 fprs[4] = 0x3ff0000000000000 # 1.0
2006 fprs[5] = 0x3ff0000000000000 # 1.0
2007 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
2008 e.fpregs[3] = 0x3ff0000000000000
2009 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
2010
2011 def case_fminmag19_(self):
2012 lst = list(SVP64Asm(["fminmag19. 3,4,5"]))
2013 gprs = [0] * 32
2014 fprs = [0] * 32
2015 fprs[4] = 0x3ff0000000000000 # 1.0
2016 fprs[5] = 0x3ff0000000000000 # 1.0
2017 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
2018 e.fpregs[3] = 0x3ff0000000000000
2019 e.crregs[1] = 0x4
2020 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
2021
2022 def case_fmaxmag19s(self):
2023 lst = list(SVP64Asm(["fmaxmag19s 3,4,5"]))
2024 gprs = [0] * 32
2025 fprs = [0] * 32
2026 fprs[4] = 0x3ff0000000000000 # 1.0
2027 fprs[5] = 0x3ff0000000000000 # 1.0
2028 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
2029 e.fpregs[3] = 0x3ff0000000000000
2030 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
2031
2032 def case_fmaxmag19s_(self):
2033 lst = list(SVP64Asm(["fmaxmag19s. 3,4,5"]))
2034 gprs = [0] * 32
2035 fprs = [0] * 32
2036 fprs[4] = 0x3ff0000000000000 # 1.0
2037 fprs[5] = 0x3ff0000000000000 # 1.0
2038 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
2039 e.fpregs[3] = 0x3ff0000000000000
2040 e.crregs[1] = 0x4
2041 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
2042
2043 def case_fmaxmag19(self):
2044 lst = list(SVP64Asm(["fmaxmag19 3,4,5"]))
2045 gprs = [0] * 32
2046 fprs = [0] * 32
2047 fprs[4] = 0x3ff0000000000000 # 1.0
2048 fprs[5] = 0x3ff0000000000000 # 1.0
2049 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
2050 e.fpregs[3] = 0x3ff0000000000000
2051 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
2052
2053 def case_fmaxmag19_(self):
2054 lst = list(SVP64Asm(["fmaxmag19. 3,4,5"]))
2055 gprs = [0] * 32
2056 fprs = [0] * 32
2057 fprs[4] = 0x3ff0000000000000 # 1.0
2058 fprs[5] = 0x3ff0000000000000 # 1.0
2059 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
2060 e.fpregs[3] = 0x3ff0000000000000
2061 e.crregs[1] = 0x4
2062 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
2063
2064 def case_fminmagnum19s(self):
2065 lst = list(SVP64Asm(["fminmagnum19s 3,4,5"]))
2066 gprs = [0] * 32
2067 fprs = [0] * 32
2068 fprs[4] = 0x3ff0000000000000 # 1.0
2069 fprs[5] = 0x3ff0000000000000 # 1.0
2070 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
2071 e.fpregs[3] = 0x3ff0000000000000
2072 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
2073
2074 def case_fminmagnum19s_(self):
2075 lst = list(SVP64Asm(["fminmagnum19s. 3,4,5"]))
2076 gprs = [0] * 32
2077 fprs = [0] * 32
2078 fprs[4] = 0x3ff0000000000000 # 1.0
2079 fprs[5] = 0x3ff0000000000000 # 1.0
2080 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
2081 e.fpregs[3] = 0x3ff0000000000000
2082 e.crregs[1] = 0x4
2083 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
2084
2085 def case_fminmagnum19(self):
2086 lst = list(SVP64Asm(["fminmagnum19 3,4,5"]))
2087 gprs = [0] * 32
2088 fprs = [0] * 32
2089 fprs[4] = 0x3ff0000000000000 # 1.0
2090 fprs[5] = 0x3ff0000000000000 # 1.0
2091 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
2092 e.fpregs[3] = 0x3ff0000000000000
2093 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
2094
2095 def case_fminmagnum19_(self):
2096 lst = list(SVP64Asm(["fminmagnum19. 3,4,5"]))
2097 gprs = [0] * 32
2098 fprs = [0] * 32
2099 fprs[4] = 0x3ff0000000000000 # 1.0
2100 fprs[5] = 0x3ff0000000000000 # 1.0
2101 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
2102 e.fpregs[3] = 0x3ff0000000000000
2103 e.crregs[1] = 0x4
2104 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
2105
2106 def case_fmaxmagnum19s(self):
2107 lst = list(SVP64Asm(["fmaxmagnum19s 3,4,5"]))
2108 gprs = [0] * 32
2109 fprs = [0] * 32
2110 fprs[4] = 0x3ff0000000000000 # 1.0
2111 fprs[5] = 0x3ff0000000000000 # 1.0
2112 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
2113 e.fpregs[3] = 0x3ff0000000000000
2114 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
2115
2116 def case_fmaxmagnum19s_(self):
2117 lst = list(SVP64Asm(["fmaxmagnum19s. 3,4,5"]))
2118 gprs = [0] * 32
2119 fprs = [0] * 32
2120 fprs[4] = 0x3ff0000000000000 # 1.0
2121 fprs[5] = 0x3ff0000000000000 # 1.0
2122 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
2123 e.fpregs[3] = 0x3ff0000000000000
2124 e.crregs[1] = 0x4
2125 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
2126
2127 def case_fmaxmagnum19(self):
2128 lst = list(SVP64Asm(["fmaxmagnum19 3,4,5"]))
2129 gprs = [0] * 32
2130 fprs = [0] * 32
2131 fprs[4] = 0x3ff0000000000000 # 1.0
2132 fprs[5] = 0x3ff0000000000000 # 1.0
2133 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
2134 e.fpregs[3] = 0x3ff0000000000000
2135 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
2136
2137 def case_fmaxmagnum19_(self):
2138 lst = list(SVP64Asm(["fmaxmagnum19. 3,4,5"]))
2139 gprs = [0] * 32
2140 fprs = [0] * 32
2141 fprs[4] = 0x3ff0000000000000 # 1.0
2142 fprs[5] = 0x3ff0000000000000 # 1.0
2143 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
2144 e.fpregs[3] = 0x3ff0000000000000
2145 e.crregs[1] = 0x4
2146 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
2147
2148 def case_fminmagcs(self):
2149 lst = list(SVP64Asm(["fminmagcs 3,4,5"]))
2150 gprs = [0] * 32
2151 fprs = [0] * 32
2152 fprs[4] = 0x3ff0000000000000 # 1.0
2153 fprs[5] = 0x3ff0000000000000 # 1.0
2154 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
2155 e.fpregs[3] = 0x3ff0000000000000
2156 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
2157
2158 def case_fminmagcs_(self):
2159 lst = list(SVP64Asm(["fminmagcs. 3,4,5"]))
2160 gprs = [0] * 32
2161 fprs = [0] * 32
2162 fprs[4] = 0x3ff0000000000000 # 1.0
2163 fprs[5] = 0x3ff0000000000000 # 1.0
2164 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
2165 e.fpregs[3] = 0x3ff0000000000000
2166 e.crregs[1] = 0x4
2167 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
2168
2169 def case_fminmagc(self):
2170 lst = list(SVP64Asm(["fminmagc 3,4,5"]))
2171 gprs = [0] * 32
2172 fprs = [0] * 32
2173 fprs[4] = 0x3ff0000000000000 # 1.0
2174 fprs[5] = 0x3ff0000000000000 # 1.0
2175 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
2176 e.fpregs[3] = 0x3ff0000000000000
2177 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
2178
2179 def case_fminmagc_(self):
2180 lst = list(SVP64Asm(["fminmagc. 3,4,5"]))
2181 gprs = [0] * 32
2182 fprs = [0] * 32
2183 fprs[4] = 0x3ff0000000000000 # 1.0
2184 fprs[5] = 0x3ff0000000000000 # 1.0
2185 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
2186 e.fpregs[3] = 0x3ff0000000000000
2187 e.crregs[1] = 0x4
2188 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
2189
2190 def case_fmaxmagcs(self):
2191 lst = list(SVP64Asm(["fmaxmagcs 3,4,5"]))
2192 gprs = [0] * 32
2193 fprs = [0] * 32
2194 fprs[4] = 0x3ff0000000000000 # 1.0
2195 fprs[5] = 0x3ff0000000000000 # 1.0
2196 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
2197 e.fpregs[3] = 0x3ff0000000000000
2198 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
2199
2200 def case_fmaxmagcs_(self):
2201 lst = list(SVP64Asm(["fmaxmagcs. 3,4,5"]))
2202 gprs = [0] * 32
2203 fprs = [0] * 32
2204 fprs[4] = 0x3ff0000000000000 # 1.0
2205 fprs[5] = 0x3ff0000000000000 # 1.0
2206 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
2207 e.fpregs[3] = 0x3ff0000000000000
2208 e.crregs[1] = 0x4
2209 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
2210
2211 def case_fmaxmagc(self):
2212 lst = list(SVP64Asm(["fmaxmagc 3,4,5"]))
2213 gprs = [0] * 32
2214 fprs = [0] * 32
2215 fprs[4] = 0x3ff0000000000000 # 1.0
2216 fprs[5] = 0x3ff0000000000000 # 1.0
2217 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
2218 e.fpregs[3] = 0x3ff0000000000000
2219 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
2220
2221 def case_fmaxmagc_(self):
2222 lst = list(SVP64Asm(["fmaxmagc. 3,4,5"]))
2223 gprs = [0] * 32
2224 fprs = [0] * 32
2225 fprs[4] = 0x3ff0000000000000 # 1.0
2226 fprs[5] = 0x3ff0000000000000 # 1.0
2227 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
2228 e.fpregs[3] = 0x3ff0000000000000
2229 e.crregs[1] = 0x4
2230 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
2231
2232 def case_fmods(self):
2233 lst = list(SVP64Asm(["fmods 3,4,5"]))
2234 gprs = [0] * 32
2235 fprs = [0] * 32
2236 fprs[4] = 0x3ff0000000000000 # 1.0
2237 fprs[5] = 0x3ff0000000000000 # 1.0
2238 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
2239 e.fpregs[3] = 0x0
2240 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
2241
2242 def case_fmods_(self):
2243 lst = list(SVP64Asm(["fmods. 3,4,5"]))
2244 gprs = [0] * 32
2245 fprs = [0] * 32
2246 fprs[4] = 0x3ff0000000000000 # 1.0
2247 fprs[5] = 0x3ff0000000000000 # 1.0
2248 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
2249 e.fpregs[3] = 0x0
2250 e.crregs[1] = 0x2
2251 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
2252
2253 def case_fmod(self):
2254 lst = list(SVP64Asm(["fmod 3,4,5"]))
2255 gprs = [0] * 32
2256 fprs = [0] * 32
2257 fprs[4] = 0x3ff0000000000000 # 1.0
2258 fprs[5] = 0x3ff0000000000000 # 1.0
2259 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
2260 e.fpregs[3] = 0x0
2261 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
2262
2263 def case_fmod_(self):
2264 lst = list(SVP64Asm(["fmod. 3,4,5"]))
2265 gprs = [0] * 32
2266 fprs = [0] * 32
2267 fprs[4] = 0x3ff0000000000000 # 1.0
2268 fprs[5] = 0x3ff0000000000000 # 1.0
2269 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
2270 e.fpregs[3] = 0x0
2271 e.crregs[1] = 0x2
2272 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
2273
2274 def case_fremainders(self):
2275 lst = list(SVP64Asm(["fremainders 3,4,5"]))
2276 gprs = [0] * 32
2277 fprs = [0] * 32
2278 fprs[4] = 0x3ff0000000000000 # 1.0
2279 fprs[5] = 0x3ff0000000000000 # 1.0
2280 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
2281 e.fpregs[3] = 0x0
2282 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
2283
2284 def case_fremainders_(self):
2285 lst = list(SVP64Asm(["fremainders. 3,4,5"]))
2286 gprs = [0] * 32
2287 fprs = [0] * 32
2288 fprs[4] = 0x3ff0000000000000 # 1.0
2289 fprs[5] = 0x3ff0000000000000 # 1.0
2290 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
2291 e.fpregs[3] = 0x0
2292 e.crregs[1] = 0x2
2293 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
2294
2295 def case_fremainder(self):
2296 lst = list(SVP64Asm(["fremainder 3,4,5"]))
2297 gprs = [0] * 32
2298 fprs = [0] * 32
2299 fprs[4] = 0x3ff0000000000000 # 1.0
2300 fprs[5] = 0x3ff0000000000000 # 1.0
2301 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
2302 e.fpregs[3] = 0x0
2303 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)
2304
2305 def case_fremainder_(self):
2306 lst = list(SVP64Asm(["fremainder. 3,4,5"]))
2307 gprs = [0] * 32
2308 fprs = [0] * 32
2309 fprs[4] = 0x3ff0000000000000 # 1.0
2310 fprs[5] = 0x3ff0000000000000 # 1.0
2311 e = ExpectedState(pc=4, int_regs=gprs, fp_regs=fprs)
2312 e.fpregs[3] = 0x0
2313 e.crregs[1] = 0x2
2314 self.add_case(Program(lst, False), gprs, fpregs=fprs, expected=e)