[mupen64plus-pandora.git] / source / mupen64plus-core / src / r4300 / interpreter_r4300.def

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 *   Mupen64plus - interpreter_r4300.def                                   *
 *   Mupen64Plus homepage: http://code.google.com/p/mupen64plus/           *
 *   Copyright (C) 2002 Hacktarux                                          *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.          *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

DECLARE_JUMP(J,   (PC->f.j.inst_index<<2) | ((PCADDR+4) & 0xF0000000), 1, &reg[0],  0, 0)
DECLARE_JUMP(JAL, (PC->f.j.inst_index<<2) | ((PCADDR+4) & 0xF0000000), 1, &reg[31], 0, 0)
DECLARE_JUMP(BEQ,     PCADDR + (iimmediate+1)*4, irs == irt, &reg[0], 0, 0)
DECLARE_JUMP(BNE,     PCADDR + (iimmediate+1)*4, irs != irt, &reg[0], 0, 0)
DECLARE_JUMP(BLEZ,    PCADDR + (iimmediate+1)*4, irs <= 0,   &reg[0], 0, 0)
DECLARE_JUMP(BGTZ,    PCADDR + (iimmediate+1)*4, irs > 0,    &reg[0], 0, 0)

DECLARE_INSTRUCTION(ADDI)
{
   irt32 = irs32 + iimmediate;
   sign_extended(irt);
   ADD_TO_PC(1);
}

DECLARE_INSTRUCTION(ADDIU)
{
   irt32 = irs32 + iimmediate;
   sign_extended(irt);
   ADD_TO_PC(1);
}

DECLARE_INSTRUCTION(SLTI)
{
   if (irs < iimmediate) irt = 1;
   else irt = 0;
   ADD_TO_PC(1);
}

DECLARE_INSTRUCTION(SLTIU)
{
   if ((unsigned long long)irs < (unsigned long long)((long long)iimmediate))
     irt = 1;
   else irt = 0;
   ADD_TO_PC(1);
}

DECLARE_INSTRUCTION(ANDI)
{
   irt = irs & (unsigned short)iimmediate;
   ADD_TO_PC(1);
}

DECLARE_INSTRUCTION(ORI)
{
   irt = irs | (unsigned short)iimmediate;
   ADD_TO_PC(1);
}

DECLARE_INSTRUCTION(XORI)
{
   irt = irs ^ (unsigned short)iimmediate;
   ADD_TO_PC(1);
}

DECLARE_INSTRUCTION(LUI)
{
   irt32 = iimmediate << 16;
   sign_extended(irt);
   ADD_TO_PC(1);
}

DECLARE_JUMP(BEQL,    PCADDR + (iimmediate+1)*4, irs == irt, &reg[0], 1, 0)
DECLARE_JUMP(BNEL,    PCADDR + (iimmediate+1)*4, irs != irt, &reg[0], 1, 0)
DECLARE_JUMP(BLEZL,   PCADDR + (iimmediate+1)*4, irs <= 0,   &reg[0], 1, 0)
DECLARE_JUMP(BGTZL,   PCADDR + (iimmediate+1)*4, irs > 0,    &reg[0], 1, 0)

DECLARE_INSTRUCTION(DADDI)
{
   irt = irs + iimmediate;
   ADD_TO_PC(1);
}

DECLARE_INSTRUCTION(DADDIU)
{
   irt = irs + iimmediate;
   ADD_TO_PC(1);
}

// TODOXXX refactor the following functions to remove the
// lsaddr and lsrpt locals. this may lead to a small speedup too

