arm-ls-x86.cpp

一个任天堂掌上游戏机NDS的源代码

/**************************************************************************
* DSemu - The Next Generation                                             *
* Portable ARM cores: Common: Load/Store [arm-ls.cpp]                     *
* Copyright Imran Nazar, 2005; released under the BSD public licence.     *
**************************************************************************/

#ifdef ARM7TDMI_X86

// __ARMHDR is set by the Makefile to be either arm7tdmi.h or arm9es.h
#include __ARMHDR

#include "armmasks.h"
#include "datadefs.h"
#include "plgmmu32.h"
#include "armhelp.h"

//---Addressing modes------------------------------------------------------
// Only a few defines need exist here, since the opcodes themselves
// combine them in many configurations. The combination method must be:
// Offset addressing: [ofm|ofp]([Si|Hi|Hr|Sr*]);
// Pre-indexed: [ofm|ofp]([Si|Hi|Hr|Sr*]); wb;
// Post-indexed: [ptm|ptp]([Si|Hi|Hr|Sr*]);

// NOTE: Halfword-style opcodes address their immediates in a different
//       way to the standard word/byte LS.

#define LSofm opUND
#define LSofp opUND

#define LSwb

#define LSptm opUND
#define LSptp opUND

#define LSi 

#define LHi
#define LHr

#define LSrll
#define LSrlr
#define LSrar
#define LSrrr

//---Simple and halfword-style addressing----------------------------------
								 
OPC xopLDRptim(){return 3;}
OPC xopLDRptip(){return 3;}
OPC xopLDRofim(){return 3;}
OPC xopLDRofip(){return 3;}
OPC xopLDRprim(){return 3;}
OPC xopLDRprip(){return 3;}

OPC xopSTRptim(){return 2;}
OPC xopSTRptip(){return 2;}
OPC xopSTRofim(){return 2;}
OPC xopSTRofip(){return 2;}
OPC xopSTRprim(){return 2;}
OPC xopSTRprip(){return 2;}

OPC xopLDRBptim(){return 3;}
OPC xopLDRBptip(){return 3;}
OPC xopLDRBofim(){return 3;}
OPC xopLDRBofip(){return 3;}
OPC xopLDRBprim(){return 3;}
OPC xopLDRBprip(){return 3;}

OPC xopSTRBptim(){return 2;}
OPC xopSTRBptip(){return 2;}
OPC xopSTRBofim(){return 2;}
OPC xopSTRBofip(){return 2;}
OPC xopSTRBprim(){return 2;}
OPC xopSTRBprip(){return 2;}

OPC xopLDRHptim(){return 3;}
OPC xopLDRHptip(){return 3;}
OPC xopLDRHptrm(){return 3;}
OPC xopLDRHptrp(){return 3;}
OPC xopLDRHofim(){return 3;}
OPC xopLDRHofip(){return 3;}
OPC xopLDRHofrm(){return 3;}
OPC xopLDRHofrp(){return 3;}
OPC xopLDRHprim(){return 3;}
OPC xopLDRHprip(){return 3;}
OPC xopLDRHprrm(){return 3;}
OPC xopLDRHprrp(){return 3;}

OPC xopSTRHptim(){return 2;}
OPC xopSTRHptip(){return 2;}
OPC xopSTRHptrm(){return 2;}
OPC xopSTRHptrp(){return 2;}
OPC xopSTRHofim(){return 2;}
OPC xopSTRHofip(){return 2;}
OPC xopSTRHofrm(){return 2;}
OPC xopSTRHofrp(){return 2;}
OPC xopSTRHprim(){return 2;}
OPC xopSTRHprip(){return 2;}
OPC xopSTRHprrm(){return 2;}
OPC xopSTRHprrp(){return 2;}

OPC xopLDRTptim(){return 3;}
OPC xopLDRTptip(){return 3;}
OPC xopLDRTofim(){return 3;}
OPC xopLDRTofip(){return 3;}
OPC xopLDRTprim(){return 3;}
OPC xopLDRTprip(){return 3;}

