spc700.asm

linux下的任天堂模拟器代码。供大家参考。

    mov bl,[ebp]
    xor eax,eax
    add ebx,[spcRamDP]
    inc ebp
    mov ax, [ebx]
    add ax,[spcY]
    mov ebx,eax
    add ebx,SPCRAM
    mov al, [spcA]
    WriteByte
    ret

;************************************************
; MOV instructions (Verified)
;************************************************

NEWSYM OpD8     ; MOV dp,X     X -> (dp)             ........
    mov bl,[ebp]
    mov al, [spcX]
    add ebx,[spcRamDP]
    inc ebp
    WriteByte
    ret

NEWSYM OpF8     ;  MOV X,dp    X <- (dp)             N......Z
    mov bl,[ebp]
    inc ebp
    add ebx,[spcRamDP]
    ReadByte
    mov [spcX], al
    mov [spcNZ],al
    ret

NEWSYM OpC9     ; MOV labs,X   X -> (abs)            ........
    mov bx,[ebp]
    mov al, [spcX]
    add ebp,2
    add ebx,SPCRAM
    WriteByte
    ret

NEWSYM OpE9     ; MOV X,labs   X <- (abs)            N......Z
    mov bx,[ebp]
    add ebx,SPCRAM
    ReadByte
    add ebp,2
    mov [spcX], al
    mov [spcNZ],al
    ret

NEWSYM OpD9     ; MOV dp+Y,X   X -> (dp+Y)           ........
    mov bl,[ebp]
    mov al, [spcX]
    add bl,[spcY]
    inc ebp
    add ebx,[spcRamDP]
    WriteByte
    ret

NEWSYM OpF9     ; MOV X,dp+Y   X <- (dp+Y)           N......Z
    mov bl,[ebp]
    add bl,[spcY]
    inc ebp
    add ebx,[spcRamDP]
    ReadByte
    mov [spcX], al
    mov [spcNZ],al
    ret

NEWSYM OpCB     ; MOV dp,Y  Y -> (dp)             ........
    mov bl,[ebp]
    mov al, [spcY]
    add ebx,[spcRamDP]
    inc ebp
    WriteByte
    ret

NEWSYM OpEB     ; MOV Y,dp  Y <- (dp)             N......Z
    mov bl,[ebp]
    add ebx,[spcRamDP]
    inc ebp
    ReadByte
    mov [spcY], al
    mov [spcNZ],al
    ret

NEWSYM OpDB     ; MOV dp+X,Y   X -> (dp+X)           ........
    mov bl,[ebp]
    add bl,[spcX]
    mov al, [spcY]
    add ebx,[spcRamDP]
    inc ebp
    WriteByte
    ret

NEWSYM OpFB     ; MOV Y,dp+X   Y <- (dp+X)           N......Z
    mov bl,[ebp]
    add bl,[spcX]
    inc ebp
    add ebx,[spcRamDP]
    ReadByte
    mov [spcY], al
    mov [spcNZ],al
    ret

NEWSYM OpCC     ; MOV labs,Y   Y -> (abs)            ........
    mov bx,[ebp]
    mov al, [spcY]
    add ebp,2
    add ebx,SPCRAM
    WriteByte
    ret

NEWSYM OpEC     ; MOV Y,labs   Y <- (abs)            N......Z
    mov bx,[ebp]
    add ebx,SPCRAM
    ReadByte
    add ebp,2
    mov [spcY],al
    mov [spcNZ],al
    ret

NEWSYM Op5D     ; MOV X,A    X <- A             N......Z
    mov al,[spcA]
    mov [spcX],al
    mov [spcNZ],al
    ret

NEWSYM Op7D     ; MOV A,X    A <- X             N......Z
    mov al,[spcX]
    mov [spcA],al
    mov [spcNZ],al
    ret

NEWSYM Op8D     ; MOV Y,#inm   Y <- inm            N......Z
    mov bl,[ebp]
    mov [spcY],bl
    inc ebp
    mov [spcNZ],bl
    ret

NEWSYM OpCD     ; MOV X,#inm   X <- inm            N......Z
    mov bl,[ebp]
    mov [spcX],bl
    inc ebp
    mov [spcNZ],bl
    ret

NEWSYM Op8F     ; MOV dp,#inm  (dp) <- inm           ........
    mov bl,[ebp+1]
    mov al,[ebp]
    add ebx,[spcRamDP]
    add ebp,2
    WriteByte
    ret