DECLARE_INSTRUCTION(LDL)
{
   const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
   long long int *lsrtp = PC->f.i.rt;
   unsigned long long int word = 0;
   ADD_TO_PC(1);
   switch ((lsaddr) & 7)
     {
      case 0:
    address = (unsigned int) lsaddr;
    rdword = (unsigned long long *) lsrtp;
    read_dword_in_memory();
    break;
      case 1:
    address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
    rdword = &word;
    read_dword_in_memory();
    if(address)
      *lsrtp = (*lsrtp & 0xFF) | (word << 8);
    break;
      case 2:
    address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
    rdword = &word;
    read_dword_in_memory();
    if(address)
      *lsrtp = (*lsrtp & 0xFFFF) | (word << 16);
    break;
      case 3:
    address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
    rdword = &word;
    read_dword_in_memory();
    if(address)
      *lsrtp = (*lsrtp & 0xFFFFFF) | (word << 24);
    break;
      case 4:
    address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
    rdword = &word;
    read_dword_in_memory();
    if(address)
      *lsrtp = (*lsrtp & 0xFFFFFFFF) | (word << 32);
    break;
      case 5:
    address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
    rdword = &word;
    read_dword_in_memory();
    if(address)
      *lsrtp = (*lsrtp & 0xFFFFFFFFFFLL) | (word << 40);
    break;
      case 6:
    address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
    rdword = &word;
    read_dword_in_memory();
    if(address)
      *lsrtp = (*lsrtp & 0xFFFFFFFFFFFFLL) | (word << 48);
    break;
      case 7:
    address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
    rdword = &word;
    read_dword_in_memory();
    if(address)
      *lsrtp = (*lsrtp & 0xFFFFFFFFFFFFFFLL) | (word << 56);
    break;
     }
}

DECLARE_INSTRUCTION(LDR)
{
   const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
   long long int *lsrtp = PC->f.i.rt;
   unsigned long long int word = 0;
   ADD_TO_PC(1);
   switch ((lsaddr) & 7)
     {
      case 0:
    address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
    rdword = &word;
    read_dword_in_memory();
    if(address)
      *lsrtp = (*lsrtp & 0xFFFFFFFFFFFFFF00LL) | (word >> 56);
    break;
      case 1:
    address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
    rdword = &word;
    read_dword_in_memory();
    if(address)
      *lsrtp = (*lsrtp & 0xFFFFFFFFFFFF0000LL) | (word >> 48);
    break;
      case 2:
    address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
    rdword = &word;
    read_dword_in_memory();
    if(address)
      *lsrtp = (*lsrtp & 0xFFFFFFFFFF000000LL) | (word >> 40);
    break;
      case 3:
    address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
    rdword = &word;
    read_dword_in_memory();
    if(address)
      *lsrtp = (*lsrtp & 0xFFFFFFFF00000000LL) | (word >> 32);
    break;
      case 4:
    address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
    rdword = &word;
    read_dword_in_memory();
    if(address)
      *lsrtp = (*lsrtp & 0xFFFFFF0000000000LL) | (word >> 24);
    break;
      case 5:
    address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
    rdword = &word;
    read_dword_in_memory();
    if(address)
      *lsrtp = (*lsrtp & 0xFFFF000000000000LL) | (word >> 16);
    break;
      case 6:
    address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
    rdword = &word;
    read_dword_in_memory();
    if(address)
      *lsrtp = (*lsrtp & 0xFF00000000000000LL) | (word >> 8);
    break;
      case 7:
    address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
    rdword = (unsigned long long *) lsrtp;
    read_dword_in_memory();
    break;
     }
}

DECLARE_INSTRUCTION(LB)
{
   const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
   long long int *lsrtp = PC->f.i.rt;
   ADD_TO_PC(1);
   address = (unsigned int) lsaddr;
   rdword = (unsigned long long *) lsrtp;
   read_byte_in_memory();
   if (address)
     sign_extendedb(*lsrtp);
}

DECLARE_INSTRUCTION(LH)
{
   const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
   long long int *lsrtp = PC->f.i.rt;
   ADD_TO_PC(1);
   address = (unsigned int) lsaddr;
   rdword = (unsigned long long *) lsrtp;
   read_hword_in_memory();
   if (address)
     sign_extendedh(*lsrtp);
}