OPC xopSTRTptim(){return 2;}
OPC xopSTRTptip(){return 2;}
OPC xopSTRTofim(){return 2;}
OPC xopSTRTofip(){return 2;}
OPC xopSTRTprim(){return 2;}
OPC xopSTRTprip(){return 2;}

OPC xopLDRBTptim(){return 3;}
OPC xopLDRBTptip(){return 3;}
OPC xopLDRBTofim(){return 3;}
OPC xopLDRBTofip(){return 3;}
OPC xopLDRBTprim(){return 3;}
OPC xopLDRBTprip(){return 3;}

OPC xopSTRBTptim(){return 2;}
OPC xopSTRBTptip(){return 2;}
OPC xopSTRBTofim(){return 2;}
OPC xopSTRBTofip(){return 2;}
OPC xopSTRBTprim(){return 2;}
OPC xopSTRBTprip(){return 2;}

OPC xopLDRSBptim(){return 3;}
OPC xopLDRSBptip(){return 3;}
OPC xopLDRSBptrm(){return 3;}
OPC xopLDRSBptrp(){return 3;}
OPC xopLDRSBofim(){return 3;}
OPC xopLDRSBofip(){return 3;}
OPC xopLDRSBofrm(){return 3;}
OPC xopLDRSBofrp(){return 3;}
OPC xopLDRSBprim(){return 3;}
OPC xopLDRSBprip(){return 3;}
OPC xopLDRSBprrm(){return 3;}
OPC xopLDRSBprrp(){return 3;}

OPC xopLDRSHptim(){return 2;}
OPC xopLDRSHptip(){return 2;}
OPC xopLDRSHptrm(){return 2;}
OPC xopLDRSHptrp(){return 2;}
OPC xopLDRSHofim(){return 2;}
OPC xopLDRSHofip(){return 2;}
OPC xopLDRSHofrm(){return 2;}
OPC xopLDRSHofrp(){return 2;}
OPC xopLDRSHprim(){return 2;}
OPC xopLDRSHprip(){return 2;}
OPC xopLDRSHprrm(){return 2;}
OPC xopLDRSHprrp(){return 2;}

//---Shifted addressing (Word/byte opcodes only, of course)----------------

OPC xopLDRptrmll(){return 3;}
OPC xopLDRptrmlr(){return 3;}
OPC xopLDRptrmar(){return 3;}
OPC xopLDRptrmrr(){return 3;}
OPC xopLDRptrpll(){return 3;}
OPC xopLDRptrplr(){return 3;}
OPC xopLDRptrpar(){return 3;}
OPC xopLDRptrprr(){return 3;}
OPC xopLDRofrmll(){return 3;}
OPC xopLDRofrmlr(){return 3;}
OPC xopLDRofrmar(){return 3;}
OPC xopLDRofrmrr(){return 3;}
OPC xopLDRofrpll(){return 3;}
OPC xopLDRofrplr(){return 3;}
OPC xopLDRofrpar(){return 3;}
OPC xopLDRofrprr(){return 3;}
OPC xopLDRprrmll(){return 3;}
OPC xopLDRprrmlr(){return 3;}
OPC xopLDRprrmar(){return 3;}
OPC xopLDRprrmrr(){return 3;}
OPC xopLDRprrpll(){return 3;}
OPC xopLDRprrplr(){return 3;}
OPC xopLDRprrpar(){return 3;}
OPC xopLDRprrprr(){return 3;}