NEWSYM Op9D     ; MOV X,SP     X <- SP            N......Z
    mov al,[spcS]
    mov [spcX],al
    mov [spcNZ],al
    ret

NEWSYM OpBD     ; MOV SP,X     SP <- X             ........
    mov al,[spcX]
    mov [spcS],al
    ret

NEWSYM OpDD     ; MOV A,Y    A <- Y             N......Z
    mov al,[spcY]
    mov [spcA],al
    mov [spcNZ],al
    ret


NEWSYM OpFD     ; MOV Y,A    Y <- A             N......Z
    mov al,[spcA]
    mov [spcY],al
    mov [spcNZ],al
    ret

NEWSYM OpAF     ; MOV (X)+,A   A -> (X) with auto inc    ........
    mov bl,[spcX]
    add ebx,[spcRamDP]
    mov al, [spcA]
    inc byte[spcX]
    WriteByte
    ret

NEWSYM OpBF     ; MOV A,(X)+  A <- (X) with auto inc    N......Z
    mov bl,[spcX]
    add ebx,[spcRamDP]
    ReadByte
    inc byte[spcX]
    mov [spcA],al
    mov [spcNZ],al
    ret


;************************************************
; CMP instructions (Verified)
;************************************************

NEWSYM OpC8     ; CMP X,#inm   X-inm             N......ZC
    mov bl,[ebp]
    inc ebp
    cmp [spcX],bl
    cmc
    SPCSetFlagnzc

NEWSYM OpAD     ; CMP Y,#inm   Y-inm             N......ZC
    mov bl,[ebp]
    inc ebp
    cmp [spcY],bl
    cmc
    SPCSetFlagnzc

NEWSYM Op1E     ; CMP X,labs   X-(abs)             N......ZC
    mov bx,[ebp]
    add ebp,2
    add ebx,SPCRAM
    ReadByte
    cmp byte[spcX], al
    cmc
    SPCSetFlagnzc

NEWSYM Op3E     ; CMP X,dp     X-(dp)            N......ZC
    mov bl,[ebp]
    add ebx,[spcRamDP]
    inc ebp
    ReadByte
    cmp byte[spcX], al
    cmc
    SPCSetFlagnzc

NEWSYM Op5E     ; CMP Y,labs   Y-(abs)             N......ZC
    mov bx,[ebp]
    add ebx,SPCRAM
    ReadByte
    add ebp,2
    cmp byte[spcY], al
    cmc
    SPCSetFlagnzc

NEWSYM Op7E     ; CMP Y,dp     Y-(dp)            N......ZC
    mov bl,[ebp]
    add ebx,[spcRamDP]
    inc ebp
    ReadByte
    cmp byte[spcY], al
    cmc
    SPCSetFlagnzc

;************************************************
; Word Instructions (Verified)
;************************************************

NEWSYM Op1A     ; DECW dp   Decrement dp memory pair  N......Z.
    mov bl,[ebp]
    add ebx,[spcRamDP]
    inc ebp
    inc ebx
    ReadByte2
    mov ah,al
    dec ebx
NEWSYM Op1AB
    ReadByte2
    dec ax
    test ax,8000h
    jnz .YesNeg
    cmp ax,0000h
    je .YesZero
    mov byte[spcNZ],1
    jmp .SkipFlag
.YesNeg
    mov byte[spcNZ],80h
    jmp .SkipFlag
.YesZero
    mov byte[spcNZ],0
.SkipFlag
    push ebx
    WriteByte
    pop ebx
NEWSYM Op1Ab
    inc ebx
    mov al,ah
    WriteByte
    ret

NEWSYM Op3A     ; INCW dp   Increment dp memory pair  N......Z.
    mov bl,[ebp]
    add ebx,[spcRamDP]
    inc ebp
    inc ebx
    ReadByte2
    mov ah,al
    dec ebx
NEWSYM Op3AB
    ReadByte2
    inc ax
    test ax,8000h
    jnz .YesNeg
    cmp ax,0000h
    je .YesZero
    mov byte[spcNZ],1
    jmp .SkipFlag
.YesNeg
    mov byte[spcNZ],80h
    jmp .SkipFlag
.YesZero
    mov byte[spcNZ],0
.SkipFlag
    push ebx
    WriteByte
    pop ebx
NEWSYM Op3Ab
    inc ebx
    mov al,ah
    WriteByte
    ret

; looks like there is the Carry flag checked in op5a..

