source/mupen64plus-core/src/r4300/interpreter_r4300.def

   1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
   2  *   Mupen64plus - interpreter_r4300.def                                   *
   3  *   Mupen64Plus homepage: http://code.google.com/p/mupen64plus/           *
   4  *   Copyright (C) 2002 Hacktarux                                          *
   5  *                                                                         *
   6  *   This program is free software; you can redistribute it and/or modify  *
   7  *   it under the terms of the GNU General Public License as published by  *
   8  *   the Free Software Foundation; either version 2 of the License, or     *
   9  *   (at your option) any later version.                                   *
  10  *                                                                         *
  11  *   This program 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         *
  14  *   GNU General Public License for more details.                          *
  15  *                                                                         *
  16  *   You should have received a copy of the GNU General Public License     *
  17  *   along with this program; if not, write to the                         *
  18  *   Free Software Foundation, Inc.,                                       *
  19  *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.          *
  20  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  21
  22 DECLARE_JUMP(J,   (PC->f.j.inst_index<<2) | ((PCADDR+4) & 0xF0000000), 1, &reg[0],  0, 0)
  23 DECLARE_JUMP(JAL, (PC->f.j.inst_index<<2) | ((PCADDR+4) & 0xF0000000), 1, &reg[31], 0, 0)
  24 DECLARE_JUMP(BEQ,     PCADDR + (iimmediate+1)*4, irs == irt, &reg[0], 0, 0)
  25 DECLARE_JUMP(BNE,     PCADDR + (iimmediate+1)*4, irs != irt, &reg[0], 0, 0)
  26 DECLARE_JUMP(BLEZ,    PCADDR + (iimmediate+1)*4, irs <= 0,   &reg[0], 0, 0)
  27 DECLARE_JUMP(BGTZ,    PCADDR + (iimmediate+1)*4, irs > 0,    &reg[0], 0, 0)
  28
  29 DECLARE_INSTRUCTION(ADDI)
  30 {
  31    irt32 = irs32 + iimmediate;
  32    sign_extended(irt);
  33    ADD_TO_PC(1);
  34 }
  35
  36 DECLARE_INSTRUCTION(ADDIU)
  37 {
  38    irt32 = irs32 + iimmediate;
  39    sign_extended(irt);
  40    ADD_TO_PC(1);
  41 }
  42
  43 DECLARE_INSTRUCTION(SLTI)
  44 {
  45    if (irs < iimmediate) irt = 1;
  46    else irt = 0;
  47    ADD_TO_PC(1);
  48 }
  49
  50 DECLARE_INSTRUCTION(SLTIU)
  51 {
  52    if ((unsigned long long)irs < (unsigned long long)((long long)iimmediate))
  53      irt = 1;
  54    else irt = 0;
  55    ADD_TO_PC(1);
  56 }
  57
  58 DECLARE_INSTRUCTION(ANDI)
  59 {
  60    irt = irs & (unsigned short)iimmediate;
  61    ADD_TO_PC(1);
  62 }
  63
  64 DECLARE_INSTRUCTION(ORI)
  65 {
  66    irt = irs | (unsigned short)iimmediate;
  67    ADD_TO_PC(1);
  68 }
  69
  70 DECLARE_INSTRUCTION(XORI)
  71 {
  72    irt = irs ^ (unsigned short)iimmediate;
  73    ADD_TO_PC(1);
  74 }
  75
  76 DECLARE_INSTRUCTION(LUI)
  77 {
  78    irt32 = iimmediate << 16;
  79    sign_extended(irt);
  80    ADD_TO_PC(1);
  81 }
  82
  83 DECLARE_JUMP(BEQL,    PCADDR + (iimmediate+1)*4, irs == irt, &reg[0], 1, 0)
  84 DECLARE_JUMP(BNEL,    PCADDR + (iimmediate+1)*4, irs != irt, &reg[0], 1, 0)
  85 DECLARE_JUMP(BLEZL,   PCADDR + (iimmediate+1)*4, irs <= 0,   &reg[0], 1, 0)
  86 DECLARE_JUMP(BGTZL,   PCADDR + (iimmediate+1)*4, irs > 0,    &reg[0], 1, 0)
  87
  88 DECLARE_INSTRUCTION(DADDI)
  89 {
  90    irt = irs + iimmediate;
  91    ADD_TO_PC(1);
  92 }
  93
  94 DECLARE_INSTRUCTION(DADDIU)
  95 {
  96    irt = irs + iimmediate;
  97    ADD_TO_PC(1);
  98 }
  99
 100 // TODOXXX refactor the following functions to remove the
 101 // lsaddr and lsrpt locals. this may lead to a small speedup too
 102
 103 DECLARE_INSTRUCTION(LDL)
 104 {
 105    const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
 106    long long int *lsrtp = PC->f.i.rt;
 107    unsigned long long int word = 0;
 108    ADD_TO_PC(1);
 109    switch ((lsaddr) & 7)
 110      {
 111       case 0:
 112     address = (unsigned int) lsaddr;
 113     rdword = (unsigned long long *) lsrtp;
 114     read_dword_in_memory();
 115     break;
 116       case 1:
 117     address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
 118     rdword = &word;
 119     read_dword_in_memory();
 120     if(address)
 121       *lsrtp = (*lsrtp & 0xFF) | (word << 8);
 122     break;
 123       case 2:
 124     address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
 125     rdword = &word;
 126     read_dword_in_memory();
 127     if(address)
 128       *lsrtp = (*lsrtp & 0xFFFF) | (word << 16);
 129     break;
 130       case 3:
 131     address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
 132     rdword = &word;
 133     read_dword_in_memory();
 134     if(address)
 135       *lsrtp = (*lsrtp & 0xFFFFFF) | (word << 24);
 136     break;
 137       case 4:
 138     address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
 139     rdword = &word;
 140     read_dword_in_memory();
 141     if(address)
 142       *lsrtp = (*lsrtp & 0xFFFFFFFF) | (word << 32);
 143     break;
 144       case 5:
 145     address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
 146     rdword = &word;
 147     read_dword_in_memory();
 148     if(address)
 149       *lsrtp = (*lsrtp & 0xFFFFFFFFFFLL) | (word << 40);
 150     break;
 151       case 6:
 152     address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
 153     rdword = &word;
 154     read_dword_in_memory();
 155     if(address)
 156       *lsrtp = (*lsrtp & 0xFFFFFFFFFFFFLL) | (word << 48);
 157     break;
 158       case 7:
 159     address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
 160     rdword = &word;
 161     read_dword_in_memory();
 162     if(address)
 163       *lsrtp = (*lsrtp & 0xFFFFFFFFFFFFFFLL) | (word << 56);
 164     break;
 165      }
 166 }
 167
 168 DECLARE_INSTRUCTION(LDR)
 169 {
 170    const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
 171    long long int *lsrtp = PC->f.i.rt;
 172    unsigned long long int word = 0;
 173    ADD_TO_PC(1);
 174    switch ((lsaddr) & 7)
 175      {
 176       case 0:
 177     address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
 178     rdword = &word;
 179     read_dword_in_memory();
 180     if(address)
 181       *lsrtp = (*lsrtp & 0xFFFFFFFFFFFFFF00LL) | (word >> 56);
 182     break;
 183       case 1:
 184     address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
 185     rdword = &word;
 186     read_dword_in_memory();
 187     if(address)
 188       *lsrtp = (*lsrtp & 0xFFFFFFFFFFFF0000LL) | (word >> 48);
 189     break;
 190       case 2:
 191     address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
 192     rdword = &word;
 193     read_dword_in_memory();
 194     if(address)
 195       *lsrtp = (*lsrtp & 0xFFFFFFFFFF000000LL) | (word >> 40);
 196     break;
 197       case 3:
 198     address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
 199     rdword = &word;
 200     read_dword_in_memory();
 201     if(address)
 202       *lsrtp = (*lsrtp & 0xFFFFFFFF00000000LL) | (word >> 32);
 203     break;
 204       case 4:
 205     address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
 206     rdword = &word;
 207     read_dword_in_memory();
 208     if(address)
 209       *lsrtp = (*lsrtp & 0xFFFFFF0000000000LL) | (word >> 24);
 210     break;
 211       case 5:
 212     address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
 213     rdword = &word;
 214     read_dword_in_memory();
 215     if(address)
 216       *lsrtp = (*lsrtp & 0xFFFF000000000000LL) | (word >> 16);
 217     break;
 218       case 6:
 219     address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
 220     rdword = &word;
 221     read_dword_in_memory();
 222     if(address)
 223       *lsrtp = (*lsrtp & 0xFF00000000000000LL) | (word >> 8);
 224     break;
 225       case 7:
 226     address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
 227     rdword = (unsigned long long *) lsrtp;
 228     read_dword_in_memory();
 229     break;
 230      }
 231 }
 232
 233 DECLARE_INSTRUCTION(LB)
 234 {
 235    const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
 236    long long int *lsrtp = PC->f.i.rt;
 237    ADD_TO_PC(1);
 238    address = (unsigned int) lsaddr;
 239    rdword = (unsigned long long *) lsrtp;
 240    read_byte_in_memory();
 241    if (address)
 242      sign_extendedb(*lsrtp);
 243 }
 244
 245 DECLARE_INSTRUCTION(LH)
 246 {
 247    const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
 248    long long int *lsrtp = PC->f.i.rt;
 249    ADD_TO_PC(1);
 250    address = (unsigned int) lsaddr;
 251    rdword = (unsigned long long *) lsrtp;
 252    read_hword_in_memory();
 253    if (address)
 254      sign_extendedh(*lsrtp);
 255 }
 256
 257 DECLARE_INSTRUCTION(LWL)
 258 {
 259    const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
 260    long long int *lsrtp = PC->f.i.rt;
 261    unsigned long long int word = 0;
 262    ADD_TO_PC(1);
 263    switch ((lsaddr) & 3)
 264      {
 265       case 0:
 266     address = (unsigned int) lsaddr;
 267     rdword = (unsigned long long *) lsrtp;
 268     read_word_in_memory();
 269     break;
 270       case 1:
 271     address = ((unsigned int) lsaddr) & 0xFFFFFFFC;
 272     rdword = &word;
 273     read_word_in_memory();
 274     if(address)
 275       *lsrtp = (*lsrtp & 0xFF) | (word << 8);
 276     break;
 277       case 2:
 278     address = ((unsigned int) lsaddr) & 0xFFFFFFFC;
 279     rdword = &word;
 280     read_word_in_memory();
 281     if(address)
 282       *lsrtp = (*lsrtp & 0xFFFF) | (word << 16);
 283     break;
 284       case 3:
 285     address = ((unsigned int) lsaddr) & 0xFFFFFFFC;
 286     rdword = &word;
 287     read_word_in_memory();
 288     if(address)
 289       *lsrtp = (*lsrtp & 0xFFFFFF) | (word << 24);
 290     break;
 291      }
 292    if(address)
 293      sign_extended(*lsrtp);
 294 }
 295
 296 DECLARE_INSTRUCTION(LW)
 297 {
 298    const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
 299    long long int *lsrtp = PC->f.i.rt;
 300    ADD_TO_PC(1);
 301    address = (unsigned int) lsaddr;
 302    rdword = (unsigned long long *) lsrtp;
 303    read_word_in_memory();
 304    if (address)
 305      sign_extended(*lsrtp);
 306 }
 307
 308 DECLARE_INSTRUCTION(LBU)
 309 {
 310    const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
 311    long long int *lsrtp = PC->f.i.rt;
 312    ADD_TO_PC(1);
 313    address = (unsigned int) lsaddr;
 314    rdword = (unsigned long long *) lsrtp;
 315    read_byte_in_memory();
 316 }
 317
 318 DECLARE_INSTRUCTION(LHU)
 319 {
 320    const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
 321    long long int *lsrtp = PC->f.i.rt;
 322    ADD_TO_PC(1);
 323    address = (unsigned int) lsaddr;
 324    rdword = (unsigned long long *) lsrtp;
 325    read_hword_in_memory();
 326 }
 327
 328 DECLARE_INSTRUCTION(LWR)
 329 {
 330    const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
 331    long long int *lsrtp = PC->f.i.rt;
 332    unsigned long long int word = 0;
 333    ADD_TO_PC(1);
 334    switch ((lsaddr) & 3)
 335      {
 336       case 0:
 337     address = ((unsigned int) lsaddr) & 0xFFFFFFFC;
 338     rdword = &word;
 339     read_word_in_memory();
 340     if(address)
 341       *lsrtp = (*lsrtp & 0xFFFFFFFFFFFFFF00LL) | ((word >> 24) & 0xFF);
 342     break;
 343       case 1:
 344     address = ((unsigned int) lsaddr) & 0xFFFFFFFC;
 345     rdword = &word;
 346     read_word_in_memory();
 347     if(address)
 348       *lsrtp = (*lsrtp & 0xFFFFFFFFFFFF0000LL) | ((word >> 16) & 0xFFFF);
 349     break;
 350       case 2:
 351     address = ((unsigned int) lsaddr) & 0xFFFFFFFC;
 352     rdword = &word;
 353     read_word_in_memory();
 354     if(address)
 355       *lsrtp = (*lsrtp & 0xFFFFFFFFFF000000LL) | ((word >> 8) & 0XFFFFFF);
 356     break;
 357       case 3:
 358     address = ((unsigned int) lsaddr) & 0xFFFFFFFC;
 359     rdword = (unsigned long long *) lsrtp;
 360     read_word_in_memory();
 361     if(address)
 362       sign_extended(*lsrtp);
 363      }
 364 }
 365
 366 DECLARE_INSTRUCTION(LWU)
 367 {
 368    const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
 369    long long int *lsrtp = PC->f.i.rt;
 370    ADD_TO_PC(1);
 371    address = (unsigned int) lsaddr;
 372    rdword = (unsigned long long *) lsrtp;
 373    read_word_in_memory();
 374 }
 375
 376 DECLARE_INSTRUCTION(SB)
 377 {
 378    const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
 379    long long int *lsrtp = PC->f.i.rt;
 380    ADD_TO_PC(1);
 381    address = (unsigned int) lsaddr;
 382    cpu_byte = (unsigned char)(*lsrtp & 0xFF);
 383    write_byte_in_memory();
 384    CHECK_MEMORY();
 385 }
 386
 387 DECLARE_INSTRUCTION(SH)
 388 {
 389    const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
 390    long long int *lsrtp = PC->f.i.rt;
 391    ADD_TO_PC(1);
 392    address = (unsigned int) lsaddr;
 393    hword = (unsigned short)(*lsrtp & 0xFFFF);
 394    write_hword_in_memory();
 395    CHECK_MEMORY();
 396 }
 397
 398 DECLARE_INSTRUCTION(SWL)
 399 {
 400    const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
 401    long long int *lsrtp = PC->f.i.rt;
 402    unsigned long long int old_word = 0;
 403    ADD_TO_PC(1);
 404    switch ((lsaddr) & 3)
 405      {
 406       case 0:
 407     address = ((unsigned int) lsaddr) & 0xFFFFFFFC;
 408     word = (unsigned int)*lsrtp;
 409     write_word_in_memory();
 410     CHECK_MEMORY();
 411     break;
 412       case 1:
 413     address = ((unsigned int) lsaddr) & 0xFFFFFFFC;
 414     rdword = &old_word;
 415     read_word_in_memory();
 416     if(address)
 417       {
 418          word = ((unsigned int)*lsrtp >> 8) | ((unsigned int) old_word & 0xFF000000);
 419          write_word_in_memory();
 420          CHECK_MEMORY();
 421       }
 422     break;
 423       case 2:
 424     address = ((unsigned int) lsaddr) & 0xFFFFFFFC;
 425     rdword = &old_word;
 426     read_word_in_memory();
 427     if(address)
 428       {
 429          word = ((unsigned int)*lsrtp >> 16) | ((unsigned int) old_word & 0xFFFF0000);
 430          write_word_in_memory();
 431          CHECK_MEMORY();
 432       }
 433     break;
 434       case 3:
 435     address = (unsigned int) lsaddr;
 436     cpu_byte = (unsigned char)(*lsrtp >> 24);
 437     write_byte_in_memory();
 438     CHECK_MEMORY();
 439     break;
 440      }
 441 }
 442
 443 DECLARE_INSTRUCTION(SW)
 444 {
 445    const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
 446    long long int *lsrtp = PC->f.i.rt;
 447    ADD_TO_PC(1);
 448    address = (unsigned int) lsaddr;
 449    word = (unsigned int)(*lsrtp & 0xFFFFFFFF);
 450    write_word_in_memory();
 451    CHECK_MEMORY();
 452 }
 453
 454 DECLARE_INSTRUCTION(SDL)
 455 {
 456    const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
 457    long long int *lsrtp = PC->f.i.rt;
 458    unsigned long long int old_word = 0;
 459    ADD_TO_PC(1);
 460    switch ((lsaddr) & 7)
 461      {
 462       case 0:
 463     address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
 464     dword = *lsrtp;
 465     write_dword_in_memory();
 466     CHECK_MEMORY();
 467     break;
 468       case 1:
 469     address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
 470     rdword = &old_word;
 471     read_dword_in_memory();
 472     if(address)
 473       {
 474          dword = ((unsigned long long)*lsrtp >> 8)|(old_word & 0xFF00000000000000LL);
 475          write_dword_in_memory();
 476          CHECK_MEMORY();
 477       }
 478     break;
 479       case 2:
 480     address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
 481     rdword = &old_word;
 482     read_dword_in_memory();
 483     if(address)
 484       {
 485          dword = ((unsigned long long)*lsrtp >> 16)|(old_word & 0xFFFF000000000000LL);
 486          write_dword_in_memory();
 487          CHECK_MEMORY();
 488       }
 489     break;
 490       case 3:
 491     address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
 492     rdword = &old_word;
 493     read_dword_in_memory();
 494     if(address)
 495       {
 496          dword = ((unsigned long long)*lsrtp >> 24)|(old_word & 0xFFFFFF0000000000LL);
 497          write_dword_in_memory();
 498          CHECK_MEMORY();
 499       }
 500     break;
 501       case 4:
 502     address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
 503     rdword = &old_word;
 504     read_dword_in_memory();
 505     if(address)
 506       {
 507          dword = ((unsigned long long)*lsrtp >> 32)|(old_word & 0xFFFFFFFF00000000LL);
 508          write_dword_in_memory();
 509          CHECK_MEMORY();
 510       }
 511     break;
 512       case 5:
 513     address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
 514     rdword = &old_word;
 515     read_dword_in_memory();
 516     if(address)
 517       {
 518          dword = ((unsigned long long)*lsrtp >> 40)|(old_word & 0xFFFFFFFFFF000000LL);
 519          write_dword_in_memory();
 520          CHECK_MEMORY();
 521       }
 522     break;
 523       case 6:
 524     address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
 525     rdword = &old_word;
 526     read_dword_in_memory();
 527     if(address)
 528       {
 529          dword = ((unsigned long long)*lsrtp >> 48)|(old_word & 0xFFFFFFFFFFFF0000LL);
 530          write_dword_in_memory();
 531          CHECK_MEMORY();
 532       }
 533     break;
 534       case 7:
 535     address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
 536     rdword = &old_word;
 537     read_dword_in_memory();
 538     if(address)
 539       {
 540          dword = ((unsigned long long)*lsrtp >> 56)|(old_word & 0xFFFFFFFFFFFFFF00LL);
 541          write_dword_in_memory();
 542          CHECK_MEMORY();
 543       }
 544     break;
 545      }
 546 }
 547
 548 DECLARE_INSTRUCTION(SDR)
 549 {
 550    const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
 551    long long int *lsrtp = PC->f.i.rt;
 552    unsigned long long int old_word = 0;
 553    ADD_TO_PC(1);
 554    switch ((lsaddr) & 7)
 555      {
 556       case 0:
 557     address = (unsigned int) lsaddr;
 558     rdword = &old_word;
 559     read_dword_in_memory();
 560     if(address)
 561       {
 562          dword = (*lsrtp << 56) | (old_word & 0x00FFFFFFFFFFFFFFLL);
 563          write_dword_in_memory();
 564          CHECK_MEMORY();
 565       }
 566     break;
 567       case 1:
 568     address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
 569     rdword = &old_word;
 570     read_dword_in_memory();
 571     if(address)
 572       {
 573          dword = (*lsrtp << 48) | (old_word & 0x0000FFFFFFFFFFFFLL);
 574          write_dword_in_memory();
 575          CHECK_MEMORY();
 576       }
 577     break;
 578       case 2:
 579     address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
 580     rdword = &old_word;
 581     read_dword_in_memory();
 582     if(address)
 583       {
 584          dword = (*lsrtp << 40) | (old_word & 0x000000FFFFFFFFFFLL);
 585          write_dword_in_memory();
 586          CHECK_MEMORY();
 587       }
 588     break;
 589       case 3:
 590     address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
 591     rdword = &old_word;
 592     read_dword_in_memory();
 593     if(address)
 594       {
 595          dword = (*lsrtp << 32) | (old_word & 0x00000000FFFFFFFFLL);
 596          write_dword_in_memory();
 597          CHECK_MEMORY();
 598       }
 599     break;
 600       case 4:
 601     address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
 602     rdword = &old_word;
 603     read_dword_in_memory();
 604     if(address)
 605       {
 606          dword = (*lsrtp << 24) | (old_word & 0x0000000000FFFFFFLL);
 607          write_dword_in_memory();
 608          CHECK_MEMORY();
 609       }
 610     break;
 611       case 5:
 612     address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
 613     rdword = &old_word;
 614     read_dword_in_memory();
 615     if(address)
 616       {
 617          dword = (*lsrtp << 16) | (old_word & 0x000000000000FFFFLL);
 618          write_dword_in_memory();
 619          CHECK_MEMORY();
 620       }
 621     break;
 622       case 6:
 623     address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
 624     rdword = &old_word;
 625     read_dword_in_memory();
 626     if(address)
 627       {
 628          dword = (*lsrtp << 8) | (old_word & 0x00000000000000FFLL);
 629          write_dword_in_memory();
 630          CHECK_MEMORY();
 631       }
 632     break;
 633       case 7:
 634     address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
 635     dword = *lsrtp;
 636     write_dword_in_memory();
 637     CHECK_MEMORY();
 638     break;
 639      }
 640 }
 641
 642 DECLARE_INSTRUCTION(SWR)
 643 {
 644    const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
 645    long long int *lsrtp = PC->f.i.rt;
 646    unsigned long long int old_word = 0;
 647    ADD_TO_PC(1);
 648    switch ((lsaddr) & 3)
 649      {
 650       case 0:
 651     address = (unsigned int) lsaddr;
 652     rdword = &old_word;
 653     read_word_in_memory();
 654     if(address)
 655       {
 656          word = ((unsigned int)*lsrtp << 24) | ((unsigned int) old_word & 0x00FFFFFF);
 657          write_word_in_memory();
 658          CHECK_MEMORY();
 659       }
 660     break;
 661       case 1:
 662     address = ((unsigned int) lsaddr) & 0xFFFFFFFC;
 663     rdword = &old_word;
 664     read_word_in_memory();
 665     if(address)
 666       {
 667          word = ((unsigned int)*lsrtp << 16) | ((unsigned int) old_word & 0x0000FFFF);
 668          write_word_in_memory();
 669          CHECK_MEMORY();
 670       }
 671     break;
 672       case 2:
 673     address = ((unsigned int) lsaddr) & 0xFFFFFFFC;
 674     rdword = &old_word;
 675     read_word_in_memory();
 676     if(address)
 677       {
 678          word = ((unsigned int)*lsrtp << 8) | ((unsigned int) old_word & 0x000000FF);
 679          write_word_in_memory();
 680          CHECK_MEMORY();
 681       }
 682     break;
 683       case 3:
 684     address = ((unsigned int) lsaddr) & 0xFFFFFFFC;
 685     word = (unsigned int)*lsrtp;
 686     write_word_in_memory();
 687     CHECK_MEMORY();
 688     break;
 689      }
 690 }
 691
 692 DECLARE_INSTRUCTION(CACHE)
 693 {
 694    ADD_TO_PC(1);
 695 }
 696
 697 DECLARE_INSTRUCTION(LL)
 698 {
 699    const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
 700    long long int *lsrtp = PC->f.i.rt;
 701    ADD_TO_PC(1);
 702    address = (unsigned int) lsaddr;
 703    rdword = (unsigned long long *) lsrtp;
 704    read_word_in_memory();
 705    if (address)
 706      {
 707     sign_extended(*lsrtp);
 708     llbit = 1;
 709      }
 710 }
 711
 712 DECLARE_INSTRUCTION(LWC1)
 713 {
 714    const unsigned char lslfft = lfft;
 715    const unsigned int lslfaddr = (unsigned int)(lfoffset + reg[lfbase]);
 716    unsigned long long int temp;
 717    if (check_cop1_unusable()) return;
 718    ADD_TO_PC(1);
 719    address = (unsigned int) lslfaddr;
 720    rdword = &temp;
 721    read_word_in_memory();
 722    if (address)
 723      *((int*)reg_cop1_simple[lslfft]) = (int) *rdword;
 724 }
 725
 726 DECLARE_INSTRUCTION(LDC1)
 727 {
 728    const unsigned char lslfft = lfft;
 729    const unsigned int lslfaddr = (unsigned int)(lfoffset + reg[lfbase]);
 730    if (check_cop1_unusable()) return;
 731    ADD_TO_PC(1);
 732    address = (unsigned int) lslfaddr;
 733    rdword = (unsigned long long *)reg_cop1_double[lslfft];
 734    read_dword_in_memory();
 735 }
 736
 737 DECLARE_INSTRUCTION(LD)
 738 {
 739    const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
 740    long long int *lsrtp = PC->f.i.rt;
 741    ADD_TO_PC(1);
 742    address = (unsigned int) lsaddr;
 743    rdword = (unsigned long long *) lsrtp;
 744    read_dword_in_memory();
 745 }
 746
 747 DECLARE_INSTRUCTION(SC)
 748 {
 749    const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
 750    long long int *lsrtp = PC->f.i.rt;
 751    ADD_TO_PC(1);
 752    if(llbit)
 753    {
 754       address = (unsigned int) lsaddr;
 755       word = (unsigned int)(*lsrtp & 0xFFFFFFFF);
 756       write_word_in_memory();
 757       CHECK_MEMORY();
 758       llbit = 0;
 759       *lsrtp = 1;
 760    }
 761    else
 762    {
 763       *lsrtp = 0;
 764    }
 765 }
 766
 767 DECLARE_INSTRUCTION(SWC1)
 768 {
 769    const unsigned char lslfft = lfft;
 770    const unsigned int lslfaddr = (unsigned int)(lfoffset + reg[lfbase]);
 771    if (check_cop1_unusable()) return;
 772    ADD_TO_PC(1);
 773    address = (unsigned int) lslfaddr;
 774    word = *((int*)reg_cop1_simple[lslfft]);
 775    write_word_in_memory();
 776    CHECK_MEMORY();
 777 }
 778
 779 DECLARE_INSTRUCTION(SDC1)
 780 {
 781    const unsigned char lslfft = lfft;
 782    const unsigned int lslfaddr = (unsigned int)(lfoffset + reg[lfbase]);
 783    if (check_cop1_unusable()) return;
 784    ADD_TO_PC(1);
 785    address = (unsigned int) lslfaddr;
 786    dword = *((unsigned long long*)reg_cop1_double[lslfft]);
 787    write_dword_in_memory();
 788    CHECK_MEMORY();
 789 }
 790
 791 DECLARE_INSTRUCTION(SD)
 792 {
 793    const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
 794    long long int *lsrtp = PC->f.i.rt;
 795    ADD_TO_PC(1);
 796    address = (unsigned int) lsaddr;
 797    dword = *lsrtp;
 798    write_dword_in_memory();
 799    CHECK_MEMORY();
 800 }