OPC xopSTRptrmll(){return 2;}
OPC xopSTRptrmlr(){return 2;}
OPC xopSTRptrmar(){return 2;}
OPC xopSTRptrmrr(){return 2;}
OPC xopSTRptrpll(){return 2;}
OPC xopSTRptrplr(){return 2;}
OPC xopSTRptrpar(){return 2;}
OPC xopSTRptrprr(){return 2;}
OPC xopSTRofrmll(){return 2;}
OPC xopSTRofrmlr(){return 2;}
OPC xopSTRofrmar(){return 2;}
OPC xopSTRofrmrr(){return 2;}
OPC xopSTRofrpll(){return 2;}
OPC xopSTRofrplr(){return 2;}
OPC xopSTRofrpar(){return 2;}
OPC xopSTRofrprr(){return 2;}
OPC xopSTRprrmll(){return 2;}
OPC xopSTRprrmlr(){return 2;}
OPC xopSTRprrmar(){return 2;}
OPC xopSTRprrmrr(){return 2;}
OPC xopSTRprrpll(){return 2;}
OPC xopSTRprrplr(){return 2;}
OPC xopSTRprrpar(){return 2;}
OPC xopSTRprrprr(){return 2;}

OPC xopLDRBptrmll(){return 3;}
OPC xopLDRBptrmlr(){return 3;}
OPC xopLDRBptrmar(){return 3;}
OPC xopLDRBptrmrr(){return 3;}
OPC xopLDRBptrpll(){return 3;}
OPC xopLDRBptrplr(){return 3;}
OPC xopLDRBptrpar(){return 3;}
OPC xopLDRBptrprr(){return 3;}
OPC xopLDRBofrmll(){return 3;}
OPC xopLDRBofrmlr(){return 3;}
OPC xopLDRBofrmar(){return 3;}
OPC xopLDRBofrmrr(){return 3;}
OPC xopLDRBofrpll(){return 3;}
OPC xopLDRBofrplr(){return 3;}
OPC xopLDRBofrpar(){return 3;}
OPC xopLDRBofrprr(){return 3;}
OPC xopLDRBprrmll(){return 3;}
OPC xopLDRBprrmlr(){return 3;}
OPC xopLDRBprrmar(){return 3;}
OPC xopLDRBprrmrr(){return 3;}
OPC xopLDRBprrpll(){return 3;}
OPC xopLDRBprrplr(){return 3;}
OPC xopLDRBprrpar(){return 3;}
OPC xopLDRBprrprr(){return 3;}

OPC xopSTRBptrmll(){return 2;}
OPC xopSTRBptrmlr(){return 2;}
OPC xopSTRBptrmar(){return 2;}
OPC xopSTRBptrmrr(){return 2;}
OPC xopSTRBptrpll(){return 2;}
OPC xopSTRBptrplr(){return 2;}
OPC xopSTRBptrpar(){return 2;}
OPC xopSTRBptrprr(){return 2;}
OPC xopSTRBofrmll(){return 2;}
OPC xopSTRBofrmlr(){return 2;}
OPC xopSTRBofrmar(){return 2;}
OPC xopSTRBofrmrr(){return 2;}
OPC xopSTRBofrpll(){return 2;}
OPC xopSTRBofrplr(){return 2;}
OPC xopSTRBofrpar(){return 2;}
OPC xopSTRBofrprr(){return 2;}
OPC xopSTRBprrmll(){return 2;}
OPC xopSTRBprrmlr(){return 2;}
OPC xopSTRBprrmar(){return 2;}
OPC xopSTRBprrmrr(){return 2;}
OPC xopSTRBprrpll(){return 2;}
OPC xopSTRBprrplr(){return 2;}
OPC xopSTRBprrpar(){return 2;}
OPC xopSTRBprrprr(){return 2;}