DECLARE_INSTRUCTION(LWL)
{
   const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
   long long int *lsrtp = PC->f.i.rt;
   unsigned long long int word = 0;
   ADD_TO_PC(1);
   switch ((lsaddr) & 3)
     {
      case 0:
    address = (unsigned int) lsaddr;
    rdword = (unsigned long long *) lsrtp;
    read_word_in_memory();
    break;
      case 1:
    address = ((unsigned int) lsaddr) & 0xFFFFFFFC;
    rdword = &word;
    read_word_in_memory();
    if(address)
      *lsrtp = (*lsrtp & 0xFF) | (word << 8);
    break;
      case 2:
    address = ((unsigned int) lsaddr) & 0xFFFFFFFC;
    rdword = &word;
    read_word_in_memory();
    if(address)
      *lsrtp = (*lsrtp & 0xFFFF) | (word << 16);
    break;
      case 3:
    address = ((unsigned int) lsaddr) & 0xFFFFFFFC;
    rdword = &word;
    read_word_in_memory();
    if(address)
      *lsrtp = (*lsrtp & 0xFFFFFF) | (word << 24);
    break;
     }
   if(address)
     sign_extended(*lsrtp);
}

DECLARE_INSTRUCTION(LW)
{
   const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
   long long int *lsrtp = PC->f.i.rt;
   ADD_TO_PC(1);
   address = (unsigned int) lsaddr;
   rdword = (unsigned long long *) lsrtp;
   read_word_in_memory();
   if (address)
     sign_extended(*lsrtp);
}

DECLARE_INSTRUCTION(LBU)
{
   const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
   long long int *lsrtp = PC->f.i.rt;
   ADD_TO_PC(1);
   address = (unsigned int) lsaddr;
   rdword = (unsigned long long *) lsrtp;
   read_byte_in_memory();
}

DECLARE_INSTRUCTION(LHU)
{
   const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
   long long int *lsrtp = PC->f.i.rt;
   ADD_TO_PC(1);
   address = (unsigned int) lsaddr;
   rdword = (unsigned long long *) lsrtp;
   read_hword_in_memory();
}

DECLARE_INSTRUCTION(LWR)
{
   const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
   long long int *lsrtp = PC->f.i.rt;
   unsigned long long int word = 0;
   ADD_TO_PC(1);
   switch ((lsaddr) & 3)
     {
      case 0:
    address = ((unsigned int) lsaddr) & 0xFFFFFFFC;
    rdword = &word;
    read_word_in_memory();
    if(address)
      *lsrtp = (*lsrtp & 0xFFFFFFFFFFFFFF00LL) | ((word >> 24) & 0xFF);
    break;
      case 1:
    address = ((unsigned int) lsaddr) & 0xFFFFFFFC;
    rdword = &word;
    read_word_in_memory();
    if(address)
      *lsrtp = (*lsrtp & 0xFFFFFFFFFFFF0000LL) | ((word >> 16) & 0xFFFF);
    break;
      case 2:
    address = ((unsigned int) lsaddr) & 0xFFFFFFFC;
    rdword = &word;
    read_word_in_memory();
    if(address)
      *lsrtp = (*lsrtp & 0xFFFFFFFFFF000000LL) | ((word >> 8) & 0XFFFFFF);
    break;
      case 3:
    address = ((unsigned int) lsaddr) & 0xFFFFFFFC;
    rdword = (unsigned long long *) lsrtp;
    read_word_in_memory();
    if(address)
      sign_extended(*lsrtp);
     }
}

DECLARE_INSTRUCTION(LWU)
{
   const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
   long long int *lsrtp = PC->f.i.rt;
   ADD_TO_PC(1);
   address = (unsigned int) lsaddr;
   rdword = (unsigned long long *) lsrtp;
   read_word_in_memory();
}

DECLARE_INSTRUCTION(SB)
{
   const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
   long long int *lsrtp = PC->f.i.rt;
   ADD_TO_PC(1);
   address = (unsigned int) lsaddr;
   cpu_byte = (unsigned char)(*lsrtp & 0xFF);
   write_byte_in_memory();
   CHECK_MEMORY();
}

