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