picsim.c

用PIC的看一看,用C仿真PIC 16F84的指令集.国外搜集而来.

//----------------------------------------------------------
//  C Simulation of the PIC 16F84 Instruction set.  For use
//  in gradually translating a C prototype into assembly
//  language.
//
//  There are several ways to use this code:
//
//  1.  Paste the contents into a single C file
//      which also contains the application source.
//  2.  #include this file into the application source file.
//  3.  Split this file into a header file (to be #included
//      into the application source file), and a C file
//      (to be linked with the application).
//
//  This simulation does not impose any limits on code size,
//  nor does it simulate the paged layout of the instruction
//  space.
//
//  This simulation does not implement the following
//  instructions:
//      CLRWDT  - Clear watchdog timer
//      RETFIE  - Return from interrupt
//      SLEEP   - Go into standby mode
//----------------------------------------------------------

//-------------------------------------------------
//      PIC SIMULATION - TYPE + VARS
//-------------------------------------------------

typedef enum { W, F } dest_type;


typedef enum
{
    PCL    = 2,

    STATUS,

#define _C	0
#define _DC	1
#define _Z	2


    USER_0 = 12  /* the first user program variable goes at this offset */

} file_usage;


typedef unsigned char  literal;
typedef unsigned char  file;
typedef unsigned char  bit;
typedef unsigned long  uint32;
typedef unsigned char  uint8;
typedef enum { FALSE, TRUE } boolean;


uint8    Wreg;
uint8    regfile[128] = { 0 };
uint32   Wtemp;





//------------------------------------------------------
//       PIC SIMULATION - MACROS + SUPPORT FUNCTIONS
//------------------------------------------------------


#define SKIPTEST   if (regfile[PCL]) { regfile[PCL]--; return; }



void  assign_files( uint8 f, uint8 *p )
{
    regfile[f]   = p[0];
    regfile[f+1] = p[1];
    regfile[f+2] = p[2];
    regfile[f+3] = p[3];
}


void  assign_var( uint8 *p, uint8 f )
{
    p[0] = regfile[f];
    p[1] = regfile[f+1];
    p[2] = regfile[f+2];
    p[3] = regfile[f+3];
}




void  update_status_bit( uint8 b, uint8 val )
{
    if (val)
    {
	    regfile[STATUS] |= (1 << b);
    }
    else
    {
	    regfile[STATUS] &= ~(1 << b);
    }
}


void  update_flags( void )
{
    update_status_bit( _C, !!(Wtemp & 0xFFFFFF00) );
    update_status_bit( _Z, !(Wtemp & 0xFF) );
    update_status_bit( _DC, !!((Wreg ^ Wtemp) & 0x10) );
}


void  update_Zflag( uint8 x )
{
    update_status_bit( _Z, !x );
}


void  update_dest( file f, boolean fr )
{
    if (fr)
    {
	    regfile[f] = Wtemp;
    }
    else
    {
	    Wreg = Wtemp;
    }
}




//---------------------------------------------------------
//  PIC SIMULATION - INSTRUCTION SET MACROS + FUNCTIONS
//---------------------------------------------------------


void  ADDLW( literal k )
{
    SKIPTEST;
    Wtemp = Wreg + k;
    update_flags();
    Wreg = Wtemp;
}


void ADDWF( file f, boolean fr )
{
    SKIPTEST;
    Wtemp = Wreg + regfile[f];
    update_flags();
    update_dest( f, fr );
}


void  ANDLW( literal k )
{
    SKIPTEST;
    Wreg &= k;
    update_Zflag( Wreg );
}


void  ANDWF( file f, boolean fr )
{
    SKIPTEST;
    Wtemp = Wreg & regfile[f];
    update_Zflag( Wtemp );
    update_dest( f, fr );
}


void  BCF( file f, bit b )
{
    SKIPTEST;
    regfile[f] &= ~(1 << b);
}


void  BSF( file f, bit b )
{
    SKIPTEST;
    regfile[f] |= (1 << b);
}


void  BTFSC( file f, bit b )
{
    SKIPTEST;
    regfile[PCL] = !(regfile[f] & (1 << b));
}