DECLARE_INSTRUCTION(SH)
{
   const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
   long long int *lsrtp = PC->f.i.rt;
   ADD_TO_PC(1);
   address = (unsigned int) lsaddr;
   hword = (unsigned short)(*lsrtp & 0xFFFF);
   write_hword_in_memory();
   CHECK_MEMORY();
}

DECLARE_INSTRUCTION(SWL)
{
   const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
   long long int *lsrtp = PC->f.i.rt;
   unsigned long long int old_word = 0;
   ADD_TO_PC(1);
   switch ((lsaddr) & 3)
     {
      case 0:
    address = ((unsigned int) lsaddr) & 0xFFFFFFFC;
    word = (unsigned int)*lsrtp;
    write_word_in_memory();
    CHECK_MEMORY();
    break;
      case 1:
    address = ((unsigned int) lsaddr) & 0xFFFFFFFC;
    rdword = &old_word;
    read_word_in_memory();
    if(address)
      {
         word = ((unsigned int)*lsrtp >> 8) | ((unsigned int) old_word & 0xFF000000);
         write_word_in_memory();
         CHECK_MEMORY();
      }
    break;
      case 2:
    address = ((unsigned int) lsaddr) & 0xFFFFFFFC;
    rdword = &old_word;
    read_word_in_memory();
    if(address)
      {
         word = ((unsigned int)*lsrtp >> 16) | ((unsigned int) old_word & 0xFFFF0000);
         write_word_in_memory();
         CHECK_MEMORY();
      }
    break;
      case 3:
    address = (unsigned int) lsaddr;
    cpu_byte = (unsigned char)(*lsrtp >> 24);
    write_byte_in_memory();
    CHECK_MEMORY();
    break;
     }
}

DECLARE_INSTRUCTION(SW)
{
   const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
   long long int *lsrtp = PC->f.i.rt;
   ADD_TO_PC(1);
   address = (unsigned int) lsaddr;
   word = (unsigned int)(*lsrtp & 0xFFFFFFFF);
   write_word_in_memory();
   CHECK_MEMORY();
}

DECLARE_INSTRUCTION(SDL)
{
   const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
   long long int *lsrtp = PC->f.i.rt;
   unsigned long long int old_word = 0;
   ADD_TO_PC(1);
   switch ((lsaddr) & 7)
     {
      case 0:
    address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
    dword = *lsrtp;
    write_dword_in_memory();
    CHECK_MEMORY();
    break;
      case 1:
    address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
    rdword = &old_word;
    read_dword_in_memory();
    if(address)
      {
         dword = ((unsigned long long)*lsrtp >> 8)|(old_word & 0xFF00000000000000LL);
         write_dword_in_memory();
         CHECK_MEMORY();
      }
    break;
      case 2:
    address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
    rdword = &old_word;
    read_dword_in_memory();
    if(address)
      {
         dword = ((unsigned long long)*lsrtp >> 16)|(old_word & 0xFFFF000000000000LL);
         write_dword_in_memory();
         CHECK_MEMORY();
      }
    break;
      case 3:
    address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
    rdword = &old_word;
    read_dword_in_memory();
    if(address)
      {
         dword = ((unsigned long long)*lsrtp >> 24)|(old_word & 0xFFFFFF0000000000LL);
         write_dword_in_memory();
         CHECK_MEMORY();
      }
    break;
      case 4:
    address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
    rdword = &old_word;
    read_dword_in_memory();
    if(address)
      {
         dword = ((unsigned long long)*lsrtp >> 32)|(old_word & 0xFFFFFFFF00000000LL);
         write_dword_in_memory();
         CHECK_MEMORY();
      }
    break;
      case 5:
    address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
    rdword = &old_word;
    read_dword_in_memory();
    if(address)
      {
         dword = ((unsigned long long)*lsrtp >> 40)|(old_word & 0xFFFFFFFFFF000000LL);
         write_dword_in_memory();
         CHECK_MEMORY();
      }
    break;
      case 6:
    address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
    rdword = &old_word;
    read_dword_in_memory();
    if(address)
      {
         dword = ((unsigned long long)*lsrtp >> 48)|(old_word & 0xFFFFFFFFFFFF0000LL);
         write_dword_in_memory();
         CHECK_MEMORY();
      }
    break;
      case 7:
    address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
    rdword = &old_word;
    read_dword_in_memory();
    if(address)
      {
         dword = ((unsigned long long)*lsrtp >> 56)|(old_word & 0xFFFFFFFFFFFFFF00LL);
         write_dword_in_memory();
         CHECK_MEMORY();
      }
    break;
     }
}

