]> 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: split up suov32 into suov32_pos and suov32_neg
[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 <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
23 /* Addressing mode helper */
24
25 static uint16_t reverse16(uint16_t val)
26 {
27 uint8_t high = (uint8_t)(val >> 8);
28 uint8_t low = (uint8_t)(val & 0xff);
29
30 uint16_t rh, rl;
31
32 rl = (uint16_t)((high * 0x0202020202ULL & 0x010884422010ULL) % 1023);
33 rh = (uint16_t)((low * 0x0202020202ULL & 0x010884422010ULL) % 1023);
34
35 return (rh << 8) | rl;
36 }
37
38 uint32_t helper_br_update(uint32_t reg)
39 {
40 uint32_t index = reg & 0xffff;
41 uint32_t incr = reg >> 16;
42 uint32_t new_index = reverse16(reverse16(index) + reverse16(incr));
43 return reg - index + new_index;
44 }
45
46 uint32_t helper_circ_update(uint32_t reg, uint32_t off)
47 {
48 uint32_t index = reg & 0xffff;
49 uint32_t length = reg >> 16;
50 int32_t new_index = index + off;
51 if (new_index < 0) {
52 new_index += length;
53 } else {
54 new_index %= length;
55 }
56 return reg - index + new_index;
57 }
58
59 static uint32_t ssov32(CPUTriCoreState *env, int64_t arg)
60 {
61 uint32_t ret;
62 int64_t max_pos = INT32_MAX;
63 int64_t max_neg = INT32_MIN;
64 if (arg > max_pos) {
65 env->PSW_USB_V = (1 << 31);
66 env->PSW_USB_SV = (1 << 31);
67 ret = (target_ulong)max_pos;
68 } else {
69 if (arg < max_neg) {
70 env->PSW_USB_V = (1 << 31);
71 env->PSW_USB_SV = (1 << 31);
72 ret = (target_ulong)max_neg;
73 } else {
74 env->PSW_USB_V = 0;
75 ret = (target_ulong)arg;
76 }
77 }
78 env->PSW_USB_AV = arg ^ arg * 2u;
79 env->PSW_USB_SAV |= env->PSW_USB_AV;
80 return ret;
81 }
82
83 static uint32_t suov32_pos(CPUTriCoreState *env, uint64_t arg)
84 {
85 uint32_t ret;
86 uint64_t max_pos = UINT32_MAX;
87 if (arg > max_pos) {
88 env->PSW_USB_V = (1 << 31);
89 env->PSW_USB_SV = (1 << 31);
90 ret = (target_ulong)max_pos;
91 } else {
92 env->PSW_USB_V = 0;
93 ret = (target_ulong)arg;
94 }
95 env->PSW_USB_AV = arg ^ arg * 2u;
96 env->PSW_USB_SAV |= env->PSW_USB_AV;
97 return ret;
98 }
99
100 static uint32_t suov32_neg(CPUTriCoreState *env, int64_t arg)
101 {
102 uint32_t ret;
103
104 if (arg < 0) {
105 env->PSW_USB_V = (1 << 31);
106 env->PSW_USB_SV = (1 << 31);
107 ret = 0;
108 } else {
109 env->PSW_USB_V = 0;
110 ret = (target_ulong)arg;
111 }
112 env->PSW_USB_AV = arg ^ arg * 2u;
113 env->PSW_USB_SAV |= env->PSW_USB_AV;
114 return ret;
115 }
116
117 static uint32_t ssov16(CPUTriCoreState *env, int32_t hw0, int32_t hw1)
118 {
119 int32_t max_pos = INT16_MAX;
120 int32_t max_neg = INT16_MIN;
121 int32_t av0, av1;
122
123 env->PSW_USB_V = 0;
124 av0 = hw0 ^ hw0 * 2u;
125 if (hw0 > max_pos) {
126 env->PSW_USB_V = (1 << 31);
127 hw0 = max_pos;
128 } else if (hw0 < max_neg) {
129 env->PSW_USB_V = (1 << 31);
130 hw0 = max_neg;
131 }
132
133 av1 = hw1 ^ hw1 * 2u;
134 if (hw1 > max_pos) {
135 env->PSW_USB_V = (1 << 31);
136 hw1 = max_pos;
137 } else if (hw1 < max_neg) {
138 env->PSW_USB_V = (1 << 31);
139 hw1 = max_neg;
140 }
141
142 env->PSW_USB_SV |= env->PSW_USB_V;
143 env->PSW_USB_AV = (av0 | av1) << 16;
144 env->PSW_USB_SAV |= env->PSW_USB_AV;
145 return (hw0 & 0xffff) | (hw1 << 16);
146 }
147
148 static uint32_t suov16(CPUTriCoreState *env, int32_t hw0, int32_t hw1)
149 {
150 int32_t max_pos = UINT16_MAX;
151 int32_t av0, av1;
152
153 env->PSW_USB_V = 0;
154 av0 = hw0 ^ hw0 * 2u;
155 if (hw0 > max_pos) {
156 env->PSW_USB_V = (1 << 31);
157 hw0 = max_pos;
158 } else if (hw0 < 0) {
159 env->PSW_USB_V = (1 << 31);
160 hw0 = 0;
161 }
162
163 av1 = hw1 ^ hw1 * 2u;
164 if (hw1 > max_pos) {
165 env->PSW_USB_V = (1 << 31);
166 hw1 = max_pos;
167 } else if (hw1 < 0) {
168 env->PSW_USB_V = (1 << 31);
169 hw1 = 0;
170 }
171
172 env->PSW_USB_SV |= env->PSW_USB_V;
173 env->PSW_USB_AV = (av0 | av1) << 16;
174 env->PSW_USB_SAV |= env->PSW_USB_AV;
175 return (hw0 & 0xffff) | (hw1 << 16);
176 }
177
178 target_ulong helper_add_ssov(CPUTriCoreState *env, target_ulong r1,
179 target_ulong r2)
180 {
181 int64_t t1 = sextract64(r1, 0, 32);
182 int64_t t2 = sextract64(r2, 0, 32);
183 int64_t result = t1 + t2;
184 return ssov32(env, result);
185 }
186
187 target_ulong helper_add_h_ssov(CPUTriCoreState *env, target_ulong r1,
188 target_ulong r2)
189 {
190 int32_t ret_hw0, ret_hw1;
191
192 ret_hw0 = sextract32(r1, 0, 16) + sextract32(r2, 0, 16);
193 ret_hw1 = sextract32(r1, 16, 16) + sextract32(r2, 16, 16);
194 return ssov16(env, ret_hw0, ret_hw1);
195 }
196
197 target_ulong helper_add_suov(CPUTriCoreState *env, target_ulong r1,
198 target_ulong r2)
199 {
200 int64_t t1 = extract64(r1, 0, 32);
201 int64_t t2 = extract64(r2, 0, 32);
202 int64_t result = t1 + t2;
203 return suov32_pos(env, result);
204 }
205
206 target_ulong helper_add_h_suov(CPUTriCoreState *env, target_ulong r1,
207 target_ulong r2)
208 {
209 int32_t ret_hw0, ret_hw1;
210
211 ret_hw0 = extract32(r1, 0, 16) + extract32(r2, 0, 16);
212 ret_hw1 = extract32(r1, 16, 16) + extract32(r2, 16, 16);
213 return suov16(env, ret_hw0, ret_hw1);
214 }
215
216 target_ulong helper_sub_ssov(CPUTriCoreState *env, target_ulong r1,
217 target_ulong r2)
218 {
219 int64_t t1 = sextract64(r1, 0, 32);
220 int64_t t2 = sextract64(r2, 0, 32);
221 int64_t result = t1 - t2;
222 return ssov32(env, result);
223 }
224
225 target_ulong helper_sub_h_ssov(CPUTriCoreState *env, target_ulong r1,
226 target_ulong r2)
227 {
228 int32_t ret_hw0, ret_hw1;
229
230 ret_hw0 = sextract32(r1, 0, 16) - sextract32(r2, 0, 16);
231 ret_hw1 = sextract32(r1, 16, 16) - sextract32(r2, 16, 16);
232 return ssov16(env, ret_hw0, ret_hw1);
233 }
234
235 target_ulong helper_sub_suov(CPUTriCoreState *env, target_ulong r1,
236 target_ulong r2)
237 {
238 int64_t t1 = extract64(r1, 0, 32);
239 int64_t t2 = extract64(r2, 0, 32);
240 int64_t result = t1 - t2;
241 return suov32_neg(env, result);
242 }
243
244 target_ulong helper_sub_h_suov(CPUTriCoreState *env, target_ulong r1,
245 target_ulong r2)
246 {
247 int32_t ret_hw0, ret_hw1;
248
249 ret_hw0 = extract32(r1, 0, 16) - extract32(r2, 0, 16);
250 ret_hw1 = extract32(r1, 16, 16) - extract32(r2, 16, 16);
251 return suov16(env, ret_hw0, ret_hw1);
252 }
253
254 target_ulong helper_mul_ssov(CPUTriCoreState *env, target_ulong r1,
255 target_ulong r2)
256 {
257 int64_t t1 = sextract64(r1, 0, 32);
258 int64_t t2 = sextract64(r2, 0, 32);
259 int64_t result = t1 * t2;
260 return ssov32(env, result);
261 }
262
263 target_ulong helper_mul_suov(CPUTriCoreState *env, target_ulong r1,
264 target_ulong r2)
265 {
266 int64_t t1 = extract64(r1, 0, 32);
267 int64_t t2 = extract64(r2, 0, 32);
268 int64_t result = t1 * t2;
269
270 return suov32_pos(env, result);
271 }
272
273 target_ulong helper_sha_ssov(CPUTriCoreState *env, target_ulong r1,
274 target_ulong r2)
275 {
276 int64_t t1 = sextract64(r1, 0, 32);
277 int32_t t2 = sextract64(r2, 0, 6);
278 int64_t result;
279 if (t2 == 0) {
280 result = t1;
281 } else if (t2 > 0) {
282 result = t1 << t2;
283 } else {
284 result = t1 >> -t2;
285 }
286 return ssov32(env, result);
287 }
288
289 uint32_t helper_abs_ssov(CPUTriCoreState *env, target_ulong r1)
290 {
291 target_ulong result;
292 result = ((int32_t)r1 >= 0) ? r1 : (0 - r1);
293 return ssov32(env, result);
294 }
295
296 uint32_t helper_abs_h_ssov(CPUTriCoreState *env, target_ulong r1)
297 {
298 int32_t ret_h0, ret_h1;
299
300 ret_h0 = sextract32(r1, 0, 16);
301 ret_h0 = (ret_h0 >= 0) ? ret_h0 : (0 - ret_h0);
302
303 ret_h1 = sextract32(r1, 16, 16);
304 ret_h1 = (ret_h1 >= 0) ? ret_h1 : (0 - ret_h1);
305
306 return ssov16(env, ret_h0, ret_h1);
307 }
308
309 target_ulong helper_absdif_ssov(CPUTriCoreState *env, target_ulong r1,
310 target_ulong r2)
311 {
312 int64_t t1 = sextract64(r1, 0, 32);
313 int64_t t2 = sextract64(r2, 0, 32);
314 int64_t result;
315
316 if (t1 > t2) {
317 result = t1 - t2;
318 } else {
319 result = t2 - t1;
320 }
321 return ssov32(env, result);
322 }
323
324 uint32_t helper_absdif_h_ssov(CPUTriCoreState *env, target_ulong r1,
325 target_ulong r2)
326 {
327 int32_t t1, t2;
328 int32_t ret_h0, ret_h1;
329
330 t1 = sextract32(r1, 0, 16);
331 t2 = sextract32(r2, 0, 16);
332 if (t1 > t2) {
333 ret_h0 = t1 - t2;
334 } else {
335 ret_h0 = t2 - t1;
336 }
337
338 t1 = sextract32(r1, 16, 16);
339 t2 = sextract32(r2, 16, 16);
340 if (t1 > t2) {
341 ret_h1 = t1 - t2;
342 } else {
343 ret_h1 = t2 - t1;
344 }
345
346 return ssov16(env, ret_h0, ret_h1);
347 }
348
349 target_ulong helper_madd32_ssov(CPUTriCoreState *env, target_ulong r1,
350 target_ulong r2, target_ulong r3)
351 {
352 int64_t t1 = sextract64(r1, 0, 32);
353 int64_t t2 = sextract64(r2, 0, 32);
354 int64_t t3 = sextract64(r3, 0, 32);
355 int64_t result;
356
357 result = t2 + (t1 * t3);
358 return ssov32(env, result);
359 }
360
361 target_ulong helper_madd32_suov(CPUTriCoreState *env, target_ulong r1,
362 target_ulong r2, target_ulong r3)
363 {
364 uint64_t t1 = extract64(r1, 0, 32);
365 uint64_t t2 = extract64(r2, 0, 32);
366 uint64_t t3 = extract64(r3, 0, 32);
367 int64_t result;
368
369 result = t2 + (t1 * t3);
370 return suov32_pos(env, result);
371 }
372
373 uint64_t helper_madd64_ssov(CPUTriCoreState *env, target_ulong r1,
374 uint64_t r2, target_ulong r3)
375 {
376 uint64_t ret, ovf;
377 int64_t t1 = sextract64(r1, 0, 32);
378 int64_t t3 = sextract64(r3, 0, 32);
379 int64_t mul;
380
381 mul = t1 * t3;
382 ret = mul + r2;
383 ovf = (ret ^ mul) & ~(mul ^ r2);
384
385 t1 = ret >> 32;
386 env->PSW_USB_AV = t1 ^ t1 * 2u;
387 env->PSW_USB_SAV |= env->PSW_USB_AV;
388
389 if ((int64_t)ovf < 0) {
390 env->PSW_USB_V = (1 << 31);
391 env->PSW_USB_SV = (1 << 31);
392 /* ext_ret > MAX_INT */
393 if (mul >= 0) {
394 ret = INT64_MAX;
395 /* ext_ret < MIN_INT */
396 } else {
397 ret = INT64_MIN;
398 }
399 } else {
400 env->PSW_USB_V = 0;
401 }
402
403 return ret;
404 }
405
406 uint64_t helper_madd64_suov(CPUTriCoreState *env, target_ulong r1,
407 uint64_t r2, target_ulong r3)
408 {
409 uint64_t ret, mul;
410 uint64_t t1 = extract64(r1, 0, 32);
411 uint64_t t3 = extract64(r3, 0, 32);
412
413 mul = t1 * t3;
414 ret = mul + r2;
415
416 t1 = ret >> 32;
417 env->PSW_USB_AV = t1 ^ t1 * 2u;
418 env->PSW_USB_SAV |= env->PSW_USB_AV;
419
420 if (ret < r2) {
421 env->PSW_USB_V = (1 << 31);
422 env->PSW_USB_SV = (1 << 31);
423 /* saturate */
424 ret = UINT64_MAX;
425 } else {
426 env->PSW_USB_V = 0;
427 }
428 return ret;
429 }
430
431 target_ulong helper_msub32_ssov(CPUTriCoreState *env, target_ulong r1,
432 target_ulong r2, target_ulong r3)
433 {
434 int64_t t1 = sextract64(r1, 0, 32);
435 int64_t t2 = sextract64(r2, 0, 32);
436 int64_t t3 = sextract64(r3, 0, 32);
437 int64_t result;
438
439 result = t2 - (t1 * t3);
440 return ssov32(env, result);
441 }
442
443 target_ulong helper_msub32_suov(CPUTriCoreState *env, target_ulong r1,
444 target_ulong r2, target_ulong r3)
445 {
446 int64_t t1 = extract64(r1, 0, 32);
447 int64_t t2 = extract64(r2, 0, 32);
448 int64_t t3 = extract64(r3, 0, 32);
449 int64_t result;
450
451 result = t2 - (t1 * t3);
452 return suov32_neg(env, result);
453 }
454
455 uint64_t helper_msub64_ssov(CPUTriCoreState *env, target_ulong r1,
456 uint64_t r2, target_ulong r3)
457 {
458 uint64_t ret, ovf;
459 int64_t t1 = sextract64(r1, 0, 32);
460 int64_t t3 = sextract64(r3, 0, 32);
461 int64_t mul;
462
463 mul = t1 * t3;
464 ret = r2 - mul;
465 ovf = (ret ^ r2) & (mul ^ r2);
466
467 t1 = ret >> 32;
468 env->PSW_USB_AV = t1 ^ t1 * 2u;
469 env->PSW_USB_SAV |= env->PSW_USB_AV;
470
471 if ((int64_t)ovf < 0) {
472 env->PSW_USB_V = (1 << 31);
473 env->PSW_USB_SV = (1 << 31);
474 /* ext_ret > MAX_INT */
475 if (mul < 0) {
476 ret = INT64_MAX;
477 /* ext_ret < MIN_INT */
478 } else {
479 ret = INT64_MIN;
480 }
481 } else {
482 env->PSW_USB_V = 0;
483 }
484 return ret;
485 }
486
487 uint64_t helper_msub64_suov(CPUTriCoreState *env, target_ulong r1,
488 uint64_t r2, target_ulong r3)
489 {
490 uint64_t ret, mul;
491 uint64_t t1 = extract64(r1, 0, 32);
492 uint64_t t3 = extract64(r3, 0, 32);
493
494 mul = t1 * t3;
495 ret = r2 - mul;
496
497 t1 = ret >> 32;
498 env->PSW_USB_AV = t1 ^ t1 * 2u;
499 env->PSW_USB_SAV |= env->PSW_USB_AV;
500
501 if (ret > r2) {
502 env->PSW_USB_V = (1 << 31);
503 env->PSW_USB_SV = (1 << 31);
504 /* saturate */
505 ret = 0;
506 } else {
507 env->PSW_USB_V = 0;
508 }
509 return ret;
510 }
511
512 uint32_t helper_abs_b(CPUTriCoreState *env, target_ulong arg)
513 {
514 int32_t b, i;
515 int32_t ovf = 0;
516 int32_t avf = 0;
517 int32_t ret = 0;
518
519 for (i = 0; i < 4; i++) {
520 b = sextract32(arg, i * 8, 8);
521 b = (b >= 0) ? b : (0 - b);
522 ovf |= (b > 0x7F) || (b < -0x80);
523 avf |= b ^ b * 2u;
524 ret |= (b & 0xff) << (i * 8);
525 }
526
527 env->PSW_USB_V = ovf << 31;
528 env->PSW_USB_SV |= env->PSW_USB_V;
529 env->PSW_USB_AV = avf << 24;
530 env->PSW_USB_SAV |= env->PSW_USB_AV;
531
532 return ret;
533 }
534
535 uint32_t helper_abs_h(CPUTriCoreState *env, target_ulong arg)
536 {
537 int32_t h, i;
538 int32_t ovf = 0;
539 int32_t avf = 0;
540 int32_t ret = 0;
541
542 for (i = 0; i < 2; i++) {
543 h = sextract32(arg, i * 16, 16);
544 h = (h >= 0) ? h : (0 - h);
545 ovf |= (h > 0x7FFF) || (h < -0x8000);
546 avf |= h ^ h * 2u;
547 ret |= (h & 0xffff) << (i * 16);
548 }
549
550 env->PSW_USB_V = ovf << 31;
551 env->PSW_USB_SV |= env->PSW_USB_V;
552 env->PSW_USB_AV = avf << 16;
553 env->PSW_USB_SAV |= env->PSW_USB_AV;
554
555 return ret;
556 }
557
558 uint32_t helper_absdif_b(CPUTriCoreState *env, target_ulong r1, target_ulong r2)
559 {
560 int32_t b, i;
561 int32_t extr_r2;
562 int32_t ovf = 0;
563 int32_t avf = 0;
564 int32_t ret = 0;
565
566 for (i = 0; i < 4; i++) {
567 extr_r2 = sextract32(r2, i * 8, 8);
568 b = sextract32(r1, i * 8, 8);
569 b = (b > extr_r2) ? (b - extr_r2) : (extr_r2 - b);
570 ovf |= (b > 0x7F) || (b < -0x80);
571 avf |= b ^ b * 2u;
572 ret |= (b & 0xff) << (i * 8);
573 }
574
575 env->PSW_USB_V = ovf << 31;
576 env->PSW_USB_SV |= env->PSW_USB_V;
577 env->PSW_USB_AV = avf << 24;
578 env->PSW_USB_SAV |= env->PSW_USB_AV;
579 return ret;
580 }
581
582 uint32_t helper_absdif_h(CPUTriCoreState *env, target_ulong r1, target_ulong r2)
583 {
584 int32_t h, i;
585 int32_t extr_r2;
586 int32_t ovf = 0;
587 int32_t avf = 0;
588 int32_t ret = 0;
589
590 for (i = 0; i < 2; i++) {
591 extr_r2 = sextract32(r2, i * 16, 16);
592 h = sextract32(r1, i * 16, 16);
593 h = (h > extr_r2) ? (h - extr_r2) : (extr_r2 - h);
594 ovf |= (h > 0x7FFF) || (h < -0x8000);
595 avf |= h ^ h * 2u;
596 ret |= (h & 0xffff) << (i * 16);
597 }
598
599 env->PSW_USB_V = ovf << 31;
600 env->PSW_USB_SV |= env->PSW_USB_V;
601 env->PSW_USB_AV = avf << 16;
602 env->PSW_USB_SAV |= env->PSW_USB_AV;
603
604 return ret;
605 }
606
607 uint32_t helper_add_b(CPUTriCoreState *env, target_ulong r1, target_ulong r2)
608 {
609 int32_t b, i;
610 int32_t extr_r1, extr_r2;
611 int32_t ovf = 0;
612 int32_t avf = 0;
613 uint32_t ret = 0;
614
615 for (i = 0; i < 4; i++) {
616 extr_r1 = sextract32(r1, i * 8, 8);
617 extr_r2 = sextract32(r2, i * 8, 8);
618
619 b = extr_r1 + extr_r2;
620 ovf |= ((b > 0x7f) || (b < -0x80));
621 avf |= b ^ b * 2u;
622 ret |= ((b & 0xff) << (i*8));
623 }
624
625 env->PSW_USB_V = (ovf << 31);
626 env->PSW_USB_SV |= env->PSW_USB_V;
627 env->PSW_USB_AV = avf << 24;
628 env->PSW_USB_SAV |= env->PSW_USB_AV;
629
630 return ret;
631 }
632
633 uint32_t helper_add_h(CPUTriCoreState *env, target_ulong r1, target_ulong r2)
634 {
635 int32_t h, i;
636 int32_t extr_r1, extr_r2;
637 int32_t ovf = 0;
638 int32_t avf = 0;
639 int32_t ret = 0;
640
641 for (i = 0; i < 2; i++) {
642 extr_r1 = sextract32(r1, i * 16, 16);
643 extr_r2 = sextract32(r2, i * 16, 16);
644 h = extr_r1 + extr_r2;
645 ovf |= ((h > 0x7fff) || (h < -0x8000));
646 avf |= h ^ h * 2u;
647 ret |= (h & 0xffff) << (i * 16);
648 }
649
650 env->PSW_USB_V = (ovf << 31);
651 env->PSW_USB_SV |= env->PSW_USB_V;
652 env->PSW_USB_AV = (avf << 16);
653 env->PSW_USB_SAV |= env->PSW_USB_AV;
654
655 return ret;
656 }
657
658 uint32_t helper_sub_b(CPUTriCoreState *env, target_ulong r1, target_ulong r2)
659 {
660 int32_t b, i;
661 int32_t extr_r1, extr_r2;
662 int32_t ovf = 0;
663 int32_t avf = 0;
664 uint32_t ret = 0;
665
666 for (i = 0; i < 4; i++) {
667 extr_r1 = sextract32(r1, i * 8, 8);
668 extr_r2 = sextract32(r2, i * 8, 8);
669
670 b = extr_r1 - extr_r2;
671 ovf |= ((b > 0x7f) || (b < -0x80));
672 avf |= b ^ b * 2u;
673 ret |= ((b & 0xff) << (i*8));
674 }
675
676 env->PSW_USB_V = (ovf << 31);
677 env->PSW_USB_SV |= env->PSW_USB_V;
678 env->PSW_USB_AV = avf << 24;
679 env->PSW_USB_SAV |= env->PSW_USB_AV;
680
681 return ret;
682 }
683
684 uint32_t helper_sub_h(CPUTriCoreState *env, target_ulong r1, target_ulong r2)
685 {
686 int32_t h, i;
687 int32_t extr_r1, extr_r2;
688 int32_t ovf = 0;
689 int32_t avf = 0;
690 int32_t ret = 0;
691
692 for (i = 0; i < 2; i++) {
693 extr_r1 = sextract32(r1, i * 16, 16);
694 extr_r2 = sextract32(r2, i * 16, 16);
695 h = extr_r1 - extr_r2;
696 ovf |= ((h > 0x7fff) || (h < -0x8000));
697 avf |= h ^ h * 2u;
698 ret |= (h & 0xffff) << (i * 16);
699 }
700
701 env->PSW_USB_V = (ovf << 31);
702 env->PSW_USB_SV |= env->PSW_USB_V;
703 env->PSW_USB_AV = avf << 16;
704 env->PSW_USB_SAV |= env->PSW_USB_AV;
705
706 return ret;
707 }
708
709 uint32_t helper_eq_b(target_ulong r1, target_ulong r2)
710 {
711 int32_t ret;
712 int32_t i, msk;
713
714 ret = 0;
715 msk = 0xff;
716 for (i = 0; i < 4; i++) {
717 if ((r1 & msk) == (r2 & msk)) {
718 ret |= msk;
719 }
720 msk = msk << 8;
721 }
722
723 return ret;
724 }
725
726 uint32_t helper_eq_h(target_ulong r1, target_ulong r2)
727 {
728 int32_t ret = 0;
729
730 if ((r1 & 0xffff) == (r2 & 0xffff)) {
731 ret = 0xffff;
732 }
733
734 if ((r1 & 0xffff0000) == (r2 & 0xffff0000)) {
735 ret |= 0xffff0000;
736 }
737
738 return ret;
739 }
740
741 uint32_t helper_eqany_b(target_ulong r1, target_ulong r2)
742 {
743 int32_t i;
744 uint32_t ret = 0;
745
746 for (i = 0; i < 4; i++) {
747 ret |= (sextract32(r1, i * 8, 8) == sextract32(r2, i * 8, 8));
748 }
749
750 return ret;
751 }
752
753 uint32_t helper_eqany_h(target_ulong r1, target_ulong r2)
754 {
755 uint32_t ret;
756
757 ret = (sextract32(r1, 0, 16) == sextract32(r2, 0, 16));
758 ret |= (sextract32(r1, 16, 16) == sextract32(r2, 16, 16));
759
760 return ret;
761 }
762
763 uint32_t helper_lt_b(target_ulong r1, target_ulong r2)
764 {
765 int32_t i;
766 uint32_t ret = 0;
767
768 for (i = 0; i < 4; i++) {
769 if (sextract32(r1, i * 8, 8) < sextract32(r2, i * 8, 8)) {
770 ret |= (0xff << (i * 8));
771 }
772 }
773
774 return ret;
775 }
776
777 uint32_t helper_lt_bu(target_ulong r1, target_ulong r2)
778 {
779 int32_t i;
780 uint32_t ret = 0;
781
782 for (i = 0; i < 4; i++) {
783 if (extract32(r1, i * 8, 8) < extract32(r2, i * 8, 8)) {
784 ret |= (0xff << (i * 8));
785 }
786 }
787
788 return ret;
789 }
790
791 uint32_t helper_lt_h(target_ulong r1, target_ulong r2)
792 {
793 uint32_t ret = 0;
794
795 if (sextract32(r1, 0, 16) < sextract32(r2, 0, 16)) {
796 ret |= 0xffff;
797 }
798
799 if (sextract32(r1, 16, 16) < sextract32(r2, 16, 16)) {
800 ret |= 0xffff0000;
801 }
802
803 return ret;
804 }
805
806 uint32_t helper_lt_hu(target_ulong r1, target_ulong r2)
807 {
808 uint32_t ret = 0;
809
810 if (extract32(r1, 0, 16) < extract32(r2, 0, 16)) {
811 ret |= 0xffff;
812 }
813
814 if (extract32(r1, 16, 16) < extract32(r2, 16, 16)) {
815 ret |= 0xffff0000;
816 }
817
818 return ret;
819 }
820
821 #define EXTREMA_H_B(name, op) \
822 uint32_t helper_##name ##_b(target_ulong r1, target_ulong r2) \
823 { \
824 int32_t i, extr_r1, extr_r2; \
825 uint32_t ret = 0; \
826 \
827 for (i = 0; i < 4; i++) { \
828 extr_r1 = sextract32(r1, i * 8, 8); \
829 extr_r2 = sextract32(r2, i * 8, 8); \
830 extr_r1 = (extr_r1 op extr_r2) ? extr_r1 : extr_r2; \
831 ret |= (extr_r1 & 0xff) << (i * 8); \
832 } \
833 return ret; \
834 } \
835 \
836 uint32_t helper_##name ##_bu(target_ulong r1, target_ulong r2)\
837 { \
838 int32_t i; \
839 uint32_t extr_r1, extr_r2; \
840 uint32_t ret = 0; \
841 \
842 for (i = 0; i < 4; i++) { \
843 extr_r1 = extract32(r1, i * 8, 8); \
844 extr_r2 = extract32(r2, i * 8, 8); \
845 extr_r1 = (extr_r1 op extr_r2) ? extr_r1 : extr_r2; \
846 ret |= (extr_r1 & 0xff) << (i * 8); \
847 } \
848 return ret; \
849 } \
850 \
851 uint32_t helper_##name ##_h(target_ulong r1, target_ulong r2) \
852 { \
853 int32_t extr_r1, extr_r2; \
854 uint32_t ret = 0; \
855 \
856 extr_r1 = sextract32(r1, 0, 16); \
857 extr_r2 = sextract32(r2, 0, 16); \
858 ret = (extr_r1 op extr_r2) ? extr_r1 : extr_r2; \
859 ret = ret & 0xffff; \
860 \
861 extr_r1 = sextract32(r1, 16, 16); \
862 extr_r2 = sextract32(r2, 16, 16); \
863 extr_r1 = (extr_r1 op extr_r2) ? extr_r1 : extr_r2; \
864 ret |= extr_r1 << 16; \
865 \
866 return ret; \
867 } \
868 \
869 uint32_t helper_##name ##_hu(target_ulong r1, target_ulong r2)\
870 { \
871 uint32_t extr_r1, extr_r2; \
872 uint32_t ret = 0; \
873 \
874 extr_r1 = extract32(r1, 0, 16); \
875 extr_r2 = extract32(r2, 0, 16); \
876 ret = (extr_r1 op extr_r2) ? extr_r1 : extr_r2; \
877 ret = ret & 0xffff; \
878 \
879 extr_r1 = extract32(r1, 16, 16); \
880 extr_r2 = extract32(r2, 16, 16); \
881 extr_r1 = (extr_r1 op extr_r2) ? extr_r1 : extr_r2; \
882 ret |= extr_r1 << (16); \
883 \
884 return ret; \
885 } \
886
887 EXTREMA_H_B(max, >)
888 EXTREMA_H_B(min, <)
889
890 #undef EXTREMA_H_B
891
892 uint32_t helper_clo(target_ulong r1)
893 {
894 return clo32(r1);
895 }
896
897 uint32_t helper_clo_h(target_ulong r1)
898 {
899 uint32_t ret_hw0 = extract32(r1, 0, 16);
900 uint32_t ret_hw1 = extract32(r1, 16, 16);
901
902 ret_hw0 = clo32(ret_hw0 << 16);
903 ret_hw1 = clo32(ret_hw1 << 16);
904
905 if (ret_hw0 > 16) {
906 ret_hw0 = 16;
907 }
908 if (ret_hw1 > 16) {
909 ret_hw1 = 16;
910 }
911
912 return ret_hw0 | (ret_hw1 << 16);
913 }
914
915 uint32_t helper_clz(target_ulong r1)
916 {
917 return clz32(r1);
918 }
919
920 uint32_t helper_clz_h(target_ulong r1)
921 {
922 uint32_t ret_hw0 = extract32(r1, 0, 16);
923 uint32_t ret_hw1 = extract32(r1, 16, 16);
924
925 ret_hw0 = clz32(ret_hw0 << 16);
926 ret_hw1 = clz32(ret_hw1 << 16);
927
928 if (ret_hw0 > 16) {
929 ret_hw0 = 16;
930 }
931 if (ret_hw1 > 16) {
932 ret_hw1 = 16;
933 }
934
935 return ret_hw0 | (ret_hw1 << 16);
936 }
937
938 uint32_t helper_cls(target_ulong r1)
939 {
940 return clrsb32(r1);
941 }
942
943 uint32_t helper_cls_h(target_ulong r1)
944 {
945 uint32_t ret_hw0 = extract32(r1, 0, 16);
946 uint32_t ret_hw1 = extract32(r1, 16, 16);
947
948 ret_hw0 = clrsb32(ret_hw0 << 16);
949 ret_hw1 = clrsb32(ret_hw1 << 16);
950
951 if (ret_hw0 > 15) {
952 ret_hw0 = 15;
953 }
954 if (ret_hw1 > 15) {
955 ret_hw1 = 15;
956 }
957
958 return ret_hw0 | (ret_hw1 << 16);
959 }
960
961 uint32_t helper_sh(target_ulong r1, target_ulong r2)
962 {
963 int32_t shift_count = sextract32(r2, 0, 6);
964
965 if (shift_count == -32) {
966 return 0;
967 } else if (shift_count < 0) {
968 return r1 >> -shift_count;
969 } else {
970 return r1 << shift_count;
971 }
972 }
973
974 uint32_t helper_sh_h(target_ulong r1, target_ulong r2)
975 {
976 int32_t ret_hw0, ret_hw1;
977 int32_t shift_count;
978
979 shift_count = sextract32(r2, 0, 5);
980
981 if (shift_count == -16) {
982 return 0;
983 } else if (shift_count < 0) {
984 ret_hw0 = extract32(r1, 0, 16) >> -shift_count;
985 ret_hw1 = extract32(r1, 16, 16) >> -shift_count;
986 return (ret_hw0 & 0xffff) | (ret_hw1 << 16);
987 } else {
988 ret_hw0 = extract32(r1, 0, 16) << shift_count;
989 ret_hw1 = extract32(r1, 16, 16) << shift_count;
990 return (ret_hw0 & 0xffff) | (ret_hw1 << 16);
991 }
992 }
993
994 uint32_t helper_sha(CPUTriCoreState *env, target_ulong r1, target_ulong r2)
995 {
996 int32_t shift_count;
997 int64_t result, t1;
998 uint32_t ret;
999
1000 shift_count = sextract32(r2, 0, 6);
1001 t1 = sextract32(r1, 0, 32);
1002
1003 if (shift_count == 0) {
1004 env->PSW_USB_C = env->PSW_USB_V = 0;
1005 ret = r1;
1006 } else if (shift_count == -32) {
1007 env->PSW_USB_C = r1;
1008 env->PSW_USB_V = 0;
1009 ret = t1 >> 31;
1010 } else if (shift_count > 0) {
1011 result = t1 << shift_count;
1012 /* calc carry */
1013 env->PSW_USB_C = ((result & 0xffffffff00000000ULL) != 0);
1014 /* calc v */
1015 env->PSW_USB_V = (((result > 0x7fffffffLL) ||
1016 (result < -0x80000000LL)) << 31);
1017 /* calc sv */
1018 env->PSW_USB_SV |= env->PSW_USB_V;
1019 ret = (uint32_t)result;
1020 } else {
1021 env->PSW_USB_V = 0;
1022 env->PSW_USB_C = (r1 & ((1 << -shift_count) - 1));
1023 ret = t1 >> -shift_count;
1024 }
1025
1026 env->PSW_USB_AV = ret ^ ret * 2u;
1027 env->PSW_USB_SAV |= env->PSW_USB_AV;
1028
1029 return ret;
1030 }
1031
1032 uint32_t helper_sha_h(target_ulong r1, target_ulong r2)
1033 {
1034 int32_t shift_count;
1035 int32_t ret_hw0, ret_hw1;
1036
1037 shift_count = sextract32(r2, 0, 5);
1038
1039 if (shift_count == 0) {
1040 return r1;
1041 } else if (shift_count < 0) {
1042 ret_hw0 = sextract32(r1, 0, 16) >> -shift_count;
1043 ret_hw1 = sextract32(r1, 16, 16) >> -shift_count;
1044 return (ret_hw0 & 0xffff) | (ret_hw1 << 16);
1045 } else {
1046 ret_hw0 = sextract32(r1, 0, 16) << shift_count;
1047 ret_hw1 = sextract32(r1, 16, 16) << shift_count;
1048 return (ret_hw0 & 0xffff) | (ret_hw1 << 16);
1049 }
1050 }
1051
1052 uint32_t helper_bmerge(target_ulong r1, target_ulong r2)
1053 {
1054 uint32_t i, ret;
1055
1056 ret = 0;
1057 for (i = 0; i < 16; i++) {
1058 ret |= (r1 & 1) << (2 * i + 1);
1059 ret |= (r2 & 1) << (2 * i);
1060 r1 = r1 >> 1;
1061 r2 = r2 >> 1;
1062 }
1063 return ret;
1064 }
1065
1066 uint64_t helper_bsplit(uint32_t r1)
1067 {
1068 int32_t i;
1069 uint64_t ret;
1070
1071 ret = 0;
1072 for (i = 0; i < 32; i = i + 2) {
1073 /* even */
1074 ret |= (r1 & 1) << (i/2);
1075 r1 = r1 >> 1;
1076 /* odd */
1077 ret |= (uint64_t)(r1 & 1) << (i/2 + 32);
1078 r1 = r1 >> 1;
1079 }
1080 return ret;
1081 }
1082
1083 uint32_t helper_parity(target_ulong r1)
1084 {
1085 uint32_t ret;
1086 uint32_t nOnes, i;
1087
1088 ret = 0;
1089 nOnes = 0;
1090 for (i = 0; i < 8; i++) {
1091 ret ^= (r1 & 1);
1092 r1 = r1 >> 1;
1093 }
1094 /* second byte */
1095 nOnes = 0;
1096 for (i = 0; i < 8; i++) {
1097 nOnes ^= (r1 & 1);
1098 r1 = r1 >> 1;
1099 }
1100 ret |= nOnes << 8;
1101 /* third byte */
1102 nOnes = 0;
1103 for (i = 0; i < 8; i++) {
1104 nOnes ^= (r1 & 1);
1105 r1 = r1 >> 1;
1106 }
1107 ret |= nOnes << 16;
1108 /* fourth byte */
1109 nOnes = 0;
1110 for (i = 0; i < 8; i++) {
1111 nOnes ^= (r1 & 1);
1112 r1 = r1 >> 1;
1113 }
1114 ret |= nOnes << 24;
1115
1116 return ret;
1117 }
1118
1119 uint64_t helper_unpack(target_ulong arg1)
1120 {
1121 int32_t fp_exp = extract32(arg1, 23, 8);
1122 int32_t fp_frac = extract32(arg1, 0, 23);
1123 uint64_t ret;
1124 int32_t int_exp, int_mant;
1125
1126 if (fp_exp == 255) {
1127 int_exp = 255;
1128 int_mant = (fp_frac << 7);
1129 } else if ((fp_exp == 0) && (fp_frac == 0)) {
1130 int_exp = -127;
1131 int_mant = 0;
1132 } else if ((fp_exp == 0) && (fp_frac != 0)) {
1133 int_exp = -126;
1134 int_mant = (fp_frac << 7);
1135 } else {
1136 int_exp = fp_exp - 127;
1137 int_mant = (fp_frac << 7);
1138 int_mant |= (1 << 30);
1139 }
1140 ret = int_exp;
1141 ret = ret << 32;
1142 ret |= int_mant;
1143
1144 return ret;
1145 }
1146
1147 uint64_t helper_dvinit_b_13(CPUTriCoreState *env, uint32_t r1, uint32_t r2)
1148 {
1149 uint64_t ret;
1150 int32_t abs_sig_dividend, abs_base_dividend, abs_divisor;
1151 int32_t quotient_sign;
1152
1153 ret = sextract32(r1, 0, 32);
1154 ret = ret << 24;
1155 quotient_sign = 0;
1156 if (!((r1 & 0x80000000) == (r2 & 0x80000000))) {
1157 ret |= 0xffffff;
1158 quotient_sign = 1;
1159 }
1160
1161 abs_sig_dividend = abs(r1) >> 7;
1162 abs_base_dividend = abs(r1) & 0x7f;
1163 abs_divisor = abs(r1);
1164 /* calc overflow */
1165 env->PSW_USB_V = 0;
1166 if ((quotient_sign) && (abs_divisor)) {
1167 env->PSW_USB_V = (((abs_sig_dividend == abs_divisor) &&
1168 (abs_base_dividend >= abs_divisor)) ||
1169 (abs_sig_dividend > abs_divisor));
1170 } else {
1171 env->PSW_USB_V = (abs_sig_dividend >= abs_divisor);
1172 }
1173 env->PSW_USB_V = env->PSW_USB_V << 31;
1174 env->PSW_USB_SV |= env->PSW_USB_V;
1175 env->PSW_USB_AV = 0;
1176
1177 return ret;
1178 }
1179
1180 uint64_t helper_dvinit_b_131(CPUTriCoreState *env, uint32_t r1, uint32_t r2)
1181 {
1182 uint64_t ret = sextract32(r1, 0, 32);
1183
1184 ret = ret << 24;
1185 if (!((r1 & 0x80000000) == (r2 & 0x80000000))) {
1186 ret |= 0xffffff;
1187 }
1188 /* calc overflow */
1189 env->PSW_USB_V = ((r2 == 0) || ((r2 == 0xffffffff) && (r1 == 0xffffff80)));
1190 env->PSW_USB_V = env->PSW_USB_V << 31;
1191 env->PSW_USB_SV |= env->PSW_USB_V;
1192 env->PSW_USB_AV = 0;
1193
1194 return ret;
1195 }
1196
1197 uint64_t helper_dvinit_h_13(CPUTriCoreState *env, uint32_t r1, uint32_t r2)
1198 {
1199 uint64_t ret;
1200 int32_t abs_sig_dividend, abs_base_dividend, abs_divisor;
1201 int32_t quotient_sign;
1202
1203 ret = sextract32(r1, 0, 32);
1204 ret = ret << 16;
1205 quotient_sign = 0;
1206 if (!((r1 & 0x80000000) == (r2 & 0x80000000))) {
1207 ret |= 0xffff;
1208 quotient_sign = 1;
1209 }
1210
1211 abs_sig_dividend = abs(r1) >> 7;
1212 abs_base_dividend = abs(r1) & 0x7f;
1213 abs_divisor = abs(r1);
1214 /* calc overflow */
1215 env->PSW_USB_V = 0;
1216 if ((quotient_sign) && (abs_divisor)) {
1217 env->PSW_USB_V = (((abs_sig_dividend == abs_divisor) &&
1218 (abs_base_dividend >= abs_divisor)) ||
1219 (abs_sig_dividend > abs_divisor));
1220 } else {
1221 env->PSW_USB_V = (abs_sig_dividend >= abs_divisor);
1222 }
1223 env->PSW_USB_V = env->PSW_USB_V << 31;
1224 env->PSW_USB_SV |= env->PSW_USB_V;
1225 env->PSW_USB_AV = 0;
1226
1227 return ret;
1228 }
1229
1230 uint64_t helper_dvinit_h_131(CPUTriCoreState *env, uint32_t r1, uint32_t r2)
1231 {
1232 uint64_t ret = sextract32(r1, 0, 32);
1233
1234 ret = ret << 16;
1235 if (!((r1 & 0x80000000) == (r2 & 0x80000000))) {
1236 ret |= 0xffff;
1237 }
1238 /* calc overflow */
1239 env->PSW_USB_V = ((r2 == 0) || ((r2 == 0xffffffff) && (r1 == 0xffff8000)));
1240 env->PSW_USB_V = env->PSW_USB_V << 31;
1241 env->PSW_USB_SV |= env->PSW_USB_V;
1242 env->PSW_USB_AV = 0;
1243
1244 return ret;
1245 }
1246
1247 uint64_t helper_mul_h(uint32_t arg00, uint32_t arg01,
1248 uint32_t arg10, uint32_t arg11, uint32_t n)
1249 {
1250 uint64_t ret;
1251 uint32_t result0, result1;
1252
1253 int32_t sc1 = ((arg00 & 0xffff) == 0x8000) &&
1254 ((arg10 & 0xffff) == 0x8000) && (n == 1);
1255 int32_t sc0 = ((arg01 & 0xffff) == 0x8000) &&
1256 ((arg11 & 0xffff) == 0x8000) && (n == 1);
1257 if (sc1) {
1258 result1 = 0x7fffffff;
1259 } else {
1260 result1 = (((uint32_t)(arg00 * arg10)) << n);
1261 }
1262 if (sc0) {
1263 result0 = 0x7fffffff;
1264 } else {
1265 result0 = (((uint32_t)(arg01 * arg11)) << n);
1266 }
1267 ret = (((uint64_t)result1 << 32)) | result0;
1268 return ret;
1269 }
1270
1271 uint64_t helper_mulm_h(uint32_t arg00, uint32_t arg01,
1272 uint32_t arg10, uint32_t arg11, uint32_t n)
1273 {
1274 uint64_t ret;
1275 int64_t result0, result1;
1276
1277 int32_t sc1 = ((arg00 & 0xffff) == 0x8000) &&
1278 ((arg10 & 0xffff) == 0x8000) && (n == 1);
1279 int32_t sc0 = ((arg01 & 0xffff) == 0x8000) &&
1280 ((arg11 & 0xffff) == 0x8000) && (n == 1);
1281
1282 if (sc1) {
1283 result1 = 0x7fffffff;
1284 } else {
1285 result1 = (((int32_t)arg00 * (int32_t)arg10) << n);
1286 }
1287 if (sc0) {
1288 result0 = 0x7fffffff;
1289 } else {
1290 result0 = (((int32_t)arg01 * (int32_t)arg11) << n);
1291 }
1292 ret = (result1 + result0);
1293 ret = ret << 16;
1294 return ret;
1295 }
1296 uint32_t helper_mulr_h(uint32_t arg00, uint32_t arg01,
1297 uint32_t arg10, uint32_t arg11, uint32_t n)
1298 {
1299 uint32_t result0, result1;
1300
1301 int32_t sc1 = ((arg00 & 0xffff) == 0x8000) &&
1302 ((arg10 & 0xffff) == 0x8000) && (n == 1);
1303 int32_t sc0 = ((arg01 & 0xffff) == 0x8000) &&
1304 ((arg11 & 0xffff) == 0x8000) && (n == 1);
1305
1306 if (sc1) {
1307 result1 = 0x7fffffff;
1308 } else {
1309 result1 = ((arg00 * arg10) << n) + 0x8000;
1310 }
1311 if (sc0) {
1312 result0 = 0x7fffffff;
1313 } else {
1314 result0 = ((arg01 * arg11) << n) + 0x8000;
1315 }
1316 return (result1 & 0xffff0000) | (result0 >> 16);
1317 }
1318
1319 /* context save area (CSA) related helpers */
1320
1321 static int cdc_increment(target_ulong *psw)
1322 {
1323 if ((*psw & MASK_PSW_CDC) == 0x7f) {
1324 return 0;
1325 }
1326
1327 (*psw)++;
1328 /* check for overflow */
1329 int lo = clo32((*psw & MASK_PSW_CDC) << (32 - 7));
1330 int mask = (1u << (7 - lo)) - 1;
1331 int count = *psw & mask;
1332 if (count == 0) {
1333 (*psw)--;
1334 return 1;
1335 }
1336 return 0;
1337 }
1338
1339 static int cdc_decrement(target_ulong *psw)
1340 {
1341 if ((*psw & MASK_PSW_CDC) == 0x7f) {
1342 return 0;
1343 }
1344 /* check for underflow */
1345 int lo = clo32((*psw & MASK_PSW_CDC) << (32 - 7));
1346 int mask = (1u << (7 - lo)) - 1;
1347 int count = *psw & mask;
1348 if (count == 0) {
1349 return 1;
1350 }
1351 (*psw)--;
1352 return 0;
1353 }
1354
1355 static bool cdc_zero(target_ulong *psw)
1356 {
1357 int cdc = *psw & MASK_PSW_CDC;
1358 /* Returns TRUE if PSW.CDC.COUNT == 0 or if PSW.CDC ==
1359 7'b1111111, otherwise returns FALSE. */
1360 if (cdc == 0x7f) {
1361 return true;
1362 }
1363 /* find CDC.COUNT */
1364 int lo = clo32((*psw & MASK_PSW_CDC) << (32 - 7));
1365 int mask = (1u << (7 - lo)) - 1;
1366 int count = *psw & mask;
1367 return count == 0;
1368 }
1369
1370 static void save_context_upper(CPUTriCoreState *env, int ea)
1371 {
1372 cpu_stl_data(env, ea, env->PCXI);
1373 cpu_stl_data(env, ea+4, env->PSW);
1374 cpu_stl_data(env, ea+8, env->gpr_a[10]);
1375 cpu_stl_data(env, ea+12, env->gpr_a[11]);
1376 cpu_stl_data(env, ea+16, env->gpr_d[8]);
1377 cpu_stl_data(env, ea+20, env->gpr_d[9]);
1378 cpu_stl_data(env, ea+24, env->gpr_d[10]);
1379 cpu_stl_data(env, ea+28, env->gpr_d[11]);
1380 cpu_stl_data(env, ea+32, env->gpr_a[12]);
1381 cpu_stl_data(env, ea+36, env->gpr_a[13]);
1382 cpu_stl_data(env, ea+40, env->gpr_a[14]);
1383 cpu_stl_data(env, ea+44, env->gpr_a[15]);
1384 cpu_stl_data(env, ea+48, env->gpr_d[12]);
1385 cpu_stl_data(env, ea+52, env->gpr_d[13]);
1386 cpu_stl_data(env, ea+56, env->gpr_d[14]);
1387 cpu_stl_data(env, ea+60, env->gpr_d[15]);
1388 }
1389
1390 static void save_context_lower(CPUTriCoreState *env, int ea)
1391 {
1392 cpu_stl_data(env, ea, env->PCXI);
1393 cpu_stl_data(env, ea+4, env->gpr_a[11]);
1394 cpu_stl_data(env, ea+8, env->gpr_a[2]);
1395 cpu_stl_data(env, ea+12, env->gpr_a[3]);
1396 cpu_stl_data(env, ea+16, env->gpr_d[0]);
1397 cpu_stl_data(env, ea+20, env->gpr_d[1]);
1398 cpu_stl_data(env, ea+24, env->gpr_d[2]);
1399 cpu_stl_data(env, ea+28, env->gpr_d[3]);
1400 cpu_stl_data(env, ea+32, env->gpr_a[4]);
1401 cpu_stl_data(env, ea+36, env->gpr_a[5]);
1402 cpu_stl_data(env, ea+40, env->gpr_a[6]);
1403 cpu_stl_data(env, ea+44, env->gpr_a[7]);
1404 cpu_stl_data(env, ea+48, env->gpr_d[4]);
1405 cpu_stl_data(env, ea+52, env->gpr_d[5]);
1406 cpu_stl_data(env, ea+56, env->gpr_d[6]);
1407 cpu_stl_data(env, ea+60, env->gpr_d[7]);
1408 }
1409
1410 static void restore_context_upper(CPUTriCoreState *env, int ea,
1411 target_ulong *new_PCXI, target_ulong *new_PSW)
1412 {
1413 *new_PCXI = cpu_ldl_data(env, ea);
1414 *new_PSW = cpu_ldl_data(env, ea+4);
1415 env->gpr_a[10] = cpu_ldl_data(env, ea+8);
1416 env->gpr_a[11] = cpu_ldl_data(env, ea+12);
1417 env->gpr_d[8] = cpu_ldl_data(env, ea+16);
1418 env->gpr_d[9] = cpu_ldl_data(env, ea+20);
1419 env->gpr_d[10] = cpu_ldl_data(env, ea+24);
1420 env->gpr_d[11] = cpu_ldl_data(env, ea+28);
1421 env->gpr_a[12] = cpu_ldl_data(env, ea+32);
1422 env->gpr_a[13] = cpu_ldl_data(env, ea+36);
1423 env->gpr_a[14] = cpu_ldl_data(env, ea+40);
1424 env->gpr_a[15] = cpu_ldl_data(env, ea+44);
1425 env->gpr_d[12] = cpu_ldl_data(env, ea+48);
1426 env->gpr_d[13] = cpu_ldl_data(env, ea+52);
1427 env->gpr_d[14] = cpu_ldl_data(env, ea+56);
1428 env->gpr_d[15] = cpu_ldl_data(env, ea+60);
1429 }
1430
1431 static void restore_context_lower(CPUTriCoreState *env, int ea,
1432 target_ulong *ra, target_ulong *pcxi)
1433 {
1434 *pcxi = cpu_ldl_data(env, ea);
1435 *ra = cpu_ldl_data(env, ea+4);
1436 env->gpr_a[2] = cpu_ldl_data(env, ea+8);
1437 env->gpr_a[3] = cpu_ldl_data(env, ea+12);
1438 env->gpr_d[0] = cpu_ldl_data(env, ea+16);
1439 env->gpr_d[1] = cpu_ldl_data(env, ea+20);
1440 env->gpr_d[2] = cpu_ldl_data(env, ea+24);
1441 env->gpr_d[3] = cpu_ldl_data(env, ea+28);
1442 env->gpr_a[4] = cpu_ldl_data(env, ea+32);
1443 env->gpr_a[5] = cpu_ldl_data(env, ea+36);
1444 env->gpr_a[6] = cpu_ldl_data(env, ea+40);
1445 env->gpr_a[7] = cpu_ldl_data(env, ea+44);
1446 env->gpr_d[4] = cpu_ldl_data(env, ea+48);
1447 env->gpr_d[5] = cpu_ldl_data(env, ea+52);
1448 env->gpr_d[6] = cpu_ldl_data(env, ea+56);
1449 env->gpr_d[7] = cpu_ldl_data(env, ea+60);
1450 }
1451
1452 void helper_call(CPUTriCoreState *env, uint32_t next_pc)
1453 {
1454 target_ulong tmp_FCX;
1455 target_ulong ea;
1456 target_ulong new_FCX;
1457 target_ulong psw;
1458
1459 psw = psw_read(env);
1460 /* if (FCX == 0) trap(FCU); */
1461 if (env->FCX == 0) {
1462 /* FCU trap */
1463 }
1464 /* if (PSW.CDE) then if (cdc_increment()) then trap(CDO); */
1465 if (psw & MASK_PSW_CDE) {
1466 if (cdc_increment(&psw)) {
1467 /* CDO trap */
1468 }
1469 }
1470 /* PSW.CDE = 1;*/
1471 psw |= MASK_PSW_CDE;
1472 /* tmp_FCX = FCX; */
1473 tmp_FCX = env->FCX;
1474 /* EA = {FCX.FCXS, 6'b0, FCX.FCXO, 6'b0}; */
1475 ea = ((env->FCX & MASK_FCX_FCXS) << 12) +
1476 ((env->FCX & MASK_FCX_FCXO) << 6);
1477 /* new_FCX = M(EA, word); */
1478 new_FCX = cpu_ldl_data(env, ea);
1479 /* M(EA, 16 * word) = {PCXI, PSW, A[10], A[11], D[8], D[9], D[10], D[11],
1480 A[12], A[13], A[14], A[15], D[12], D[13], D[14],
1481 D[15]}; */
1482 save_context_upper(env, ea);
1483
1484 /* PCXI.PCPN = ICR.CCPN; */
1485 env->PCXI = (env->PCXI & 0xffffff) +
1486 ((env->ICR & MASK_ICR_CCPN) << 24);
1487 /* PCXI.PIE = ICR.IE; */
1488 env->PCXI = ((env->PCXI & ~MASK_PCXI_PIE) +
1489 ((env->ICR & MASK_ICR_IE) << 15));
1490 /* PCXI.UL = 1; */
1491 env->PCXI |= MASK_PCXI_UL;
1492
1493 /* PCXI[19: 0] = FCX[19: 0]; */
1494 env->PCXI = (env->PCXI & 0xfff00000) + (env->FCX & 0xfffff);
1495 /* FCX[19: 0] = new_FCX[19: 0]; */
1496 env->FCX = (env->FCX & 0xfff00000) + (new_FCX & 0xfffff);
1497 /* A[11] = next_pc[31: 0]; */
1498 env->gpr_a[11] = next_pc;
1499
1500 /* if (tmp_FCX == LCX) trap(FCD);*/
1501 if (tmp_FCX == env->LCX) {
1502 /* FCD trap */
1503 }
1504 psw_write(env, psw);
1505 }
1506
1507 void helper_ret(CPUTriCoreState *env)
1508 {
1509 target_ulong ea;
1510 target_ulong new_PCXI;
1511 target_ulong new_PSW, psw;
1512
1513 psw = psw_read(env);
1514 /* if (PSW.CDE) then if (cdc_decrement()) then trap(CDU);*/
1515 if (env->PSW & MASK_PSW_CDE) {
1516 if (cdc_decrement(&(env->PSW))) {
1517 /* CDU trap */
1518 }
1519 }
1520 /* if (PCXI[19: 0] == 0) then trap(CSU); */
1521 if ((env->PCXI & 0xfffff) == 0) {
1522 /* CSU trap */
1523 }
1524 /* if (PCXI.UL == 0) then trap(CTYP); */
1525 if ((env->PCXI & MASK_PCXI_UL) == 0) {
1526 /* CTYP trap */
1527 }
1528 /* PC = {A11 [31: 1], 1’b0}; */
1529 env->PC = env->gpr_a[11] & 0xfffffffe;
1530
1531 /* EA = {PCXI.PCXS, 6'b0, PCXI.PCXO, 6'b0}; */
1532 ea = ((env->PCXI & MASK_PCXI_PCXS) << 12) +
1533 ((env->PCXI & MASK_PCXI_PCXO) << 6);
1534 /* {new_PCXI, new_PSW, A[10], A[11], D[8], D[9], D[10], D[11], A[12],
1535 A[13], A[14], A[15], D[12], D[13], D[14], D[15]} = M(EA, 16 * word); */
1536 restore_context_upper(env, ea, &new_PCXI, &new_PSW);
1537 /* M(EA, word) = FCX; */
1538 cpu_stl_data(env, ea, env->FCX);
1539 /* FCX[19: 0] = PCXI[19: 0]; */
1540 env->FCX = (env->FCX & 0xfff00000) + (env->PCXI & 0x000fffff);
1541 /* PCXI = new_PCXI; */
1542 env->PCXI = new_PCXI;
1543
1544 if (tricore_feature(env, TRICORE_FEATURE_13)) {
1545 /* PSW = new_PSW */
1546 psw_write(env, new_PSW);
1547 } else {
1548 /* PSW = {new_PSW[31:26], PSW[25:24], new_PSW[23:0]}; */
1549 psw_write(env, (new_PSW & ~(0x3000000)) + (psw & (0x3000000)));
1550 }
1551 }
1552
1553 void helper_bisr(CPUTriCoreState *env, uint32_t const9)
1554 {
1555 target_ulong tmp_FCX;
1556 target_ulong ea;
1557 target_ulong new_FCX;
1558
1559 if (env->FCX == 0) {
1560 /* FCU trap */
1561 }
1562
1563 tmp_FCX = env->FCX;
1564 ea = ((env->FCX & 0xf0000) << 12) + ((env->FCX & 0xffff) << 6);
1565
1566 /* new_FCX = M(EA, word); */
1567 new_FCX = cpu_ldl_data(env, ea);
1568 /* M(EA, 16 * word) = {PCXI, A[11], A[2], A[3], D[0], D[1], D[2], D[3], A[4]
1569 , A[5], A[6], A[7], D[4], D[5], D[6], D[7]}; */
1570 save_context_lower(env, ea);
1571
1572
1573 /* PCXI.PCPN = ICR.CCPN */
1574 env->PCXI = (env->PCXI & 0xffffff) +
1575 ((env->ICR & MASK_ICR_CCPN) << 24);
1576 /* PCXI.PIE = ICR.IE */
1577 env->PCXI = ((env->PCXI & ~MASK_PCXI_PIE) +
1578 ((env->ICR & MASK_ICR_IE) << 15));
1579 /* PCXI.UL = 0 */
1580 env->PCXI &= ~(MASK_PCXI_UL);
1581 /* PCXI[19: 0] = FCX[19: 0] */
1582 env->PCXI = (env->PCXI & 0xfff00000) + (env->FCX & 0xfffff);
1583 /* FXC[19: 0] = new_FCX[19: 0] */
1584 env->FCX = (env->FCX & 0xfff00000) + (new_FCX & 0xfffff);
1585 /* ICR.IE = 1 */
1586 env->ICR |= MASK_ICR_IE;
1587
1588 env->ICR |= const9; /* ICR.CCPN = const9[7: 0];*/
1589
1590 if (tmp_FCX == env->LCX) {
1591 /* FCD trap */
1592 }
1593 }
1594
1595 void helper_rfe(CPUTriCoreState *env)
1596 {
1597 target_ulong ea;
1598 target_ulong new_PCXI;
1599 target_ulong new_PSW;
1600 /* if (PCXI[19: 0] == 0) then trap(CSU); */
1601 if ((env->PCXI & 0xfffff) == 0) {
1602 /* raise csu trap */
1603 }
1604 /* if (PCXI.UL == 0) then trap(CTYP); */
1605 if ((env->PCXI & MASK_PCXI_UL) == 0) {
1606 /* raise CTYP trap */
1607 }
1608 /* if (!cdc_zero() AND PSW.CDE) then trap(NEST); */
1609 if (!cdc_zero(&(env->PSW)) && (env->PSW & MASK_PSW_CDE)) {
1610 /* raise MNG trap */
1611 }
1612 /* ICR.IE = PCXI.PIE; */
1613 env->ICR = (env->ICR & ~MASK_ICR_IE) + ((env->PCXI & MASK_PCXI_PIE) >> 15);
1614 /* ICR.CCPN = PCXI.PCPN; */
1615 env->ICR = (env->ICR & ~MASK_ICR_CCPN) +
1616 ((env->PCXI & MASK_PCXI_PCPN) >> 24);
1617 /*EA = {PCXI.PCXS, 6'b0, PCXI.PCXO, 6'b0};*/
1618 ea = ((env->PCXI & MASK_PCXI_PCXS) << 12) +
1619 ((env->PCXI & MASK_PCXI_PCXO) << 6);
1620 /*{new_PCXI, PSW, A[10], A[11], D[8], D[9], D[10], D[11], A[12],
1621 A[13], A[14], A[15], D[12], D[13], D[14], D[15]} = M(EA, 16 * word); */
1622 restore_context_upper(env, ea, &new_PCXI, &new_PSW);
1623 /* M(EA, word) = FCX;*/
1624 cpu_stl_data(env, ea, env->FCX);
1625 /* FCX[19: 0] = PCXI[19: 0]; */
1626 env->FCX = (env->FCX & 0xfff00000) + (env->PCXI & 0x000fffff);
1627 /* PCXI = new_PCXI; */
1628 env->PCXI = new_PCXI;
1629 /* write psw */
1630 psw_write(env, new_PSW);
1631 }
1632
1633 void helper_ldlcx(CPUTriCoreState *env, uint32_t ea)
1634 {
1635 uint32_t dummy;
1636 /* insn doesn't load PCXI and RA */
1637 restore_context_lower(env, ea, &dummy, &dummy);
1638 }
1639
1640 void helper_lducx(CPUTriCoreState *env, uint32_t ea)
1641 {
1642 uint32_t dummy;
1643 /* insn doesn't load PCXI and PSW */
1644 restore_context_upper(env, ea, &dummy, &dummy);
1645 }
1646
1647 void helper_stlcx(CPUTriCoreState *env, uint32_t ea)
1648 {
1649 save_context_lower(env, ea);
1650 }
1651
1652 void helper_stucx(CPUTriCoreState *env, uint32_t ea)
1653 {
1654 save_context_upper(env, ea);
1655 }
1656
1657 void helper_psw_write(CPUTriCoreState *env, uint32_t arg)
1658 {
1659 psw_write(env, arg);
1660 }
1661
1662 uint32_t helper_psw_read(CPUTriCoreState *env)
1663 {
1664 return psw_read(env);
1665 }
1666
1667
1668 static inline void QEMU_NORETURN do_raise_exception_err(CPUTriCoreState *env,
1669 uint32_t exception,
1670 int error_code,
1671 uintptr_t pc)
1672 {
1673 CPUState *cs = CPU(tricore_env_get_cpu(env));
1674 cs->exception_index = exception;
1675 env->error_code = error_code;
1676
1677 if (pc) {
1678 /* now we have a real cpu fault */
1679 cpu_restore_state(cs, pc);
1680 }
1681
1682 cpu_loop_exit(cs);
1683 }
1684
1685 void tlb_fill(CPUState *cs, target_ulong addr, int is_write, int mmu_idx,
1686 uintptr_t retaddr)
1687 {
1688 int ret;
1689 ret = cpu_tricore_handle_mmu_fault(cs, addr, is_write, mmu_idx);
1690 if (ret) {
1691 TriCoreCPU *cpu = TRICORE_CPU(cs);
1692 CPUTriCoreState *env = &cpu->env;
1693 do_raise_exception_err(env, cs->exception_index,
1694 env->error_code, retaddr);
1695 }
1696 }
QEMU mirror