NEWSYM Op5A     ; CMPW YA,dp   YA - (dp+1)(dp)      N......ZC
    mov bl,[ebp]
    add ebx,[spcRamDP]
    inc ebp
    inc ebx
    ReadByte2
    mov ah,al
    dec ebx
NEWSYM Op5AB
    ReadByte
    mov bl,[spcA]
    mov bh,[spcY]
    cmp bx,ax
    cmc
    SPCSetFlagnzc

NEWSYM Op7A     ; ADDW YA,dp   YA  <- YA + (dp+1)(dp)   NV..H..ZC
    mov bl,[ebp]
    add ebx,[spcRamDP]
    inc ebp
    inc ebx
    ReadByte2
    mov ah,al
    dec ebx
NEWSYM Op7AB
    ReadByte
    mov bl,[spcA]
    mov bh,[spcY]
    add bx,ax
    mov [spcA],bl
    mov [spcY],bh
    SPCSetFlagnvhzc

NEWSYM Op9A     ; SUBW YA,dp   YA  <- YA - (dp+1)(dp)   NV..H..ZC
    mov bl,[ebp]
    add ebx,[spcRamDP]
    inc ebp
    inc ebx
    ReadByte2
    mov ah,al
    dec ebx
NEWSYM Op9AB
    ReadByte
    mov bl,[spcA]
    mov bh,[spcY]
    sub bx,ax
    cmc
    mov [spcA],bl
    mov [spcY],bh
    SPCSetFlagnvhzc

NEWSYM OpBA     ; MOVW YA,dp   YA  - (dp+1)(dp)     N......Z.
    mov bl,[ebp]
    add ebx,[spcRamDP]
    inc ebp
    inc ebx
    ReadByte2
    mov ah,al
    dec ebx
NEWSYM OpBAb
    ReadByte
    mov [spcA],al
    mov [spcY],ah
    test ax,8000h
    jnz .YesNeg
    cmp ax,0000h
    je .YesZero
    mov byte[spcNZ],1
    ret
.YesNeg
    mov byte[spcNZ],80h
    ret
.YesZero
    mov byte[spcNZ],0
    ret

NEWSYM OpDA     ; MOVW dp,YA   (dp+1)(dp) - YA       .........
    mov bl,[ebp]
    mov al,[spcA]
    add ebx,[spcRamDP]
    inc ebp
    push ebx
    WriteByte
    pop ebx
    inc ebx
    mov al,[spcY]
NEWSYM OpDAb
    WriteByte
    ret

;************************************************
; mem.bit instructions (Verified)
;************************************************

%macro spcaddrmembit 0
    mov bx,[ebp]

    mov cl,bh
    add ebp,2
    shr cl,5
    and bx,1FFFh

;    mov cl,bl
;    add ebp,2
;    shr bx,3
;    and cl,00000111b

    add ebx,SPCRAM
    ReadByte
    shr al,cl
    and al,01h
%endmacro

NEWSYM Op0A     ; OR1 C,mem.bit   C <- C OR  (mem.bit)    ........C
    spcaddrmembit
    or [spcP],al
    ret

NEWSYM Op2A     ; OR1 C,/mem.bit  C <- C OR  !(mem.bit)     ........C
    spcaddrmembit
    xor al,01h
    or [spcP],al
    ret

NEWSYM Op4A     ; AND1 C,mem.bit  C <- C AND (mem.bit)    ........C
    mov bx,[ebp]

    mov cl,bh
    add ebp,2
    shr cl,5
    and bx,1FFFh

;    mov cl,bl
;    add ebp,2
;    shr bx,3
;    and cl,00000111b

    add ebx,SPCRAM
    ReadByte
    shr al,cl
    or al,0FEh
    and [spcP],al
    ret

NEWSYM Op6A     ; AND1 C,/mem.bit C <- C AND !(mem.bit)     ........C
    mov bx,[ebp]

    mov cl,bh
    add ebp,2
    shr cl,5
    and bx,1FFFh

;    mov cl,bl
;    add ebp,2
;    shr bx,3
;    and cl,00000111b

    add ebx,SPCRAM
    ReadByte
    shr al,cl
    or al,0FEh
    xor al,01h
    and [spcP],al
    ret

NEWSYM Op8A     ; EOR1 C,mem.bit  C <- C EOR (mem.bit)    ........C
    spcaddrmembit
    xor [spcP],al
    ret