DECLARE_INSTRUCTION(SDR)
{
   const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
   long long int *lsrtp = PC->f.i.rt;
   unsigned long long int old_word = 0;
   ADD_TO_PC(1);
   switch ((lsaddr) & 7)
     {
      case 0:
    address = (unsigned int) lsaddr;
    rdword = &old_word;
    read_dword_in_memory();
    if(address)
      {
         dword = (*lsrtp << 56) | (old_word & 0x00FFFFFFFFFFFFFFLL);
         write_dword_in_memory();
         CHECK_MEMORY();
      }
    break;
      case 1:
    address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
    rdword = &old_word;
    read_dword_in_memory();
    if(address)
      {
         dword = (*lsrtp << 48) | (old_word & 0x0000FFFFFFFFFFFFLL);
         write_dword_in_memory();
         CHECK_MEMORY();
      }
    break;
      case 2:
    address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
    rdword = &old_word;
    read_dword_in_memory();
    if(address)
      {
         dword = (*lsrtp << 40) | (old_word & 0x000000FFFFFFFFFFLL);
         write_dword_in_memory();
         CHECK_MEMORY();
      }
    break;
      case 3:
    address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
    rdword = &old_word;
    read_dword_in_memory();
    if(address)
      {
         dword = (*lsrtp << 32) | (old_word & 0x00000000FFFFFFFFLL);
         write_dword_in_memory();
         CHECK_MEMORY();
      }
    break;
      case 4:
    address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
    rdword = &old_word;
    read_dword_in_memory();
    if(address)
      {
         dword = (*lsrtp << 24) | (old_word & 0x0000000000FFFFFFLL);
         write_dword_in_memory();
         CHECK_MEMORY();
      }
    break;
      case 5:
    address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
    rdword = &old_word;
    read_dword_in_memory();
    if(address)
      {
         dword = (*lsrtp << 16) | (old_word & 0x000000000000FFFFLL);
         write_dword_in_memory();
         CHECK_MEMORY();
      }
    break;
      case 6:
    address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
    rdword = &old_word;
    read_dword_in_memory();
    if(address)
      {
         dword = (*lsrtp << 8) | (old_word & 0x00000000000000FFLL);
         write_dword_in_memory();
         CHECK_MEMORY();
      }
    break;
      case 7:
    address = ((unsigned int) lsaddr) & 0xFFFFFFF8;
    dword = *lsrtp;
    write_dword_in_memory();
    CHECK_MEMORY();
    break;
     }
}

DECLARE_INSTRUCTION(SWR)
{
   const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
   long long int *lsrtp = PC->f.i.rt;
   unsigned long long int old_word = 0;
   ADD_TO_PC(1);
   switch ((lsaddr) & 3)
     {
      case 0:
    address = (unsigned int) lsaddr;
    rdword = &old_word;
    read_word_in_memory();
    if(address)
      {
         word = ((unsigned int)*lsrtp << 24) | ((unsigned int) old_word & 0x00FFFFFF);
         write_word_in_memory();
         CHECK_MEMORY();
      }
    break;
      case 1:
    address = ((unsigned int) lsaddr) & 0xFFFFFFFC;
    rdword = &old_word;
    read_word_in_memory();
    if(address)
      {
         word = ((unsigned int)*lsrtp << 16) | ((unsigned int) old_word & 0x0000FFFF);
         write_word_in_memory();
         CHECK_MEMORY();
      }
    break;
      case 2:
    address = ((unsigned int) lsaddr) & 0xFFFFFFFC;
    rdword = &old_word;
    read_word_in_memory();
    if(address)
      {
         word = ((unsigned int)*lsrtp << 8) | ((unsigned int) old_word & 0x000000FF);
         write_word_in_memory();
         CHECK_MEMORY();
      }
    break;
      case 3:
    address = ((unsigned int) lsaddr) & 0xFFFFFFFC;
    word = (unsigned int)*lsrtp;
    write_word_in_memory();
    CHECK_MEMORY();
    break;
     }
}

