target-sh4/op_helper.c

   1 /*
   2  *  SH4 emulation
   3  *
   4  *  Copyright (c) 2005 Samuel Tardieu
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19 #include <assert.h>
  20 #include <stdlib.h>
  21 #include "exec.h"
  22 #include "helper.h"
  23
  24 static void cpu_restore_state_from_retaddr(void *retaddr)
  25 {
  26     TranslationBlock *tb;
  27     unsigned long pc;
  28
  29     if (retaddr) {
  30         pc = (unsigned long) retaddr;
  31         tb = tb_find_pc(pc);
  32         if (tb) {
  33             /* the PC is inside the translated code. It means that we have
  34                a virtual CPU fault */
  35             cpu_restore_state(tb, env, pc);
  36         }
  37     }
  38 }
  39
  40 #ifndef CONFIG_USER_ONLY
  41
  42 #define MMUSUFFIX _mmu
  43
  44 #define SHIFT 0
  45 #include "softmmu_template.h"
  46
  47 #define SHIFT 1
  48 #include "softmmu_template.h"
  49
  50 #define SHIFT 2
  51 #include "softmmu_template.h"
  52
  53 #define SHIFT 3
  54 #include "softmmu_template.h"
  55
  56 void tlb_fill(target_ulong addr, int is_write, int mmu_idx, void *retaddr)
  57 {
  58     CPUState *saved_env;
  59     int ret;
  60
  61     /* XXX: hack to restore env in all cases, even if not called from
  62        generated code */
  63     saved_env = env;
  64     env = cpu_single_env;
  65     ret = cpu_sh4_handle_mmu_fault(env, addr, is_write, mmu_idx, 1);
  66     if (ret) {
  67         /* now we have a real cpu fault */
  68         cpu_restore_state_from_retaddr(retaddr);
  69         cpu_loop_exit(env);
  70     }
  71     env = saved_env;
  72 }
  73
  74 #endif
  75
  76 void helper_ldtlb(void)
  77 {
  78 #ifdef CONFIG_USER_ONLY
  79     /* XXXXX */
  80     cpu_abort(env, "Unhandled ldtlb");
  81 #else
  82     cpu_load_tlb(env);
  83 #endif
  84 }
  85
  86 static inline void raise_exception(int index, void *retaddr)
  87 {
  88     env->exception_index = index;
  89     cpu_restore_state_from_retaddr(retaddr);
  90     cpu_loop_exit(env);
  91 }
  92
  93 void helper_raise_illegal_instruction(void)
  94 {
  95     raise_exception(0x180, GETPC());
  96 }
  97
  98 void helper_raise_slot_illegal_instruction(void)
  99 {
 100     raise_exception(0x1a0, GETPC());
 101 }
 102
 103 void helper_raise_fpu_disable(void)
 104 {
 105     raise_exception(0x800, GETPC());
 106 }
 107
 108 void helper_raise_slot_fpu_disable(void)
 109 {
 110     raise_exception(0x820, GETPC());
 111 }
 112
 113 void helper_debug(void)
 114 {
 115     env->exception_index = EXCP_DEBUG;
 116     cpu_loop_exit(env);
 117 }
 118
 119 void helper_sleep(uint32_t next_pc)
 120 {
 121     env->halted = 1;
 122     env->in_sleep = 1;
 123     env->exception_index = EXCP_HLT;
 124     env->pc = next_pc;
 125     cpu_loop_exit(env);
 126 }
 127
 128 void helper_trapa(uint32_t tra)
 129 {
 130     env->tra = tra << 2;
 131     raise_exception(0x160, GETPC());
 132 }
 133
 134 void helper_movcal(uint32_t address, uint32_t value)
 135 {
 136     if (cpu_sh4_is_cached (env, address))
 137     {
 138         memory_content *r = malloc (sizeof(memory_content));
 139         r->address = address;
 140         r->value = value;
 141         r->next = NULL;
 142
 143         *(env->movcal_backup_tail) = r;
 144         env->movcal_backup_tail = &(r->next);
 145     }
 146 }
 147
 148 void helper_discard_movcal_backup(void)
 149 {
 150     memory_content *current = env->movcal_backup;
 151
 152     while(current)
 153     {
 154         memory_content *next = current->next;
 155         free (current);
 156         env->movcal_backup = current = next;
 157         if (current == NULL)
 158             env->movcal_backup_tail = &(env->movcal_backup);
 159     }
 160 }
 161
 162 void helper_ocbi(uint32_t address)
 163 {
 164     memory_content **current = &(env->movcal_backup);
 165     while (*current)
 166     {
 167         uint32_t a = (*current)->address;
 168         if ((a & ~0x1F) == (address & ~0x1F))
 169         {
 170             memory_content *next = (*current)->next;
 171             stl(a, (*current)->value);
 172
 173             if (next == NULL)
 174             {
 175                 env->movcal_backup_tail = current;
 176             }
 177
 178             free (*current);
 179             *current = next;
 180             break;
 181         }
 182     }
 183 }
 184
 185 uint32_t helper_addc(uint32_t arg0, uint32_t arg1)
 186 {
 187     uint32_t tmp0, tmp1;
 188
 189     tmp1 = arg0 + arg1;
 190     tmp0 = arg1;
 191     arg1 = tmp1 + (env->sr & 1);
 192     if (tmp0 > tmp1)
 193         env->sr |= SR_T;
 194     else
 195         env->sr &= ~SR_T;
 196     if (tmp1 > arg1)
 197         env->sr |= SR_T;
 198     return arg1;
 199 }
 200
 201 uint32_t helper_addv(uint32_t arg0, uint32_t arg1)
 202 {
 203     uint32_t dest, src, ans;
 204
 205     if ((int32_t) arg1 >= 0)
 206         dest = 0;
 207     else
 208         dest = 1;
 209     if ((int32_t) arg0 >= 0)
 210         src = 0;
 211     else
 212         src = 1;
 213     src += dest;
 214     arg1 += arg0;
 215     if ((int32_t) arg1 >= 0)
 216         ans = 0;
 217     else
 218         ans = 1;
 219     ans += dest;
 220     if (src == 0 || src == 2) {
 221         if (ans == 1)
 222             env->sr |= SR_T;
 223         else
 224             env->sr &= ~SR_T;
 225     } else
 226         env->sr &= ~SR_T;
 227     return arg1;
 228 }
 229
 230 #define T (env->sr & SR_T)
 231 #define Q (env->sr & SR_Q ? 1 : 0)
 232 #define M (env->sr & SR_M ? 1 : 0)
 233 #define SETT env->sr |= SR_T
 234 #define CLRT env->sr &= ~SR_T
 235 #define SETQ env->sr |= SR_Q
 236 #define CLRQ env->sr &= ~SR_Q
 237 #define SETM env->sr |= SR_M
 238 #define CLRM env->sr &= ~SR_M
 239
 240 uint32_t helper_div1(uint32_t arg0, uint32_t arg1)
 241 {
 242     uint32_t tmp0, tmp2;
 243     uint8_t old_q, tmp1 = 0xff;
 244
 245     //printf("div1 arg0=0x%08x arg1=0x%08x M=%d Q=%d T=%d\n", arg0, arg1, M, Q, T);
 246     old_q = Q;
 247     if ((0x80000000 & arg1) != 0)
 248         SETQ;
 249     else
 250         CLRQ;
 251     tmp2 = arg0;
 252     arg1 <<= 1;
 253     arg1 |= T;
 254     switch (old_q) {
 255     case 0:
 256         switch (M) {
 257         case 0:
 258             tmp0 = arg1;
 259             arg1 -= tmp2;
 260             tmp1 = arg1 > tmp0;
 261             switch (Q) {
 262             case 0:
 263                 if (tmp1)
 264                     SETQ;
 265                 else
 266                     CLRQ;
 267                 break;
 268             case 1:
 269                 if (tmp1 == 0)
 270                     SETQ;
 271                 else
 272                     CLRQ;
 273                 break;
 274             }
 275             break;
 276         case 1:
 277             tmp0 = arg1;
 278             arg1 += tmp2;
 279             tmp1 = arg1 < tmp0;
 280             switch (Q) {
 281             case 0:
 282                 if (tmp1 == 0)
 283                     SETQ;
 284                 else
 285                     CLRQ;
 286                 break;
 287             case 1:
 288                 if (tmp1)
 289                     SETQ;
 290                 else
 291                     CLRQ;
 292                 break;
 293             }
 294             break;
 295         }
 296         break;
 297     case 1:
 298         switch (M) {
 299         case 0:
 300             tmp0 = arg1;
 301             arg1 += tmp2;
 302             tmp1 = arg1 < tmp0;
 303             switch (Q) {
 304             case 0:
 305                 if (tmp1)
 306                     SETQ;
 307                 else
 308                     CLRQ;
 309                 break;
 310             case 1:
 311                 if (tmp1 == 0)
 312                     SETQ;
 313                 else
 314                     CLRQ;
 315                 break;
 316             }
 317             break;
 318         case 1:
 319             tmp0 = arg1;
 320             arg1 -= tmp2;
 321             tmp1 = arg1 > tmp0;
 322             switch (Q) {
 323             case 0:
 324                 if (tmp1 == 0)
 325                     SETQ;
 326                 else
 327                     CLRQ;
 328                 break;
 329             case 1:
 330                 if (tmp1)
 331                     SETQ;
 332                 else
 333                     CLRQ;
 334                 break;
 335             }
 336             break;
 337         }
 338         break;
 339     }
 340     if (Q == M)
 341         SETT;
 342     else
 343         CLRT;
 344     //printf("Output: arg1=0x%08x M=%d Q=%d T=%d\n", arg1, M, Q, T);
 345     return arg1;
 346 }
 347
 348 void helper_macl(uint32_t arg0, uint32_t arg1)
 349 {
 350     int64_t res;
 351
 352     res = ((uint64_t) env->mach << 32) | env->macl;
 353     res += (int64_t) (int32_t) arg0 *(int64_t) (int32_t) arg1;
 354     env->mach = (res >> 32) & 0xffffffff;
 355     env->macl = res & 0xffffffff;
 356     if (env->sr & SR_S) {
 357         if (res < 0)
 358             env->mach |= 0xffff0000;
 359         else
 360             env->mach &= 0x00007fff;
 361     }
 362 }
 363
 364 void helper_macw(uint32_t arg0, uint32_t arg1)
 365 {
 366     int64_t res;
 367
 368     res = ((uint64_t) env->mach << 32) | env->macl;
 369     res += (int64_t) (int16_t) arg0 *(int64_t) (int16_t) arg1;
 370     env->mach = (res >> 32) & 0xffffffff;
 371     env->macl = res & 0xffffffff;
 372     if (env->sr & SR_S) {
 373         if (res < -0x80000000) {
 374             env->mach = 1;
 375             env->macl = 0x80000000;
 376         } else if (res > 0x000000007fffffff) {
 377             env->mach = 1;
 378             env->macl = 0x7fffffff;
 379         }
 380     }
 381 }
 382
 383 uint32_t helper_subc(uint32_t arg0, uint32_t arg1)
 384 {
 385     uint32_t tmp0, tmp1;
 386
 387     tmp1 = arg1 - arg0;
 388     tmp0 = arg1;
 389     arg1 = tmp1 - (env->sr & SR_T);
 390     if (tmp0 < tmp1)
 391         env->sr |= SR_T;
 392     else
 393         env->sr &= ~SR_T;
 394     if (tmp1 < arg1)
 395         env->sr |= SR_T;
 396     return arg1;
 397 }
 398
 399 uint32_t helper_subv(uint32_t arg0, uint32_t arg1)
 400 {
 401     int32_t dest, src, ans;
 402
 403     if ((int32_t) arg1 >= 0)
 404         dest = 0;
 405     else
 406         dest = 1;
 407     if ((int32_t) arg0 >= 0)
 408         src = 0;
 409     else
 410         src = 1;
 411     src += dest;
 412     arg1 -= arg0;
 413     if ((int32_t) arg1 >= 0)
 414         ans = 0;
 415     else
 416         ans = 1;
 417     ans += dest;
 418     if (src == 1) {
 419         if (ans == 1)
 420             env->sr |= SR_T;
 421         else
 422             env->sr &= ~SR_T;
 423     } else
 424         env->sr &= ~SR_T;
 425     return arg1;
 426 }
 427
 428 static inline void set_t(void)
 429 {
 430     env->sr |= SR_T;
 431 }
 432
 433 static inline void clr_t(void)
 434 {
 435     env->sr &= ~SR_T;
 436 }
 437
 438 void helper_ld_fpscr(uint32_t val)
 439 {
 440     env->fpscr = val & FPSCR_MASK;
 441     if ((val & FPSCR_RM_MASK) == FPSCR_RM_ZERO) {
 442         set_float_rounding_mode(float_round_to_zero, &env->fp_status);
 443     } else {
 444         set_float_rounding_mode(float_round_nearest_even, &env->fp_status);
 445     }
 446     set_flush_to_zero((val & FPSCR_DN) != 0, &env->fp_status);
 447 }
 448
 449 static void update_fpscr(void *retaddr)
 450 {
 451     int xcpt, cause, enable;
 452
 453     xcpt = get_float_exception_flags(&env->fp_status);
 454
 455     /* Clear the flag entries */
 456     env->fpscr &= ~FPSCR_FLAG_MASK;
 457
 458     if (unlikely(xcpt)) {
 459         if (xcpt & float_flag_invalid) {
 460             env->fpscr |= FPSCR_FLAG_V;
 461         }
 462         if (xcpt & float_flag_divbyzero) {
 463             env->fpscr |= FPSCR_FLAG_Z;
 464         }
 465         if (xcpt & float_flag_overflow) {
 466             env->fpscr |= FPSCR_FLAG_O;
 467         }
 468         if (xcpt & float_flag_underflow) {
 469             env->fpscr |= FPSCR_FLAG_U;
 470         }
 471         if (xcpt & float_flag_inexact) {
 472             env->fpscr |= FPSCR_FLAG_I;
 473         }
 474
 475         /* Accumulate in cause entries */
 476         env->fpscr |= (env->fpscr & FPSCR_FLAG_MASK)
 477                       << (FPSCR_CAUSE_SHIFT - FPSCR_FLAG_SHIFT);
 478
 479         /* Generate an exception if enabled */
 480         cause = (env->fpscr & FPSCR_CAUSE_MASK) >> FPSCR_CAUSE_SHIFT;
 481         enable = (env->fpscr & FPSCR_ENABLE_MASK) >> FPSCR_ENABLE_SHIFT;
 482         if (cause & enable) {
 483             cpu_restore_state_from_retaddr(retaddr);
 484             env->exception_index = 0x120;
 485             cpu_loop_exit(env);
 486         }
 487     }
 488 }
 489
 490 float32 helper_fabs_FT(float32 t0)
 491 {
 492     return float32_abs(t0);
 493 }
 494
 495 float64 helper_fabs_DT(float64 t0)
 496 {
 497     return float64_abs(t0);
 498 }
 499
 500 float32 helper_fadd_FT(float32 t0, float32 t1)
 501 {
 502     set_float_exception_flags(0, &env->fp_status);
 503     t0 = float32_add(t0, t1, &env->fp_status);
 504     update_fpscr(GETPC());
 505     return t0;
 506 }
 507
 508 float64 helper_fadd_DT(float64 t0, float64 t1)
 509 {
 510     set_float_exception_flags(0, &env->fp_status);
 511     t0 = float64_add(t0, t1, &env->fp_status);
 512     update_fpscr(GETPC());
 513     return t0;
 514 }
 515
 516 void helper_fcmp_eq_FT(float32 t0, float32 t1)
 517 {
 518     int relation;
 519
 520     set_float_exception_flags(0, &env->fp_status);
 521     relation = float32_compare(t0, t1, &env->fp_status);
 522     if (unlikely(relation == float_relation_unordered)) {
 523         update_fpscr(GETPC());
 524     } else if (relation == float_relation_equal) {
 525         set_t();
 526     } else {
 527         clr_t();
 528     }
 529 }
 530
 531 void helper_fcmp_eq_DT(float64 t0, float64 t1)
 532 {
 533     int relation;
 534
 535     set_float_exception_flags(0, &env->fp_status);
 536     relation = float64_compare(t0, t1, &env->fp_status);
 537     if (unlikely(relation == float_relation_unordered)) {
 538         update_fpscr(GETPC());
 539     } else if (relation == float_relation_equal) {
 540         set_t();
 541     } else {
 542         clr_t();
 543     }
 544 }
 545
 546 void helper_fcmp_gt_FT(float32 t0, float32 t1)
 547 {
 548     int relation;
 549
 550     set_float_exception_flags(0, &env->fp_status);
 551     relation = float32_compare(t0, t1, &env->fp_status);
 552     if (unlikely(relation == float_relation_unordered)) {
 553         update_fpscr(GETPC());
 554     } else if (relation == float_relation_greater) {
 555         set_t();
 556     } else {
 557         clr_t();
 558     }
 559 }
 560
 561 void helper_fcmp_gt_DT(float64 t0, float64 t1)
 562 {
 563     int relation;
 564
 565     set_float_exception_flags(0, &env->fp_status);
 566     relation = float64_compare(t0, t1, &env->fp_status);
 567     if (unlikely(relation == float_relation_unordered)) {
 568         update_fpscr(GETPC());
 569     } else if (relation == float_relation_greater) {
 570         set_t();
 571     } else {
 572         clr_t();
 573     }
 574 }
 575
 576 float64 helper_fcnvsd_FT_DT(float32 t0)
 577 {
 578     float64 ret;
 579     set_float_exception_flags(0, &env->fp_status);
 580     ret = float32_to_float64(t0, &env->fp_status);
 581     update_fpscr(GETPC());
 582     return ret;
 583 }
 584
 585 float32 helper_fcnvds_DT_FT(float64 t0)
 586 {
 587     float32 ret;
 588     set_float_exception_flags(0, &env->fp_status);
 589     ret = float64_to_float32(t0, &env->fp_status);
 590     update_fpscr(GETPC());
 591     return ret;
 592 }
 593
 594 float32 helper_fdiv_FT(float32 t0, float32 t1)
 595 {
 596     set_float_exception_flags(0, &env->fp_status);
 597     t0 = float32_div(t0, t1, &env->fp_status);
 598     update_fpscr(GETPC());
 599     return t0;
 600 }
 601
 602 float64 helper_fdiv_DT(float64 t0, float64 t1)
 603 {
 604     set_float_exception_flags(0, &env->fp_status);
 605     t0 = float64_div(t0, t1, &env->fp_status);
 606     update_fpscr(GETPC());
 607     return t0;
 608 }
 609
 610 float32 helper_float_FT(uint32_t t0)
 611 {
 612     float32 ret;
 613     set_float_exception_flags(0, &env->fp_status);
 614     ret = int32_to_float32(t0, &env->fp_status);
 615     update_fpscr(GETPC());
 616     return ret;
 617 }
 618
 619 float64 helper_float_DT(uint32_t t0)
 620 {
 621     float64 ret;
 622     set_float_exception_flags(0, &env->fp_status);
 623     ret = int32_to_float64(t0, &env->fp_status);
 624     update_fpscr(GETPC());
 625     return ret;
 626 }
 627
 628 float32 helper_fmac_FT(float32 t0, float32 t1, float32 t2)
 629 {
 630     set_float_exception_flags(0, &env->fp_status);
 631     t0 = float32_mul(t0, t1, &env->fp_status);
 632     t0 = float32_add(t0, t2, &env->fp_status);
 633     update_fpscr(GETPC());
 634     return t0;
 635 }
 636
 637 float32 helper_fmul_FT(float32 t0, float32 t1)
 638 {
 639     set_float_exception_flags(0, &env->fp_status);
 640     t0 = float32_mul(t0, t1, &env->fp_status);
 641     update_fpscr(GETPC());
 642     return t0;
 643 }
 644
 645 float64 helper_fmul_DT(float64 t0, float64 t1)
 646 {
 647     set_float_exception_flags(0, &env->fp_status);
 648     t0 = float64_mul(t0, t1, &env->fp_status);
 649     update_fpscr(GETPC());
 650     return t0;
 651 }
 652
 653 float32 helper_fneg_T(float32 t0)
 654 {
 655     return float32_chs(t0);
 656 }
 657
 658 float32 helper_fsqrt_FT(float32 t0)
 659 {
 660     set_float_exception_flags(0, &env->fp_status);
 661     t0 = float32_sqrt(t0, &env->fp_status);
 662     update_fpscr(GETPC());
 663     return t0;
 664 }
 665
 666 float64 helper_fsqrt_DT(float64 t0)
 667 {
 668     set_float_exception_flags(0, &env->fp_status);
 669     t0 = float64_sqrt(t0, &env->fp_status);
 670     update_fpscr(GETPC());
 671     return t0;
 672 }
 673
 674 float32 helper_fsub_FT(float32 t0, float32 t1)
 675 {
 676     set_float_exception_flags(0, &env->fp_status);
 677     t0 = float32_sub(t0, t1, &env->fp_status);
 678     update_fpscr(GETPC());
 679     return t0;
 680 }
 681
 682 float64 helper_fsub_DT(float64 t0, float64 t1)
 683 {
 684     set_float_exception_flags(0, &env->fp_status);
 685     t0 = float64_sub(t0, t1, &env->fp_status);
 686     update_fpscr(GETPC());
 687     return t0;
 688 }
 689
 690 uint32_t helper_ftrc_FT(float32 t0)
 691 {
 692     uint32_t ret;
 693     set_float_exception_flags(0, &env->fp_status);
 694     ret = float32_to_int32_round_to_zero(t0, &env->fp_status);
 695     update_fpscr(GETPC());
 696     return ret;
 697 }
 698
 699 uint32_t helper_ftrc_DT(float64 t0)
 700 {
 701     uint32_t ret;
 702     set_float_exception_flags(0, &env->fp_status);
 703     ret = float64_to_int32_round_to_zero(t0, &env->fp_status);
 704     update_fpscr(GETPC());
 705     return ret;
 706 }
 707
 708 void helper_fipr(uint32_t m, uint32_t n)
 709 {
 710     int bank, i;
 711     float32 r, p;
 712
 713     bank = (env->sr & FPSCR_FR) ? 16 : 0;
 714     r = float32_zero;
 715     set_float_exception_flags(0, &env->fp_status);
 716
 717     for (i = 0 ; i < 4 ; i++) {
 718         p = float32_mul(env->fregs[bank + m + i],
 719                         env->fregs[bank + n + i],
 720                         &env->fp_status);
 721         r = float32_add(r, p, &env->fp_status);
 722     }
 723     update_fpscr(GETPC());
 724
 725     env->fregs[bank + n + 3] = r;
 726 }
 727
 728 void helper_ftrv(uint32_t n)
 729 {
 730     int bank_matrix, bank_vector;
 731     int i, j;
 732     float32 r[4];
 733     float32 p;
 734
 735     bank_matrix = (env->sr & FPSCR_FR) ? 0 : 16;
 736     bank_vector = (env->sr & FPSCR_FR) ? 16 : 0;
 737     set_float_exception_flags(0, &env->fp_status);
 738     for (i = 0 ; i < 4 ; i++) {
 739         r[i] = float32_zero;
 740         for (j = 0 ; j < 4 ; j++) {
 741             p = float32_mul(env->fregs[bank_matrix + 4 * j + i],
 742                             env->fregs[bank_vector + j],
 743                             &env->fp_status);
 744             r[i] = float32_add(r[i], p, &env->fp_status);
 745         }
 746     }
 747     update_fpscr(GETPC());
 748
 749     for (i = 0 ; i < 4 ; i++) {
 750         env->fregs[bank_vector + i] = r[i];
 751     }
 752 }