NEWSYM OpAA     ; MOV1 C,mem.bit  C <- (mem.bit)
    spcaddrmembit
    and byte[spcP],0FEh
    or [spcP],al
    ret

NEWSYM OpCA     ; MOV1 mem.bit,C  C -> (mem.bit)        .........
    mov bx,[ebp]
    mov al,[spcP]

    mov cl,bh
    mov ah,01h
    shr cl,5
    and bx,1FFFh

;    mov cl,bl
;    mov ah,01h
;    and cl,00000111b
;    shr bx,3

    shl ah,cl
    and al,01h
    add ebp,2
    shl al,cl
    add ebx,SPCRAM
    ; al = carry flag positioned in correct location, ah = 1 positioned
    mov cl,al
    xor ah,0FFh
    ReadByte2
    and al,ah
    or al,cl
    WriteByte
    ret

NEWSYM OpEA     ; NOT1 mem.bit    complement (mem.bit)    .........
    mov bx,[ebp]

    mov cl,bh
    mov ah,01h
    shr cl,5
    and bx,1FFFh

;    mov cl,bl
;    mov ah,01h
;    and cl,00000111b
;    shr bx,3

    shl ah,cl
    add ebp,2
    add ebx,SPCRAM
    ReadByte2
    xor al,ah
    WriteByte
    ret

;************************************************
; Shift Instructions (Verified)
;************************************************

NEWSYM Op0B     ; ASL dp    C << (dp)   <<0     N......ZC
    mov bl,[ebp]
    add ebx,[spcRamDP]
    inc ebp
    ReadByte2
    shl al,1
    SPCSetFlagnzcnoret
    WriteByte
    ret

NEWSYM Op4B     ; LSR dp    0 >> (dp)   <<C     N......ZC
    mov bl,[ebp]
    add ebx,[spcRamDP]
    inc ebp
    ReadByte2
    shr al,1
    SPCSetFlagnzcnoret
    WriteByte
    ret

NEWSYM Op1B     ; ASL dp+X  C << (dp+X) <<0     N......ZC
    mov bl,[ebp]
    add bl,[spcX]
    inc ebp
    add ebx,[spcRamDP]
    ReadByte2
    shl al,1
    SPCSetFlagnzcnoret
    WriteByte
    ret

NEWSYM Op5B     ; LSR dp+X  0 >> (dp+X) <<C     N......ZC
    mov bl,[ebp]
    add bl,[spcX]
    inc ebp
    add ebx,[spcRamDP]
    ReadByte2
    shr al,1
    SPCSetFlagnzcnoret
    WriteByte
    ret

NEWSYM Op0C     ; ASL labs  C << (abs)  <<0     N......ZC
    mov bx,[ebp]
    add ebx,SPCRAM
    add ebp,2
    ReadByte2
    shl al,1
    SPCSetFlagnzcnoret
    WriteByte
    ret

NEWSYM Op4C     ; LSR labs  0 >> (abs)  <<C     N......ZC
    mov bx,[ebp]
    add ebx,SPCRAM
    add ebp,2
    ReadByte2
    shr al,1
    SPCSetFlagnzcnoret
    WriteByte
    ret

NEWSYM Op1C     ; ASL A  C << A    <<0     N......ZC
    shl byte[spcA],1
    SPCSetFlagnzc

NEWSYM Op5C     ; LSR A  0 >> A    <<C     N......ZC
    shr byte[spcA],1
    SPCSetFlagnzc

%macro spcROLstuff 0
    rcl al,1
    jc .setcarryflag
    and byte[spcP],0FEh
    mov [spcNZ],al
    jmp .skipflags
.setcarryflag
    or byte[spcP],01h
    mov [spcNZ],al
.skipflags
%endmacro

%macro spcRORstuff 0
    rcr al,1
    jc .setcarryflag
    and byte[spcP],0FEh
    mov [spcNZ],al
    jmp .skipflags
.setcarryflag
    or byte[spcP],01h
    mov [spcNZ],al
.skipflags
%endmacro

NEWSYM Op2B     ; ROL dp    C << (dp)   <<C     N......ZC
    mov bl,[ebp]
    add ebx,[spcRamDP]
    inc ebp
    test byte[spcP],01h
    jnz near Op2Bb
    ReadByte2
    clc
    spcROLstuff
    WriteByte
    ret
NEWSYM Op2Bb
    ReadByte2
    stc
    spcROLstuff
    WriteByte
    ret