OPC xopLDRTptrmll(){return 3;}
OPC xopLDRTptrmlr(){return 3;}
OPC xopLDRTptrmar(){return 3;}
OPC xopLDRTptrmrr(){return 3;}
OPC xopLDRTptrpll(){return 3;}
OPC xopLDRTptrplr(){return 3;}
OPC xopLDRTptrpar(){return 3;}
OPC xopLDRTptrprr(){return 3;}
OPC xopLDRTofrmll(){return 3;}
OPC xopLDRTofrmlr(){return 3;}
OPC xopLDRTofrmar(){return 3;}
OPC xopLDRTofrmrr(){return 3;}
OPC xopLDRTofrpll(){return 3;}
OPC xopLDRTofrplr(){return 3;}
OPC xopLDRTofrpar(){return 3;}
OPC xopLDRTofrprr(){return 3;}
OPC xopLDRTprrmll(){return 3;}
OPC xopLDRTprrmlr(){return 3;}
OPC xopLDRTprrmar(){return 3;}
OPC xopLDRTprrmrr(){return 3;}
OPC xopLDRTprrpll(){return 3;}
OPC xopLDRTprrplr(){return 3;}
OPC xopLDRTprrpar(){return 3;}
OPC xopLDRTprrprr(){return 3;}

OPC xopSTRTptrmll(){return 2;}
OPC xopSTRTptrmlr(){return 2;}
OPC xopSTRTptrmar(){return 2;}
OPC xopSTRTptrmrr(){return 2;}
OPC xopSTRTptrpll(){return 2;}
OPC xopSTRTptrplr(){return 2;}
OPC xopSTRTptrpar(){return 2;}
OPC xopSTRTptrprr(){return 2;}
OPC xopSTRTofrmll(){return 2;}
OPC xopSTRTofrmlr(){return 2;}
OPC xopSTRTofrmar(){return 2;}
OPC xopSTRTofrmrr(){return 2;}
OPC xopSTRTofrpll(){return 2;}
OPC xopSTRTofrplr(){return 2;}
OPC xopSTRTofrpar(){return 2;}
OPC xopSTRTofrprr(){return 2;}
OPC xopSTRTprrmll(){return 2;}
OPC xopSTRTprrmlr(){return 2;}
OPC xopSTRTprrmar(){return 2;}
OPC xopSTRTprrmrr(){return 2;}
OPC xopSTRTprrpll(){return 2;}
OPC xopSTRTprrplr(){return 2;}
OPC xopSTRTprrpar(){return 2;}
OPC xopSTRTprrprr(){return 2;}

OPC xopLDRBTptrmll(){return 3;}
OPC xopLDRBTptrmlr(){return 3;}
OPC xopLDRBTptrmar(){return 3;}
OPC xopLDRBTptrmrr(){return 3;}
OPC xopLDRBTptrpll(){return 3;}
OPC xopLDRBTptrplr(){return 3;}
OPC xopLDRBTptrpar(){return 3;}
OPC xopLDRBTptrprr(){return 3;}
OPC xopLDRBTofrmll(){return 3;}
OPC xopLDRBTofrmlr(){return 3;}
OPC xopLDRBTofrmar(){return 3;}
OPC xopLDRBTofrmrr(){return 3;}
OPC xopLDRBTofrpll(){return 3;}
OPC xopLDRBTofrplr(){return 3;}
OPC xopLDRBTofrpar(){return 3;}
OPC xopLDRBTofrprr(){return 3;}
OPC xopLDRBTprrmll(){return 3;}
OPC xopLDRBTprrmlr(){return 3;}
OPC xopLDRBTprrmar(){return 3;}
OPC xopLDRBTprrmrr(){return 3;}
OPC xopLDRBTprrpll(){return 3;}
OPC xopLDRBTprrplr(){return 3;}
OPC xopLDRBTprrpar(){return 3;}
OPC xopLDRBTprrprr(){return 3;}

