?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
target-arm: get_phys_addr_lpae: more xn control
[qemu/ar7.git] / target-tricore / op_helper.c
blob40d32af5d3b08425085967441d1644e3a79cff4a
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 uint64_t helper_add64_ssov(CPUTriCoreState *env, uint64_t r1, uint64_t r2)
188 {
189 uint64_t result;
190 int64_t ovf;
191
192 result = r1 + r2;
193 ovf = (result ^ r1) & ~(r1 ^ r2);
194 env->PSW_USB_AV = (result ^ result * 2u) >> 32;
195 env->PSW_USB_SAV |= env->PSW_USB_AV;
196 if (ovf < 0) {
197 env->PSW_USB_V = (1 << 31);
198 env->PSW_USB_SV = (1 << 31);
199 /* ext_ret > MAX_INT */
200 if ((int64_t)r1 >= 0) {
201 result = INT64_MAX;
202 /* ext_ret < MIN_INT */
203 } else {
204 result = INT64_MIN;
205 }
206 } else {
207 env->PSW_USB_V = 0;
208 }
209 return result;
210 }
211
212 target_ulong helper_add_h_ssov(CPUTriCoreState *env, target_ulong r1,
213 target_ulong r2)
214 {
215 int32_t ret_hw0, ret_hw1;
216
217 ret_hw0 = sextract32(r1, 0, 16) + sextract32(r2, 0, 16);
218 ret_hw1 = sextract32(r1, 16, 16) + sextract32(r2, 16, 16);
219 return ssov16(env, ret_hw0, ret_hw1);
220 }
221
222 uint32_t helper_addr_h_ssov(CPUTriCoreState *env, uint64_t r1, uint32_t r2_l,
223 uint32_t r2_h)
224 {
225 int64_t mul_res0 = sextract64(r1, 0, 32);
226 int64_t mul_res1 = sextract64(r1, 32, 32);
227 int64_t r2_low = sextract64(r2_l, 0, 32);
228 int64_t r2_high = sextract64(r2_h, 0, 32);
229 int64_t result0, result1;
230 uint32_t ovf0, ovf1;
231 uint32_t avf0, avf1;
232
233 ovf0 = ovf1 = 0;
234
235 result0 = r2_low + mul_res0 + 0x8000;
236 result1 = r2_high + mul_res1 + 0x8000;
237
238 avf0 = result0 * 2u;
239 avf0 = result0 ^ avf0;
240 avf1 = result1 * 2u;
241 avf1 = result1 ^ avf1;
242
243 if (result0 > INT32_MAX) {
244 ovf0 = (1 << 31);
245 result0 = INT32_MAX;
246 } else if (result0 < INT32_MIN) {
247 ovf0 = (1 << 31);
248 result0 = INT32_MIN;
249 }
250
251 if (result1 > INT32_MAX) {
252 ovf1 = (1 << 31);
253 result1 = INT32_MAX;
254 } else if (result1 < INT32_MIN) {
255 ovf1 = (1 << 31);
256 result1 = INT32_MIN;
257 }
258
259 env->PSW_USB_V = ovf0 | ovf1;
260 env->PSW_USB_SV |= env->PSW_USB_V;
261
262 env->PSW_USB_AV = avf0 | avf1;
263 env->PSW_USB_SAV |= env->PSW_USB_AV;
264
265 return (result1 & 0xffff0000ULL) | ((result0 >> 16) & 0xffffULL);
266 }
267
268 uint32_t helper_addsur_h_ssov(CPUTriCoreState *env, uint64_t r1, uint32_t r2_l,
269 uint32_t r2_h)
270 {
271 int64_t mul_res0 = sextract64(r1, 0, 32);
272 int64_t mul_res1 = sextract64(r1, 32, 32);
273 int64_t r2_low = sextract64(r2_l, 0, 32);
274 int64_t r2_high = sextract64(r2_h, 0, 32);
275 int64_t result0, result1;
276 uint32_t ovf0, ovf1;
277 uint32_t avf0, avf1;
278
279 ovf0 = ovf1 = 0;
280
281 result0 = r2_low - mul_res0 + 0x8000;
282 result1 = r2_high + mul_res1 + 0x8000;
283
284 avf0 = result0 * 2u;
285 avf0 = result0 ^ avf0;
286 avf1 = result1 * 2u;
287 avf1 = result1 ^ avf1;
288
289 if (result0 > INT32_MAX) {
290 ovf0 = (1 << 31);
291 result0 = INT32_MAX;
292 } else if (result0 < INT32_MIN) {
293 ovf0 = (1 << 31);
294 result0 = INT32_MIN;
295 }
296
297 if (result1 > INT32_MAX) {
298 ovf1 = (1 << 31);
299 result1 = INT32_MAX;
300 } else if (result1 < INT32_MIN) {
301 ovf1 = (1 << 31);
302 result1 = INT32_MIN;
303 }
304
305 env->PSW_USB_V = ovf0 | ovf1;
306 env->PSW_USB_SV |= env->PSW_USB_V;
307
308 env->PSW_USB_AV = avf0 | avf1;
309 env->PSW_USB_SAV |= env->PSW_USB_AV;
310
311 return (result1 & 0xffff0000ULL) | ((result0 >> 16) & 0xffffULL);
312 }
313
314
315 target_ulong helper_add_suov(CPUTriCoreState *env, target_ulong r1,
316 target_ulong r2)
317 {
318 int64_t t1 = extract64(r1, 0, 32);
319 int64_t t2 = extract64(r2, 0, 32);
320 int64_t result = t1 + t2;
321 return suov32_pos(env, result);
322 }
323
324 target_ulong helper_add_h_suov(CPUTriCoreState *env, target_ulong r1,
325 target_ulong r2)
326 {
327 int32_t ret_hw0, ret_hw1;
328
329 ret_hw0 = extract32(r1, 0, 16) + extract32(r2, 0, 16);
330 ret_hw1 = extract32(r1, 16, 16) + extract32(r2, 16, 16);
331 return suov16(env, ret_hw0, ret_hw1);
332 }
333
334 target_ulong helper_sub_ssov(CPUTriCoreState *env, target_ulong r1,
335 target_ulong r2)
336 {
337 int64_t t1 = sextract64(r1, 0, 32);
338 int64_t t2 = sextract64(r2, 0, 32);
339 int64_t result = t1 - t2;
340 return ssov32(env, result);
341 }
342
343 target_ulong helper_sub_h_ssov(CPUTriCoreState *env, target_ulong r1,
344 target_ulong r2)
345 {
346 int32_t ret_hw0, ret_hw1;
347
348 ret_hw0 = sextract32(r1, 0, 16) - sextract32(r2, 0, 16);
349 ret_hw1 = sextract32(r1, 16, 16) - sextract32(r2, 16, 16);
350 return ssov16(env, ret_hw0, ret_hw1);
351 }
352
353 target_ulong helper_sub_suov(CPUTriCoreState *env, target_ulong r1,
354 target_ulong r2)
355 {
356 int64_t t1 = extract64(r1, 0, 32);
357 int64_t t2 = extract64(r2, 0, 32);
358 int64_t result = t1 - t2;
359 return suov32_neg(env, result);
360 }
361
362 target_ulong helper_sub_h_suov(CPUTriCoreState *env, target_ulong r1,
363 target_ulong r2)
364 {
365 int32_t ret_hw0, ret_hw1;
366
367 ret_hw0 = extract32(r1, 0, 16) - extract32(r2, 0, 16);
368 ret_hw1 = extract32(r1, 16, 16) - extract32(r2, 16, 16);
369 return suov16(env, ret_hw0, ret_hw1);
370 }
371
372 target_ulong helper_mul_ssov(CPUTriCoreState *env, target_ulong r1,
373 target_ulong r2)
374 {
375 int64_t t1 = sextract64(r1, 0, 32);
376 int64_t t2 = sextract64(r2, 0, 32);
377 int64_t result = t1 * t2;
378 return ssov32(env, result);
379 }
380
381 target_ulong helper_mul_suov(CPUTriCoreState *env, target_ulong r1,
382 target_ulong r2)
383 {
384 int64_t t1 = extract64(r1, 0, 32);
385 int64_t t2 = extract64(r2, 0, 32);
386 int64_t result = t1 * t2;
387
388 return suov32_pos(env, result);
389 }
390
391 target_ulong helper_sha_ssov(CPUTriCoreState *env, target_ulong r1,
392 target_ulong r2)
393 {
394 int64_t t1 = sextract64(r1, 0, 32);
395 int32_t t2 = sextract64(r2, 0, 6);
396 int64_t result;
397 if (t2 == 0) {
398 result = t1;
399 } else if (t2 > 0) {
400 result = t1 << t2;
401 } else {
402 result = t1 >> -t2;
403 }
404 return ssov32(env, result);
405 }
406
407 uint32_t helper_abs_ssov(CPUTriCoreState *env, target_ulong r1)
408 {
409 target_ulong result;
410 result = ((int32_t)r1 >= 0) ? r1 : (0 - r1);
411 return ssov32(env, result);
412 }
413
414 uint32_t helper_abs_h_ssov(CPUTriCoreState *env, target_ulong r1)
415 {
416 int32_t ret_h0, ret_h1;
417
418 ret_h0 = sextract32(r1, 0, 16);
419 ret_h0 = (ret_h0 >= 0) ? ret_h0 : (0 - ret_h0);
420
421 ret_h1 = sextract32(r1, 16, 16);
422 ret_h1 = (ret_h1 >= 0) ? ret_h1 : (0 - ret_h1);
423
424 return ssov16(env, ret_h0, ret_h1);
425 }
426
427 target_ulong helper_absdif_ssov(CPUTriCoreState *env, target_ulong r1,
428 target_ulong r2)
429 {
430 int64_t t1 = sextract64(r1, 0, 32);
431 int64_t t2 = sextract64(r2, 0, 32);
432 int64_t result;
433
434 if (t1 > t2) {
435 result = t1 - t2;
436 } else {
437 result = t2 - t1;
438 }
439 return ssov32(env, result);
440 }
441
442 uint32_t helper_absdif_h_ssov(CPUTriCoreState *env, target_ulong r1,
443 target_ulong r2)
444 {
445 int32_t t1, t2;
446 int32_t ret_h0, ret_h1;
447
448 t1 = sextract32(r1, 0, 16);
449 t2 = sextract32(r2, 0, 16);
450 if (t1 > t2) {
451 ret_h0 = t1 - t2;
452 } else {
453 ret_h0 = t2 - t1;
454 }
455
456 t1 = sextract32(r1, 16, 16);
457 t2 = sextract32(r2, 16, 16);
458 if (t1 > t2) {
459 ret_h1 = t1 - t2;
460 } else {
461 ret_h1 = t2 - t1;
462 }
463
464 return ssov16(env, ret_h0, ret_h1);
465 }
466
467 target_ulong helper_madd32_ssov(CPUTriCoreState *env, target_ulong r1,
468 target_ulong r2, target_ulong r3)
469 {
470 int64_t t1 = sextract64(r1, 0, 32);
471 int64_t t2 = sextract64(r2, 0, 32);
472 int64_t t3 = sextract64(r3, 0, 32);
473 int64_t result;
474
475 result = t2 + (t1 * t3);
476 return ssov32(env, result);
477 }
478
479 target_ulong helper_madd32_suov(CPUTriCoreState *env, target_ulong r1,
480 target_ulong r2, target_ulong r3)
481 {
482 uint64_t t1 = extract64(r1, 0, 32);
483 uint64_t t2 = extract64(r2, 0, 32);
484 uint64_t t3 = extract64(r3, 0, 32);
485 int64_t result;
486
487 result = t2 + (t1 * t3);
488 return suov32_pos(env, result);
489 }
490
491 uint64_t helper_madd64_ssov(CPUTriCoreState *env, target_ulong r1,
492 uint64_t r2, target_ulong r3)
493 {
494 uint64_t ret, ovf;
495 int64_t t1 = sextract64(r1, 0, 32);
496 int64_t t3 = sextract64(r3, 0, 32);
497 int64_t mul;
498
499 mul = t1 * t3;
500 ret = mul + r2;
501 ovf = (ret ^ mul) & ~(mul ^ r2);
502
503 t1 = ret >> 32;
504 env->PSW_USB_AV = t1 ^ t1 * 2u;
505 env->PSW_USB_SAV |= env->PSW_USB_AV;
506
507 if ((int64_t)ovf < 0) {
508 env->PSW_USB_V = (1 << 31);
509 env->PSW_USB_SV = (1 << 31);
510 /* ext_ret > MAX_INT */
511 if (mul >= 0) {
512 ret = INT64_MAX;
513 /* ext_ret < MIN_INT */
514 } else {
515 ret = INT64_MIN;
516 }
517 } else {
518 env->PSW_USB_V = 0;
519 }
520
521 return ret;
522 }
523
524 uint32_t
525 helper_madd32_q_add_ssov(CPUTriCoreState *env, uint64_t r1, uint64_t r2)
526 {
527 int64_t result;
528
529 result = (r1 + r2);
530
531 env->PSW_USB_AV = (result ^ result * 2u);
532 env->PSW_USB_SAV |= env->PSW_USB_AV;
533
534 /* we do the saturation by hand, since we produce an overflow on the host
535 if the mul before was (0x80000000 * 0x80000000) << 1). If this is the
536 case, we flip the saturated value. */
537 if (r2 == 0x8000000000000000LL) {
538 if (result > 0x7fffffffLL) {
539 env->PSW_USB_V = (1 << 31);
540 env->PSW_USB_SV = (1 << 31);
541 result = INT32_MIN;
542 } else if (result < -0x80000000LL) {
543 env->PSW_USB_V = (1 << 31);
544 env->PSW_USB_SV = (1 << 31);
545 result = INT32_MAX;
546 } else {
547 env->PSW_USB_V = 0;
548 }
549 } else {
550 if (result > 0x7fffffffLL) {
551 env->PSW_USB_V = (1 << 31);
552 env->PSW_USB_SV = (1 << 31);
553 result = INT32_MAX;
554 } else if (result < -0x80000000LL) {
555 env->PSW_USB_V = (1 << 31);
556 env->PSW_USB_SV = (1 << 31);
557 result = INT32_MIN;
558 } else {
559 env->PSW_USB_V = 0;
560 }
561 }
562 return (uint32_t)result;
563 }
564
565 uint64_t helper_madd64_q_ssov(CPUTriCoreState *env, uint64_t r1, uint32_t r2,
566 uint32_t r3, uint32_t n)
567 {
568 int64_t t1 = (int64_t)r1;
569 int64_t t2 = sextract64(r2, 0, 32);
570 int64_t t3 = sextract64(r3, 0, 32);
571 int64_t result, mul;
572 int64_t ovf;
573
574 mul = (t2 * t3) << n;
575 result = mul + t1;
576
577 env->PSW_USB_AV = (result ^ result * 2u) >> 32;
578 env->PSW_USB_SAV |= env->PSW_USB_AV;
579
580 ovf = (result ^ mul) & ~(mul ^ t1);
581 /* we do the saturation by hand, since we produce an overflow on the host
582 if the mul was (0x80000000 * 0x80000000) << 1). If this is the
583 case, we flip the saturated value. */
584 if ((r2 == 0x80000000) && (r3 == 0x80000000) && (n == 1)) {
585 if (ovf >= 0) {
586 env->PSW_USB_V = (1 << 31);
587 env->PSW_USB_SV = (1 << 31);
588 /* ext_ret > MAX_INT */
589 if (mul < 0) {
590 result = INT64_MAX;
591 /* ext_ret < MIN_INT */
592 } else {
593 result = INT64_MIN;
594 }
595 } else {
596 env->PSW_USB_V = 0;
597 }
598 } else {
599 if (ovf < 0) {
600 env->PSW_USB_V = (1 << 31);
601 env->PSW_USB_SV = (1 << 31);
602 /* ext_ret > MAX_INT */
603 if (mul >= 0) {
604 result = INT64_MAX;
605 /* ext_ret < MIN_INT */
606 } else {
607 result = INT64_MIN;
608 }
609 } else {
610 env->PSW_USB_V = 0;
611 }
612 }
613 return (uint64_t)result;
614 }
615
616 uint32_t helper_maddr_q_ssov(CPUTriCoreState *env, uint32_t r1, uint32_t r2,
617 uint32_t r3, uint32_t n)
618 {
619 int64_t t1 = sextract64(r1, 0, 32);
620 int64_t t2 = sextract64(r2, 0, 32);
621 int64_t t3 = sextract64(r3, 0, 32);
622 int64_t mul, ret;
623
624 if ((t2 == -0x8000ll) && (t3 == -0x8000ll) && (n == 1)) {
625 mul = 0x7fffffff;
626 } else {
627 mul = (t2 * t3) << n;
628 }
629
630 ret = t1 + mul + 0x8000;
631
632 env->PSW_USB_AV = ret ^ ret * 2u;
633 env->PSW_USB_SAV |= env->PSW_USB_AV;
634
635 if (ret > 0x7fffffffll) {
636 env->PSW_USB_V = (1 << 31);
637 env->PSW_USB_SV |= env->PSW_USB_V;
638 ret = INT32_MAX;
639 } else if (ret < -0x80000000ll) {
640 env->PSW_USB_V = (1 << 31);
641 env->PSW_USB_SV |= env->PSW_USB_V;
642 ret = INT32_MIN;
643 } else {
644 env->PSW_USB_V = 0;
645 }
646 return ret & 0xffff0000ll;
647 }
648
649 uint64_t helper_madd64_suov(CPUTriCoreState *env, target_ulong r1,
650 uint64_t r2, target_ulong r3)
651 {
652 uint64_t ret, mul;
653 uint64_t t1 = extract64(r1, 0, 32);
654 uint64_t t3 = extract64(r3, 0, 32);
655
656 mul = t1 * t3;
657 ret = mul + r2;
658
659 t1 = ret >> 32;
660 env->PSW_USB_AV = t1 ^ t1 * 2u;
661 env->PSW_USB_SAV |= env->PSW_USB_AV;
662
663 if (ret < r2) {
664 env->PSW_USB_V = (1 << 31);
665 env->PSW_USB_SV = (1 << 31);
666 /* saturate */
667 ret = UINT64_MAX;
668 } else {
669 env->PSW_USB_V = 0;
670 }
671 return ret;
672 }
673
674 target_ulong helper_msub32_ssov(CPUTriCoreState *env, target_ulong r1,
675 target_ulong r2, target_ulong r3)
676 {
677 int64_t t1 = sextract64(r1, 0, 32);
678 int64_t t2 = sextract64(r2, 0, 32);
679 int64_t t3 = sextract64(r3, 0, 32);
680 int64_t result;
681
682 result = t2 - (t1 * t3);
683 return ssov32(env, result);
684 }
685
686 target_ulong helper_msub32_suov(CPUTriCoreState *env, target_ulong r1,
687 target_ulong r2, target_ulong r3)
688 {
689 uint64_t t1 = extract64(r1, 0, 32);
690 uint64_t t2 = extract64(r2, 0, 32);
691 uint64_t t3 = extract64(r3, 0, 32);
692 uint64_t result;
693 uint64_t mul;
694
695 mul = (t1 * t3);
696 result = t2 - mul;
697
698 env->PSW_USB_AV = result ^ result * 2u;
699 env->PSW_USB_SAV |= env->PSW_USB_AV;
700 /* we calculate ovf by hand here, because the multiplication can overflow on
701 the host, which would give false results if we compare to less than
702 zero */
703 if (mul > t2) {
704 env->PSW_USB_V = (1 << 31);
705 env->PSW_USB_SV = (1 << 31);
706 result = 0;
707 } else {
708 env->PSW_USB_V = 0;
709 }
710 return result;
711 }
712
713 uint64_t helper_msub64_ssov(CPUTriCoreState *env, target_ulong r1,
714 uint64_t r2, target_ulong r3)
715 {
716 uint64_t ret, ovf;
717 int64_t t1 = sextract64(r1, 0, 32);
718 int64_t t3 = sextract64(r3, 0, 32);
719 int64_t mul;
720
721 mul = t1 * t3;
722 ret = r2 - mul;
723 ovf = (ret ^ r2) & (mul ^ r2);
724
725 t1 = ret >> 32;
726 env->PSW_USB_AV = t1 ^ t1 * 2u;
727 env->PSW_USB_SAV |= env->PSW_USB_AV;
728
729 if ((int64_t)ovf < 0) {
730 env->PSW_USB_V = (1 << 31);
731 env->PSW_USB_SV = (1 << 31);
732 /* ext_ret > MAX_INT */
733 if (mul < 0) {
734 ret = INT64_MAX;
735 /* ext_ret < MIN_INT */
736 } else {
737 ret = INT64_MIN;
738 }
739 } else {
740 env->PSW_USB_V = 0;
741 }
742 return ret;
743 }
744
745 uint64_t helper_msub64_suov(CPUTriCoreState *env, target_ulong r1,
746 uint64_t r2, target_ulong r3)
747 {
748 uint64_t ret, mul;
749 uint64_t t1 = extract64(r1, 0, 32);
750 uint64_t t3 = extract64(r3, 0, 32);
751
752 mul = t1 * t3;
753 ret = r2 - mul;
754
755 t1 = ret >> 32;
756 env->PSW_USB_AV = t1 ^ t1 * 2u;
757 env->PSW_USB_SAV |= env->PSW_USB_AV;
758
759 if (ret > r2) {
760 env->PSW_USB_V = (1 << 31);
761 env->PSW_USB_SV = (1 << 31);
762 /* saturate */
763 ret = 0;
764 } else {
765 env->PSW_USB_V = 0;
766 }
767 return ret;
768 }
769
770 uint32_t helper_abs_b(CPUTriCoreState *env, target_ulong arg)
771 {
772 int32_t b, i;
773 int32_t ovf = 0;
774 int32_t avf = 0;
775 int32_t ret = 0;
776
777 for (i = 0; i < 4; i++) {
778 b = sextract32(arg, i * 8, 8);
779 b = (b >= 0) ? b : (0 - b);
780 ovf |= (b > 0x7F) || (b < -0x80);
781 avf |= b ^ b * 2u;
782 ret |= (b & 0xff) << (i * 8);
783 }
784
785 env->PSW_USB_V = ovf << 31;
786 env->PSW_USB_SV |= env->PSW_USB_V;
787 env->PSW_USB_AV = avf << 24;
788 env->PSW_USB_SAV |= env->PSW_USB_AV;
789
790 return ret;
791 }
792
793 uint32_t helper_abs_h(CPUTriCoreState *env, target_ulong arg)
794 {
795 int32_t h, i;
796 int32_t ovf = 0;
797 int32_t avf = 0;
798 int32_t ret = 0;
799
800 for (i = 0; i < 2; i++) {
801 h = sextract32(arg, i * 16, 16);
802 h = (h >= 0) ? h : (0 - h);
803 ovf |= (h > 0x7FFF) || (h < -0x8000);
804 avf |= h ^ h * 2u;
805 ret |= (h & 0xffff) << (i * 16);
806 }
807
808 env->PSW_USB_V = ovf << 31;
809 env->PSW_USB_SV |= env->PSW_USB_V;
810 env->PSW_USB_AV = avf << 16;
811 env->PSW_USB_SAV |= env->PSW_USB_AV;
812
813 return ret;
814 }
815
816 uint32_t helper_absdif_b(CPUTriCoreState *env, target_ulong r1, target_ulong r2)
817 {
818 int32_t b, i;
819 int32_t extr_r2;
820 int32_t ovf = 0;
821 int32_t avf = 0;
822 int32_t ret = 0;
823
824 for (i = 0; i < 4; i++) {
825 extr_r2 = sextract32(r2, i * 8, 8);
826 b = sextract32(r1, i * 8, 8);
827 b = (b > extr_r2) ? (b - extr_r2) : (extr_r2 - b);
828 ovf |= (b > 0x7F) || (b < -0x80);
829 avf |= b ^ b * 2u;
830 ret |= (b & 0xff) << (i * 8);
831 }
832
833 env->PSW_USB_V = ovf << 31;
834 env->PSW_USB_SV |= env->PSW_USB_V;
835 env->PSW_USB_AV = avf << 24;
836 env->PSW_USB_SAV |= env->PSW_USB_AV;
837 return ret;
838 }
839
840 uint32_t helper_absdif_h(CPUTriCoreState *env, target_ulong r1, target_ulong r2)
841 {
842 int32_t h, i;
843 int32_t extr_r2;
844 int32_t ovf = 0;
845 int32_t avf = 0;
846 int32_t ret = 0;
847
848 for (i = 0; i < 2; i++) {
849 extr_r2 = sextract32(r2, i * 16, 16);
850 h = sextract32(r1, i * 16, 16);
851 h = (h > extr_r2) ? (h - extr_r2) : (extr_r2 - h);
852 ovf |= (h > 0x7FFF) || (h < -0x8000);
853 avf |= h ^ h * 2u;
854 ret |= (h & 0xffff) << (i * 16);
855 }
856
857 env->PSW_USB_V = ovf << 31;
858 env->PSW_USB_SV |= env->PSW_USB_V;
859 env->PSW_USB_AV = avf << 16;
860 env->PSW_USB_SAV |= env->PSW_USB_AV;
861
862 return ret;
863 }
864
865 uint32_t helper_addr_h(CPUTriCoreState *env, uint64_t r1, uint32_t r2_l,
866 uint32_t r2_h)
867 {
868 int64_t mul_res0 = sextract64(r1, 0, 32);
869 int64_t mul_res1 = sextract64(r1, 32, 32);
870 int64_t r2_low = sextract64(r2_l, 0, 32);
871 int64_t r2_high = sextract64(r2_h, 0, 32);
872 int64_t result0, result1;
873 uint32_t ovf0, ovf1;
874 uint32_t avf0, avf1;
875
876 ovf0 = ovf1 = 0;
877
878 result0 = r2_low + mul_res0 + 0x8000;
879 result1 = r2_high + mul_res1 + 0x8000;
880
881 if ((result0 > INT32_MAX) || (result0 < INT32_MIN)) {
882 ovf0 = (1 << 31);
883 }
884
885 if ((result1 > INT32_MAX) || (result1 < INT32_MIN)) {
886 ovf1 = (1 << 31);
887 }
888
889 env->PSW_USB_V = ovf0 | ovf1;
890 env->PSW_USB_SV |= env->PSW_USB_V;
891
892 avf0 = result0 * 2u;
893 avf0 = result0 ^ avf0;
894 avf1 = result1 * 2u;
895 avf1 = result1 ^ avf1;
896
897 env->PSW_USB_AV = avf0 | avf1;
898 env->PSW_USB_SAV |= env->PSW_USB_AV;
899
900 return (result1 & 0xffff0000ULL) | ((result0 >> 16) & 0xffffULL);
901 }
902
903 uint32_t helper_addsur_h(CPUTriCoreState *env, uint64_t r1, uint32_t r2_l,
904 uint32_t r2_h)
905 {
906 int64_t mul_res0 = sextract64(r1, 0, 32);
907 int64_t mul_res1 = sextract64(r1, 32, 32);
908 int64_t r2_low = sextract64(r2_l, 0, 32);
909 int64_t r2_high = sextract64(r2_h, 0, 32);
910 int64_t result0, result1;
911 uint32_t ovf0, ovf1;
912 uint32_t avf0, avf1;
913
914 ovf0 = ovf1 = 0;
915
916 result0 = r2_low - mul_res0 + 0x8000;
917 result1 = r2_high + mul_res1 + 0x8000;
918
919 if ((result0 > INT32_MAX) || (result0 < INT32_MIN)) {
920 ovf0 = (1 << 31);
921 }
922
923 if ((result1 > INT32_MAX) || (result1 < INT32_MIN)) {
924 ovf1 = (1 << 31);
925 }
926
927 env->PSW_USB_V = ovf0 | ovf1;
928 env->PSW_USB_SV |= env->PSW_USB_V;
929
930 avf0 = result0 * 2u;
931 avf0 = result0 ^ avf0;
932 avf1 = result1 * 2u;
933 avf1 = result1 ^ avf1;
934
935 env->PSW_USB_AV = avf0 | avf1;
936 env->PSW_USB_SAV |= env->PSW_USB_AV;
937
938 return (result1 & 0xffff0000ULL) | ((result0 >> 16) & 0xffffULL);
939 }
940
941 uint32_t helper_maddr_q(CPUTriCoreState *env, uint32_t r1, uint32_t r2,
942 uint32_t r3, uint32_t n)
943 {
944 int64_t t1 = sextract64(r1, 0, 32);
945 int64_t t2 = sextract64(r2, 0, 32);
946 int64_t t3 = sextract64(r3, 0, 32);
947 int64_t mul, ret;
948
949 if ((t2 == -0x8000ll) && (t3 == -0x8000ll) && (n == 1)) {
950 mul = 0x7fffffff;
951 } else {
952 mul = (t2 * t3) << n;
953 }
954
955 ret = t1 + mul + 0x8000;
956
957 if ((ret > 0x7fffffffll) || (ret < -0x80000000ll)) {
958 env->PSW_USB_V = (1 << 31);
959 env->PSW_USB_SV |= env->PSW_USB_V;
960 } else {
961 env->PSW_USB_V = 0;
962 }
963 env->PSW_USB_AV = ret ^ ret * 2u;
964 env->PSW_USB_SAV |= env->PSW_USB_AV;
965
966 return ret & 0xffff0000ll;
967 }
968
969 uint32_t helper_add_b(CPUTriCoreState *env, target_ulong r1, target_ulong r2)
970 {
971 int32_t b, i;
972 int32_t extr_r1, extr_r2;
973 int32_t ovf = 0;
974 int32_t avf = 0;
975 uint32_t ret = 0;
976
977 for (i = 0; i < 4; i++) {
978 extr_r1 = sextract32(r1, i * 8, 8);
979 extr_r2 = sextract32(r2, i * 8, 8);
980
981 b = extr_r1 + extr_r2;
982 ovf |= ((b > 0x7f) || (b < -0x80));
983 avf |= b ^ b * 2u;
984 ret |= ((b & 0xff) << (i*8));
985 }
986
987 env->PSW_USB_V = (ovf << 31);
988 env->PSW_USB_SV |= env->PSW_USB_V;
989 env->PSW_USB_AV = avf << 24;
990 env->PSW_USB_SAV |= env->PSW_USB_AV;
991
992 return ret;
993 }
994
995 uint32_t helper_add_h(CPUTriCoreState *env, target_ulong r1, target_ulong r2)
996 {
997 int32_t h, i;
998 int32_t extr_r1, extr_r2;
999 int32_t ovf = 0;
1000 int32_t avf = 0;
1001 int32_t ret = 0;
1002
1003 for (i = 0; i < 2; i++) {
1004 extr_r1 = sextract32(r1, i * 16, 16);
1005 extr_r2 = sextract32(r2, i * 16, 16);
1006 h = extr_r1 + extr_r2;
1007 ovf |= ((h > 0x7fff) || (h < -0x8000));
1008 avf |= h ^ h * 2u;
1009 ret |= (h & 0xffff) << (i * 16);
1010 }
1011
1012 env->PSW_USB_V = (ovf << 31);
1013 env->PSW_USB_SV |= env->PSW_USB_V;
1014 env->PSW_USB_AV = (avf << 16);
1015 env->PSW_USB_SAV |= env->PSW_USB_AV;
1016
1017 return ret;
1018 }
1019
1020 uint32_t helper_sub_b(CPUTriCoreState *env, target_ulong r1, target_ulong r2)
1021 {
1022 int32_t b, i;
1023 int32_t extr_r1, extr_r2;
1024 int32_t ovf = 0;
1025 int32_t avf = 0;
1026 uint32_t ret = 0;
1027
1028 for (i = 0; i < 4; i++) {
1029 extr_r1 = sextract32(r1, i * 8, 8);
1030 extr_r2 = sextract32(r2, i * 8, 8);
1031
1032 b = extr_r1 - extr_r2;
1033 ovf |= ((b > 0x7f) || (b < -0x80));
1034 avf |= b ^ b * 2u;
1035 ret |= ((b & 0xff) << (i*8));
1036 }
1037
1038 env->PSW_USB_V = (ovf << 31);
1039 env->PSW_USB_SV |= env->PSW_USB_V;
1040 env->PSW_USB_AV = avf << 24;
1041 env->PSW_USB_SAV |= env->PSW_USB_AV;
1042
1043 return ret;
1044 }
1045
1046 uint32_t helper_sub_h(CPUTriCoreState *env, target_ulong r1, target_ulong r2)
1047 {
1048 int32_t h, i;
1049 int32_t extr_r1, extr_r2;
1050 int32_t ovf = 0;
1051 int32_t avf = 0;
1052 int32_t ret = 0;
1053
1054 for (i = 0; i < 2; i++) {
1055 extr_r1 = sextract32(r1, i * 16, 16);
1056 extr_r2 = sextract32(r2, i * 16, 16);
1057 h = extr_r1 - extr_r2;
1058 ovf |= ((h > 0x7fff) || (h < -0x8000));
1059 avf |= h ^ h * 2u;
1060 ret |= (h & 0xffff) << (i * 16);
1061 }
1062
1063 env->PSW_USB_V = (ovf << 31);
1064 env->PSW_USB_SV |= env->PSW_USB_V;
1065 env->PSW_USB_AV = avf << 16;
1066 env->PSW_USB_SAV |= env->PSW_USB_AV;
1067
1068 return ret;
1069 }
1070
1071 uint32_t helper_eq_b(target_ulong r1, target_ulong r2)
1072 {
1073 int32_t ret;
1074 int32_t i, msk;
1075
1076 ret = 0;
1077 msk = 0xff;
1078 for (i = 0; i < 4; i++) {
1079 if ((r1 & msk) == (r2 & msk)) {
1080 ret |= msk;
1081 }
1082 msk = msk << 8;
1083 }
1084
1085 return ret;
1086 }
1087
1088 uint32_t helper_eq_h(target_ulong r1, target_ulong r2)
1089 {
1090 int32_t ret = 0;
1091
1092 if ((r1 & 0xffff) == (r2 & 0xffff)) {
1093 ret = 0xffff;
1094 }
1095
1096 if ((r1 & 0xffff0000) == (r2 & 0xffff0000)) {
1097 ret |= 0xffff0000;
1098 }
1099
1100 return ret;
1101 }
1102
1103 uint32_t helper_eqany_b(target_ulong r1, target_ulong r2)
1104 {
1105 int32_t i;
1106 uint32_t ret = 0;
1107
1108 for (i = 0; i < 4; i++) {
1109 ret |= (sextract32(r1, i * 8, 8) == sextract32(r2, i * 8, 8));
1110 }
1111
1112 return ret;
1113 }
1114
1115 uint32_t helper_eqany_h(target_ulong r1, target_ulong r2)
1116 {
1117 uint32_t ret;
1118
1119 ret = (sextract32(r1, 0, 16) == sextract32(r2, 0, 16));
1120 ret |= (sextract32(r1, 16, 16) == sextract32(r2, 16, 16));
1121
1122 return ret;
1123 }
1124
1125 uint32_t helper_lt_b(target_ulong r1, target_ulong r2)
1126 {
1127 int32_t i;
1128 uint32_t ret = 0;
1129
1130 for (i = 0; i < 4; i++) {
1131 if (sextract32(r1, i * 8, 8) < sextract32(r2, i * 8, 8)) {
1132 ret |= (0xff << (i * 8));
1133 }
1134 }
1135
1136 return ret;
1137 }
1138
1139 uint32_t helper_lt_bu(target_ulong r1, target_ulong r2)
1140 {
1141 int32_t i;
1142 uint32_t ret = 0;
1143
1144 for (i = 0; i < 4; i++) {
1145 if (extract32(r1, i * 8, 8) < extract32(r2, i * 8, 8)) {
1146 ret |= (0xff << (i * 8));
1147 }
1148 }
1149
1150 return ret;
1151 }
1152
1153 uint32_t helper_lt_h(target_ulong r1, target_ulong r2)
1154 {
1155 uint32_t ret = 0;
1156
1157 if (sextract32(r1, 0, 16) < sextract32(r2, 0, 16)) {
1158 ret |= 0xffff;
1159 }
1160
1161 if (sextract32(r1, 16, 16) < sextract32(r2, 16, 16)) {
1162 ret |= 0xffff0000;
1163 }
1164
1165 return ret;
1166 }
1167
1168 uint32_t helper_lt_hu(target_ulong r1, target_ulong r2)
1169 {
1170 uint32_t ret = 0;
1171
1172 if (extract32(r1, 0, 16) < extract32(r2, 0, 16)) {
1173 ret |= 0xffff;
1174 }
1175
1176 if (extract32(r1, 16, 16) < extract32(r2, 16, 16)) {
1177 ret |= 0xffff0000;
1178 }
1179
1180 return ret;
1181 }
1182
1183 #define EXTREMA_H_B(name, op) \
1184 uint32_t helper_##name ##_b(target_ulong r1, target_ulong r2) \
1185 { \
1186 int32_t i, extr_r1, extr_r2; \
1187 uint32_t ret = 0; \
1188 \
1189 for (i = 0; i < 4; i++) { \
1190 extr_r1 = sextract32(r1, i * 8, 8); \
1191 extr_r2 = sextract32(r2, i * 8, 8); \
1192 extr_r1 = (extr_r1 op extr_r2) ? extr_r1 : extr_r2; \
1193 ret |= (extr_r1 & 0xff) << (i * 8); \
1194 } \
1195 return ret; \
1196 } \
1197 \
1198 uint32_t helper_##name ##_bu(target_ulong r1, target_ulong r2)\
1199 { \
1200 int32_t i; \
1201 uint32_t extr_r1, extr_r2; \
1202 uint32_t ret = 0; \
1203 \
1204 for (i = 0; i < 4; i++) { \
1205 extr_r1 = extract32(r1, i * 8, 8); \
1206 extr_r2 = extract32(r2, i * 8, 8); \
1207 extr_r1 = (extr_r1 op extr_r2) ? extr_r1 : extr_r2; \
1208 ret |= (extr_r1 & 0xff) << (i * 8); \
1209 } \
1210 return ret; \
1211 } \
1212 \
1213 uint32_t helper_##name ##_h(target_ulong r1, target_ulong r2) \
1214 { \
1215 int32_t extr_r1, extr_r2; \
1216 uint32_t ret = 0; \
1217 \
1218 extr_r1 = sextract32(r1, 0, 16); \
1219 extr_r2 = sextract32(r2, 0, 16); \
1220 ret = (extr_r1 op extr_r2) ? extr_r1 : extr_r2; \
1221 ret = ret & 0xffff; \
1222 \
1223 extr_r1 = sextract32(r1, 16, 16); \
1224 extr_r2 = sextract32(r2, 16, 16); \
1225 extr_r1 = (extr_r1 op extr_r2) ? extr_r1 : extr_r2; \
1226 ret |= extr_r1 << 16; \
1227 \
1228 return ret; \
1229 } \
1230 \
1231 uint32_t helper_##name ##_hu(target_ulong r1, target_ulong r2)\
1232 { \
1233 uint32_t extr_r1, extr_r2; \
1234 uint32_t ret = 0; \
1235 \
1236 extr_r1 = extract32(r1, 0, 16); \
1237 extr_r2 = extract32(r2, 0, 16); \
1238 ret = (extr_r1 op extr_r2) ? extr_r1 : extr_r2; \
1239 ret = ret & 0xffff; \
1240 \
1241 extr_r1 = extract32(r1, 16, 16); \
1242 extr_r2 = extract32(r2, 16, 16); \
1243 extr_r1 = (extr_r1 op extr_r2) ? extr_r1 : extr_r2; \
1244 ret |= extr_r1 << (16); \
1245 \
1246 return ret; \
1247 } \
1248 \
1249 uint64_t helper_ix##name(uint64_t r1, uint32_t r2) \
1250 { \
1251 int64_t r2l, r2h, r1hl; \
1252 uint64_t ret = 0; \
1253 \
1254 ret = ((r1 + 2) & 0xffff); \
1255 r2l = sextract64(r2, 0, 16); \
1256 r2h = sextract64(r2, 16, 16); \
1257 r1hl = sextract64(r1, 32, 16); \
1258 \
1259 if ((r2l op ## = r2h) && (r2l op r1hl)) { \
1260 ret |= (r2l & 0xffff) << 32; \
1261 ret |= extract64(r1, 0, 16) << 16; \
1262 } else if ((r2h op r2l) && (r2h op r1hl)) { \
1263 ret |= extract64(r2, 16, 16) << 32; \
1264 ret |= extract64(r1 + 1, 0, 16) << 16; \
1265 } else { \
1266 ret |= r1 & 0xffffffff0000ull; \
1267 } \
1268 return ret; \
1269 } \
1270 \
1271 uint64_t helper_ix##name ##_u(uint64_t r1, uint32_t r2) \
1272 { \
1273 int64_t r2l, r2h, r1hl; \
1274 uint64_t ret = 0; \
1275 \
1276 ret = ((r1 + 2) & 0xffff); \
1277 r2l = extract64(r2, 0, 16); \
1278 r2h = extract64(r2, 16, 16); \
1279 r1hl = extract64(r1, 32, 16); \
1280 \
1281 if ((r2l op ## = r2h) && (r2l op r1hl)) { \
1282 ret |= (r2l & 0xffff) << 32; \
1283 ret |= extract64(r1, 0, 16) << 16; \
1284 } else if ((r2h op r2l) && (r2h op r1hl)) { \
1285 ret |= extract64(r2, 16, 16) << 32; \
1286 ret |= extract64(r1 + 1, 0, 16) << 16; \
1287 } else { \
1288 ret |= r1 & 0xffffffff0000ull; \
1289 } \
1290 return ret; \
1291 }
1292
1293 EXTREMA_H_B(max, >)
1294 EXTREMA_H_B(min, <)
1295
1296 #undef EXTREMA_H_B
1297
1298 uint32_t helper_clo(target_ulong r1)
1299 {
1300 return clo32(r1);
1301 }
1302
1303 uint32_t helper_clo_h(target_ulong r1)
1304 {
1305 uint32_t ret_hw0 = extract32(r1, 0, 16);
1306 uint32_t ret_hw1 = extract32(r1, 16, 16);
1307
1308 ret_hw0 = clo32(ret_hw0 << 16);
1309 ret_hw1 = clo32(ret_hw1 << 16);
1310
1311 if (ret_hw0 > 16) {
1312 ret_hw0 = 16;
1313 }
1314 if (ret_hw1 > 16) {
1315 ret_hw1 = 16;
1316 }
1317
1318 return ret_hw0 | (ret_hw1 << 16);
1319 }
1320
1321 uint32_t helper_clz(target_ulong r1)
1322 {
1323 return clz32(r1);
1324 }
1325
1326 uint32_t helper_clz_h(target_ulong r1)
1327 {
1328 uint32_t ret_hw0 = extract32(r1, 0, 16);
1329 uint32_t ret_hw1 = extract32(r1, 16, 16);
1330
1331 ret_hw0 = clz32(ret_hw0 << 16);
1332 ret_hw1 = clz32(ret_hw1 << 16);
1333
1334 if (ret_hw0 > 16) {
1335 ret_hw0 = 16;
1336 }
1337 if (ret_hw1 > 16) {
1338 ret_hw1 = 16;
1339 }
1340
1341 return ret_hw0 | (ret_hw1 << 16);
1342 }
1343
1344 uint32_t helper_cls(target_ulong r1)
1345 {
1346 return clrsb32(r1);
1347 }
1348
1349 uint32_t helper_cls_h(target_ulong r1)
1350 {
1351 uint32_t ret_hw0 = extract32(r1, 0, 16);
1352 uint32_t ret_hw1 = extract32(r1, 16, 16);
1353
1354 ret_hw0 = clrsb32(ret_hw0 << 16);
1355 ret_hw1 = clrsb32(ret_hw1 << 16);
1356
1357 if (ret_hw0 > 15) {
1358 ret_hw0 = 15;
1359 }
1360 if (ret_hw1 > 15) {
1361 ret_hw1 = 15;
1362 }
1363
1364 return ret_hw0 | (ret_hw1 << 16);
1365 }
1366
1367 uint32_t helper_sh(target_ulong r1, target_ulong r2)
1368 {
1369 int32_t shift_count = sextract32(r2, 0, 6);
1370
1371 if (shift_count == -32) {
1372 return 0;
1373 } else if (shift_count < 0) {
1374 return r1 >> -shift_count;
1375 } else {
1376 return r1 << shift_count;
1377 }
1378 }
1379
1380 uint32_t helper_sh_h(target_ulong r1, target_ulong r2)
1381 {
1382 int32_t ret_hw0, ret_hw1;
1383 int32_t shift_count;
1384
1385 shift_count = sextract32(r2, 0, 5);
1386
1387 if (shift_count == -16) {
1388 return 0;
1389 } else if (shift_count < 0) {
1390 ret_hw0 = extract32(r1, 0, 16) >> -shift_count;
1391 ret_hw1 = extract32(r1, 16, 16) >> -shift_count;
1392 return (ret_hw0 & 0xffff) | (ret_hw1 << 16);
1393 } else {
1394 ret_hw0 = extract32(r1, 0, 16) << shift_count;
1395 ret_hw1 = extract32(r1, 16, 16) << shift_count;
1396 return (ret_hw0 & 0xffff) | (ret_hw1 << 16);
1397 }
1398 }
1399
1400 uint32_t helper_sha(CPUTriCoreState *env, target_ulong r1, target_ulong r2)
1401 {
1402 int32_t shift_count;
1403 int64_t result, t1;
1404 uint32_t ret;
1405
1406 shift_count = sextract32(r2, 0, 6);
1407 t1 = sextract32(r1, 0, 32);
1408
1409 if (shift_count == 0) {
1410 env->PSW_USB_C = env->PSW_USB_V = 0;
1411 ret = r1;
1412 } else if (shift_count == -32) {
1413 env->PSW_USB_C = r1;
1414 env->PSW_USB_V = 0;
1415 ret = t1 >> 31;
1416 } else if (shift_count > 0) {
1417 result = t1 << shift_count;
1418 /* calc carry */
1419 env->PSW_USB_C = ((result & 0xffffffff00000000ULL) != 0);
1420 /* calc v */
1421 env->PSW_USB_V = (((result > 0x7fffffffLL) ||
1422 (result < -0x80000000LL)) << 31);
1423 /* calc sv */
1424 env->PSW_USB_SV |= env->PSW_USB_V;
1425 ret = (uint32_t)result;
1426 } else {
1427 env->PSW_USB_V = 0;
1428 env->PSW_USB_C = (r1 & ((1 << -shift_count) - 1));
1429 ret = t1 >> -shift_count;
1430 }
1431
1432 env->PSW_USB_AV = ret ^ ret * 2u;
1433 env->PSW_USB_SAV |= env->PSW_USB_AV;
1434
1435 return ret;
1436 }
1437
1438 uint32_t helper_sha_h(target_ulong r1, target_ulong r2)
1439 {
1440 int32_t shift_count;
1441 int32_t ret_hw0, ret_hw1;
1442
1443 shift_count = sextract32(r2, 0, 5);
1444
1445 if (shift_count == 0) {
1446 return r1;
1447 } else if (shift_count < 0) {
1448 ret_hw0 = sextract32(r1, 0, 16) >> -shift_count;
1449 ret_hw1 = sextract32(r1, 16, 16) >> -shift_count;
1450 return (ret_hw0 & 0xffff) | (ret_hw1 << 16);
1451 } else {
1452 ret_hw0 = sextract32(r1, 0, 16) << shift_count;
1453 ret_hw1 = sextract32(r1, 16, 16) << shift_count;
1454 return (ret_hw0 & 0xffff) | (ret_hw1 << 16);
1455 }
1456 }
1457
1458 uint32_t helper_bmerge(target_ulong r1, target_ulong r2)
1459 {
1460 uint32_t i, ret;
1461
1462 ret = 0;
1463 for (i = 0; i < 16; i++) {
1464 ret |= (r1 & 1) << (2 * i + 1);
1465 ret |= (r2 & 1) << (2 * i);
1466 r1 = r1 >> 1;
1467 r2 = r2 >> 1;
1468 }
1469 return ret;
1470 }
1471
1472 uint64_t helper_bsplit(uint32_t r1)
1473 {
1474 int32_t i;
1475 uint64_t ret;
1476
1477 ret = 0;
1478 for (i = 0; i < 32; i = i + 2) {
1479 /* even */
1480 ret |= (r1 & 1) << (i/2);
1481 r1 = r1 >> 1;
1482 /* odd */
1483 ret |= (uint64_t)(r1 & 1) << (i/2 + 32);
1484 r1 = r1 >> 1;
1485 }
1486 return ret;
1487 }
1488
1489 uint32_t helper_parity(target_ulong r1)
1490 {
1491 uint32_t ret;
1492 uint32_t nOnes, i;
1493
1494 ret = 0;
1495 nOnes = 0;
1496 for (i = 0; i < 8; i++) {
1497 ret ^= (r1 & 1);
1498 r1 = r1 >> 1;
1499 }
1500 /* second byte */
1501 nOnes = 0;
1502 for (i = 0; i < 8; i++) {
1503 nOnes ^= (r1 & 1);
1504 r1 = r1 >> 1;
1505 }
1506 ret |= nOnes << 8;
1507 /* third byte */
1508 nOnes = 0;
1509 for (i = 0; i < 8; i++) {
1510 nOnes ^= (r1 & 1);
1511 r1 = r1 >> 1;
1512 }
1513 ret |= nOnes << 16;
1514 /* fourth byte */
1515 nOnes = 0;
1516 for (i = 0; i < 8; i++) {
1517 nOnes ^= (r1 & 1);
1518 r1 = r1 >> 1;
1519 }
1520 ret |= nOnes << 24;
1521
1522 return ret;
1523 }
1524
1525 uint32_t helper_pack(uint32_t carry, uint32_t r1_low, uint32_t r1_high,
1526 target_ulong r2)
1527 {
1528 uint32_t ret;
1529 int32_t fp_exp, fp_frac, temp_exp, fp_exp_frac;
1530 int32_t int_exp = r1_high;
1531 int32_t int_mant = r1_low;
1532 uint32_t flag_rnd = (int_mant & (1 << 7)) && (
1533 (int_mant & (1 << 8)) ||
1534 (int_mant & 0x7f) ||
1535 (carry != 0));
1536 if (((int_mant & (1<<31)) == 0) && (int_exp == 255)) {
1537 fp_exp = 255;
1538 fp_frac = extract32(int_mant, 8, 23);
1539 } else if ((int_mant & (1<<31)) && (int_exp >= 127)) {
1540 fp_exp = 255;
1541 fp_frac = 0;
1542 } else if ((int_mant & (1<<31)) && (int_exp <= -128)) {
1543 fp_exp = 0;
1544 fp_frac = 0;
1545 } else if (int_mant == 0) {
1546 fp_exp = 0;
1547 fp_frac = 0;
1548 } else {
1549 if (((int_mant & (1 << 31)) == 0)) {
1550 temp_exp = 0;
1551 } else {
1552 temp_exp = int_exp + 128;
1553 }
1554 fp_exp_frac = (((temp_exp & 0xff) << 23) |
1555 extract32(int_mant, 8, 23))
1556 + flag_rnd;
1557 fp_exp = extract32(fp_exp_frac, 23, 8);
1558 fp_frac = extract32(fp_exp_frac, 0, 23);
1559 }
1560 ret = r2 & (1 << 31);
1561 ret = ret + (fp_exp << 23);
1562 ret = ret + (fp_frac & 0x7fffff);
1563
1564 return ret;
1565 }
1566
1567 uint64_t helper_unpack(target_ulong arg1)
1568 {
1569 int32_t fp_exp = extract32(arg1, 23, 8);
1570 int32_t fp_frac = extract32(arg1, 0, 23);
1571 uint64_t ret;
1572 int32_t int_exp, int_mant;
1573
1574 if (fp_exp == 255) {
1575 int_exp = 255;
1576 int_mant = (fp_frac << 7);
1577 } else if ((fp_exp == 0) && (fp_frac == 0)) {
1578 int_exp = -127;
1579 int_mant = 0;
1580 } else if ((fp_exp == 0) && (fp_frac != 0)) {
1581 int_exp = -126;
1582 int_mant = (fp_frac << 7);
1583 } else {
1584 int_exp = fp_exp - 127;
1585 int_mant = (fp_frac << 7);
1586 int_mant |= (1 << 30);
1587 }
1588 ret = int_exp;
1589 ret = ret << 32;
1590 ret |= int_mant;
1591
1592 return ret;
1593 }
1594
1595 uint64_t helper_dvinit_b_13(CPUTriCoreState *env, uint32_t r1, uint32_t r2)
1596 {
1597 uint64_t ret;
1598 int32_t abs_sig_dividend, abs_base_dividend, abs_divisor;
1599 int32_t quotient_sign;
1600
1601 ret = sextract32(r1, 0, 32);
1602 ret = ret << 24;
1603 quotient_sign = 0;
1604 if (!((r1 & 0x80000000) == (r2 & 0x80000000))) {
1605 ret |= 0xffffff;
1606 quotient_sign = 1;
1607 }
1608
1609 abs_sig_dividend = abs(r1) >> 7;
1610 abs_base_dividend = abs(r1) & 0x7f;
1611 abs_divisor = abs(r1);
1612 /* calc overflow */
1613 env->PSW_USB_V = 0;
1614 if ((quotient_sign) && (abs_divisor)) {
1615 env->PSW_USB_V = (((abs_sig_dividend == abs_divisor) &&
1616 (abs_base_dividend >= abs_divisor)) ||
1617 (abs_sig_dividend > abs_divisor));
1618 } else {
1619 env->PSW_USB_V = (abs_sig_dividend >= abs_divisor);
1620 }
1621 env->PSW_USB_V = env->PSW_USB_V << 31;
1622 env->PSW_USB_SV |= env->PSW_USB_V;
1623 env->PSW_USB_AV = 0;
1624
1625 return ret;
1626 }
1627
1628 uint64_t helper_dvinit_b_131(CPUTriCoreState *env, uint32_t r1, uint32_t r2)
1629 {
1630 uint64_t ret = sextract32(r1, 0, 32);
1631
1632 ret = ret << 24;
1633 if (!((r1 & 0x80000000) == (r2 & 0x80000000))) {
1634 ret |= 0xffffff;
1635 }
1636 /* calc overflow */
1637 env->PSW_USB_V = ((r2 == 0) || ((r2 == 0xffffffff) && (r1 == 0xffffff80)));
1638 env->PSW_USB_V = env->PSW_USB_V << 31;
1639 env->PSW_USB_SV |= env->PSW_USB_V;
1640 env->PSW_USB_AV = 0;
1641
1642 return ret;
1643 }
1644
1645 uint64_t helper_dvinit_h_13(CPUTriCoreState *env, uint32_t r1, uint32_t r2)
1646 {
1647 uint64_t ret;
1648 int32_t abs_sig_dividend, abs_base_dividend, abs_divisor;
1649 int32_t quotient_sign;
1650
1651 ret = sextract32(r1, 0, 32);
1652 ret = ret << 16;
1653 quotient_sign = 0;
1654 if (!((r1 & 0x80000000) == (r2 & 0x80000000))) {
1655 ret |= 0xffff;
1656 quotient_sign = 1;
1657 }
1658
1659 abs_sig_dividend = abs(r1) >> 7;
1660 abs_base_dividend = abs(r1) & 0x7f;
1661 abs_divisor = abs(r1);
1662 /* calc overflow */
1663 env->PSW_USB_V = 0;
1664 if ((quotient_sign) && (abs_divisor)) {
1665 env->PSW_USB_V = (((abs_sig_dividend == abs_divisor) &&
1666 (abs_base_dividend >= abs_divisor)) ||
1667 (abs_sig_dividend > abs_divisor));
1668 } else {
1669 env->PSW_USB_V = (abs_sig_dividend >= abs_divisor);
1670 }
1671 env->PSW_USB_V = env->PSW_USB_V << 31;
1672 env->PSW_USB_SV |= env->PSW_USB_V;
1673 env->PSW_USB_AV = 0;
1674
1675 return ret;
1676 }
1677
1678 uint64_t helper_dvinit_h_131(CPUTriCoreState *env, uint32_t r1, uint32_t r2)
1679 {
1680 uint64_t ret = sextract32(r1, 0, 32);
1681
1682 ret = ret << 16;
1683 if (!((r1 & 0x80000000) == (r2 & 0x80000000))) {
1684 ret |= 0xffff;
1685 }
1686 /* calc overflow */
1687 env->PSW_USB_V = ((r2 == 0) || ((r2 == 0xffffffff) && (r1 == 0xffff8000)));
1688 env->PSW_USB_V = env->PSW_USB_V << 31;
1689 env->PSW_USB_SV |= env->PSW_USB_V;
1690 env->PSW_USB_AV = 0;
1691
1692 return ret;
1693 }
1694
1695 uint64_t helper_dvadj(uint64_t r1, uint32_t r2)
1696 {
1697 int32_t x_sign = (r1 >> 63);
1698 int32_t q_sign = x_sign ^ (r2 >> 31);
1699 int32_t eq_pos = x_sign & ((r1 >> 32) == r2);
1700 int32_t eq_neg = x_sign & ((r1 >> 32) == -r2);
1701 uint32_t quotient;
1702 uint64_t ret, remainder;
1703
1704 if ((q_sign & ~eq_neg) | eq_pos) {
1705 quotient = (r1 + 1) & 0xffffffff;
1706 } else {
1707 quotient = r1 & 0xffffffff;
1708 }
1709
1710 if (eq_pos | eq_neg) {
1711 remainder = 0;
1712 } else {
1713 remainder = (r1 & 0xffffffff00000000ull);
1714 }
1715 ret = remainder|quotient;
1716 return ret;
1717 }
1718
1719 uint64_t helper_dvstep(uint64_t r1, uint32_t r2)
1720 {
1721 int32_t dividend_sign = extract64(r1, 63, 1);
1722 int32_t divisor_sign = extract32(r2, 31, 1);
1723 int32_t quotient_sign = (dividend_sign != divisor_sign);
1724 int32_t addend, dividend_quotient, remainder;
1725 int32_t i, temp;
1726
1727 if (quotient_sign) {
1728 addend = r2;
1729 } else {
1730 addend = -r2;
1731 }
1732 dividend_quotient = (int32_t)r1;
1733 remainder = (int32_t)(r1 >> 32);
1734
1735 for (i = 0; i < 8; i++) {
1736 remainder = (remainder << 1) | extract32(dividend_quotient, 31, 1);
1737 dividend_quotient <<= 1;
1738 temp = remainder + addend;
1739 if ((temp < 0) == dividend_sign) {
1740 remainder = temp;
1741 }
1742 if (((temp < 0) == dividend_sign)) {
1743 dividend_quotient = dividend_quotient | !quotient_sign;
1744 } else {
1745 dividend_quotient = dividend_quotient | quotient_sign;
1746 }
1747 }
1748 return ((uint64_t)remainder << 32) | (uint32_t)dividend_quotient;
1749 }
1750
1751 uint64_t helper_dvstep_u(uint64_t r1, uint32_t r2)
1752 {
1753 int32_t dividend_quotient = extract64(r1, 0, 32);
1754 int64_t remainder = extract64(r1, 32, 32);
1755 int32_t i;
1756 int64_t temp;
1757 for (i = 0; i < 8; i++) {
1758 remainder = (remainder << 1) | extract32(dividend_quotient, 31, 1);
1759 dividend_quotient <<= 1;
1760 temp = (remainder & 0xffffffff) - r2;
1761 if (temp >= 0) {
1762 remainder = temp;
1763 }
1764 dividend_quotient = dividend_quotient | !(temp < 0);
1765 }
1766 return ((uint64_t)remainder << 32) | (uint32_t)dividend_quotient;
1767 }
1768
1769 uint64_t helper_mul_h(uint32_t arg00, uint32_t arg01,
1770 uint32_t arg10, uint32_t arg11, uint32_t n)
1771 {
1772 uint64_t ret;
1773 uint32_t result0, result1;
1774
1775 int32_t sc1 = ((arg00 & 0xffff) == 0x8000) &&
1776 ((arg10 & 0xffff) == 0x8000) && (n == 1);
1777 int32_t sc0 = ((arg01 & 0xffff) == 0x8000) &&
1778 ((arg11 & 0xffff) == 0x8000) && (n == 1);
1779 if (sc1) {
1780 result1 = 0x7fffffff;
1781 } else {
1782 result1 = (((uint32_t)(arg00 * arg10)) << n);
1783 }
1784 if (sc0) {
1785 result0 = 0x7fffffff;
1786 } else {
1787 result0 = (((uint32_t)(arg01 * arg11)) << n);
1788 }
1789 ret = (((uint64_t)result1 << 32)) | result0;
1790 return ret;
1791 }
1792
1793 uint64_t helper_mulm_h(uint32_t arg00, uint32_t arg01,
1794 uint32_t arg10, uint32_t arg11, uint32_t n)
1795 {
1796 uint64_t ret;
1797 int64_t result0, result1;
1798
1799 int32_t sc1 = ((arg00 & 0xffff) == 0x8000) &&
1800 ((arg10 & 0xffff) == 0x8000) && (n == 1);
1801 int32_t sc0 = ((arg01 & 0xffff) == 0x8000) &&
1802 ((arg11 & 0xffff) == 0x8000) && (n == 1);
1803
1804 if (sc1) {
1805 result1 = 0x7fffffff;
1806 } else {
1807 result1 = (((int32_t)arg00 * (int32_t)arg10) << n);
1808 }
1809 if (sc0) {
1810 result0 = 0x7fffffff;
1811 } else {
1812 result0 = (((int32_t)arg01 * (int32_t)arg11) << n);
1813 }
1814 ret = (result1 + result0);
1815 ret = ret << 16;
1816 return ret;
1817 }
1818 uint32_t helper_mulr_h(uint32_t arg00, uint32_t arg01,
1819 uint32_t arg10, uint32_t arg11, uint32_t n)
1820 {
1821 uint32_t result0, result1;
1822
1823 int32_t sc1 = ((arg00 & 0xffff) == 0x8000) &&
1824 ((arg10 & 0xffff) == 0x8000) && (n == 1);
1825 int32_t sc0 = ((arg01 & 0xffff) == 0x8000) &&
1826 ((arg11 & 0xffff) == 0x8000) && (n == 1);
1827
1828 if (sc1) {
1829 result1 = 0x7fffffff;
1830 } else {
1831 result1 = ((arg00 * arg10) << n) + 0x8000;
1832 }
1833 if (sc0) {
1834 result0 = 0x7fffffff;
1835 } else {
1836 result0 = ((arg01 * arg11) << n) + 0x8000;
1837 }
1838 return (result1 & 0xffff0000) | (result0 >> 16);
1839 }
1840
1841 /* context save area (CSA) related helpers */
1842
1843 static int cdc_increment(target_ulong *psw)
1844 {
1845 if ((*psw & MASK_PSW_CDC) == 0x7f) {
1846 return 0;
1847 }
1848
1849 (*psw)++;
1850 /* check for overflow */
1851 int lo = clo32((*psw & MASK_PSW_CDC) << (32 - 7));
1852 int mask = (1u << (7 - lo)) - 1;
1853 int count = *psw & mask;
1854 if (count == 0) {
1855 (*psw)--;
1856 return 1;
1857 }
1858 return 0;
1859 }
1860
1861 static int cdc_decrement(target_ulong *psw)
1862 {
1863 if ((*psw & MASK_PSW_CDC) == 0x7f) {
1864 return 0;
1865 }
1866 /* check for underflow */
1867 int lo = clo32((*psw & MASK_PSW_CDC) << (32 - 7));
1868 int mask = (1u << (7 - lo)) - 1;
1869 int count = *psw & mask;
1870 if (count == 0) {
1871 return 1;
1872 }
1873 (*psw)--;
1874 return 0;
1875 }
1876
1877 static bool cdc_zero(target_ulong *psw)
1878 {
1879 int cdc = *psw & MASK_PSW_CDC;
1880 /* Returns TRUE if PSW.CDC.COUNT == 0 or if PSW.CDC ==
1881 7'b1111111, otherwise returns FALSE. */
1882 if (cdc == 0x7f) {
1883 return true;
1884 }
1885 /* find CDC.COUNT */
1886 int lo = clo32((*psw & MASK_PSW_CDC) << (32 - 7));
1887 int mask = (1u << (7 - lo)) - 1;
1888 int count = *psw & mask;
1889 return count == 0;
1890 }
1891
1892 static void save_context_upper(CPUTriCoreState *env, int ea)
1893 {
1894 cpu_stl_data(env, ea, env->PCXI);
1895 cpu_stl_data(env, ea+4, env->PSW);
1896 cpu_stl_data(env, ea+8, env->gpr_a[10]);
1897 cpu_stl_data(env, ea+12, env->gpr_a[11]);
1898 cpu_stl_data(env, ea+16, env->gpr_d[8]);
1899 cpu_stl_data(env, ea+20, env->gpr_d[9]);
1900 cpu_stl_data(env, ea+24, env->gpr_d[10]);
1901 cpu_stl_data(env, ea+28, env->gpr_d[11]);
1902 cpu_stl_data(env, ea+32, env->gpr_a[12]);
1903 cpu_stl_data(env, ea+36, env->gpr_a[13]);
1904 cpu_stl_data(env, ea+40, env->gpr_a[14]);
1905 cpu_stl_data(env, ea+44, env->gpr_a[15]);
1906 cpu_stl_data(env, ea+48, env->gpr_d[12]);
1907 cpu_stl_data(env, ea+52, env->gpr_d[13]);
1908 cpu_stl_data(env, ea+56, env->gpr_d[14]);
1909 cpu_stl_data(env, ea+60, env->gpr_d[15]);
1910 }
1911
1912 static void save_context_lower(CPUTriCoreState *env, int ea)
1913 {
1914 cpu_stl_data(env, ea, env->PCXI);
1915 cpu_stl_data(env, ea+4, env->gpr_a[11]);
1916 cpu_stl_data(env, ea+8, env->gpr_a[2]);
1917 cpu_stl_data(env, ea+12, env->gpr_a[3]);
1918 cpu_stl_data(env, ea+16, env->gpr_d[0]);
1919 cpu_stl_data(env, ea+20, env->gpr_d[1]);
1920 cpu_stl_data(env, ea+24, env->gpr_d[2]);
1921 cpu_stl_data(env, ea+28, env->gpr_d[3]);
1922 cpu_stl_data(env, ea+32, env->gpr_a[4]);
1923 cpu_stl_data(env, ea+36, env->gpr_a[5]);
1924 cpu_stl_data(env, ea+40, env->gpr_a[6]);
1925 cpu_stl_data(env, ea+44, env->gpr_a[7]);
1926 cpu_stl_data(env, ea+48, env->gpr_d[4]);
1927 cpu_stl_data(env, ea+52, env->gpr_d[5]);
1928 cpu_stl_data(env, ea+56, env->gpr_d[6]);
1929 cpu_stl_data(env, ea+60, env->gpr_d[7]);
1930 }
1931
1932 static void restore_context_upper(CPUTriCoreState *env, int ea,
1933 target_ulong *new_PCXI, target_ulong *new_PSW)
1934 {
1935 *new_PCXI = cpu_ldl_data(env, ea);
1936 *new_PSW = cpu_ldl_data(env, ea+4);
1937 env->gpr_a[10] = cpu_ldl_data(env, ea+8);
1938 env->gpr_a[11] = cpu_ldl_data(env, ea+12);
1939 env->gpr_d[8] = cpu_ldl_data(env, ea+16);
1940 env->gpr_d[9] = cpu_ldl_data(env, ea+20);
1941 env->gpr_d[10] = cpu_ldl_data(env, ea+24);
1942 env->gpr_d[11] = cpu_ldl_data(env, ea+28);
1943 env->gpr_a[12] = cpu_ldl_data(env, ea+32);
1944 env->gpr_a[13] = cpu_ldl_data(env, ea+36);
1945 env->gpr_a[14] = cpu_ldl_data(env, ea+40);
1946 env->gpr_a[15] = cpu_ldl_data(env, ea+44);
1947 env->gpr_d[12] = cpu_ldl_data(env, ea+48);
1948 env->gpr_d[13] = cpu_ldl_data(env, ea+52);
1949 env->gpr_d[14] = cpu_ldl_data(env, ea+56);
1950 env->gpr_d[15] = cpu_ldl_data(env, ea+60);
1951 }
1952
1953 static void restore_context_lower(CPUTriCoreState *env, int ea,
1954 target_ulong *ra, target_ulong *pcxi)
1955 {
1956 *pcxi = cpu_ldl_data(env, ea);
1957 *ra = cpu_ldl_data(env, ea+4);
1958 env->gpr_a[2] = cpu_ldl_data(env, ea+8);
1959 env->gpr_a[3] = cpu_ldl_data(env, ea+12);
1960 env->gpr_d[0] = cpu_ldl_data(env, ea+16);
1961 env->gpr_d[1] = cpu_ldl_data(env, ea+20);
1962 env->gpr_d[2] = cpu_ldl_data(env, ea+24);
1963 env->gpr_d[3] = cpu_ldl_data(env, ea+28);
1964 env->gpr_a[4] = cpu_ldl_data(env, ea+32);
1965 env->gpr_a[5] = cpu_ldl_data(env, ea+36);
1966 env->gpr_a[6] = cpu_ldl_data(env, ea+40);
1967 env->gpr_a[7] = cpu_ldl_data(env, ea+44);
1968 env->gpr_d[4] = cpu_ldl_data(env, ea+48);
1969 env->gpr_d[5] = cpu_ldl_data(env, ea+52);
1970 env->gpr_d[6] = cpu_ldl_data(env, ea+56);
1971 env->gpr_d[7] = cpu_ldl_data(env, ea+60);
1972 }
1973
1974 void helper_call(CPUTriCoreState *env, uint32_t next_pc)
1975 {
1976 target_ulong tmp_FCX;
1977 target_ulong ea;
1978 target_ulong new_FCX;
1979 target_ulong psw;
1980
1981 psw = psw_read(env);
1982 /* if (FCX == 0) trap(FCU); */
1983 if (env->FCX == 0) {
1984 /* FCU trap */
1985 }
1986 /* if (PSW.CDE) then if (cdc_increment()) then trap(CDO); */
1987 if (psw & MASK_PSW_CDE) {
1988 if (cdc_increment(&psw)) {
1989 /* CDO trap */
1990 }
1991 }
1992 /* PSW.CDE = 1;*/
1993 psw |= MASK_PSW_CDE;
1994 /* tmp_FCX = FCX; */
1995 tmp_FCX = env->FCX;
1996 /* EA = {FCX.FCXS, 6'b0, FCX.FCXO, 6'b0}; */
1997 ea = ((env->FCX & MASK_FCX_FCXS) << 12) +
1998 ((env->FCX & MASK_FCX_FCXO) << 6);
1999 /* new_FCX = M(EA, word); */
2000 new_FCX = cpu_ldl_data(env, ea);
2001 /* M(EA, 16 * word) = {PCXI, PSW, A[10], A[11], D[8], D[9], D[10], D[11],
2002 A[12], A[13], A[14], A[15], D[12], D[13], D[14],
2003 D[15]}; */
2004 save_context_upper(env, ea);
2005
2006 /* PCXI.PCPN = ICR.CCPN; */
2007 env->PCXI = (env->PCXI & 0xffffff) +
2008 ((env->ICR & MASK_ICR_CCPN) << 24);
2009 /* PCXI.PIE = ICR.IE; */
2010 env->PCXI = ((env->PCXI & ~MASK_PCXI_PIE) +
2011 ((env->ICR & MASK_ICR_IE) << 15));
2012 /* PCXI.UL = 1; */
2013 env->PCXI |= MASK_PCXI_UL;
2014
2015 /* PCXI[19: 0] = FCX[19: 0]; */
2016 env->PCXI = (env->PCXI & 0xfff00000) + (env->FCX & 0xfffff);
2017 /* FCX[19: 0] = new_FCX[19: 0]; */
2018 env->FCX = (env->FCX & 0xfff00000) + (new_FCX & 0xfffff);
2019 /* A[11] = next_pc[31: 0]; */
2020 env->gpr_a[11] = next_pc;
2021
2022 /* if (tmp_FCX == LCX) trap(FCD);*/
2023 if (tmp_FCX == env->LCX) {
2024 /* FCD trap */
2025 }
2026 psw_write(env, psw);
2027 }
2028
2029 void helper_ret(CPUTriCoreState *env)
2030 {
2031 target_ulong ea;
2032 target_ulong new_PCXI;
2033 target_ulong new_PSW, psw;
2034
2035 psw = psw_read(env);
2036 /* if (PSW.CDE) then if (cdc_decrement()) then trap(CDU);*/
2037 if (env->PSW & MASK_PSW_CDE) {
2038 if (cdc_decrement(&(env->PSW))) {
2039 /* CDU trap */
2040 }
2041 }
2042 /* if (PCXI[19: 0] == 0) then trap(CSU); */
2043 if ((env->PCXI & 0xfffff) == 0) {
2044 /* CSU trap */
2045 }
2046 /* if (PCXI.UL == 0) then trap(CTYP); */
2047 if ((env->PCXI & MASK_PCXI_UL) == 0) {
2048 /* CTYP trap */
2049 }
2050 /* PC = {A11 [31: 1], 1’b0}; */
2051 env->PC = env->gpr_a[11] & 0xfffffffe;
2052
2053 /* EA = {PCXI.PCXS, 6'b0, PCXI.PCXO, 6'b0}; */
2054 ea = ((env->PCXI & MASK_PCXI_PCXS) << 12) +
2055 ((env->PCXI & MASK_PCXI_PCXO) << 6);
2056 /* {new_PCXI, new_PSW, A[10], A[11], D[8], D[9], D[10], D[11], A[12],
2057 A[13], A[14], A[15], D[12], D[13], D[14], D[15]} = M(EA, 16 * word); */
2058 restore_context_upper(env, ea, &new_PCXI, &new_PSW);
2059 /* M(EA, word) = FCX; */
2060 cpu_stl_data(env, ea, env->FCX);
2061 /* FCX[19: 0] = PCXI[19: 0]; */
2062 env->FCX = (env->FCX & 0xfff00000) + (env->PCXI & 0x000fffff);
2063 /* PCXI = new_PCXI; */
2064 env->PCXI = new_PCXI;
2065
2066 if (tricore_feature(env, TRICORE_FEATURE_13)) {
2067 /* PSW = new_PSW */
2068 psw_write(env, new_PSW);
2069 } else {
2070 /* PSW = {new_PSW[31:26], PSW[25:24], new_PSW[23:0]}; */
2071 psw_write(env, (new_PSW & ~(0x3000000)) + (psw & (0x3000000)));
2072 }
2073 }
2074
2075 void helper_bisr(CPUTriCoreState *env, uint32_t const9)
2076 {
2077 target_ulong tmp_FCX;
2078 target_ulong ea;
2079 target_ulong new_FCX;
2080
2081 if (env->FCX == 0) {
2082 /* FCU trap */
2083 }
2084
2085 tmp_FCX = env->FCX;
2086 ea = ((env->FCX & 0xf0000) << 12) + ((env->FCX & 0xffff) << 6);
2087
2088 /* new_FCX = M(EA, word); */
2089 new_FCX = cpu_ldl_data(env, ea);
2090 /* M(EA, 16 * word) = {PCXI, A[11], A[2], A[3], D[0], D[1], D[2], D[3], A[4]
2091 , A[5], A[6], A[7], D[4], D[5], D[6], D[7]}; */
2092 save_context_lower(env, ea);
2093
2094
2095 /* PCXI.PCPN = ICR.CCPN */
2096 env->PCXI = (env->PCXI & 0xffffff) +
2097 ((env->ICR & MASK_ICR_CCPN) << 24);
2098 /* PCXI.PIE = ICR.IE */
2099 env->PCXI = ((env->PCXI & ~MASK_PCXI_PIE) +
2100 ((env->ICR & MASK_ICR_IE) << 15));
2101 /* PCXI.UL = 0 */
2102 env->PCXI &= ~(MASK_PCXI_UL);
2103 /* PCXI[19: 0] = FCX[19: 0] */
2104 env->PCXI = (env->PCXI & 0xfff00000) + (env->FCX & 0xfffff);
2105 /* FXC[19: 0] = new_FCX[19: 0] */
2106 env->FCX = (env->FCX & 0xfff00000) + (new_FCX & 0xfffff);
2107 /* ICR.IE = 1 */
2108 env->ICR |= MASK_ICR_IE;
2109
2110 env->ICR |= const9; /* ICR.CCPN = const9[7: 0];*/
2111
2112 if (tmp_FCX == env->LCX) {
2113 /* FCD trap */
2114 }
2115 }
2116
2117 void helper_rfe(CPUTriCoreState *env)
2118 {
2119 target_ulong ea;
2120 target_ulong new_PCXI;
2121 target_ulong new_PSW;
2122 /* if (PCXI[19: 0] == 0) then trap(CSU); */
2123 if ((env->PCXI & 0xfffff) == 0) {
2124 /* raise csu trap */
2125 }
2126 /* if (PCXI.UL == 0) then trap(CTYP); */
2127 if ((env->PCXI & MASK_PCXI_UL) == 0) {
2128 /* raise CTYP trap */
2129 }
2130 /* if (!cdc_zero() AND PSW.CDE) then trap(NEST); */
2131 if (!cdc_zero(&(env->PSW)) && (env->PSW & MASK_PSW_CDE)) {
2132 /* raise MNG trap */
2133 }
2134 /* ICR.IE = PCXI.PIE; */
2135 env->ICR = (env->ICR & ~MASK_ICR_IE) + ((env->PCXI & MASK_PCXI_PIE) >> 15);
2136 /* ICR.CCPN = PCXI.PCPN; */
2137 env->ICR = (env->ICR & ~MASK_ICR_CCPN) +
2138 ((env->PCXI & MASK_PCXI_PCPN) >> 24);
2139 /*EA = {PCXI.PCXS, 6'b0, PCXI.PCXO, 6'b0};*/
2140 ea = ((env->PCXI & MASK_PCXI_PCXS) << 12) +
2141 ((env->PCXI & MASK_PCXI_PCXO) << 6);
2142 /*{new_PCXI, PSW, A[10], A[11], D[8], D[9], D[10], D[11], A[12],
2143 A[13], A[14], A[15], D[12], D[13], D[14], D[15]} = M(EA, 16 * word); */
2144 restore_context_upper(env, ea, &new_PCXI, &new_PSW);
2145 /* M(EA, word) = FCX;*/
2146 cpu_stl_data(env, ea, env->FCX);
2147 /* FCX[19: 0] = PCXI[19: 0]; */
2148 env->FCX = (env->FCX & 0xfff00000) + (env->PCXI & 0x000fffff);
2149 /* PCXI = new_PCXI; */
2150 env->PCXI = new_PCXI;
2151 /* write psw */
2152 psw_write(env, new_PSW);
2153 }
2154
2155 void helper_ldlcx(CPUTriCoreState *env, uint32_t ea)
2156 {
2157 uint32_t dummy;
2158 /* insn doesn't load PCXI and RA */
2159 restore_context_lower(env, ea, &dummy, &dummy);
2160 }
2161
2162 void helper_lducx(CPUTriCoreState *env, uint32_t ea)
2163 {
2164 uint32_t dummy;
2165 /* insn doesn't load PCXI and PSW */
2166 restore_context_upper(env, ea, &dummy, &dummy);
2167 }
2168
2169 void helper_stlcx(CPUTriCoreState *env, uint32_t ea)
2170 {
2171 save_context_lower(env, ea);
2172 }
2173
2174 void helper_stucx(CPUTriCoreState *env, uint32_t ea)
2175 {
2176 save_context_upper(env, ea);
2177 }
2178
2179 void helper_psw_write(CPUTriCoreState *env, uint32_t arg)
2180 {
2181 psw_write(env, arg);
2182 }
2183
2184 uint32_t helper_psw_read(CPUTriCoreState *env)
2185 {
2186 return psw_read(env);
2187 }
2188
2189
2190 static inline void QEMU_NORETURN do_raise_exception_err(CPUTriCoreState *env,
2191 uint32_t exception,
2192 int error_code,
2193 uintptr_t pc)
2194 {
2195 CPUState *cs = CPU(tricore_env_get_cpu(env));
2196 cs->exception_index = exception;
2197 env->error_code = error_code;
2198
2199 if (pc) {
2200 /* now we have a real cpu fault */
2201 cpu_restore_state(cs, pc);
2202 }
2203
2204 cpu_loop_exit(cs);
2205 }
2206
2207 void tlb_fill(CPUState *cs, target_ulong addr, int is_write, int mmu_idx,
2208 uintptr_t retaddr)
2209 {
2210 int ret;
2211 ret = cpu_tricore_handle_mmu_fault(cs, addr, is_write, mmu_idx);
2212 if (ret) {
2213 TriCoreCPU *cpu = TRICORE_CPU(cs);
2214 CPUTriCoreState *env = &cpu->env;
2215 do_raise_exception_err(env, cs->exception_index,
2216 env->error_code, retaddr);
2217 }
2218 }
AR7 emulation for QEMU