DECLARE_INSTRUCTION(CACHE)
{
   ADD_TO_PC(1);
}

DECLARE_INSTRUCTION(LL)
{
   const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
   long long int *lsrtp = PC->f.i.rt;
   ADD_TO_PC(1);
   address = (unsigned int) lsaddr;
   rdword = (unsigned long long *) lsrtp;
   read_word_in_memory();
   if (address)
     {
    sign_extended(*lsrtp);
    llbit = 1;
     }
}

DECLARE_INSTRUCTION(LWC1)
{
   const unsigned char lslfft = lfft;
   const unsigned int lslfaddr = (unsigned int)(lfoffset + reg[lfbase]);
   unsigned long long int temp;
   if (check_cop1_unusable()) return;
   ADD_TO_PC(1);
   address = (unsigned int) lslfaddr;
   rdword = &temp;
   read_word_in_memory();
   if (address)
     *((int*)reg_cop1_simple[lslfft]) = (int) *rdword;
}

DECLARE_INSTRUCTION(LDC1)
{
   const unsigned char lslfft = lfft;
   const unsigned int lslfaddr = (unsigned int)(lfoffset + reg[lfbase]);
   if (check_cop1_unusable()) return;
   ADD_TO_PC(1);
   address = (unsigned int) lslfaddr;
   rdword = (unsigned long long *)reg_cop1_double[lslfft];
   read_dword_in_memory();
}

DECLARE_INSTRUCTION(LD)
{
   const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
   long long int *lsrtp = PC->f.i.rt;
   ADD_TO_PC(1);
   address = (unsigned int) lsaddr;
   rdword = (unsigned long long *) lsrtp;
   read_dword_in_memory();
}

DECLARE_INSTRUCTION(SC)
{
   const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
   long long int *lsrtp = PC->f.i.rt;
   ADD_TO_PC(1);
   if(llbit)
   {
      address = (unsigned int) lsaddr;
      word = (unsigned int)(*lsrtp & 0xFFFFFFFF);
      write_word_in_memory();
      CHECK_MEMORY();
      llbit = 0;
      *lsrtp = 1;
   }
   else
   {
      *lsrtp = 0;
   }
}

DECLARE_INSTRUCTION(SWC1)
{
   const unsigned char lslfft = lfft;
   const unsigned int lslfaddr = (unsigned int)(lfoffset + reg[lfbase]);
   if (check_cop1_unusable()) return;
   ADD_TO_PC(1);
   address = (unsigned int) lslfaddr;
   word = *((int*)reg_cop1_simple[lslfft]);
   write_word_in_memory();
   CHECK_MEMORY();
}

DECLARE_INSTRUCTION(SDC1)
{
   const unsigned char lslfft = lfft;
   const unsigned int lslfaddr = (unsigned int)(lfoffset + reg[lfbase]);
   if (check_cop1_unusable()) return;
   ADD_TO_PC(1);
   address = (unsigned int) lslfaddr;
   dword = *((unsigned long long*)reg_cop1_double[lslfft]);
   write_dword_in_memory();
   CHECK_MEMORY();
}

DECLARE_INSTRUCTION(SD)
{
   const unsigned int lsaddr = (unsigned int)(iimmediate + irs32);
   long long int *lsrtp = PC->f.i.rt;
   ADD_TO_PC(1);
   address = (unsigned int) lsaddr;
   dword = *lsrtp;
   write_dword_in_memory();
   CHECK_MEMORY();
}
Commit	Line	Data
451ab91e	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	}