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