OPC xopSTRBTptrmll(){return 2;}
OPC xopSTRBTptrmlr(){return 2;}
OPC xopSTRBTptrmar(){return 2;}
OPC xopSTRBTptrmrr(){return 2;}
OPC xopSTRBTptrpll(){return 2;}
OPC xopSTRBTptrplr(){return 2;}
OPC xopSTRBTptrpar(){return 2;}
OPC xopSTRBTptrprr(){return 2;}
OPC xopSTRBTofrmll(){return 2;}
OPC xopSTRBTofrmlr(){return 2;}
OPC xopSTRBTofrmar(){return 2;}
OPC xopSTRBTofrmrr(){return 2;}
OPC xopSTRBTofrpll(){return 2;}
OPC xopSTRBTofrplr(){return 2;}
OPC xopSTRBTofrpar(){return 2;}
OPC xopSTRBTofrprr(){return 2;}
OPC xopSTRBTprrmll(){return 2;}
OPC xopSTRBTprrmlr(){return 2;}
OPC xopSTRBTprrmar(){return 2;}
OPC xopSTRBTprrmrr(){return 2;}
OPC xopSTRBTprrpll(){return 2;}
OPC xopSTRBTprrplr(){return 2;}
OPC xopSTRBTprrpar(){return 2;}
OPC xopSTRBTprrprr(){return 2;}

// Load/store multiple is also in this file, since it's common between
// the cores.

//---Initial pointer setup-------------------------------------------------
// Note: Rn is written back differently dependent on direction

#define addrLMIA 
#define addrLMIB
#define addrLMDA
#define addrLMDB

#define addrLMwi
#define addrLMwd

//---Opcode defines (Simple loops, really)---------------------------------
// BUGBUG: User-mode LDM assumes linear storage of r0-r15 (safe assumption)

#define opLDM \
    return 3

#define opSTM \
    return 2

#define opLDMu \
    return 3

#define opSTMu \
    return 2

// Just as with the one-value load/store, once the opcodes are defined,
// it's a matter of plugging defines together.

OPC xopLDMIA() { addrLMIA; opLDM; }
OPC xopLDMIB() { addrLMIB; opLDM; }
OPC xopLDMDA() { addrLMDA; opLDM; }
OPC xopLDMDB() { addrLMDB; opLDM; }

OPC xopLDMIAw() { addrLMIA; addrLMwi; opLDM; }
OPC xopLDMIBw() { addrLMIB; addrLMwi; opLDM; }
OPC xopLDMDAw() { addrLMDA; addrLMwd; opLDM; }
OPC xopLDMDBw() { addrLMDB; addrLMwd; opLDM; }

OPC xopSTMIA() { addrLMIA; opSTM; }
OPC xopSTMIB() { addrLMIB; opSTM; }
OPC xopSTMDA() { addrLMDA; opSTM; }
OPC xopSTMDB() { addrLMDB; opSTM; }

OPC xopSTMIAw() { addrLMIA; addrLMwi; opSTM; }
OPC xopSTMIBw() { addrLMIB; addrLMwi; opSTM; }
OPC xopSTMDAw() { addrLMDA; addrLMwd; opSTM; }
OPC xopSTMDBw() { addrLMDB; addrLMwd; opSTM; }

OPC xopLDMIAu() { addrLMIA; opLDMu; }
OPC xopLDMIBu() { addrLMIB; opLDMu; }
OPC xopLDMDAu() { addrLMDA; opLDMu; }
OPC xopLDMDBu() { addrLMDB; opLDMu; }

OPC xopLDMIAuw() { addrLMIA; addrLMwi; opLDMu; }
OPC xopLDMIBuw() { addrLMIB; addrLMwi; opLDMu; }
OPC xopLDMDAuw() { addrLMDA; addrLMwd; opLDMu; }
OPC xopLDMDBuw() { addrLMDB; addrLMwd; opLDMu; }

OPC xopSTMIAu() { addrLMIA; opSTMu; }
OPC xopSTMIBu() { addrLMIB; opSTMu; }
OPC xopSTMDAu() { addrLMDA; opSTMu; }
OPC xopSTMDBu() { addrLMDB; opSTMu; }

OPC xopSTMIAuw() { addrLMIA; addrLMwi; opSTMu; }
OPC xopSTMIBuw() { addrLMIB; addrLMwi; opSTMu; }
OPC xopSTMDAuw() { addrLMDA; addrLMwd; opSTMu; }
OPC xopSTMDBuw() { addrLMDB; addrLMwd; opSTMu; }

#endif

/*** EOF: arm-ls.cpp *****************************************************/