xref: /openbmc/qemu/target/tricore/op_helper.c (revision b69c95e7)
1 /*
2  *  Copyright (c) 2012-2014 Bastian Koppelmann C-Lab/University Paderborn
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
16  */
17 #include "qemu/osdep.h"
18 #include "cpu.h"
19 #include "qemu/host-utils.h"
20 #include "exec/helper-proto.h"
21 #include "exec/exec-all.h"
22 #include "exec/cpu_ldst.h"
23 #include <zlib.h> /* for crc32 */
24 
25 
26 /* Exception helpers */
27 
28 static G_NORETURN
raise_exception_sync_internal(CPUTriCoreState * env,uint32_t class,int tin,uintptr_t pc,uint32_t fcd_pc)29 void raise_exception_sync_internal(CPUTriCoreState *env, uint32_t class, int tin,
30                                    uintptr_t pc, uint32_t fcd_pc)
31 {
32     CPUState *cs = env_cpu(env);
33     /* in case we come from a helper-call we need to restore the PC */
34     cpu_restore_state(cs, pc);
35 
36     /* Tin is loaded into d[15] */
37     env->gpr_d[15] = tin;
38 
39     if (class == TRAPC_CTX_MNG && tin == TIN3_FCU) {
40         /* upper context cannot be saved, if the context list is empty */
41     } else {
42         helper_svucx(env);
43     }
44 
45     /* The return address in a[11] is updated */
46     if (class == TRAPC_CTX_MNG && tin == TIN3_FCD) {
47         env->SYSCON |= MASK_SYSCON_FCD_SF;
48         /* when we run out of CSAs after saving a context a FCD trap is taken
49            and the return address is the start of the trap handler which used
50            the last CSA */
51         env->gpr_a[11] = fcd_pc;
52     } else if (class == TRAPC_SYSCALL) {
53         env->gpr_a[11] = env->PC + 4;
54     } else {
55         env->gpr_a[11] = env->PC;
56     }
57     /* The stack pointer in A[10] is set to the Interrupt Stack Pointer (ISP)
58        when the processor was not previously using the interrupt stack
59        (in case of PSW.IS = 0). The stack pointer bit is set for using the
60        interrupt stack: PSW.IS = 1. */
61     if ((env->PSW & MASK_PSW_IS) == 0) {
62         env->gpr_a[10] = env->ISP;
63     }
64     env->PSW |= MASK_PSW_IS;
65     /* The I/O mode is set to Supervisor mode, which means all permissions
66        are enabled: PSW.IO = 10 B .*/
67     env->PSW |= (2 << 10);
68 
69     /*The current Protection Register Set is set to 0: PSW.PRS = 00 B .*/
70     env->PSW &= ~MASK_PSW_PRS;
71 
72     /* The Call Depth Counter (CDC) is cleared, and the call depth limit is
73        set for 64: PSW.CDC = 0000000 B .*/
74     env->PSW &= ~MASK_PSW_CDC;
75 
76     /* Call Depth Counter is enabled, PSW.CDE = 1. */
77     env->PSW |= MASK_PSW_CDE;
78 
79     /* Write permission to global registers A[0], A[1], A[8], A[9] is
80        disabled: PSW.GW = 0. */
81     env->PSW &= ~MASK_PSW_GW;
82 
83     /*The interrupt system is globally disabled: ICR.IE = 0. The ‘old’
84       ICR.IE and ICR.CCPN are saved */
85 
86     /* PCXI.PIE = ICR.IE */
87     pcxi_set_pie(env, icr_get_ie(env));
88 
89     /* PCXI.PCPN = ICR.CCPN */
90     pcxi_set_pcpn(env, icr_get_ccpn(env));
91     /* Update PC using the trap vector table */
92     env->PC = env->BTV | (class << 5);
93 
94     cpu_loop_exit(cs);
95 }
96 
helper_raise_exception_sync(CPUTriCoreState * env,uint32_t class,uint32_t tin)97 void helper_raise_exception_sync(CPUTriCoreState *env, uint32_t class,
98                                  uint32_t tin)
99 {
100     raise_exception_sync_internal(env, class, tin, 0, 0);
101 }
102 
raise_exception_sync_helper(CPUTriCoreState * env,uint32_t class,uint32_t tin,uintptr_t pc)103 static void raise_exception_sync_helper(CPUTriCoreState *env, uint32_t class,
104                                         uint32_t tin, uintptr_t pc)
105 {
106     raise_exception_sync_internal(env, class, tin, pc, 0);
107 }
108 
109 /* Addressing mode helper */
110 
reverse16(uint16_t val)111 static uint16_t reverse16(uint16_t val)
112 {
113     uint8_t high = (uint8_t)(val >> 8);
114     uint8_t low  = (uint8_t)(val & 0xff);
115 
116     uint16_t rh, rl;
117 
118     rl = (uint16_t)((high * 0x0202020202ULL & 0x010884422010ULL) % 1023);
119     rh = (uint16_t)((low * 0x0202020202ULL & 0x010884422010ULL) % 1023);
120 
121     return (rh << 8) | rl;
122 }
123 
helper_br_update(uint32_t reg)124 uint32_t helper_br_update(uint32_t reg)
125 {
126     uint32_t index = reg & 0xffff;
127     uint32_t incr  = reg >> 16;
128     uint32_t new_index = reverse16(reverse16(index) + reverse16(incr));
129     return reg - index + new_index;
130 }
131 
helper_circ_update(uint32_t reg,uint32_t off)132 uint32_t helper_circ_update(uint32_t reg, uint32_t off)
133 {
134     uint32_t index = reg & 0xffff;
135     uint32_t length = reg >> 16;
136     int32_t new_index = index + off;
137     if (new_index < 0) {
138         new_index += length;
139     } else {
140         new_index %= length;
141     }
142     return reg - index + new_index;
143 }
144 
ssov32(CPUTriCoreState * env,int64_t arg)145 static uint32_t ssov32(CPUTriCoreState *env, int64_t arg)
146 {
147     uint32_t ret;
148     int64_t max_pos = INT32_MAX;
149     int64_t max_neg = INT32_MIN;
150     if (arg > max_pos) {
151         env->PSW_USB_V = (1 << 31);
152         env->PSW_USB_SV = (1 << 31);
153         ret = (target_ulong)max_pos;
154     } else {
155         if (arg < max_neg) {
156             env->PSW_USB_V = (1 << 31);
157             env->PSW_USB_SV = (1 << 31);
158             ret = (target_ulong)max_neg;
159         } else {
160             env->PSW_USB_V = 0;
161             ret = (target_ulong)arg;
162         }
163     }
164     env->PSW_USB_AV = arg ^ arg * 2u;
165     env->PSW_USB_SAV |= env->PSW_USB_AV;
166     return ret;
167 }
168 
suov32_pos(CPUTriCoreState * env,uint64_t arg)169 static uint32_t suov32_pos(CPUTriCoreState *env, uint64_t arg)
170 {
171     uint32_t ret;
172     uint64_t max_pos = UINT32_MAX;
173     if (arg > max_pos) {
174         env->PSW_USB_V = (1 << 31);
175         env->PSW_USB_SV = (1 << 31);
176         ret = (target_ulong)max_pos;
177     } else {
178         env->PSW_USB_V = 0;
179         ret = (target_ulong)arg;
180      }
181     env->PSW_USB_AV = arg ^ arg * 2u;
182     env->PSW_USB_SAV |= env->PSW_USB_AV;
183     return ret;
184 }
185 
suov32_neg(CPUTriCoreState * env,int64_t arg)186 static uint32_t suov32_neg(CPUTriCoreState *env, int64_t arg)
187 {
188     uint32_t ret;
189 
190     if (arg < 0) {
191         env->PSW_USB_V = (1 << 31);
192         env->PSW_USB_SV = (1 << 31);
193         ret = 0;
194     } else {
195         env->PSW_USB_V = 0;
196         ret = (target_ulong)arg;
197     }
198     env->PSW_USB_AV = arg ^ arg * 2u;
199     env->PSW_USB_SAV |= env->PSW_USB_AV;
200     return ret;
201 }
202 
ssov16(CPUTriCoreState * env,int32_t hw0,int32_t hw1)203 static uint32_t ssov16(CPUTriCoreState *env, int32_t hw0, int32_t hw1)
204 {
205     int32_t max_pos = INT16_MAX;
206     int32_t max_neg = INT16_MIN;
207     int32_t av0, av1;
208 
209     env->PSW_USB_V = 0;
210     av0 = hw0 ^ hw0 * 2u;
211     if (hw0 > max_pos) {
212         env->PSW_USB_V = (1 << 31);
213         hw0 = max_pos;
214     } else if (hw0 < max_neg) {
215         env->PSW_USB_V = (1 << 31);
216         hw0 = max_neg;
217     }
218 
219     av1 = hw1 ^ hw1 * 2u;
220     if (hw1 > max_pos) {
221         env->PSW_USB_V = (1 << 31);
222         hw1 = max_pos;
223     } else if (hw1 < max_neg) {
224         env->PSW_USB_V = (1 << 31);
225         hw1 = max_neg;
226     }
227 
228     env->PSW_USB_SV |= env->PSW_USB_V;
229     env->PSW_USB_AV = (av0 | av1) << 16;
230     env->PSW_USB_SAV |= env->PSW_USB_AV;
231     return (hw0 & 0xffff) | (hw1 << 16);
232 }
233 
suov16(CPUTriCoreState * env,int32_t hw0,int32_t hw1)234 static uint32_t suov16(CPUTriCoreState *env, int32_t hw0, int32_t hw1)
235 {
236     int32_t max_pos = UINT16_MAX;
237     int32_t av0, av1;
238 
239     env->PSW_USB_V = 0;
240     av0 = hw0 ^ hw0 * 2u;
241     if (hw0 > max_pos) {
242         env->PSW_USB_V = (1 << 31);
243         hw0 = max_pos;
244     } else if (hw0 < 0) {
245         env->PSW_USB_V = (1 << 31);
246         hw0 = 0;
247     }
248 
249     av1 = hw1 ^ hw1 * 2u;
250     if (hw1 > max_pos) {
251         env->PSW_USB_V = (1 << 31);
252         hw1 = max_pos;
253     } else if (hw1 < 0) {
254         env->PSW_USB_V = (1 << 31);
255         hw1 = 0;
256     }
257 
258     env->PSW_USB_SV |= env->PSW_USB_V;
259     env->PSW_USB_AV = (av0 | av1) << 16;
260     env->PSW_USB_SAV |= env->PSW_USB_AV;
261     return (hw0 & 0xffff) | (hw1 << 16);
262 }
263 
helper_add_ssov(CPUTriCoreState * env,target_ulong r1,target_ulong r2)264 target_ulong helper_add_ssov(CPUTriCoreState *env, target_ulong r1,
265                              target_ulong r2)
266 {
267     int64_t t1 = sextract64(r1, 0, 32);
268     int64_t t2 = sextract64(r2, 0, 32);
269     int64_t result = t1 + t2;
270     return ssov32(env, result);
271 }
272 
helper_add64_ssov(CPUTriCoreState * env,uint64_t r1,uint64_t r2)273 uint64_t helper_add64_ssov(CPUTriCoreState *env, uint64_t r1, uint64_t r2)
274 {
275     uint64_t result;
276     int64_t ovf;
277 
278     result = r1 + r2;
279     ovf = (result ^ r1) & ~(r1 ^ r2);
280     env->PSW_USB_AV = (result ^ result * 2u) >> 32;
281     env->PSW_USB_SAV |= env->PSW_USB_AV;
282     if (ovf < 0) {
283         env->PSW_USB_V = (1 << 31);
284         env->PSW_USB_SV = (1 << 31);
285         /* ext_ret > MAX_INT */
286         if ((int64_t)r1 >= 0) {
287             result = INT64_MAX;
288         /* ext_ret < MIN_INT */
289         } else {
290             result = INT64_MIN;
291         }
292     } else {
293         env->PSW_USB_V = 0;
294     }
295     return result;
296 }
297 
helper_add_h_ssov(CPUTriCoreState * env,target_ulong r1,target_ulong r2)298 target_ulong helper_add_h_ssov(CPUTriCoreState *env, target_ulong r1,
299                                target_ulong r2)
300 {
301     int32_t ret_hw0, ret_hw1;
302 
303     ret_hw0 = sextract32(r1, 0, 16) + sextract32(r2, 0, 16);
304     ret_hw1 = sextract32(r1, 16, 16) + sextract32(r2, 16, 16);
305     return ssov16(env, ret_hw0, ret_hw1);
306 }
307 
helper_addr_h_ssov(CPUTriCoreState * env,uint64_t r1,uint32_t r2_l,uint32_t r2_h)308 uint32_t helper_addr_h_ssov(CPUTriCoreState *env, uint64_t r1, uint32_t r2_l,
309                             uint32_t r2_h)
310 {
311     int64_t mul_res0 = sextract64(r1, 0, 32);
312     int64_t mul_res1 = sextract64(r1, 32, 32);
313     int64_t r2_low = sextract64(r2_l, 0, 32);
314     int64_t r2_high = sextract64(r2_h, 0, 32);
315     int64_t result0, result1;
316     uint32_t ovf0, ovf1;
317     uint32_t avf0, avf1;
318 
319     ovf0 = ovf1 = 0;
320 
321     result0 = r2_low + mul_res0 + 0x8000;
322     result1 = r2_high + mul_res1 + 0x8000;
323 
324     avf0 = result0 * 2u;
325     avf0 = result0 ^ avf0;
326     avf1 = result1 * 2u;
327     avf1 = result1 ^ avf1;
328 
329     if (result0 > INT32_MAX) {
330         ovf0 = (1 << 31);
331         result0 = INT32_MAX;
332     } else if (result0 < INT32_MIN) {
333         ovf0 = (1 << 31);
334         result0 = INT32_MIN;
335     }
336 
337     if (result1 > INT32_MAX) {
338         ovf1 = (1 << 31);
339         result1 = INT32_MAX;
340     } else if (result1 < INT32_MIN) {
341         ovf1 = (1 << 31);
342         result1 = INT32_MIN;
343     }
344 
345     env->PSW_USB_V = ovf0 | ovf1;
346     env->PSW_USB_SV |= env->PSW_USB_V;
347 
348     env->PSW_USB_AV = avf0 | avf1;
349     env->PSW_USB_SAV |= env->PSW_USB_AV;
350 
351     return (result1 & 0xffff0000ULL) | ((result0 >> 16) & 0xffffULL);
352 }
353 
helper_addsur_h_ssov(CPUTriCoreState * env,uint64_t r1,uint32_t r2_l,uint32_t r2_h)354 uint32_t helper_addsur_h_ssov(CPUTriCoreState *env, uint64_t r1, uint32_t r2_l,
355                               uint32_t r2_h)
356 {
357     int64_t mul_res0 = sextract64(r1, 0, 32);
358     int64_t mul_res1 = sextract64(r1, 32, 32);
359     int64_t r2_low = sextract64(r2_l, 0, 32);
360     int64_t r2_high = sextract64(r2_h, 0, 32);
361     int64_t result0, result1;
362     uint32_t ovf0, ovf1;
363     uint32_t avf0, avf1;
364 
365     ovf0 = ovf1 = 0;
366 
367     result0 = r2_low - mul_res0 + 0x8000;
368     result1 = r2_high + mul_res1 + 0x8000;
369 
370     avf0 = result0 * 2u;
371     avf0 = result0 ^ avf0;
372     avf1 = result1 * 2u;
373     avf1 = result1 ^ avf1;
374 
375     if (result0 > INT32_MAX) {
376         ovf0 = (1 << 31);
377         result0 = INT32_MAX;
378     } else if (result0 < INT32_MIN) {
379         ovf0 = (1 << 31);
380         result0 = INT32_MIN;
381     }
382 
383     if (result1 > INT32_MAX) {
384         ovf1 = (1 << 31);
385         result1 = INT32_MAX;
386     } else if (result1 < INT32_MIN) {
387         ovf1 = (1 << 31);
388         result1 = INT32_MIN;
389     }
390 
391     env->PSW_USB_V = ovf0 | ovf1;
392     env->PSW_USB_SV |= env->PSW_USB_V;
393 
394     env->PSW_USB_AV = avf0 | avf1;
395     env->PSW_USB_SAV |= env->PSW_USB_AV;
396 
397     return (result1 & 0xffff0000ULL) | ((result0 >> 16) & 0xffffULL);
398 }
399 
400 
helper_add_suov(CPUTriCoreState * env,target_ulong r1,target_ulong r2)401 target_ulong helper_add_suov(CPUTriCoreState *env, target_ulong r1,
402                              target_ulong r2)
403 {
404     int64_t t1 = extract64(r1, 0, 32);
405     int64_t t2 = extract64(r2, 0, 32);
406     int64_t result = t1 + t2;
407     return suov32_pos(env, result);
408 }
409 
helper_add_h_suov(CPUTriCoreState * env,target_ulong r1,target_ulong r2)410 target_ulong helper_add_h_suov(CPUTriCoreState *env, target_ulong r1,
411                                target_ulong r2)
412 {
413     int32_t ret_hw0, ret_hw1;
414 
415     ret_hw0 = extract32(r1, 0, 16) + extract32(r2, 0, 16);
416     ret_hw1 = extract32(r1, 16, 16) + extract32(r2, 16, 16);
417     return suov16(env, ret_hw0, ret_hw1);
418 }
419 
helper_sub_ssov(CPUTriCoreState * env,target_ulong r1,target_ulong r2)420 target_ulong helper_sub_ssov(CPUTriCoreState *env, target_ulong r1,
421                              target_ulong r2)
422 {
423     int64_t t1 = sextract64(r1, 0, 32);
424     int64_t t2 = sextract64(r2, 0, 32);
425     int64_t result = t1 - t2;
426     return ssov32(env, result);
427 }
428 
helper_sub64_ssov(CPUTriCoreState * env,uint64_t r1,uint64_t r2)429 uint64_t helper_sub64_ssov(CPUTriCoreState *env, uint64_t r1, uint64_t r2)
430 {
431     uint64_t result;
432     int64_t ovf;
433 
434     result = r1 - r2;
435     ovf = (result ^ r1) & (r1 ^ r2);
436     env->PSW_USB_AV = (result ^ result * 2u) >> 32;
437     env->PSW_USB_SAV |= env->PSW_USB_AV;
438     if (ovf < 0) {
439         env->PSW_USB_V = (1 << 31);
440         env->PSW_USB_SV = (1 << 31);
441         /* ext_ret > MAX_INT */
442         if ((int64_t)r1 >= 0) {
443             result = INT64_MAX;
444         /* ext_ret < MIN_INT */
445         } else {
446             result = INT64_MIN;
447         }
448     } else {
449         env->PSW_USB_V = 0;
450     }
451     return result;
452 }
453 
helper_sub_h_ssov(CPUTriCoreState * env,target_ulong r1,target_ulong r2)454 target_ulong helper_sub_h_ssov(CPUTriCoreState *env, target_ulong r1,
455                              target_ulong r2)
456 {
457     int32_t ret_hw0, ret_hw1;
458 
459     ret_hw0 = sextract32(r1, 0, 16) - sextract32(r2, 0, 16);
460     ret_hw1 = sextract32(r1, 16, 16) - sextract32(r2, 16, 16);
461     return ssov16(env, ret_hw0, ret_hw1);
462 }
463 
helper_subr_h_ssov(CPUTriCoreState * env,uint64_t r1,uint32_t r2_l,uint32_t r2_h)464 uint32_t helper_subr_h_ssov(CPUTriCoreState *env, uint64_t r1, uint32_t r2_l,
465                             uint32_t r2_h)
466 {
467     int64_t mul_res0 = sextract64(r1, 0, 32);
468     int64_t mul_res1 = sextract64(r1, 32, 32);
469     int64_t r2_low = sextract64(r2_l, 0, 32);
470     int64_t r2_high = sextract64(r2_h, 0, 32);
471     int64_t result0, result1;
472     uint32_t ovf0, ovf1;
473     uint32_t avf0, avf1;
474 
475     ovf0 = ovf1 = 0;
476 
477     result0 = r2_low - mul_res0 + 0x8000;
478     result1 = r2_high - mul_res1 + 0x8000;
479 
480     avf0 = result0 * 2u;
481     avf0 = result0 ^ avf0;
482     avf1 = result1 * 2u;
483     avf1 = result1 ^ avf1;
484 
485     if (result0 > INT32_MAX) {
486         ovf0 = (1 << 31);
487         result0 = INT32_MAX;
488     } else if (result0 < INT32_MIN) {
489         ovf0 = (1 << 31);
490         result0 = INT32_MIN;
491     }
492 
493     if (result1 > INT32_MAX) {
494         ovf1 = (1 << 31);
495         result1 = INT32_MAX;
496     } else if (result1 < INT32_MIN) {
497         ovf1 = (1 << 31);
498         result1 = INT32_MIN;
499     }
500 
501     env->PSW_USB_V = ovf0 | ovf1;
502     env->PSW_USB_SV |= env->PSW_USB_V;
503 
504     env->PSW_USB_AV = avf0 | avf1;
505     env->PSW_USB_SAV |= env->PSW_USB_AV;
506 
507     return (result1 & 0xffff0000ULL) | ((result0 >> 16) & 0xffffULL);
508 }
509 
helper_subadr_h_ssov(CPUTriCoreState * env,uint64_t r1,uint32_t r2_l,uint32_t r2_h)510 uint32_t helper_subadr_h_ssov(CPUTriCoreState *env, uint64_t r1, uint32_t r2_l,
511                               uint32_t r2_h)
512 {
513     int64_t mul_res0 = sextract64(r1, 0, 32);
514     int64_t mul_res1 = sextract64(r1, 32, 32);
515     int64_t r2_low = sextract64(r2_l, 0, 32);
516     int64_t r2_high = sextract64(r2_h, 0, 32);
517     int64_t result0, result1;
518     uint32_t ovf0, ovf1;
519     uint32_t avf0, avf1;
520 
521     ovf0 = ovf1 = 0;
522 
523     result0 = r2_low + mul_res0 + 0x8000;
524     result1 = r2_high - mul_res1 + 0x8000;
525 
526     avf0 = result0 * 2u;
527     avf0 = result0 ^ avf0;
528     avf1 = result1 * 2u;
529     avf1 = result1 ^ avf1;
530 
531     if (result0 > INT32_MAX) {
532         ovf0 = (1 << 31);
533         result0 = INT32_MAX;
534     } else if (result0 < INT32_MIN) {
535         ovf0 = (1 << 31);
536         result0 = INT32_MIN;
537     }
538 
539     if (result1 > INT32_MAX) {
540         ovf1 = (1 << 31);
541         result1 = INT32_MAX;
542     } else if (result1 < INT32_MIN) {
543         ovf1 = (1 << 31);
544         result1 = INT32_MIN;
545     }
546 
547     env->PSW_USB_V = ovf0 | ovf1;
548     env->PSW_USB_SV |= env->PSW_USB_V;
549 
550     env->PSW_USB_AV = avf0 | avf1;
551     env->PSW_USB_SAV |= env->PSW_USB_AV;
552 
553     return (result1 & 0xffff0000ULL) | ((result0 >> 16) & 0xffffULL);
554 }
555 
helper_sub_suov(CPUTriCoreState * env,target_ulong r1,target_ulong r2)556 target_ulong helper_sub_suov(CPUTriCoreState *env, target_ulong r1,
557                              target_ulong r2)
558 {
559     int64_t t1 = extract64(r1, 0, 32);
560     int64_t t2 = extract64(r2, 0, 32);
561     int64_t result = t1 - t2;
562     return suov32_neg(env, result);
563 }
564 
helper_sub_h_suov(CPUTriCoreState * env,target_ulong r1,target_ulong r2)565 target_ulong helper_sub_h_suov(CPUTriCoreState *env, target_ulong r1,
566                                target_ulong r2)
567 {
568     int32_t ret_hw0, ret_hw1;
569 
570     ret_hw0 = extract32(r1, 0, 16) - extract32(r2, 0, 16);
571     ret_hw1 = extract32(r1, 16, 16) - extract32(r2, 16, 16);
572     return suov16(env, ret_hw0, ret_hw1);
573 }
574 
helper_mul_ssov(CPUTriCoreState * env,target_ulong r1,target_ulong r2)575 target_ulong helper_mul_ssov(CPUTriCoreState *env, target_ulong r1,
576                              target_ulong r2)
577 {
578     int64_t t1 = sextract64(r1, 0, 32);
579     int64_t t2 = sextract64(r2, 0, 32);
580     int64_t result = t1 * t2;
581     return ssov32(env, result);
582 }
583 
helper_mul_suov(CPUTriCoreState * env,target_ulong r1,target_ulong r2)584 target_ulong helper_mul_suov(CPUTriCoreState *env, target_ulong r1,
585                              target_ulong r2)
586 {
587     int64_t t1 = extract64(r1, 0, 32);
588     int64_t t2 = extract64(r2, 0, 32);
589     int64_t result = t1 * t2;
590 
591     return suov32_pos(env, result);
592 }
593 
helper_sha_ssov(CPUTriCoreState * env,target_ulong r1,target_ulong r2)594 target_ulong helper_sha_ssov(CPUTriCoreState *env, target_ulong r1,
595                              target_ulong r2)
596 {
597     int64_t t1 = sextract64(r1, 0, 32);
598     int32_t t2 = sextract64(r2, 0, 6);
599     int64_t result;
600     if (t2 == 0) {
601         result = t1;
602     } else if (t2 > 0) {
603         result = t1 << t2;
604     } else {
605         result = t1 >> -t2;
606     }
607     return ssov32(env, result);
608 }
609 
helper_abs_ssov(CPUTriCoreState * env,target_ulong r1)610 uint32_t helper_abs_ssov(CPUTriCoreState *env, target_ulong r1)
611 {
612     target_ulong result;
613     result = ((int32_t)r1 >= 0) ? r1 : (0 - r1);
614     return ssov32(env, result);
615 }
616 
helper_abs_h_ssov(CPUTriCoreState * env,target_ulong r1)617 uint32_t helper_abs_h_ssov(CPUTriCoreState *env, target_ulong r1)
618 {
619     int32_t ret_h0, ret_h1;
620 
621     ret_h0 = sextract32(r1, 0, 16);
622     ret_h0 = (ret_h0 >= 0) ? ret_h0 : (0 - ret_h0);
623 
624     ret_h1 = sextract32(r1, 16, 16);
625     ret_h1 = (ret_h1 >= 0) ? ret_h1 : (0 - ret_h1);
626 
627     return ssov16(env, ret_h0, ret_h1);
628 }
629 
helper_absdif_ssov(CPUTriCoreState * env,target_ulong r1,target_ulong r2)630 target_ulong helper_absdif_ssov(CPUTriCoreState *env, target_ulong r1,
631                                 target_ulong r2)
632 {
633     int64_t t1 = sextract64(r1, 0, 32);
634     int64_t t2 = sextract64(r2, 0, 32);
635     int64_t result;
636 
637     if (t1 > t2) {
638         result = t1 - t2;
639     } else {
640         result = t2 - t1;
641     }
642     return ssov32(env, result);
643 }
644 
helper_absdif_h_ssov(CPUTriCoreState * env,target_ulong r1,target_ulong r2)645 uint32_t helper_absdif_h_ssov(CPUTriCoreState *env, target_ulong r1,
646                               target_ulong r2)
647 {
648     int32_t t1, t2;
649     int32_t ret_h0, ret_h1;
650 
651     t1 = sextract32(r1, 0, 16);
652     t2 = sextract32(r2, 0, 16);
653     if (t1 > t2) {
654         ret_h0 = t1 - t2;
655     } else {
656         ret_h0 = t2 - t1;
657     }
658 
659     t1 = sextract32(r1, 16, 16);
660     t2 = sextract32(r2, 16, 16);
661     if (t1 > t2) {
662         ret_h1 = t1 - t2;
663     } else {
664         ret_h1 = t2 - t1;
665     }
666 
667     return ssov16(env, ret_h0, ret_h1);
668 }
669 
helper_madd32_ssov(CPUTriCoreState * env,target_ulong r1,target_ulong r2,target_ulong r3)670 target_ulong helper_madd32_ssov(CPUTriCoreState *env, target_ulong r1,
671                                 target_ulong r2, target_ulong r3)
672 {
673     int64_t t1 = sextract64(r1, 0, 32);
674     int64_t t2 = sextract64(r2, 0, 32);
675     int64_t t3 = sextract64(r3, 0, 32);
676     int64_t result;
677 
678     result = t2 + (t1 * t3);
679     return ssov32(env, result);
680 }
681 
helper_madd32_suov(CPUTriCoreState * env,target_ulong r1,target_ulong r2,target_ulong r3)682 target_ulong helper_madd32_suov(CPUTriCoreState *env, target_ulong r1,
683                                 target_ulong r2, target_ulong r3)
684 {
685     uint64_t t1 = extract64(r1, 0, 32);
686     uint64_t t2 = extract64(r2, 0, 32);
687     uint64_t t3 = extract64(r3, 0, 32);
688     int64_t result;
689 
690     result = t2 + (t1 * t3);
691     return suov32_pos(env, result);
692 }
693 
helper_madd64_ssov(CPUTriCoreState * env,target_ulong r1,uint64_t r2,target_ulong r3)694 uint64_t helper_madd64_ssov(CPUTriCoreState *env, target_ulong r1,
695                             uint64_t r2, target_ulong r3)
696 {
697     uint64_t ret, ovf;
698     int64_t t1 = sextract64(r1, 0, 32);
699     int64_t t3 = sextract64(r3, 0, 32);
700     int64_t mul;
701 
702     mul = t1 * t3;
703     ret = mul + r2;
704     ovf = (ret ^ mul) & ~(mul ^ r2);
705 
706     t1 = ret >> 32;
707     env->PSW_USB_AV = t1 ^ t1 * 2u;
708     env->PSW_USB_SAV |= env->PSW_USB_AV;
709 
710     if ((int64_t)ovf < 0) {
711         env->PSW_USB_V = (1 << 31);
712         env->PSW_USB_SV = (1 << 31);
713         /* ext_ret > MAX_INT */
714         if (mul >= 0) {
715             ret = INT64_MAX;
716         /* ext_ret < MIN_INT */
717         } else {
718             ret = INT64_MIN;
719         }
720     } else {
721         env->PSW_USB_V = 0;
722     }
723 
724     return ret;
725 }
726 
727 uint32_t
helper_madd32_q_add_ssov(CPUTriCoreState * env,uint64_t r1,uint64_t r2)728 helper_madd32_q_add_ssov(CPUTriCoreState *env, uint64_t r1, uint64_t r2)
729 {
730     int64_t result;
731 
732     result = (r1 + r2);
733 
734     env->PSW_USB_AV = (result ^ result * 2u);
735     env->PSW_USB_SAV |= env->PSW_USB_AV;
736 
737     /* we do the saturation by hand, since we produce an overflow on the host
738        if the mul before was (0x80000000 * 0x80000000) << 1). If this is the
739        case, we flip the saturated value. */
740     if (r2 == 0x8000000000000000LL) {
741         if (result > 0x7fffffffLL) {
742             env->PSW_USB_V = (1 << 31);
743             env->PSW_USB_SV = (1 << 31);
744             result = INT32_MIN;
745         } else if (result < -0x80000000LL) {
746             env->PSW_USB_V = (1 << 31);
747             env->PSW_USB_SV = (1 << 31);
748             result = INT32_MAX;
749         } else {
750             env->PSW_USB_V = 0;
751         }
752     } else {
753         if (result > 0x7fffffffLL) {
754             env->PSW_USB_V = (1 << 31);
755             env->PSW_USB_SV = (1 << 31);
756             result = INT32_MAX;
757         } else if (result < -0x80000000LL) {
758             env->PSW_USB_V = (1 << 31);
759             env->PSW_USB_SV = (1 << 31);
760             result = INT32_MIN;
761         } else {
762             env->PSW_USB_V = 0;
763         }
764     }
765     return (uint32_t)result;
766 }
767 
helper_madd64_q_ssov(CPUTriCoreState * env,uint64_t r1,uint32_t r2,uint32_t r3,uint32_t n)768 uint64_t helper_madd64_q_ssov(CPUTriCoreState *env, uint64_t r1, uint32_t r2,
769                               uint32_t r3, uint32_t n)
770 {
771     int64_t t1 = (int64_t)r1;
772     int64_t t2 = sextract64(r2, 0, 32);
773     int64_t t3 = sextract64(r3, 0, 32);
774     int64_t result, mul;
775     int64_t ovf;
776 
777     mul = (t2 * t3) << n;
778     result = mul + t1;
779 
780     env->PSW_USB_AV = (result ^ result * 2u) >> 32;
781     env->PSW_USB_SAV |= env->PSW_USB_AV;
782 
783     ovf = (result ^ mul) & ~(mul ^ t1);
784     /* we do the saturation by hand, since we produce an overflow on the host
785        if the mul was (0x80000000 * 0x80000000) << 1). If this is the
786        case, we flip the saturated value. */
787     if ((r2 == 0x80000000) && (r3 == 0x80000000) && (n == 1)) {
788         if (ovf >= 0) {
789             env->PSW_USB_V = (1 << 31);
790             env->PSW_USB_SV = (1 << 31);
791             /* ext_ret > MAX_INT */
792             if (mul < 0) {
793                 result = INT64_MAX;
794             /* ext_ret < MIN_INT */
795             } else {
796                result = INT64_MIN;
797             }
798         } else {
799             env->PSW_USB_V = 0;
800         }
801     } else {
802         if (ovf < 0) {
803             env->PSW_USB_V = (1 << 31);
804             env->PSW_USB_SV = (1 << 31);
805             /* ext_ret > MAX_INT */
806             if (mul >= 0) {
807                 result = INT64_MAX;
808             /* ext_ret < MIN_INT */
809             } else {
810                result = INT64_MIN;
811             }
812         } else {
813             env->PSW_USB_V = 0;
814         }
815     }
816     return (uint64_t)result;
817 }
818 
helper_maddr_q_ssov(CPUTriCoreState * env,uint32_t r1,uint32_t r2,uint32_t r3,uint32_t n)819 uint32_t helper_maddr_q_ssov(CPUTriCoreState *env, uint32_t r1, uint32_t r2,
820                              uint32_t r3, uint32_t n)
821 {
822     int64_t t1 = sextract64(r1, 0, 32);
823     int64_t t2 = sextract64(r2, 0, 32);
824     int64_t t3 = sextract64(r3, 0, 32);
825     int64_t mul, ret;
826 
827     if ((t2 == -0x8000ll) && (t3 == -0x8000ll) && (n == 1)) {
828         mul = 0x7fffffff;
829     } else {
830         mul = (t2 * t3) << n;
831     }
832 
833     ret = t1 + mul + 0x8000;
834 
835     env->PSW_USB_AV = ret ^ ret * 2u;
836     env->PSW_USB_SAV |= env->PSW_USB_AV;
837 
838     if (ret > 0x7fffffffll) {
839         env->PSW_USB_V = (1 << 31);
840         env->PSW_USB_SV |= env->PSW_USB_V;
841         ret = INT32_MAX;
842     } else if (ret < -0x80000000ll) {
843         env->PSW_USB_V = (1 << 31);
844         env->PSW_USB_SV |= env->PSW_USB_V;
845         ret = INT32_MIN;
846     } else {
847         env->PSW_USB_V = 0;
848     }
849     return ret & 0xffff0000ll;
850 }
851 
helper_madd64_suov(CPUTriCoreState * env,target_ulong r1,uint64_t r2,target_ulong r3)852 uint64_t helper_madd64_suov(CPUTriCoreState *env, target_ulong r1,
853                             uint64_t r2, target_ulong r3)
854 {
855     uint64_t ret, mul;
856     uint64_t t1 = extract64(r1, 0, 32);
857     uint64_t t3 = extract64(r3, 0, 32);
858 
859     mul = t1 * t3;
860     ret = mul + r2;
861 
862     t1 = ret >> 32;
863     env->PSW_USB_AV = t1 ^ t1 * 2u;
864     env->PSW_USB_SAV |= env->PSW_USB_AV;
865 
866     if (ret < r2) {
867         env->PSW_USB_V = (1 << 31);
868         env->PSW_USB_SV = (1 << 31);
869         /* saturate */
870         ret = UINT64_MAX;
871     } else {
872         env->PSW_USB_V = 0;
873     }
874     return ret;
875 }
876 
helper_msub32_ssov(CPUTriCoreState * env,target_ulong r1,target_ulong r2,target_ulong r3)877 target_ulong helper_msub32_ssov(CPUTriCoreState *env, target_ulong r1,
878                                 target_ulong r2, target_ulong r3)
879 {
880     int64_t t1 = sextract64(r1, 0, 32);
881     int64_t t2 = sextract64(r2, 0, 32);
882     int64_t t3 = sextract64(r3, 0, 32);
883     int64_t result;
884 
885     result = t2 - (t1 * t3);
886     return ssov32(env, result);
887 }
888 
helper_msub32_suov(CPUTriCoreState * env,target_ulong r1,target_ulong r2,target_ulong r3)889 target_ulong helper_msub32_suov(CPUTriCoreState *env, target_ulong r1,
890                                 target_ulong r2, target_ulong r3)
891 {
892     uint64_t t1 = extract64(r1, 0, 32);
893     uint64_t t2 = extract64(r2, 0, 32);
894     uint64_t t3 = extract64(r3, 0, 32);
895     uint64_t result;
896     uint64_t mul;
897 
898     mul = (t1 * t3);
899     result = t2 - mul;
900 
901     env->PSW_USB_AV = result ^ result * 2u;
902     env->PSW_USB_SAV |= env->PSW_USB_AV;
903     /* we calculate ovf by hand here, because the multiplication can overflow on
904        the host, which would give false results if we compare to less than
905        zero */
906     if (mul > t2) {
907         env->PSW_USB_V = (1 << 31);
908         env->PSW_USB_SV = (1 << 31);
909         result = 0;
910     } else {
911         env->PSW_USB_V = 0;
912     }
913     return result;
914 }
915 
helper_msub64_ssov(CPUTriCoreState * env,target_ulong r1,uint64_t r2,target_ulong r3)916 uint64_t helper_msub64_ssov(CPUTriCoreState *env, target_ulong r1,
917                             uint64_t r2, target_ulong r3)
918 {
919     uint64_t ret, ovf;
920     int64_t t1 = sextract64(r1, 0, 32);
921     int64_t t3 = sextract64(r3, 0, 32);
922     int64_t mul;
923 
924     mul = t1 * t3;
925     ret = r2 - mul;
926     ovf = (ret ^ r2) & (mul ^ r2);
927 
928     t1 = ret >> 32;
929     env->PSW_USB_AV = t1 ^ t1 * 2u;
930     env->PSW_USB_SAV |= env->PSW_USB_AV;
931 
932     if ((int64_t)ovf < 0) {
933         env->PSW_USB_V = (1 << 31);
934         env->PSW_USB_SV = (1 << 31);
935         /* ext_ret > MAX_INT */
936         if (mul < 0) {
937             ret = INT64_MAX;
938         /* ext_ret < MIN_INT */
939         } else {
940             ret = INT64_MIN;
941         }
942     } else {
943         env->PSW_USB_V = 0;
944     }
945     return ret;
946 }
947 
helper_msub64_suov(CPUTriCoreState * env,target_ulong r1,uint64_t r2,target_ulong r3)948 uint64_t helper_msub64_suov(CPUTriCoreState *env, target_ulong r1,
949                             uint64_t r2, target_ulong r3)
950 {
951     uint64_t ret, mul;
952     uint64_t t1 = extract64(r1, 0, 32);
953     uint64_t t3 = extract64(r3, 0, 32);
954 
955     mul = t1 * t3;
956     ret = r2 - mul;
957 
958     t1 = ret >> 32;
959     env->PSW_USB_AV = t1 ^ t1 * 2u;
960     env->PSW_USB_SAV |= env->PSW_USB_AV;
961 
962     if (ret > r2) {
963         env->PSW_USB_V = (1 << 31);
964         env->PSW_USB_SV = (1 << 31);
965         /* saturate */
966         ret = 0;
967     } else {
968         env->PSW_USB_V = 0;
969     }
970     return ret;
971 }
972 
973 uint32_t
helper_msub32_q_sub_ssov(CPUTriCoreState * env,uint64_t r1,uint64_t r2)974 helper_msub32_q_sub_ssov(CPUTriCoreState *env, uint64_t r1, uint64_t r2)
975 {
976     int64_t result;
977     int64_t t1 = (int64_t)r1;
978     int64_t t2 = (int64_t)r2;
979 
980     result = t1 - t2;
981 
982     env->PSW_USB_AV = (result ^ result * 2u);
983     env->PSW_USB_SAV |= env->PSW_USB_AV;
984 
985     /* we do the saturation by hand, since we produce an overflow on the host
986        if the mul before was (0x80000000 * 0x80000000) << 1). If this is the
987        case, we flip the saturated value. */
988     if (r2 == 0x8000000000000000LL) {
989         if (result > 0x7fffffffLL) {
990             env->PSW_USB_V = (1 << 31);
991             env->PSW_USB_SV = (1 << 31);
992             result = INT32_MIN;
993         } else if (result < -0x80000000LL) {
994             env->PSW_USB_V = (1 << 31);
995             env->PSW_USB_SV = (1 << 31);
996             result = INT32_MAX;
997         } else {
998             env->PSW_USB_V = 0;
999         }
1000     } else {
1001         if (result > 0x7fffffffLL) {
1002             env->PSW_USB_V = (1 << 31);
1003             env->PSW_USB_SV = (1 << 31);
1004             result = INT32_MAX;
1005         } else if (result < -0x80000000LL) {
1006             env->PSW_USB_V = (1 << 31);
1007             env->PSW_USB_SV = (1 << 31);
1008             result = INT32_MIN;
1009         } else {
1010             env->PSW_USB_V = 0;
1011         }
1012     }
1013     return (uint32_t)result;
1014 }
1015 
helper_msub64_q_ssov(CPUTriCoreState * env,uint64_t r1,uint32_t r2,uint32_t r3,uint32_t n)1016 uint64_t helper_msub64_q_ssov(CPUTriCoreState *env, uint64_t r1, uint32_t r2,
1017                               uint32_t r3, uint32_t n)
1018 {
1019     int64_t t1 = (int64_t)r1;
1020     int64_t t2 = sextract64(r2, 0, 32);
1021     int64_t t3 = sextract64(r3, 0, 32);
1022     int64_t result, mul;
1023     int64_t ovf;
1024 
1025     mul = (t2 * t3) << n;
1026     result = t1 - mul;
1027 
1028     env->PSW_USB_AV = (result ^ result * 2u) >> 32;
1029     env->PSW_USB_SAV |= env->PSW_USB_AV;
1030 
1031     ovf = (result ^ t1) & (t1 ^ mul);
1032     /* we do the saturation by hand, since we produce an overflow on the host
1033        if the mul before was (0x80000000 * 0x80000000) << 1). If this is the
1034        case, we flip the saturated value. */
1035     if (mul == 0x8000000000000000LL) {
1036         if (ovf >= 0) {
1037             env->PSW_USB_V = (1 << 31);
1038             env->PSW_USB_SV = (1 << 31);
1039             /* ext_ret > MAX_INT */
1040             if (mul >= 0) {
1041                 result = INT64_MAX;
1042             /* ext_ret < MIN_INT */
1043             } else {
1044                result = INT64_MIN;
1045             }
1046         } else {
1047             env->PSW_USB_V = 0;
1048         }
1049     } else {
1050         if (ovf < 0) {
1051             env->PSW_USB_V = (1 << 31);
1052             env->PSW_USB_SV = (1 << 31);
1053             /* ext_ret > MAX_INT */
1054             if (mul < 0) {
1055                 result = INT64_MAX;
1056             /* ext_ret < MIN_INT */
1057             } else {
1058                result = INT64_MIN;
1059             }
1060         } else {
1061             env->PSW_USB_V = 0;
1062         }
1063     }
1064 
1065     return (uint64_t)result;
1066 }
1067 
helper_msubr_q_ssov(CPUTriCoreState * env,uint32_t r1,uint32_t r2,uint32_t r3,uint32_t n)1068 uint32_t helper_msubr_q_ssov(CPUTriCoreState *env, uint32_t r1, uint32_t r2,
1069                              uint32_t r3, uint32_t n)
1070 {
1071     int64_t t1 = sextract64(r1, 0, 32);
1072     int64_t t2 = sextract64(r2, 0, 32);
1073     int64_t t3 = sextract64(r3, 0, 32);
1074     int64_t mul, ret;
1075 
1076     if ((t2 == -0x8000ll) && (t3 == -0x8000ll) && (n == 1)) {
1077         mul = 0x7fffffff;
1078     } else {
1079         mul = (t2 * t3) << n;
1080     }
1081 
1082     ret = t1 - mul + 0x8000;
1083 
1084     env->PSW_USB_AV = ret ^ ret * 2u;
1085     env->PSW_USB_SAV |= env->PSW_USB_AV;
1086 
1087     if (ret > 0x7fffffffll) {
1088         env->PSW_USB_V = (1 << 31);
1089         env->PSW_USB_SV |= env->PSW_USB_V;
1090         ret = INT32_MAX;
1091     } else if (ret < -0x80000000ll) {
1092         env->PSW_USB_V = (1 << 31);
1093         env->PSW_USB_SV |= env->PSW_USB_V;
1094         ret = INT32_MIN;
1095     } else {
1096         env->PSW_USB_V = 0;
1097     }
1098     return ret & 0xffff0000ll;
1099 }
1100 
helper_abs_b(CPUTriCoreState * env,target_ulong arg)1101 uint32_t helper_abs_b(CPUTriCoreState *env, target_ulong arg)
1102 {
1103     int32_t b, i;
1104     int32_t ovf = 0;
1105     int32_t avf = 0;
1106     int32_t ret = 0;
1107 
1108     for (i = 0; i < 4; i++) {
1109         b = sextract32(arg, i * 8, 8);
1110         b = (b >= 0) ? b : (0 - b);
1111         ovf |= (b > 0x7F) || (b < -0x80);
1112         avf |= b ^ b * 2u;
1113         ret |= (b & 0xff) << (i * 8);
1114     }
1115 
1116     env->PSW_USB_V = ovf << 31;
1117     env->PSW_USB_SV |= env->PSW_USB_V;
1118     env->PSW_USB_AV = avf << 24;
1119     env->PSW_USB_SAV |= env->PSW_USB_AV;
1120 
1121     return ret;
1122 }
1123 
helper_abs_h(CPUTriCoreState * env,target_ulong arg)1124 uint32_t helper_abs_h(CPUTriCoreState *env, target_ulong arg)
1125 {
1126     int32_t h, i;
1127     int32_t ovf = 0;
1128     int32_t avf = 0;
1129     int32_t ret = 0;
1130 
1131     for (i = 0; i < 2; i++) {
1132         h = sextract32(arg, i * 16, 16);
1133         h = (h >= 0) ? h : (0 - h);
1134         ovf |= (h > 0x7FFF) || (h < -0x8000);
1135         avf |= h ^ h * 2u;
1136         ret |= (h & 0xffff) << (i * 16);
1137     }
1138 
1139     env->PSW_USB_V = ovf << 31;
1140     env->PSW_USB_SV |= env->PSW_USB_V;
1141     env->PSW_USB_AV = avf << 16;
1142     env->PSW_USB_SAV |= env->PSW_USB_AV;
1143 
1144     return ret;
1145 }
1146 
helper_absdif_b(CPUTriCoreState * env,target_ulong r1,target_ulong r2)1147 uint32_t helper_absdif_b(CPUTriCoreState *env, target_ulong r1, target_ulong r2)
1148 {
1149     int32_t b, i;
1150     int32_t extr_r2;
1151     int32_t ovf = 0;
1152     int32_t avf = 0;
1153     int32_t ret = 0;
1154 
1155     for (i = 0; i < 4; i++) {
1156         extr_r2 = sextract32(r2, i * 8, 8);
1157         b = sextract32(r1, i * 8, 8);
1158         b = (b > extr_r2) ? (b - extr_r2) : (extr_r2 - b);
1159         ovf |= (b > 0x7F) || (b < -0x80);
1160         avf |= b ^ b * 2u;
1161         ret |= (b & 0xff) << (i * 8);
1162     }
1163 
1164     env->PSW_USB_V = ovf << 31;
1165     env->PSW_USB_SV |= env->PSW_USB_V;
1166     env->PSW_USB_AV = avf << 24;
1167     env->PSW_USB_SAV |= env->PSW_USB_AV;
1168     return ret;
1169 }
1170 
helper_absdif_h(CPUTriCoreState * env,target_ulong r1,target_ulong r2)1171 uint32_t helper_absdif_h(CPUTriCoreState *env, target_ulong r1, target_ulong r2)
1172 {
1173     int32_t h, i;
1174     int32_t extr_r2;
1175     int32_t ovf = 0;
1176     int32_t avf = 0;
1177     int32_t ret = 0;
1178 
1179     for (i = 0; i < 2; i++) {
1180         extr_r2 = sextract32(r2, i * 16, 16);
1181         h = sextract32(r1, i * 16, 16);
1182         h = (h > extr_r2) ? (h - extr_r2) : (extr_r2 - h);
1183         ovf |= (h > 0x7FFF) || (h < -0x8000);
1184         avf |= h ^ h * 2u;
1185         ret |= (h & 0xffff) << (i * 16);
1186     }
1187 
1188     env->PSW_USB_V = ovf << 31;
1189     env->PSW_USB_SV |= env->PSW_USB_V;
1190     env->PSW_USB_AV = avf << 16;
1191     env->PSW_USB_SAV |= env->PSW_USB_AV;
1192 
1193     return ret;
1194 }
1195 
helper_addr_h(CPUTriCoreState * env,uint64_t r1,uint32_t r2_l,uint32_t r2_h)1196 uint32_t helper_addr_h(CPUTriCoreState *env, uint64_t r1, uint32_t r2_l,
1197                        uint32_t r2_h)
1198 {
1199     int64_t mul_res0 = sextract64(r1, 0, 32);
1200     int64_t mul_res1 = sextract64(r1, 32, 32);
1201     int64_t r2_low = sextract64(r2_l, 0, 32);
1202     int64_t r2_high = sextract64(r2_h, 0, 32);
1203     int64_t result0, result1;
1204     uint32_t ovf0, ovf1;
1205     uint32_t avf0, avf1;
1206 
1207     ovf0 = ovf1 = 0;
1208 
1209     result0 = r2_low + mul_res0 + 0x8000;
1210     result1 = r2_high + mul_res1 + 0x8000;
1211 
1212     if ((result0 > INT32_MAX) || (result0 < INT32_MIN)) {
1213         ovf0 = (1 << 31);
1214     }
1215 
1216     if ((result1 > INT32_MAX) || (result1 < INT32_MIN)) {
1217         ovf1 = (1 << 31);
1218     }
1219 
1220     env->PSW_USB_V = ovf0 | ovf1;
1221     env->PSW_USB_SV |= env->PSW_USB_V;
1222 
1223     avf0 = result0 * 2u;
1224     avf0 = result0 ^ avf0;
1225     avf1 = result1 * 2u;
1226     avf1 = result1 ^ avf1;
1227 
1228     env->PSW_USB_AV = avf0 | avf1;
1229     env->PSW_USB_SAV |= env->PSW_USB_AV;
1230 
1231     return (result1 & 0xffff0000ULL) | ((result0 >> 16) & 0xffffULL);
1232 }
1233 
helper_addsur_h(CPUTriCoreState * env,uint64_t r1,uint32_t r2_l,uint32_t r2_h)1234 uint32_t helper_addsur_h(CPUTriCoreState *env, uint64_t r1, uint32_t r2_l,
1235                          uint32_t r2_h)
1236 {
1237     int64_t mul_res0 = sextract64(r1, 0, 32);
1238     int64_t mul_res1 = sextract64(r1, 32, 32);
1239     int64_t r2_low = sextract64(r2_l, 0, 32);
1240     int64_t r2_high = sextract64(r2_h, 0, 32);
1241     int64_t result0, result1;
1242     uint32_t ovf0, ovf1;
1243     uint32_t avf0, avf1;
1244 
1245     ovf0 = ovf1 = 0;
1246 
1247     result0 = r2_low - mul_res0 + 0x8000;
1248     result1 = r2_high + mul_res1 + 0x8000;
1249 
1250     if ((result0 > INT32_MAX) || (result0 < INT32_MIN)) {
1251         ovf0 = (1 << 31);
1252     }
1253 
1254     if ((result1 > INT32_MAX) || (result1 < INT32_MIN)) {
1255         ovf1 = (1 << 31);
1256     }
1257 
1258     env->PSW_USB_V = ovf0 | ovf1;
1259     env->PSW_USB_SV |= env->PSW_USB_V;
1260 
1261     avf0 = result0 * 2u;
1262     avf0 = result0 ^ avf0;
1263     avf1 = result1 * 2u;
1264     avf1 = result1 ^ avf1;
1265 
1266     env->PSW_USB_AV = avf0 | avf1;
1267     env->PSW_USB_SAV |= env->PSW_USB_AV;
1268 
1269     return (result1 & 0xffff0000ULL) | ((result0 >> 16) & 0xffffULL);
1270 }
1271 
helper_maddr_q(CPUTriCoreState * env,uint32_t r1,uint32_t r2,uint32_t r3,uint32_t n)1272 uint32_t helper_maddr_q(CPUTriCoreState *env, uint32_t r1, uint32_t r2,
1273                         uint32_t r3, uint32_t n)
1274 {
1275     int64_t t1 = sextract64(r1, 0, 32);
1276     int64_t t2 = sextract64(r2, 0, 32);
1277     int64_t t3 = sextract64(r3, 0, 32);
1278     int64_t mul, ret;
1279 
1280     if ((t2 == -0x8000ll) && (t3 == -0x8000ll) && (n == 1)) {
1281         mul = 0x7fffffff;
1282     } else {
1283         mul = (t2 * t3) << n;
1284     }
1285 
1286     ret = t1 + mul + 0x8000;
1287 
1288     if ((ret > 0x7fffffffll) || (ret < -0x80000000ll)) {
1289         env->PSW_USB_V = (1 << 31);
1290         env->PSW_USB_SV |= env->PSW_USB_V;
1291     } else {
1292         env->PSW_USB_V = 0;
1293     }
1294     env->PSW_USB_AV = ret ^ ret * 2u;
1295     env->PSW_USB_SAV |= env->PSW_USB_AV;
1296 
1297     return ret & 0xffff0000ll;
1298 }
1299 
helper_add_b(CPUTriCoreState * env,target_ulong r1,target_ulong r2)1300 uint32_t helper_add_b(CPUTriCoreState *env, target_ulong r1, target_ulong r2)
1301 {
1302     int32_t b, i;
1303     int32_t extr_r1, extr_r2;
1304     int32_t ovf = 0;
1305     int32_t avf = 0;
1306     uint32_t ret = 0;
1307 
1308     for (i = 0; i < 4; i++) {
1309         extr_r1 = sextract32(r1, i * 8, 8);
1310         extr_r2 = sextract32(r2, i * 8, 8);
1311 
1312         b = extr_r1 + extr_r2;
1313         ovf |= ((b > 0x7f) || (b < -0x80));
1314         avf |= b ^ b * 2u;
1315         ret |= ((b & 0xff) << (i*8));
1316     }
1317 
1318     env->PSW_USB_V = (ovf << 31);
1319     env->PSW_USB_SV |= env->PSW_USB_V;
1320     env->PSW_USB_AV = avf << 24;
1321     env->PSW_USB_SAV |= env->PSW_USB_AV;
1322 
1323     return ret;
1324 }
1325 
helper_add_h(CPUTriCoreState * env,target_ulong r1,target_ulong r2)1326 uint32_t helper_add_h(CPUTriCoreState *env, target_ulong r1, target_ulong r2)
1327 {
1328     int32_t h, i;
1329     int32_t extr_r1, extr_r2;
1330     int32_t ovf = 0;
1331     int32_t avf = 0;
1332     int32_t ret = 0;
1333 
1334     for (i = 0; i < 2; i++) {
1335         extr_r1 = sextract32(r1, i * 16, 16);
1336         extr_r2 = sextract32(r2, i * 16, 16);
1337         h = extr_r1 + extr_r2;
1338         ovf |= ((h > 0x7fff) || (h < -0x8000));
1339         avf |= h ^ h * 2u;
1340         ret |= (h & 0xffff) << (i * 16);
1341     }
1342 
1343     env->PSW_USB_V = (ovf << 31);
1344     env->PSW_USB_SV |= env->PSW_USB_V;
1345     env->PSW_USB_AV = (avf << 16);
1346     env->PSW_USB_SAV |= env->PSW_USB_AV;
1347 
1348     return ret;
1349 }
1350 
helper_subr_h(CPUTriCoreState * env,uint64_t r1,uint32_t r2_l,uint32_t r2_h)1351 uint32_t helper_subr_h(CPUTriCoreState *env, uint64_t r1, uint32_t r2_l,
1352                        uint32_t r2_h)
1353 {
1354     int64_t mul_res0 = sextract64(r1, 0, 32);
1355     int64_t mul_res1 = sextract64(r1, 32, 32);
1356     int64_t r2_low = sextract64(r2_l, 0, 32);
1357     int64_t r2_high = sextract64(r2_h, 0, 32);
1358     int64_t result0, result1;
1359     uint32_t ovf0, ovf1;
1360     uint32_t avf0, avf1;
1361 
1362     ovf0 = ovf1 = 0;
1363 
1364     result0 = r2_low - mul_res0 + 0x8000;
1365     result1 = r2_high - mul_res1 + 0x8000;
1366 
1367     if ((result0 > INT32_MAX) || (result0 < INT32_MIN)) {
1368         ovf0 = (1 << 31);
1369     }
1370 
1371     if ((result1 > INT32_MAX) || (result1 < INT32_MIN)) {
1372         ovf1 = (1 << 31);
1373     }
1374 
1375     env->PSW_USB_V = ovf0 | ovf1;
1376     env->PSW_USB_SV |= env->PSW_USB_V;
1377 
1378     avf0 = result0 * 2u;
1379     avf0 = result0 ^ avf0;
1380     avf1 = result1 * 2u;
1381     avf1 = result1 ^ avf1;
1382 
1383     env->PSW_USB_AV = avf0 | avf1;
1384     env->PSW_USB_SAV |= env->PSW_USB_AV;
1385 
1386     return (result1 & 0xffff0000ULL) | ((result0 >> 16) & 0xffffULL);
1387 }
1388 
helper_subadr_h(CPUTriCoreState * env,uint64_t r1,uint32_t r2_l,uint32_t r2_h)1389 uint32_t helper_subadr_h(CPUTriCoreState *env, uint64_t r1, uint32_t r2_l,
1390                          uint32_t r2_h)
1391 {
1392     int64_t mul_res0 = sextract64(r1, 0, 32);
1393     int64_t mul_res1 = sextract64(r1, 32, 32);
1394     int64_t r2_low = sextract64(r2_l, 0, 32);
1395     int64_t r2_high = sextract64(r2_h, 0, 32);
1396     int64_t result0, result1;
1397     uint32_t ovf0, ovf1;
1398     uint32_t avf0, avf1;
1399 
1400     ovf0 = ovf1 = 0;
1401 
1402     result0 = r2_low + mul_res0 + 0x8000;
1403     result1 = r2_high - mul_res1 + 0x8000;
1404 
1405     if ((result0 > INT32_MAX) || (result0 < INT32_MIN)) {
1406         ovf0 = (1 << 31);
1407     }
1408 
1409     if ((result1 > INT32_MAX) || (result1 < INT32_MIN)) {
1410         ovf1 = (1 << 31);
1411     }
1412 
1413     env->PSW_USB_V = ovf0 | ovf1;
1414     env->PSW_USB_SV |= env->PSW_USB_V;
1415 
1416     avf0 = result0 * 2u;
1417     avf0 = result0 ^ avf0;
1418     avf1 = result1 * 2u;
1419     avf1 = result1 ^ avf1;
1420 
1421     env->PSW_USB_AV = avf0 | avf1;
1422     env->PSW_USB_SAV |= env->PSW_USB_AV;
1423 
1424     return (result1 & 0xffff0000ULL) | ((result0 >> 16) & 0xffffULL);
1425 }
1426 
helper_msubr_q(CPUTriCoreState * env,uint32_t r1,uint32_t r2,uint32_t r3,uint32_t n)1427 uint32_t helper_msubr_q(CPUTriCoreState *env, uint32_t r1, uint32_t r2,
1428                         uint32_t r3, uint32_t n)
1429 {
1430     int64_t t1 = sextract64(r1, 0, 32);
1431     int64_t t2 = sextract64(r2, 0, 32);
1432     int64_t t3 = sextract64(r3, 0, 32);
1433     int64_t mul, ret;
1434 
1435     if ((t2 == -0x8000ll) && (t3 == -0x8000ll) && (n == 1)) {
1436         mul = 0x7fffffff;
1437     } else {
1438         mul = (t2 * t3) << n;
1439     }
1440 
1441     ret = t1 - mul + 0x8000;
1442 
1443     if ((ret > 0x7fffffffll) || (ret < -0x80000000ll)) {
1444         env->PSW_USB_V = (1 << 31);
1445         env->PSW_USB_SV |= env->PSW_USB_V;
1446     } else {
1447         env->PSW_USB_V = 0;
1448     }
1449     env->PSW_USB_AV = ret ^ ret * 2u;
1450     env->PSW_USB_SAV |= env->PSW_USB_AV;
1451 
1452     return ret & 0xffff0000ll;
1453 }
1454 
helper_sub_b(CPUTriCoreState * env,target_ulong r1,target_ulong r2)1455 uint32_t helper_sub_b(CPUTriCoreState *env, target_ulong r1, target_ulong r2)
1456 {
1457     int32_t b, i;
1458     int32_t extr_r1, extr_r2;
1459     int32_t ovf = 0;
1460     int32_t avf = 0;
1461     uint32_t ret = 0;
1462 
1463     for (i = 0; i < 4; i++) {
1464         extr_r1 = sextract32(r1, i * 8, 8);
1465         extr_r2 = sextract32(r2, i * 8, 8);
1466 
1467         b = extr_r1 - extr_r2;
1468         ovf |= ((b > 0x7f) || (b < -0x80));
1469         avf |= b ^ b * 2u;
1470         ret |= ((b & 0xff) << (i*8));
1471     }
1472 
1473     env->PSW_USB_V = (ovf << 31);
1474     env->PSW_USB_SV |= env->PSW_USB_V;
1475     env->PSW_USB_AV = avf << 24;
1476     env->PSW_USB_SAV |= env->PSW_USB_AV;
1477 
1478     return ret;
1479 }
1480 
helper_sub_h(CPUTriCoreState * env,target_ulong r1,target_ulong r2)1481 uint32_t helper_sub_h(CPUTriCoreState *env, target_ulong r1, target_ulong r2)
1482 {
1483     int32_t h, i;
1484     int32_t extr_r1, extr_r2;
1485     int32_t ovf = 0;
1486     int32_t avf = 0;
1487     int32_t ret = 0;
1488 
1489     for (i = 0; i < 2; i++) {
1490         extr_r1 = sextract32(r1, i * 16, 16);
1491         extr_r2 = sextract32(r2, i * 16, 16);
1492         h = extr_r1 - extr_r2;
1493         ovf |= ((h > 0x7fff) || (h < -0x8000));
1494         avf |= h ^ h * 2u;
1495         ret |= (h & 0xffff) << (i * 16);
1496     }
1497 
1498     env->PSW_USB_V = (ovf << 31);
1499     env->PSW_USB_SV |= env->PSW_USB_V;
1500     env->PSW_USB_AV = avf << 16;
1501     env->PSW_USB_SAV |= env->PSW_USB_AV;
1502 
1503     return ret;
1504 }
1505 
helper_eq_b(target_ulong r1,target_ulong r2)1506 uint32_t helper_eq_b(target_ulong r1, target_ulong r2)
1507 {
1508     uint32_t ret, msk;
1509     int32_t i;
1510 
1511     ret = 0;
1512     msk = 0xff;
1513     for (i = 0; i < 4; i++) {
1514         if ((r1 & msk) == (r2 & msk)) {
1515             ret |= msk;
1516         }
1517         msk = msk << 8;
1518     }
1519 
1520     return ret;
1521 }
1522 
helper_eq_h(target_ulong r1,target_ulong r2)1523 uint32_t helper_eq_h(target_ulong r1, target_ulong r2)
1524 {
1525     int32_t ret = 0;
1526 
1527     if ((r1 & 0xffff) == (r2 & 0xffff)) {
1528         ret = 0xffff;
1529     }
1530 
1531     if ((r1 & 0xffff0000) == (r2 & 0xffff0000)) {
1532         ret |= 0xffff0000;
1533     }
1534 
1535     return ret;
1536 }
1537 
helper_eqany_b(target_ulong r1,target_ulong r2)1538 uint32_t helper_eqany_b(target_ulong r1, target_ulong r2)
1539 {
1540     int32_t i;
1541     uint32_t ret = 0;
1542 
1543     for (i = 0; i < 4; i++) {
1544         ret |= (sextract32(r1,  i * 8, 8) == sextract32(r2,  i * 8, 8));
1545     }
1546 
1547     return ret;
1548 }
1549 
helper_eqany_h(target_ulong r1,target_ulong r2)1550 uint32_t helper_eqany_h(target_ulong r1, target_ulong r2)
1551 {
1552     uint32_t ret;
1553 
1554     ret = (sextract32(r1, 0, 16) == sextract32(r2,  0, 16));
1555     ret |= (sextract32(r1, 16, 16) == sextract32(r2,  16, 16));
1556 
1557     return ret;
1558 }
1559 
helper_lt_b(target_ulong r1,target_ulong r2)1560 uint32_t helper_lt_b(target_ulong r1, target_ulong r2)
1561 {
1562     int32_t i;
1563     uint32_t ret = 0;
1564 
1565     for (i = 0; i < 4; i++) {
1566         if (sextract32(r1,  i * 8, 8) < sextract32(r2,  i * 8, 8)) {
1567             ret |= (0xff << (i * 8));
1568         }
1569     }
1570 
1571     return ret;
1572 }
1573 
helper_lt_bu(target_ulong r1,target_ulong r2)1574 uint32_t helper_lt_bu(target_ulong r1, target_ulong r2)
1575 {
1576     int32_t i;
1577     uint32_t ret = 0;
1578 
1579     for (i = 0; i < 4; i++) {
1580         if (extract32(r1,  i * 8, 8) < extract32(r2,  i * 8, 8)) {
1581             ret |= (0xff << (i * 8));
1582         }
1583     }
1584 
1585     return ret;
1586 }
1587 
helper_lt_h(target_ulong r1,target_ulong r2)1588 uint32_t helper_lt_h(target_ulong r1, target_ulong r2)
1589 {
1590     uint32_t ret = 0;
1591 
1592     if (sextract32(r1,  0, 16) < sextract32(r2,  0, 16)) {
1593         ret |= 0xffff;
1594     }
1595 
1596     if (sextract32(r1,  16, 16) < sextract32(r2,  16, 16)) {
1597         ret |= 0xffff0000;
1598     }
1599 
1600     return ret;
1601 }
1602 
helper_lt_hu(target_ulong r1,target_ulong r2)1603 uint32_t helper_lt_hu(target_ulong r1, target_ulong r2)
1604 {
1605     uint32_t ret = 0;
1606 
1607     if (extract32(r1,  0, 16) < extract32(r2,  0, 16)) {
1608         ret |= 0xffff;
1609     }
1610 
1611     if (extract32(r1,  16, 16) < extract32(r2,  16, 16)) {
1612         ret |= 0xffff0000;
1613     }
1614 
1615     return ret;
1616 }
1617 
1618 #define EXTREMA_H_B(name, op)                                 \
1619 uint32_t helper_##name ##_b(target_ulong r1, target_ulong r2) \
1620 {                                                             \
1621     int32_t i, extr_r1, extr_r2;                              \
1622     uint32_t ret = 0;                                         \
1623                                                               \
1624     for (i = 0; i < 4; i++) {                                 \
1625         extr_r1 = sextract32(r1, i * 8, 8);                   \
1626         extr_r2 = sextract32(r2, i * 8, 8);                   \
1627         extr_r1 = (extr_r1 op extr_r2) ? extr_r1 : extr_r2;   \
1628         ret |= (extr_r1 & 0xff) << (i * 8);                   \
1629     }                                                         \
1630     return ret;                                               \
1631 }                                                             \
1632                                                               \
1633 uint32_t helper_##name ##_bu(target_ulong r1, target_ulong r2)\
1634 {                                                             \
1635     int32_t i;                                                \
1636     uint32_t extr_r1, extr_r2;                                \
1637     uint32_t ret = 0;                                         \
1638                                                               \
1639     for (i = 0; i < 4; i++) {                                 \
1640         extr_r1 = extract32(r1, i * 8, 8);                    \
1641         extr_r2 = extract32(r2, i * 8, 8);                    \
1642         extr_r1 = (extr_r1 op extr_r2) ? extr_r1 : extr_r2;   \
1643         ret |= (extr_r1 & 0xff) << (i * 8);                   \
1644     }                                                         \
1645     return ret;                                               \
1646 }                                                             \
1647                                                               \
1648 uint32_t helper_##name ##_h(target_ulong r1, target_ulong r2) \
1649 {                                                             \
1650     int32_t extr_r1, extr_r2;                                 \
1651     uint32_t ret = 0;                                         \
1652                                                               \
1653     extr_r1 = sextract32(r1, 0, 16);                          \
1654     extr_r2 = sextract32(r2, 0, 16);                          \
1655     ret = (extr_r1 op extr_r2) ? extr_r1 : extr_r2;           \
1656     ret = ret & 0xffff;                                       \
1657                                                               \
1658     extr_r1 = sextract32(r1, 16, 16);                         \
1659     extr_r2 = sextract32(r2, 16, 16);                         \
1660     extr_r1 = (extr_r1 op extr_r2) ? extr_r1 : extr_r2;       \
1661     ret |= extr_r1 << 16;                                     \
1662                                                               \
1663     return ret;                                               \
1664 }                                                             \
1665                                                               \
1666 uint32_t helper_##name ##_hu(target_ulong r1, target_ulong r2)\
1667 {                                                             \
1668     uint32_t extr_r1, extr_r2;                                \
1669     uint32_t ret = 0;                                         \
1670                                                               \
1671     extr_r1 = extract32(r1, 0, 16);                           \
1672     extr_r2 = extract32(r2, 0, 16);                           \
1673     ret = (extr_r1 op extr_r2) ? extr_r1 : extr_r2;           \
1674     ret = ret & 0xffff;                                       \
1675                                                               \
1676     extr_r1 = extract32(r1, 16, 16);                          \
1677     extr_r2 = extract32(r2, 16, 16);                          \
1678     extr_r1 = (extr_r1 op extr_r2) ? extr_r1 : extr_r2;       \
1679     ret |= extr_r1 << (16);                                   \
1680                                                               \
1681     return ret;                                               \
1682 }                                                             \
1683                                                               \
1684 uint64_t helper_ix##name(uint64_t r1, uint32_t r2)            \
1685 {                                                             \
1686     int64_t r2l, r2h, r1hl;                                   \
1687     uint64_t ret = 0;                                         \
1688                                                               \
1689     ret = ((r1 + 2) & 0xffff);                                \
1690     r2l = sextract64(r2, 0, 16);                              \
1691     r2h = sextract64(r2, 16, 16);                             \
1692     r1hl = sextract64(r1, 32, 16);                            \
1693                                                               \
1694     if ((r2l op ## = r2h) && (r2l op r1hl)) {                 \
1695         ret |= (r2l & 0xffff) << 32;                          \
1696         ret |= extract64(r1, 0, 16) << 16;                    \
1697     } else if ((r2h op r2l) && (r2h op r1hl)) {               \
1698         ret |= extract64(r2, 16, 16) << 32;                   \
1699         ret |= extract64(r1 + 1, 0, 16) << 16;                \
1700     } else {                                                  \
1701         ret |= r1 & 0xffffffff0000ull;                        \
1702     }                                                         \
1703     return ret;                                               \
1704 }                                                             \
1705                                                               \
1706 uint64_t helper_ix##name ##_u(uint64_t r1, uint32_t r2)       \
1707 {                                                             \
1708     int64_t r2l, r2h, r1hl;                                   \
1709     uint64_t ret = 0;                                         \
1710                                                               \
1711     ret = ((r1 + 2) & 0xffff);                                \
1712     r2l = extract64(r2, 0, 16);                               \
1713     r2h = extract64(r2, 16, 16);                              \
1714     r1hl = extract64(r1, 32, 16);                             \
1715                                                               \
1716     if ((r2l op ## = r2h) && (r2l op r1hl)) {                 \
1717         ret |= (r2l & 0xffff) << 32;                          \
1718         ret |= extract64(r1, 0, 16) << 16;                    \
1719     } else if ((r2h op r2l) && (r2h op r1hl)) {               \
1720         ret |= extract64(r2, 16, 16) << 32;                   \
1721         ret |= extract64(r1 + 1, 0, 16) << 16;                \
1722     } else {                                                  \
1723         ret |= r1 & 0xffffffff0000ull;                        \
1724     }                                                         \
1725     return ret;                                               \
1726 }
1727 
1728 EXTREMA_H_B(max, >)
1729 EXTREMA_H_B(min, <)
1730 
1731 #undef EXTREMA_H_B
1732 
helper_clo_h(target_ulong r1)1733 uint32_t helper_clo_h(target_ulong r1)
1734 {
1735     uint32_t ret_hw0 = extract32(r1, 0, 16);
1736     uint32_t ret_hw1 = extract32(r1, 16, 16);
1737 
1738     ret_hw0 = clo32(ret_hw0 << 16);
1739     ret_hw1 = clo32(ret_hw1 << 16);
1740 
1741     if (ret_hw0 > 16) {
1742         ret_hw0 = 16;
1743     }
1744     if (ret_hw1 > 16) {
1745         ret_hw1 = 16;
1746     }
1747 
1748     return ret_hw0 | (ret_hw1 << 16);
1749 }
1750 
helper_clz_h(target_ulong r1)1751 uint32_t helper_clz_h(target_ulong r1)
1752 {
1753     uint32_t ret_hw0 = extract32(r1, 0, 16);
1754     uint32_t ret_hw1 = extract32(r1, 16, 16);
1755 
1756     ret_hw0 = clz32(ret_hw0 << 16);
1757     ret_hw1 = clz32(ret_hw1 << 16);
1758 
1759     if (ret_hw0 > 16) {
1760         ret_hw0 = 16;
1761     }
1762     if (ret_hw1 > 16) {
1763         ret_hw1 = 16;
1764     }
1765 
1766     return ret_hw0 | (ret_hw1 << 16);
1767 }
1768 
helper_cls_h(target_ulong r1)1769 uint32_t helper_cls_h(target_ulong r1)
1770 {
1771     uint32_t ret_hw0 = extract32(r1, 0, 16);
1772     uint32_t ret_hw1 = extract32(r1, 16, 16);
1773 
1774     ret_hw0 = clrsb32(ret_hw0 << 16);
1775     ret_hw1 = clrsb32(ret_hw1 << 16);
1776 
1777     if (ret_hw0 > 15) {
1778         ret_hw0 = 15;
1779     }
1780     if (ret_hw1 > 15) {
1781         ret_hw1 = 15;
1782     }
1783 
1784     return ret_hw0 | (ret_hw1 << 16);
1785 }
1786 
helper_sh(target_ulong r1,target_ulong r2)1787 uint32_t helper_sh(target_ulong r1, target_ulong r2)
1788 {
1789     int32_t shift_count = sextract32(r2, 0, 6);
1790 
1791     if (shift_count == -32) {
1792         return 0;
1793     } else if (shift_count < 0) {
1794         return r1 >> -shift_count;
1795     } else {
1796         return r1 << shift_count;
1797     }
1798 }
1799 
helper_sh_h(target_ulong r1,target_ulong r2)1800 uint32_t helper_sh_h(target_ulong r1, target_ulong r2)
1801 {
1802     int32_t ret_hw0, ret_hw1;
1803     int32_t shift_count;
1804 
1805     shift_count = sextract32(r2, 0, 5);
1806 
1807     if (shift_count == -16) {
1808         return 0;
1809     } else if (shift_count < 0) {
1810         ret_hw0 = extract32(r1, 0, 16) >> -shift_count;
1811         ret_hw1 = extract32(r1, 16, 16) >> -shift_count;
1812         return (ret_hw0 & 0xffff) | (ret_hw1 << 16);
1813     } else {
1814         ret_hw0 = extract32(r1, 0, 16) << shift_count;
1815         ret_hw1 = extract32(r1, 16, 16) << shift_count;
1816         return (ret_hw0 & 0xffff) | (ret_hw1 << 16);
1817     }
1818 }
1819 
helper_sha(CPUTriCoreState * env,target_ulong r1,target_ulong r2)1820 uint32_t helper_sha(CPUTriCoreState *env, target_ulong r1, target_ulong r2)
1821 {
1822     int32_t shift_count;
1823     int64_t result, t1;
1824     uint32_t ret;
1825 
1826     shift_count = sextract32(r2, 0, 6);
1827     t1 = sextract32(r1, 0, 32);
1828 
1829     if (shift_count == 0) {
1830         env->PSW_USB_C = env->PSW_USB_V = 0;
1831         ret = r1;
1832     } else if (shift_count == -32) {
1833         env->PSW_USB_C = r1;
1834         env->PSW_USB_V = 0;
1835         ret = t1 >> 31;
1836     } else if (shift_count > 0) {
1837         result = t1 << shift_count;
1838         /* calc carry */
1839         env->PSW_USB_C = ((result & 0xffffffff00000000ULL) != 0);
1840         /* calc v */
1841         env->PSW_USB_V = (((result > 0x7fffffffLL) ||
1842                            (result < -0x80000000LL)) << 31);
1843         /* calc sv */
1844         env->PSW_USB_SV |= env->PSW_USB_V;
1845         ret = (uint32_t)result;
1846     } else {
1847         env->PSW_USB_V = 0;
1848         env->PSW_USB_C = (r1 & ((1 << -shift_count) - 1));
1849         ret = t1 >> -shift_count;
1850     }
1851 
1852     env->PSW_USB_AV = ret ^ ret * 2u;
1853     env->PSW_USB_SAV |= env->PSW_USB_AV;
1854 
1855     return ret;
1856 }
1857 
helper_sha_h(target_ulong r1,target_ulong r2)1858 uint32_t helper_sha_h(target_ulong r1, target_ulong r2)
1859 {
1860     int32_t shift_count;
1861     int32_t ret_hw0, ret_hw1;
1862 
1863     shift_count = sextract32(r2, 0, 5);
1864 
1865     if (shift_count == 0) {
1866         return r1;
1867     } else if (shift_count < 0) {
1868         ret_hw0 = sextract32(r1, 0, 16) >> -shift_count;
1869         ret_hw1 = sextract32(r1, 16, 16) >> -shift_count;
1870         return (ret_hw0 & 0xffff) | (ret_hw1 << 16);
1871     } else {
1872         ret_hw0 = sextract32(r1, 0, 16) << shift_count;
1873         ret_hw1 = sextract32(r1, 16, 16) << shift_count;
1874         return (ret_hw0 & 0xffff) | (ret_hw1 << 16);
1875     }
1876 }
1877 
helper_bmerge(target_ulong r1,target_ulong r2)1878 uint32_t helper_bmerge(target_ulong r1, target_ulong r2)
1879 {
1880     uint32_t i, ret;
1881 
1882     ret = 0;
1883     for (i = 0; i < 16; i++) {
1884         ret |= (r1 & 1) << (2 * i + 1);
1885         ret |= (r2 & 1) << (2 * i);
1886         r1 = r1 >> 1;
1887         r2 = r2 >> 1;
1888     }
1889     return ret;
1890 }
1891 
helper_bsplit(uint32_t r1)1892 uint64_t helper_bsplit(uint32_t r1)
1893 {
1894     int32_t i;
1895     uint64_t ret;
1896 
1897     ret = 0;
1898     for (i = 0; i < 32; i = i + 2) {
1899         /* even */
1900         ret |= (r1 & 1) << (i/2);
1901         r1 = r1 >> 1;
1902         /* odd */
1903         ret |= (uint64_t)(r1 & 1) << (i/2 + 32);
1904         r1 = r1 >> 1;
1905     }
1906     return ret;
1907 }
1908 
helper_parity(target_ulong r1)1909 uint32_t helper_parity(target_ulong r1)
1910 {
1911     uint32_t ret;
1912     uint32_t nOnes, i;
1913 
1914     ret = 0;
1915     nOnes = 0;
1916     for (i = 0; i < 8; i++) {
1917         ret ^= (r1 & 1);
1918         r1 = r1 >> 1;
1919     }
1920     /* second byte */
1921     nOnes = 0;
1922     for (i = 0; i < 8; i++) {
1923         nOnes ^= (r1 & 1);
1924         r1 = r1 >> 1;
1925     }
1926     ret |= nOnes << 8;
1927     /* third byte */
1928     nOnes = 0;
1929     for (i = 0; i < 8; i++) {
1930         nOnes ^= (r1 & 1);
1931         r1 = r1 >> 1;
1932     }
1933     ret |= nOnes << 16;
1934     /* fourth byte */
1935     nOnes = 0;
1936     for (i = 0; i < 8; i++) {
1937         nOnes ^= (r1 & 1);
1938         r1 = r1 >> 1;
1939     }
1940     ret |= nOnes << 24;
1941 
1942     return ret;
1943 }
1944 
helper_pack(uint32_t carry,uint32_t r1_low,uint32_t r1_high,target_ulong r2)1945 uint32_t helper_pack(uint32_t carry, uint32_t r1_low, uint32_t r1_high,
1946                      target_ulong r2)
1947 {
1948     uint32_t ret;
1949     int32_t fp_exp, fp_frac, temp_exp, fp_exp_frac;
1950     int32_t int_exp  = r1_high;
1951     int32_t int_mant = r1_low;
1952     uint32_t flag_rnd = (int_mant & (1 << 7)) && (
1953                         (int_mant & (1 << 8)) ||
1954                         (int_mant & 0x7f)     ||
1955                         (carry != 0));
1956     if (((int_mant & (1<<31)) == 0) && (int_exp == 255)) {
1957         fp_exp = 255;
1958         fp_frac = extract32(int_mant, 8, 23);
1959     } else if ((int_mant & (1<<31)) && (int_exp >= 127)) {
1960         fp_exp  = 255;
1961         fp_frac = 0;
1962     } else if ((int_mant & (1<<31)) && (int_exp <= -128)) {
1963         fp_exp  = 0;
1964         fp_frac = 0;
1965     } else if (int_mant == 0) {
1966         fp_exp  = 0;
1967         fp_frac = 0;
1968     } else {
1969         if (((int_mant & (1 << 31)) == 0)) {
1970             temp_exp = 0;
1971         } else {
1972             temp_exp = int_exp + 128;
1973         }
1974         fp_exp_frac = (((temp_exp & 0xff) << 23) |
1975                       extract32(int_mant, 8, 23))
1976                       + flag_rnd;
1977         fp_exp  = extract32(fp_exp_frac, 23, 8);
1978         fp_frac = extract32(fp_exp_frac, 0, 23);
1979     }
1980     ret = r2 & (1 << 31);
1981     ret = ret + (fp_exp << 23);
1982     ret = ret + (fp_frac & 0x7fffff);
1983 
1984     return ret;
1985 }
1986 
helper_unpack(target_ulong arg1)1987 uint64_t helper_unpack(target_ulong arg1)
1988 {
1989     int32_t fp_exp  = extract32(arg1, 23, 8);
1990     int32_t fp_frac = extract32(arg1, 0, 23);
1991     uint64_t ret;
1992     int32_t int_exp, int_mant;
1993 
1994     if (fp_exp == 255) {
1995         int_exp = 255;
1996         int_mant = (fp_frac << 7);
1997     } else if ((fp_exp == 0) && (fp_frac == 0)) {
1998         int_exp  = -127;
1999         int_mant = 0;
2000     } else if ((fp_exp == 0) && (fp_frac != 0)) {
2001         int_exp  = -126;
2002         int_mant = (fp_frac << 7);
2003     } else {
2004         int_exp  = fp_exp - 127;
2005         int_mant = (fp_frac << 7);
2006         int_mant |= (1 << 30);
2007     }
2008     ret = int_exp;
2009     ret = ret << 32;
2010     ret |= int_mant;
2011 
2012     return ret;
2013 }
2014 
helper_dvinit_b_13(CPUTriCoreState * env,uint32_t r1,uint32_t r2)2015 uint64_t helper_dvinit_b_13(CPUTriCoreState *env, uint32_t r1, uint32_t r2)
2016 {
2017     uint64_t ret;
2018     int32_t abs_sig_dividend, abs_divisor;
2019 
2020     ret = sextract32(r1, 0, 32);
2021     ret = ret << 24;
2022     if (!((r1 & 0x80000000) == (r2 & 0x80000000))) {
2023         ret |= 0xffffff;
2024     }
2025 
2026     abs_sig_dividend = abs((int32_t)r1) >> 8;
2027     abs_divisor = abs((int32_t)r2);
2028     /* calc overflow
2029        ofv if (a/b >= 255) <=> (a/255 >= b) */
2030     env->PSW_USB_V = (abs_sig_dividend >= abs_divisor) << 31;
2031     env->PSW_USB_V = env->PSW_USB_V << 31;
2032     env->PSW_USB_SV |= env->PSW_USB_V;
2033     env->PSW_USB_AV = 0;
2034 
2035     return ret;
2036 }
2037 
helper_dvinit_b_131(CPUTriCoreState * env,uint32_t r1,uint32_t r2)2038 uint64_t helper_dvinit_b_131(CPUTriCoreState *env, uint32_t r1, uint32_t r2)
2039 {
2040     uint64_t ret = sextract32(r1, 0, 32);
2041 
2042     ret = ret << 24;
2043     if (!((r1 & 0x80000000) == (r2 & 0x80000000))) {
2044         ret |= 0xffffff;
2045     }
2046     /* calc overflow */
2047     env->PSW_USB_V = ((r2 == 0) || ((r2 == 0xffffffff) && (r1 == 0xffffff80)));
2048     env->PSW_USB_V = env->PSW_USB_V << 31;
2049     env->PSW_USB_SV |= env->PSW_USB_V;
2050     env->PSW_USB_AV = 0;
2051 
2052     return ret;
2053 }
2054 
helper_dvinit_h_13(CPUTriCoreState * env,uint32_t r1,uint32_t r2)2055 uint64_t helper_dvinit_h_13(CPUTriCoreState *env, uint32_t r1, uint32_t r2)
2056 {
2057     uint64_t ret;
2058     int32_t abs_sig_dividend, abs_divisor;
2059 
2060     ret = sextract32(r1, 0, 32);
2061     ret = ret << 16;
2062     if (!((r1 & 0x80000000) == (r2 & 0x80000000))) {
2063         ret |= 0xffff;
2064     }
2065 
2066     abs_sig_dividend = abs((int32_t)r1) >> 16;
2067     abs_divisor = abs((int32_t)r2);
2068     /* calc overflow
2069        ofv if (a/b >= 0xffff) <=> (a/0xffff >= b) */
2070     env->PSW_USB_V = (abs_sig_dividend >= abs_divisor) << 31;
2071     env->PSW_USB_V = env->PSW_USB_V << 31;
2072     env->PSW_USB_SV |= env->PSW_USB_V;
2073     env->PSW_USB_AV = 0;
2074 
2075     return ret;
2076 }
2077 
helper_dvinit_h_131(CPUTriCoreState * env,uint32_t r1,uint32_t r2)2078 uint64_t helper_dvinit_h_131(CPUTriCoreState *env, uint32_t r1, uint32_t r2)
2079 {
2080     uint64_t ret = sextract32(r1, 0, 32);
2081 
2082     ret = ret << 16;
2083     if (!((r1 & 0x80000000) == (r2 & 0x80000000))) {
2084         ret |= 0xffff;
2085     }
2086     /* calc overflow */
2087     env->PSW_USB_V = ((r2 == 0) || ((r2 == 0xffffffff) && (r1 == 0xffff8000)));
2088     env->PSW_USB_V = env->PSW_USB_V << 31;
2089     env->PSW_USB_SV |= env->PSW_USB_V;
2090     env->PSW_USB_AV = 0;
2091 
2092     return ret;
2093 }
2094 
helper_dvadj(uint64_t r1,uint32_t r2)2095 uint64_t helper_dvadj(uint64_t r1, uint32_t r2)
2096 {
2097     int32_t x_sign = (r1 >> 63);
2098     int32_t q_sign = x_sign ^ (r2 >> 31);
2099     int32_t eq_pos = x_sign & ((r1 >> 32) == r2);
2100     int32_t eq_neg = x_sign & ((r1 >> 32) == -r2);
2101     uint32_t quotient;
2102     uint64_t remainder;
2103 
2104     if ((q_sign & ~eq_neg) | eq_pos) {
2105         quotient = (r1 + 1) & 0xffffffff;
2106     } else {
2107         quotient = r1 & 0xffffffff;
2108     }
2109 
2110     if (eq_pos | eq_neg) {
2111         remainder = 0;
2112     } else {
2113         remainder = (r1 & 0xffffffff00000000ull);
2114     }
2115     return remainder | quotient;
2116 }
2117 
helper_dvstep(uint64_t r1,uint32_t r2)2118 uint64_t helper_dvstep(uint64_t r1, uint32_t r2)
2119 {
2120     int32_t dividend_sign = extract64(r1, 63, 1);
2121     int32_t divisor_sign = extract32(r2, 31, 1);
2122     int32_t quotient_sign = (dividend_sign != divisor_sign);
2123     int32_t addend, dividend_quotient, remainder;
2124     int32_t i, temp;
2125 
2126     if (quotient_sign) {
2127         addend = r2;
2128     } else {
2129         addend = -r2;
2130     }
2131     dividend_quotient = (int32_t)r1;
2132     remainder = (int32_t)(r1 >> 32);
2133 
2134     for (i = 0; i < 8; i++) {
2135         remainder = (remainder << 1) | extract32(dividend_quotient, 31, 1);
2136         dividend_quotient <<= 1;
2137         temp = remainder + addend;
2138         if ((temp < 0) == dividend_sign) {
2139             remainder = temp;
2140         }
2141         if (((temp < 0) == dividend_sign)) {
2142             dividend_quotient = dividend_quotient | !quotient_sign;
2143         } else {
2144             dividend_quotient = dividend_quotient | quotient_sign;
2145         }
2146     }
2147     return ((uint64_t)remainder << 32) | (uint32_t)dividend_quotient;
2148 }
2149 
helper_dvstep_u(uint64_t r1,uint32_t r2)2150 uint64_t helper_dvstep_u(uint64_t r1, uint32_t r2)
2151 {
2152     int32_t dividend_quotient = extract64(r1, 0, 32);
2153     int64_t remainder = extract64(r1, 32, 32);
2154     int32_t i;
2155     int64_t temp;
2156     for (i = 0; i < 8; i++) {
2157         remainder = (remainder << 1) | extract32(dividend_quotient, 31, 1);
2158         dividend_quotient <<= 1;
2159         temp = (remainder & 0xffffffff) - r2;
2160         if (temp >= 0) {
2161             remainder = temp;
2162         }
2163         dividend_quotient = dividend_quotient | !(temp < 0);
2164     }
2165     return ((uint64_t)remainder << 32) | (uint32_t)dividend_quotient;
2166 }
2167 
helper_divide(CPUTriCoreState * env,uint32_t r1,uint32_t r2)2168 uint64_t helper_divide(CPUTriCoreState *env, uint32_t r1, uint32_t r2)
2169 {
2170     int32_t quotient, remainder;
2171     int32_t dividend = (int32_t)r1;
2172     int32_t divisor = (int32_t)r2;
2173 
2174     if (divisor == 0) {
2175         if (dividend >= 0) {
2176             quotient = 0x7fffffff;
2177             remainder = 0;
2178         } else {
2179             quotient = 0x80000000;
2180             remainder = 0;
2181         }
2182         env->PSW_USB_V = (1 << 31);
2183     } else if ((divisor == 0xffffffff) && (dividend == 0x80000000)) {
2184         quotient = 0x7fffffff;
2185         remainder = 0;
2186         env->PSW_USB_V = (1 << 31);
2187     } else {
2188         remainder = dividend % divisor;
2189         quotient = (dividend - remainder)/divisor;
2190         env->PSW_USB_V = 0;
2191     }
2192     env->PSW_USB_SV |= env->PSW_USB_V;
2193     env->PSW_USB_AV = 0;
2194     return ((uint64_t)remainder << 32) | (uint32_t)quotient;
2195 }
2196 
helper_divide_u(CPUTriCoreState * env,uint32_t r1,uint32_t r2)2197 uint64_t helper_divide_u(CPUTriCoreState *env, uint32_t r1, uint32_t r2)
2198 {
2199     uint32_t quotient, remainder;
2200     uint32_t dividend = r1;
2201     uint32_t divisor = r2;
2202 
2203     if (divisor == 0) {
2204         quotient = 0xffffffff;
2205         remainder = 0;
2206         env->PSW_USB_V = (1 << 31);
2207     } else {
2208         remainder = dividend % divisor;
2209         quotient = (dividend - remainder)/divisor;
2210         env->PSW_USB_V = 0;
2211     }
2212     env->PSW_USB_SV |= env->PSW_USB_V;
2213     env->PSW_USB_AV = 0;
2214     return ((uint64_t)remainder << 32) | quotient;
2215 }
2216 
helper_mul_h(uint32_t arg00,uint32_t arg01,uint32_t arg10,uint32_t arg11,uint32_t n)2217 uint64_t helper_mul_h(uint32_t arg00, uint32_t arg01,
2218                       uint32_t arg10, uint32_t arg11, uint32_t n)
2219 {
2220     uint32_t result0, result1;
2221 
2222     int32_t sc1 = ((arg00 & 0xffff) == 0x8000) &&
2223                   ((arg10 & 0xffff) == 0x8000) && (n == 1);
2224     int32_t sc0 = ((arg01 & 0xffff) == 0x8000) &&
2225                   ((arg11 & 0xffff) == 0x8000) && (n == 1);
2226     if (sc1) {
2227         result1 = 0x7fffffff;
2228     } else {
2229         result1 = (((uint32_t)(arg00 * arg10)) << n);
2230     }
2231     if (sc0) {
2232         result0 = 0x7fffffff;
2233     } else {
2234         result0 = (((uint32_t)(arg01 * arg11)) << n);
2235     }
2236     return (((uint64_t)result1 << 32)) | result0;
2237 }
2238 
helper_mulm_h(uint32_t arg00,uint32_t arg01,uint32_t arg10,uint32_t arg11,uint32_t n)2239 uint64_t helper_mulm_h(uint32_t arg00, uint32_t arg01,
2240                        uint32_t arg10, uint32_t arg11, uint32_t n)
2241 {
2242     uint64_t ret;
2243     int64_t result0, result1;
2244 
2245     int32_t sc1 = ((arg00 & 0xffff) == 0x8000) &&
2246                   ((arg10 & 0xffff) == 0x8000) && (n == 1);
2247     int32_t sc0 = ((arg01 & 0xffff) == 0x8000) &&
2248                   ((arg11 & 0xffff) == 0x8000) && (n == 1);
2249 
2250     if (sc1) {
2251         result1 = 0x7fffffff;
2252     } else {
2253         result1 = (((int32_t)arg00 * (int32_t)arg10) << n);
2254     }
2255     if (sc0) {
2256         result0 = 0x7fffffff;
2257     } else {
2258         result0 = (((int32_t)arg01 * (int32_t)arg11) << n);
2259     }
2260     ret = (result1 + result0);
2261     ret = ret << 16;
2262     return ret;
2263 }
helper_mulr_h(uint32_t arg00,uint32_t arg01,uint32_t arg10,uint32_t arg11,uint32_t n)2264 uint32_t helper_mulr_h(uint32_t arg00, uint32_t arg01,
2265                        uint32_t arg10, uint32_t arg11, uint32_t n)
2266 {
2267     uint32_t result0, result1;
2268 
2269     int32_t sc1 = ((arg00 & 0xffff) == 0x8000) &&
2270                   ((arg10 & 0xffff) == 0x8000) && (n == 1);
2271     int32_t sc0 = ((arg01 & 0xffff) == 0x8000) &&
2272                   ((arg11 & 0xffff) == 0x8000) && (n == 1);
2273 
2274     if (sc1) {
2275         result1 = 0x7fffffff;
2276     } else {
2277         result1 = ((arg00 * arg10) << n) + 0x8000;
2278     }
2279     if (sc0) {
2280         result0 = 0x7fffffff;
2281     } else {
2282         result0 = ((arg01 * arg11) << n) + 0x8000;
2283     }
2284     return (result1 & 0xffff0000) | (result0 >> 16);
2285 }
2286 
helper_crc32b(uint32_t arg0,uint32_t arg1)2287 uint32_t helper_crc32b(uint32_t arg0, uint32_t arg1)
2288 {
2289     uint8_t buf[1] = { arg0 & 0xff };
2290 
2291     return crc32(arg1, buf, 1);
2292 }
2293 
2294 
helper_crc32_be(uint32_t arg0,uint32_t arg1)2295 uint32_t helper_crc32_be(uint32_t arg0, uint32_t arg1)
2296 {
2297     uint8_t buf[4];
2298     stl_be_p(buf, arg0);
2299 
2300     return crc32(arg1, buf, 4);
2301 }
2302 
helper_crc32_le(uint32_t arg0,uint32_t arg1)2303 uint32_t helper_crc32_le(uint32_t arg0, uint32_t arg1)
2304 {
2305     uint8_t buf[4];
2306     stl_le_p(buf, arg0);
2307 
2308     return crc32(arg1, buf, 4);
2309 }
2310 
crc_div(uint32_t crc_in,uint32_t data,uint32_t gen,uint32_t n,uint32_t m)2311 static uint32_t crc_div(uint32_t crc_in, uint32_t data, uint32_t gen,
2312                         uint32_t n, uint32_t m)
2313 {
2314     uint32_t i;
2315 
2316     data = data << n;
2317     for (i = 0; i < m; i++) {
2318         if (crc_in & (1u << (n - 1))) {
2319             crc_in <<= 1;
2320             if (data & (1u << (m - 1))) {
2321                 crc_in++;
2322             }
2323             crc_in ^= gen;
2324         } else {
2325             crc_in <<= 1;
2326             if (data & (1u << (m - 1))) {
2327                 crc_in++;
2328             }
2329         }
2330         data <<= 1;
2331     }
2332 
2333     return crc_in;
2334 }
2335 
helper_crcn(uint32_t arg0,uint32_t arg1,uint32_t arg2)2336 uint32_t helper_crcn(uint32_t arg0, uint32_t arg1, uint32_t arg2)
2337 {
2338     uint32_t crc_out, crc_in;
2339     uint32_t n = extract32(arg0, 12, 4) + 1;
2340     uint32_t gen = extract32(arg0, 16, n);
2341     uint32_t inv = extract32(arg0, 9, 1);
2342     uint32_t le = extract32(arg0, 8, 1);
2343     uint32_t m = extract32(arg0, 0, 3) + 1;
2344     uint32_t data = extract32(arg1, 0, m);
2345     uint32_t seed = extract32(arg2, 0, n);
2346 
2347     if (le == 1) {
2348         if (m == 0) {
2349             data = 0;
2350         } else {
2351             data = revbit32(data) >> (32 - m);
2352         }
2353     }
2354 
2355     if (inv == 1) {
2356         seed = ~seed;
2357     }
2358 
2359     if (m > n) {
2360         crc_in = (data >> (m - n)) ^ seed;
2361     } else {
2362         crc_in = (data << (n - m)) ^ seed;
2363     }
2364 
2365     crc_out = crc_div(crc_in, data, gen, n, m);
2366 
2367     if (inv) {
2368         crc_out = ~crc_out;
2369     }
2370 
2371     return extract32(crc_out, 0, n);
2372 }
2373 
helper_shuffle(uint32_t arg0,uint32_t arg1)2374 uint32_t helper_shuffle(uint32_t arg0, uint32_t arg1)
2375 {
2376     uint32_t resb;
2377     uint32_t byte_select;
2378     uint32_t res = 0;
2379 
2380     byte_select = arg1 & 0x3;
2381     resb = extract32(arg0, byte_select * 8, 8);
2382     res |= resb << 0;
2383 
2384     byte_select = (arg1 >> 2) & 0x3;
2385     resb = extract32(arg0, byte_select * 8, 8);
2386     res |= resb << 8;
2387 
2388     byte_select = (arg1 >> 4) & 0x3;
2389     resb = extract32(arg0, byte_select * 8, 8);
2390     res |= resb << 16;
2391 
2392     byte_select = (arg1 >> 6) & 0x3;
2393     resb = extract32(arg0, byte_select * 8, 8);
2394     res |= resb << 24;
2395 
2396     if (arg1 & 0x100) {
2397         /* Assign the correct nibble position.  */
2398         res = ((res & 0xf0f0f0f0) >> 4)
2399           | ((res & 0x0f0f0f0f) << 4);
2400         /* Assign the correct bit position.  */
2401         res = ((res & 0x88888888) >> 3)
2402           | ((res & 0x44444444) >> 1)
2403           | ((res & 0x22222222) << 1)
2404           | ((res & 0x11111111) << 3);
2405     }
2406 
2407     return res;
2408 }
2409 
2410 /* context save area (CSA) related helpers */
2411 
cdc_increment(target_ulong * psw)2412 static int cdc_increment(target_ulong *psw)
2413 {
2414     if ((*psw & MASK_PSW_CDC) == 0x7f) {
2415         return 0;
2416     }
2417 
2418     (*psw)++;
2419     /* check for overflow */
2420     int lo = clo32((*psw & MASK_PSW_CDC) << (32 - 7));
2421     int mask = (1u << (7 - lo)) - 1;
2422     int count = *psw & mask;
2423     if (count == 0) {
2424         (*psw)--;
2425         return 1;
2426     }
2427     return 0;
2428 }
2429 
cdc_decrement(target_ulong * psw)2430 static int cdc_decrement(target_ulong *psw)
2431 {
2432     if ((*psw & MASK_PSW_CDC) == 0x7f) {
2433         return 0;
2434     }
2435     /* check for underflow */
2436     int lo = clo32((*psw & MASK_PSW_CDC) << (32 - 7));
2437     int mask = (1u << (7 - lo)) - 1;
2438     int count = *psw & mask;
2439     if (count == 0) {
2440         return 1;
2441     }
2442     (*psw)--;
2443     return 0;
2444 }
2445 
cdc_zero(target_ulong * psw)2446 static bool cdc_zero(target_ulong *psw)
2447 {
2448     int cdc = *psw & MASK_PSW_CDC;
2449     /* Returns TRUE if PSW.CDC.COUNT == 0 or if PSW.CDC ==
2450        7'b1111111, otherwise returns FALSE. */
2451     if (cdc == 0x7f) {
2452         return true;
2453     }
2454     /* find CDC.COUNT */
2455     int lo = clo32((*psw & MASK_PSW_CDC) << (32 - 7));
2456     int mask = (1u << (7 - lo)) - 1;
2457     int count = *psw & mask;
2458     return count == 0;
2459 }
2460 
save_context_upper(CPUTriCoreState * env,target_ulong ea)2461 static void save_context_upper(CPUTriCoreState *env, target_ulong ea)
2462 {
2463     cpu_stl_data(env, ea, env->PCXI);
2464     cpu_stl_data(env, ea+4, psw_read(env));
2465     cpu_stl_data(env, ea+8, env->gpr_a[10]);
2466     cpu_stl_data(env, ea+12, env->gpr_a[11]);
2467     cpu_stl_data(env, ea+16, env->gpr_d[8]);
2468     cpu_stl_data(env, ea+20, env->gpr_d[9]);
2469     cpu_stl_data(env, ea+24, env->gpr_d[10]);
2470     cpu_stl_data(env, ea+28, env->gpr_d[11]);
2471     cpu_stl_data(env, ea+32, env->gpr_a[12]);
2472     cpu_stl_data(env, ea+36, env->gpr_a[13]);
2473     cpu_stl_data(env, ea+40, env->gpr_a[14]);
2474     cpu_stl_data(env, ea+44, env->gpr_a[15]);
2475     cpu_stl_data(env, ea+48, env->gpr_d[12]);
2476     cpu_stl_data(env, ea+52, env->gpr_d[13]);
2477     cpu_stl_data(env, ea+56, env->gpr_d[14]);
2478     cpu_stl_data(env, ea+60, env->gpr_d[15]);
2479 }
2480 
save_context_lower(CPUTriCoreState * env,target_ulong ea)2481 static void save_context_lower(CPUTriCoreState *env, target_ulong ea)
2482 {
2483     cpu_stl_data(env, ea, env->PCXI);
2484     cpu_stl_data(env, ea+4, env->gpr_a[11]);
2485     cpu_stl_data(env, ea+8, env->gpr_a[2]);
2486     cpu_stl_data(env, ea+12, env->gpr_a[3]);
2487     cpu_stl_data(env, ea+16, env->gpr_d[0]);
2488     cpu_stl_data(env, ea+20, env->gpr_d[1]);
2489     cpu_stl_data(env, ea+24, env->gpr_d[2]);
2490     cpu_stl_data(env, ea+28, env->gpr_d[3]);
2491     cpu_stl_data(env, ea+32, env->gpr_a[4]);
2492     cpu_stl_data(env, ea+36, env->gpr_a[5]);
2493     cpu_stl_data(env, ea+40, env->gpr_a[6]);
2494     cpu_stl_data(env, ea+44, env->gpr_a[7]);
2495     cpu_stl_data(env, ea+48, env->gpr_d[4]);
2496     cpu_stl_data(env, ea+52, env->gpr_d[5]);
2497     cpu_stl_data(env, ea+56, env->gpr_d[6]);
2498     cpu_stl_data(env, ea+60, env->gpr_d[7]);
2499 }
2500 
restore_context_upper(CPUTriCoreState * env,target_ulong ea,target_ulong * new_PCXI,target_ulong * new_PSW)2501 static void restore_context_upper(CPUTriCoreState *env, target_ulong ea,
2502                                   target_ulong *new_PCXI, target_ulong *new_PSW)
2503 {
2504     *new_PCXI = cpu_ldl_data(env, ea);
2505     *new_PSW = cpu_ldl_data(env, ea+4);
2506     env->gpr_a[10] = cpu_ldl_data(env, ea+8);
2507     env->gpr_a[11] = cpu_ldl_data(env, ea+12);
2508     env->gpr_d[8]  = cpu_ldl_data(env, ea+16);
2509     env->gpr_d[9]  = cpu_ldl_data(env, ea+20);
2510     env->gpr_d[10] = cpu_ldl_data(env, ea+24);
2511     env->gpr_d[11] = cpu_ldl_data(env, ea+28);
2512     env->gpr_a[12] = cpu_ldl_data(env, ea+32);
2513     env->gpr_a[13] = cpu_ldl_data(env, ea+36);
2514     env->gpr_a[14] = cpu_ldl_data(env, ea+40);
2515     env->gpr_a[15] = cpu_ldl_data(env, ea+44);
2516     env->gpr_d[12] = cpu_ldl_data(env, ea+48);
2517     env->gpr_d[13] = cpu_ldl_data(env, ea+52);
2518     env->gpr_d[14] = cpu_ldl_data(env, ea+56);
2519     env->gpr_d[15] = cpu_ldl_data(env, ea+60);
2520 }
2521 
restore_context_lower(CPUTriCoreState * env,target_ulong ea,target_ulong * ra,target_ulong * pcxi)2522 static void restore_context_lower(CPUTriCoreState *env, target_ulong ea,
2523                                   target_ulong *ra, target_ulong *pcxi)
2524 {
2525     *pcxi = cpu_ldl_data(env, ea);
2526     *ra = cpu_ldl_data(env, ea+4);
2527     env->gpr_a[2] = cpu_ldl_data(env, ea+8);
2528     env->gpr_a[3] = cpu_ldl_data(env, ea+12);
2529     env->gpr_d[0] = cpu_ldl_data(env, ea+16);
2530     env->gpr_d[1] = cpu_ldl_data(env, ea+20);
2531     env->gpr_d[2] = cpu_ldl_data(env, ea+24);
2532     env->gpr_d[3] = cpu_ldl_data(env, ea+28);
2533     env->gpr_a[4] = cpu_ldl_data(env, ea+32);
2534     env->gpr_a[5] = cpu_ldl_data(env, ea+36);
2535     env->gpr_a[6] = cpu_ldl_data(env, ea+40);
2536     env->gpr_a[7] = cpu_ldl_data(env, ea+44);
2537     env->gpr_d[4] = cpu_ldl_data(env, ea+48);
2538     env->gpr_d[5] = cpu_ldl_data(env, ea+52);
2539     env->gpr_d[6] = cpu_ldl_data(env, ea+56);
2540     env->gpr_d[7] = cpu_ldl_data(env, ea+60);
2541 }
2542 
helper_call(CPUTriCoreState * env,uint32_t next_pc)2543 void helper_call(CPUTriCoreState *env, uint32_t next_pc)
2544 {
2545     target_ulong tmp_FCX;
2546     target_ulong ea;
2547     target_ulong new_FCX;
2548     target_ulong psw;
2549 
2550     psw = psw_read(env);
2551     /* if (FCX == 0) trap(FCU); */
2552     if (env->FCX == 0) {
2553         /* FCU trap */
2554         raise_exception_sync_helper(env, TRAPC_CTX_MNG, TIN3_FCU, GETPC());
2555     }
2556     /* if (PSW.CDE) then if (cdc_increment()) then trap(CDO); */
2557     if (psw & MASK_PSW_CDE) {
2558         if (cdc_increment(&psw)) {
2559             /* CDO trap */
2560             raise_exception_sync_helper(env, TRAPC_CTX_MNG, TIN3_CDO, GETPC());
2561         }
2562     }
2563     /* PSW.CDE = 1;*/
2564     psw |= MASK_PSW_CDE;
2565     /*
2566      * we need to save PSW.CDE and not PSW.CDC into the CSAs. psw already
2567      * contains the CDC from cdc_increment(), so we cannot call psw_write()
2568      * here.
2569      */
2570     env->PSW |= MASK_PSW_CDE;
2571 
2572     /* tmp_FCX = FCX; */
2573     tmp_FCX = env->FCX;
2574     /* EA = {FCX.FCXS, 6'b0, FCX.FCXO, 6'b0}; */
2575     ea = ((env->FCX & MASK_FCX_FCXS) << 12) +
2576          ((env->FCX & MASK_FCX_FCXO) << 6);
2577     /* new_FCX = M(EA, word); */
2578     new_FCX = cpu_ldl_data(env, ea);
2579     /* M(EA, 16 * word) = {PCXI, PSW, A[10], A[11], D[8], D[9], D[10], D[11],
2580                            A[12], A[13], A[14], A[15], D[12], D[13], D[14],
2581                            D[15]}; */
2582     save_context_upper(env, ea);
2583 
2584     /* PCXI.PCPN = ICR.CCPN; */
2585     pcxi_set_pcpn(env, icr_get_ccpn(env));
2586     /* PCXI.PIE = ICR.IE; */
2587     pcxi_set_pie(env, icr_get_ie(env));
2588     /* PCXI.UL = 1; */
2589     pcxi_set_ul(env, 1);
2590 
2591     /* PCXI[19: 0] = FCX[19: 0]; */
2592     env->PCXI = (env->PCXI & 0xfff00000) + (env->FCX & 0xfffff);
2593     /* FCX[19: 0] = new_FCX[19: 0]; */
2594     env->FCX = (env->FCX & 0xfff00000) + (new_FCX & 0xfffff);
2595     /* A[11] = next_pc[31: 0]; */
2596     env->gpr_a[11] = next_pc;
2597 
2598     /* if (tmp_FCX == LCX) trap(FCD);*/
2599     if (tmp_FCX == env->LCX) {
2600         /* FCD trap */
2601         raise_exception_sync_helper(env, TRAPC_CTX_MNG, TIN3_FCD, GETPC());
2602     }
2603     psw_write(env, psw);
2604 }
2605 
helper_ret(CPUTriCoreState * env)2606 void helper_ret(CPUTriCoreState *env)
2607 {
2608     target_ulong ea;
2609     target_ulong new_PCXI;
2610     target_ulong new_PSW, psw;
2611 
2612     psw = psw_read(env);
2613      /* if (PSW.CDE) then if (cdc_decrement()) then trap(CDU);*/
2614     if (psw & MASK_PSW_CDE) {
2615         if (cdc_decrement(&psw)) {
2616             /* CDU trap */
2617             psw_write(env, psw);
2618             raise_exception_sync_helper(env, TRAPC_CTX_MNG, TIN3_CDU, GETPC());
2619         }
2620     }
2621     /*   if (PCXI[19: 0] == 0) then trap(CSU); */
2622     if ((env->PCXI & 0xfffff) == 0) {
2623         /* CSU trap */
2624         psw_write(env, psw);
2625         raise_exception_sync_helper(env, TRAPC_CTX_MNG, TIN3_CSU, GETPC());
2626     }
2627     /* if (PCXI.UL == 0) then trap(CTYP); */
2628     if (pcxi_get_ul(env) == 0) {
2629         /* CTYP trap */
2630         cdc_increment(&psw); /* restore to the start of helper */
2631         psw_write(env, psw);
2632         raise_exception_sync_helper(env, TRAPC_CTX_MNG, TIN3_CTYP, GETPC());
2633     }
2634     /* PC = {A11 [31: 1], 1’b0}; */
2635     env->PC = env->gpr_a[11] & 0xfffffffe;
2636 
2637     /* EA = {PCXI.PCXS, 6'b0, PCXI.PCXO, 6'b0}; */
2638     ea = (pcxi_get_pcxs(env) << 28) |
2639          (pcxi_get_pcxo(env) << 6);
2640     /* {new_PCXI, new_PSW, A[10], A[11], D[8], D[9], D[10], D[11], A[12],
2641         A[13], A[14], A[15], D[12], D[13], D[14], D[15]} = M(EA, 16 * word); */
2642     restore_context_upper(env, ea, &new_PCXI, &new_PSW);
2643     /* M(EA, word) = FCX; */
2644     cpu_stl_data(env, ea, env->FCX);
2645     /* FCX[19: 0] = PCXI[19: 0]; */
2646     env->FCX = (env->FCX & 0xfff00000) + (env->PCXI & 0x000fffff);
2647     /* PCXI = new_PCXI; */
2648     env->PCXI = new_PCXI;
2649 
2650     if (tricore_has_feature(env, TRICORE_FEATURE_131)) {
2651         /* PSW = {new_PSW[31:26], PSW[25:24], new_PSW[23:0]}; */
2652         psw_write(env, (new_PSW & ~(0x3000000)) + (psw & (0x3000000)));
2653     } else { /* TRICORE_FEATURE_13 only */
2654         /* PSW = new_PSW */
2655         psw_write(env, new_PSW);
2656     }
2657 }
2658 
helper_bisr(CPUTriCoreState * env,uint32_t const9)2659 void helper_bisr(CPUTriCoreState *env, uint32_t const9)
2660 {
2661     target_ulong tmp_FCX;
2662     target_ulong ea;
2663     target_ulong new_FCX;
2664 
2665     if (env->FCX == 0) {
2666         /* FCU trap */
2667        raise_exception_sync_helper(env, TRAPC_CTX_MNG, TIN3_FCU, GETPC());
2668     }
2669 
2670     tmp_FCX = env->FCX;
2671     ea = ((env->FCX & 0xf0000) << 12) + ((env->FCX & 0xffff) << 6);
2672 
2673     /* new_FCX = M(EA, word); */
2674     new_FCX = cpu_ldl_data(env, ea);
2675     /* M(EA, 16 * word) = {PCXI, A[11], A[2], A[3], D[0], D[1], D[2], D[3], A[4]
2676                            , A[5], A[6], A[7], D[4], D[5], D[6], D[7]}; */
2677     save_context_lower(env, ea);
2678 
2679 
2680     /* PCXI.PCPN = ICR.CCPN */
2681     pcxi_set_pcpn(env, icr_get_ccpn(env));
2682     /* PCXI.PIE  = ICR.IE */
2683     pcxi_set_pie(env, icr_get_ie(env));
2684     /* PCXI.UL = 0 */
2685     pcxi_set_ul(env, 0);
2686 
2687     /* PCXI[19: 0] = FCX[19: 0] */
2688     env->PCXI = (env->PCXI & 0xfff00000) + (env->FCX & 0xfffff);
2689     /* FXC[19: 0] = new_FCX[19: 0] */
2690     env->FCX = (env->FCX & 0xfff00000) + (new_FCX & 0xfffff);
2691 
2692     /* ICR.IE = 1 */
2693     icr_set_ie(env, 1);
2694 
2695     icr_set_ccpn(env, const9);
2696 
2697     if (tmp_FCX == env->LCX) {
2698         /* FCD trap */
2699         raise_exception_sync_helper(env, TRAPC_CTX_MNG, TIN3_FCD, GETPC());
2700     }
2701 }
2702 
helper_rfe(CPUTriCoreState * env)2703 void helper_rfe(CPUTriCoreState *env)
2704 {
2705     target_ulong ea;
2706     target_ulong new_PCXI;
2707     target_ulong new_PSW;
2708     /* if (PCXI[19: 0] == 0) then trap(CSU); */
2709     if ((env->PCXI & 0xfffff) == 0) {
2710         /* raise csu trap */
2711         raise_exception_sync_helper(env, TRAPC_CTX_MNG, TIN3_CSU, GETPC());
2712     }
2713     /* if (PCXI.UL == 0) then trap(CTYP); */
2714     if (pcxi_get_ul(env) == 0) {
2715         /* raise CTYP trap */
2716         raise_exception_sync_helper(env, TRAPC_CTX_MNG, TIN3_CTYP, GETPC());
2717     }
2718     /* if (!cdc_zero() AND PSW.CDE) then trap(NEST); */
2719     if (!cdc_zero(&(env->PSW)) && (env->PSW & MASK_PSW_CDE)) {
2720         /* raise NEST trap */
2721         raise_exception_sync_helper(env, TRAPC_CTX_MNG, TIN3_NEST, GETPC());
2722     }
2723     env->PC = env->gpr_a[11] & ~0x1;
2724     /* ICR.IE = PCXI.PIE; */
2725     icr_set_ie(env, pcxi_get_pie(env));
2726 
2727     /* ICR.CCPN = PCXI.PCPN; */
2728     icr_set_ccpn(env, pcxi_get_pcpn(env));
2729 
2730     /*EA = {PCXI.PCXS, 6'b0, PCXI.PCXO, 6'b0};*/
2731     ea = (pcxi_get_pcxs(env) << 28) |
2732          (pcxi_get_pcxo(env) << 6);
2733 
2734     /*{new_PCXI, PSW, A[10], A[11], D[8], D[9], D[10], D[11], A[12],
2735       A[13], A[14], A[15], D[12], D[13], D[14], D[15]} = M(EA, 16 * word); */
2736     restore_context_upper(env, ea, &new_PCXI, &new_PSW);
2737     /* M(EA, word) = FCX;*/
2738     cpu_stl_data(env, ea, env->FCX);
2739     /* FCX[19: 0] = PCXI[19: 0]; */
2740     env->FCX = (env->FCX & 0xfff00000) + (env->PCXI & 0x000fffff);
2741     /* PCXI = new_PCXI; */
2742     env->PCXI = new_PCXI;
2743     /* write psw */
2744     psw_write(env, new_PSW);
2745 }
2746 
helper_rfm(CPUTriCoreState * env)2747 void helper_rfm(CPUTriCoreState *env)
2748 {
2749     env->PC = (env->gpr_a[11] & ~0x1);
2750     /* ICR.IE = PCXI.PIE; */
2751     icr_set_ie(env, pcxi_get_pie(env));
2752     /* ICR.CCPN = PCXI.PCPN; */
2753     icr_set_ccpn(env, pcxi_get_pcpn(env));
2754 
2755     /* {PCXI, PSW, A[10], A[11]} = M(DCX, 4 * word); */
2756     env->PCXI = cpu_ldl_data(env, env->DCX);
2757     psw_write(env, cpu_ldl_data(env, env->DCX+4));
2758     env->gpr_a[10] = cpu_ldl_data(env, env->DCX+8);
2759     env->gpr_a[11] = cpu_ldl_data(env, env->DCX+12);
2760 
2761     if (tricore_has_feature(env, TRICORE_FEATURE_131)) {
2762         env->DBGTCR = 0;
2763     }
2764 }
2765 
helper_ldlcx(CPUTriCoreState * env,target_ulong ea)2766 void helper_ldlcx(CPUTriCoreState *env, target_ulong ea)
2767 {
2768     uint32_t dummy;
2769     /* insn doesn't load PCXI and RA */
2770     restore_context_lower(env, ea, &dummy, &dummy);
2771 }
2772 
helper_lducx(CPUTriCoreState * env,target_ulong ea)2773 void helper_lducx(CPUTriCoreState *env, target_ulong ea)
2774 {
2775     uint32_t dummy;
2776     /* insn doesn't load PCXI and PSW */
2777     restore_context_upper(env, ea, &dummy, &dummy);
2778 }
2779 
helper_stlcx(CPUTriCoreState * env,target_ulong ea)2780 void helper_stlcx(CPUTriCoreState *env, target_ulong ea)
2781 {
2782     save_context_lower(env, ea);
2783 }
2784 
helper_stucx(CPUTriCoreState * env,target_ulong ea)2785 void helper_stucx(CPUTriCoreState *env, target_ulong ea)
2786 {
2787     save_context_upper(env, ea);
2788 }
2789 
helper_svlcx(CPUTriCoreState * env)2790 void helper_svlcx(CPUTriCoreState *env)
2791 {
2792     target_ulong tmp_FCX;
2793     target_ulong ea;
2794     target_ulong new_FCX;
2795 
2796     if (env->FCX == 0) {
2797         /* FCU trap */
2798         raise_exception_sync_helper(env, TRAPC_CTX_MNG, TIN3_FCU, GETPC());
2799     }
2800     /* tmp_FCX = FCX; */
2801     tmp_FCX = env->FCX;
2802     /* EA = {FCX.FCXS, 6'b0, FCX.FCXO, 6'b0}; */
2803     ea = ((env->FCX & MASK_FCX_FCXS) << 12) +
2804          ((env->FCX & MASK_FCX_FCXO) << 6);
2805     /* new_FCX = M(EA, word); */
2806     new_FCX = cpu_ldl_data(env, ea);
2807     /* M(EA, 16 * word) = {PCXI, PSW, A[10], A[11], D[8], D[9], D[10], D[11],
2808                            A[12], A[13], A[14], A[15], D[12], D[13], D[14],
2809                            D[15]}; */
2810     save_context_lower(env, ea);
2811 
2812     /* PCXI.PCPN = ICR.CCPN; */
2813     pcxi_set_pcpn(env, icr_get_ccpn(env));
2814 
2815     /* PCXI.PIE = ICR.IE; */
2816     pcxi_set_pie(env, icr_get_ie(env));
2817 
2818     /* PCXI.UL = 0; */
2819     pcxi_set_ul(env, 0);
2820 
2821     /* PCXI[19: 0] = FCX[19: 0]; */
2822     env->PCXI = (env->PCXI & 0xfff00000) + (env->FCX & 0xfffff);
2823     /* FCX[19: 0] = new_FCX[19: 0]; */
2824     env->FCX = (env->FCX & 0xfff00000) + (new_FCX & 0xfffff);
2825 
2826     /* if (tmp_FCX == LCX) trap(FCD);*/
2827     if (tmp_FCX == env->LCX) {
2828         /* FCD trap */
2829         raise_exception_sync_helper(env, TRAPC_CTX_MNG, TIN3_FCD, GETPC());
2830     }
2831 }
2832 
helper_svucx(CPUTriCoreState * env)2833 void helper_svucx(CPUTriCoreState *env)
2834 {
2835     target_ulong tmp_FCX;
2836     target_ulong ea;
2837     target_ulong new_FCX;
2838 
2839     if (env->FCX == 0) {
2840         /* FCU trap */
2841         raise_exception_sync_helper(env, TRAPC_CTX_MNG, TIN3_FCU, GETPC());
2842     }
2843     /* tmp_FCX = FCX; */
2844     tmp_FCX = env->FCX;
2845     /* EA = {FCX.FCXS, 6'b0, FCX.FCXO, 6'b0}; */
2846     ea = ((env->FCX & MASK_FCX_FCXS) << 12) +
2847          ((env->FCX & MASK_FCX_FCXO) << 6);
2848     /* new_FCX = M(EA, word); */
2849     new_FCX = cpu_ldl_data(env, ea);
2850     /* M(EA, 16 * word) = {PCXI, PSW, A[10], A[11], D[8], D[9], D[10], D[11],
2851                            A[12], A[13], A[14], A[15], D[12], D[13], D[14],
2852                            D[15]}; */
2853     save_context_upper(env, ea);
2854 
2855     /* PCXI.PCPN = ICR.CCPN; */
2856     pcxi_set_pcpn(env, icr_get_ccpn(env));
2857 
2858     /* PCXI.PIE = ICR.IE; */
2859     pcxi_set_pie(env, icr_get_ie(env));
2860 
2861     /* PCXI.UL = 1; */
2862     pcxi_set_ul(env, 1);
2863 
2864     /* PCXI[19: 0] = FCX[19: 0]; */
2865     env->PCXI = (env->PCXI & 0xfff00000) + (env->FCX & 0xfffff);
2866     /* FCX[19: 0] = new_FCX[19: 0]; */
2867     env->FCX = (env->FCX & 0xfff00000) + (new_FCX & 0xfffff);
2868 
2869     /* if (tmp_FCX == LCX) trap(FCD);*/
2870     if (tmp_FCX == env->LCX) {
2871         /* FCD trap */
2872         raise_exception_sync_helper(env, TRAPC_CTX_MNG, TIN3_FCD, GETPC());
2873     }
2874 }
2875 
helper_rslcx(CPUTriCoreState * env)2876 void helper_rslcx(CPUTriCoreState *env)
2877 {
2878     target_ulong ea;
2879     target_ulong new_PCXI;
2880     /*   if (PCXI[19: 0] == 0) then trap(CSU); */
2881     if ((env->PCXI & 0xfffff) == 0) {
2882         /* CSU trap */
2883         raise_exception_sync_helper(env, TRAPC_CTX_MNG, TIN3_CSU, GETPC());
2884     }
2885     /* if (PCXI.UL == 1) then trap(CTYP); */
2886     if (pcxi_get_ul(env) == 1) {
2887         /* CTYP trap */
2888         raise_exception_sync_helper(env, TRAPC_CTX_MNG, TIN3_CTYP, GETPC());
2889     }
2890     /* EA = {PCXI.PCXS, 6'b0, PCXI.PCXO, 6'b0}; */
2891     /* EA = {PCXI.PCXS, 6'b0, PCXI.PCXO, 6'b0}; */
2892     ea = (pcxi_get_pcxs(env) << 28) |
2893          (pcxi_get_pcxo(env) << 6);
2894 
2895     /* {new_PCXI, A[11], A[10], A[11], D[8], D[9], D[10], D[11], A[12],
2896         A[13], A[14], A[15], D[12], D[13], D[14], D[15]} = M(EA, 16 * word); */
2897     restore_context_lower(env, ea, &env->gpr_a[11], &new_PCXI);
2898     /* M(EA, word) = FCX; */
2899     cpu_stl_data(env, ea, env->FCX);
2900     /* M(EA, word) = FCX; */
2901     cpu_stl_data(env, ea, env->FCX);
2902     /* FCX[19: 0] = PCXI[19: 0]; */
2903     env->FCX = (env->FCX & 0xfff00000) + (env->PCXI & 0x000fffff);
2904     /* PCXI = new_PCXI; */
2905     env->PCXI = new_PCXI;
2906 }
2907 
helper_psw_write(CPUTriCoreState * env,uint32_t arg)2908 void helper_psw_write(CPUTriCoreState *env, uint32_t arg)
2909 {
2910     psw_write(env, arg);
2911 }
2912 
helper_psw_read(CPUTriCoreState * env)2913 uint32_t helper_psw_read(CPUTriCoreState *env)
2914 {
2915     return psw_read(env);
2916 }
2917