target-tricore/op_helper.c

   1 /*
   2  *  Copyright (c) 2012-2014 Bastian Koppelmann C-Lab/University Paderborn
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  16  */
  17 #include <stdlib.h>
  18 #include "cpu.h"
  19 #include "qemu/host-utils.h"
  20 #include "exec/helper-proto.h"
  21 #include "exec/cpu_ldst.h"
  22
  23 /* Addressing mode helper */
  24
  25 static uint16_t reverse16(uint16_t val)
  26 {
  27     uint8_t high = (uint8_t)(val >> 8);
  28     uint8_t low  = (uint8_t)(val & 0xff);
  29
  30     uint16_t rh, rl;
  31
  32     rl = (uint16_t)((high * 0x0202020202ULL & 0x010884422010ULL) % 1023);
  33     rh = (uint16_t)((low * 0x0202020202ULL & 0x010884422010ULL) % 1023);
  34
  35     return (rh << 8) | rl;
  36 }
  37
  38 uint32_t helper_br_update(uint32_t reg)
  39 {
  40     uint32_t index = reg & 0xffff;
  41     uint32_t incr  = reg >> 16;
  42     uint32_t new_index = reverse16(reverse16(index) + reverse16(incr));
  43     return reg - index + new_index;
  44 }
  45
  46 uint32_t helper_circ_update(uint32_t reg, uint32_t off)
  47 {
  48     uint32_t index = reg & 0xffff;
  49     uint32_t length = reg >> 16;
  50     int32_t new_index = index + off;
  51     if (new_index < 0) {
  52         new_index += length;
  53     } else {
  54         new_index %= length;
  55     }
  56     return reg - index + new_index;
  57 }
  58
  59 static uint32_t ssov32(CPUTriCoreState *env, int64_t arg)
  60 {
  61     uint32_t ret;
  62     int64_t max_pos = INT32_MAX;
  63     int64_t max_neg = INT32_MIN;
  64     if (arg > max_pos) {
  65         env->PSW_USB_V = (1 << 31);
  66         env->PSW_USB_SV = (1 << 31);
  67         ret = (target_ulong)max_pos;
  68     } else {
  69         if (arg < max_neg) {
  70             env->PSW_USB_V = (1 << 31);
  71             env->PSW_USB_SV = (1 << 31);
  72             ret = (target_ulong)max_neg;
  73         } else {
  74             env->PSW_USB_V = 0;
  75             ret = (target_ulong)arg;
  76         }
  77     }
  78     env->PSW_USB_AV = arg ^ arg * 2u;
  79     env->PSW_USB_SAV |= env->PSW_USB_AV;
  80     return ret;
  81 }
  82
  83 static uint32_t suov32_pos(CPUTriCoreState *env, uint64_t arg)
  84 {
  85     uint32_t ret;
  86     uint64_t max_pos = UINT32_MAX;
  87     if (arg > max_pos) {
  88         env->PSW_USB_V = (1 << 31);
  89         env->PSW_USB_SV = (1 << 31);
  90         ret = (target_ulong)max_pos;
  91     } else {
  92         env->PSW_USB_V = 0;
  93         ret = (target_ulong)arg;
  94      }
  95     env->PSW_USB_AV = arg ^ arg * 2u;
  96     env->PSW_USB_SAV |= env->PSW_USB_AV;
  97     return ret;
  98 }
  99
 100 static uint32_t suov32_neg(CPUTriCoreState *env, int64_t arg)
 101 {
 102     uint32_t ret;
 103
 104     if (arg < 0) {
 105         env->PSW_USB_V = (1 << 31);
 106         env->PSW_USB_SV = (1 << 31);
 107         ret = 0;
 108     } else {
 109         env->PSW_USB_V = 0;
 110         ret = (target_ulong)arg;
 111     }
 112     env->PSW_USB_AV = arg ^ arg * 2u;
 113     env->PSW_USB_SAV |= env->PSW_USB_AV;
 114     return ret;
 115 }
 116
 117 static uint32_t ssov16(CPUTriCoreState *env, int32_t hw0, int32_t hw1)
 118 {
 119     int32_t max_pos = INT16_MAX;
 120     int32_t max_neg = INT16_MIN;
 121     int32_t av0, av1;
 122
 123     env->PSW_USB_V = 0;
 124     av0 = hw0 ^ hw0 * 2u;
 125     if (hw0 > max_pos) {
 126         env->PSW_USB_V = (1 << 31);
 127         hw0 = max_pos;
 128     } else if (hw0 < max_neg) {
 129         env->PSW_USB_V = (1 << 31);
 130         hw0 = max_neg;
 131     }
 132
 133     av1 = hw1 ^ hw1 * 2u;
 134     if (hw1 > max_pos) {
 135         env->PSW_USB_V = (1 << 31);
 136         hw1 = max_pos;
 137     } else if (hw1 < max_neg) {
 138         env->PSW_USB_V = (1 << 31);
 139         hw1 = max_neg;
 140     }
 141
 142     env->PSW_USB_SV |= env->PSW_USB_V;
 143     env->PSW_USB_AV = (av0 | av1) << 16;
 144     env->PSW_USB_SAV |= env->PSW_USB_AV;
 145     return (hw0 & 0xffff) | (hw1 << 16);
 146 }
 147
 148 static uint32_t suov16(CPUTriCoreState *env, int32_t hw0, int32_t hw1)
 149 {
 150     int32_t max_pos = UINT16_MAX;
 151     int32_t av0, av1;
 152
 153     env->PSW_USB_V = 0;
 154     av0 = hw0 ^ hw0 * 2u;
 155     if (hw0 > max_pos) {
 156         env->PSW_USB_V = (1 << 31);
 157         hw0 = max_pos;
 158     } else if (hw0 < 0) {
 159         env->PSW_USB_V = (1 << 31);
 160         hw0 = 0;
 161     }
 162
 163     av1 = hw1 ^ hw1 * 2u;
 164     if (hw1 > max_pos) {
 165         env->PSW_USB_V = (1 << 31);
 166         hw1 = max_pos;
 167     } else if (hw1 < 0) {
 168         env->PSW_USB_V = (1 << 31);
 169         hw1 = 0;
 170     }
 171
 172     env->PSW_USB_SV |= env->PSW_USB_V;
 173     env->PSW_USB_AV = (av0 | av1) << 16;
 174     env->PSW_USB_SAV |= env->PSW_USB_AV;
 175     return (hw0 & 0xffff) | (hw1 << 16);
 176 }
 177
 178 target_ulong helper_add_ssov(CPUTriCoreState *env, target_ulong r1,
 179                              target_ulong r2)
 180 {
 181     int64_t t1 = sextract64(r1, 0, 32);
 182     int64_t t2 = sextract64(r2, 0, 32);
 183     int64_t result = t1 + t2;
 184     return ssov32(env, result);
 185 }
 186
 187 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 }