void  BTFSS( file f, bit b )
{
    SKIPTEST;
    regfile[PCL] = !!(regfile[f] & (1 << b));
}


#define CALL( fname )    if (regfile[PCL]) { regfile[PCL]--; } else { fname(); }



void  CLRF( file f )
{
    SKIPTEST;
    regfile[f] = 0;
    update_status_bit( _Z, 1 );
}


void  CLRW( void )
{
    SKIPTEST;
    Wreg = 0;
    update_status_bit( _Z, 1 );
}


void  COMF( file f, boolean fr )
{
    SKIPTEST;
    Wtemp = ~regfile[f];
    update_Zflag( Wtemp );
    update_dest( f, fr );
}


void  DECF( file f, boolean fr )
{
    SKIPTEST;
    Wtemp = regfile[f] - 1;
    update_Zflag( Wtemp );
    update_dest( f, fr );
}


void  DECFSZ( file f, boolean fr )
{
    SKIPTEST;
    Wtemp = regfile[f] - 1;
    regfile[PCL] = !(Wtemp & 0xFF);
    update_dest( f, fr );
}


#define GOTO(label)   if (regfile[PCL])   regfile[PCL]--; else goto label;


void  INCF( file f, boolean fr )
{
    SKIPTEST;
    Wtemp = regfile[f] + 1;
    update_Zflag( Wtemp );
    update_dest( f, fr );
}


void  INCFSZ( file f, boolean fr )
{
    SKIPTEST;
    Wtemp = regfile[f] + 1;
    regfile[PCL] = !(Wtemp & 0xFF);
    update_dest( f, fr );
}


void  IORLW( literal k )
{
    SKIPTEST;
    Wreg |= k;
    update_Zflag( Wreg );
}


void  IORWF( file f, boolean fr )
{
    SKIPTEST;
    Wtemp = Wreg | regfile[f];
    update_Zflag( Wtemp );
    update_dest( f, fr );
}


void  MOVF( file f, boolean fr )
{
    SKIPTEST;
    Wtemp = regfile[f];
    update_Zflag( Wtemp );
    update_dest( f, fr );
}


void  MOVLW( literal k )
{
    SKIPTEST;
    Wreg = k;
}


void  MOVWF( file f )
{
    SKIPTEST;
    regfile[f] = Wreg;
}


#define NOP           if (regfile[PCL])  regfile[PCL]--;


#define RETLW( k )    if (regfile[PCL])  regfile[PCL]--; else { Wreg = k; return; }


#define RETURN        if (regfile[PCL])  regfile[PCL]--; else { return; }



void  RLF( file f, boolean fr )
{
    SKIPTEST;
    Wtemp = (regfile[f] << 1) | !!(regfile[STATUS] & (1 << _C));
    update_status_bit( _C, !!(Wtemp & 0x100) );
    update_dest( f, fr );
}


void  RRF( file f, boolean fr )
{
    boolean newC;

    SKIPTEST;
    Wtemp = regfile[f];
    newC  = Wtemp & 0x01;
    if (regfile[STATUS] & (1 << _C))  Wtemp |= 0x100;
    Wtemp >>= 1;
    update_status_bit( _C, newC );
    update_dest( f, fr );
}


void  SUBLW( literal k )
{
    SKIPTEST;
    Wtemp = k - Wreg;
    update_flags();
    regfile[STATUS] ^= 1;	// C flag behaves opposite to expected
    Wreg = Wtemp;
}


void  SUBWF( file f, boolean fr )
{
    SKIPTEST;
    Wtemp = regfile[f] - Wreg;
    update_flags();
    regfile[STATUS] ^= 1;	// C flag behaves opposite to expected
    update_dest( f, fr );
}


void  SWAPF( file f, boolean fr )
{
    SKIPTEST;
    Wtemp = (regfile[f] & 0x0F) << 4;
    Wtemp |= (regfile[f] >> 4);
    update_dest( f, fr );
}


void  XORLW( literal k )
{
    SKIPTEST;
    Wreg ^= k;
    update_Zflag( Wreg );
}



void  XORWF( file f, boolean fr )
{
    SKIPTEST;
    Wtemp = Wreg ^ regfile[f];
    update_Zflag( Wtemp );
    update_dest( f, fr );
}