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