

FrontZ801


******************************************************************************
*          Z80 TO MC68000 CONVERSION FRONT END INCLUDE CODE                  *
*                  (C) Copyright 1982 by Motorola Inc.
*
*                           ***FRONTZ80***
*
*        THIS CODE SHOULD BE INSERTED AT THE FRONT OF THE
*        CONVERTED FILE FOR PROPER ASSEMBLY
*
*    NOTE: THROUGHOUT THERE ARE ' MOVE.W SR,XX' WHICH SHOULD
*          BE CHANGED TO 'MOVE.W CCR,XX' IN MC68010 SYSTEMS FOR EFFICIENCY.
*
 
         ORG.S     0        READ/WRITE SEGMENT STARTING AT ZERO LOGICAL ADDRES
 
* THE CODE BELOW MUST BE THE PRIMARY ENTRY POINT TO THE CONVERTED SYSTEM.
* IT SETS UP THE Z80 RUN-TIME ENVIRONMENT WHICH INCLUDES Z80 REGISTERS
* ALLOCATED ON THE SYSTEM (68K) STACK AND POINTED TO BY THE ADDRESS REGISTERS.
 
...INIT   LEA    ...STACK-2,SP   STACK FOR INTERNAL AND USER 68000 CODE USE
*                                (-2 IS PADDING FOR EXX INSTRUCTION )
          LEA    -30(SP),A6      DEFAULT PROGRAM STACK OF 30 BYTES
          LEA    -1(SP),A4       POINT TO E
          LEA    -1(A4),A3       POINT TO D (DE)
          LEA    -1(A3),A2       POINT TO C
          LEA    -1(A2),A1       POINT TO B (BC)
          LEA    -1(A1),A5       POINT TO L
          LEA    -1(A5),SP       POINT TO H (HL) AND ALLOCATE
          MOVE.L #$10,D4         X BIT MASK
          MOVE.L #$0F,D5         NOT X BIT MASK
 
          BRA    ...START        GO TO THE FIRST Z80 STATEMENT TO GET CONTROL
 
...STACK  DS.W   30              INTERNAL USE AND USER 68000 CODE STACK
 
*      THE ABOVE STACK IS ONLY USED FOR INTERNAL SUBROUTINE CALLS
*      AND POSSIBLE 68000 CODE ADDED BY THE USER.  USER ADDED
*      CODE MUST REMEMBER THAT SP DOES NOT POINT TO THE CONVERTED
*      PROGRAM'S OPERATIVE STACK WHICH INSTEAD IS BASED ON A6.
*
 
...PRIME  DS.L   2               STORAGE FOR Z80 PRIME REGISTER SET
 
* THE ABOVE AREA IS TO SAVE THE BC,DE,HL PRIME REGISTERS FOR EXX INSTRUCTION
 
******************************
* SIMULATION ASSIST RUN-TIME *
*         SUBROUTINES        *
******************************
 
* .PARITY - SET PARITY IN P/V BIT
* THIS SPECIAL ROUTINE IS NOT USED BY THE CONVERTER BUT IS
* PROVIDED FOR USE WHEN PARITY MUST BE ASCERTAINED.
*
*  INPUT: D2.B HAS BYTE TO TEST
*  OUTPUT: THE P/V FLAG IN THE Z80 SIMULATED FLAGS IS SET FOR PARITY
*  EXECUTION TIME: 78 TO 168 CYCLES (DATA DEPENDENT)
.PARITY  MOVE.L    #1,D3     START PARITY INDICATOR AT EVEN
         CLR.B     D4        DUMMY ZERO TO ASSIST X BIT ADD
         ADD.B     D2,D2     SET X TO NEXT BIT
...PLP   ADDX.B    D4,D3     ADD TO CARRY SUM
         ADD.B     D2,D2     LOAD NEXT BIT
         BNE.S     ...PLP    ADD IT IF MORE BITS TO GO
         ADDX.B    D4,D3     ADD FINAL BIT
         BCLR.L    #1,D1     ASSUME PARITY ODD P/V=0
         AND.B     #$01,D3   ISOLATE FINAL PARITY
         ADD.B     D3,D3     MOVE TO BIT 1
         OR.B      D3,D1     SET TO ONE IF EVEN PARITY
         MOVE.L    #$10,D4   RESTORE GLOBAL X BIT MASK
         RTS                 RETURN
 
* CALL - SUBROUTINE CALL PROCESSOR
* NOTE: ROUTINE MUST BE AT LEAST 128 BYTES FROM CONVERTED CODE
...CALL  MOVE.B    2(SP),-(A6) HIGH BYTE ON Z80 STACK
         MOVE.B    3(SP),-(A6) LOW BYTE ON Z80 STACK
         ADD.W     #4,SP     RID ADDR OFF 68K STACK
         JMP       (A0)      ENTER ROUTINE
 
* RET - RETURN PROCESSOR
* NOTE: ROUTINE MUST BE AT LEAST 128 BYTES FROM CONVERTED CODE
...RET   CLR.L     -(SP)     CREATE RETURN ZERO
         MOVE.B    (A6)+,3(SP) COPY LOW
         MOVE.B    (A6)+,2(SP) AND HIGH
         RTS                 RETURN TO CALLER
 
* RLD
...RLD   MOVE.W    4(SP),A0   (HL)
         MOVE.B    D0,D2      COPY A
         ROR.W     #4,D2      A.L TO HIGH END OF WORD
         MOVE.B    (A0),D2    (HL) TO LOW BYTE
         ROL.W     #4,D2      SHIFT
         MOVE.B    D2,(A0)    REPLACE MEMORY BACK SHIFTED
         LSR.W     #8,D2      NEW LOW BACK TO LOW BITS
         AND.B     #$F0,D0    CLEAR LOW BITS IN A
         AND.B     D5,D2      CLEAR HIGH BITS IN TEMP
         MOVE.W    D1,CCR     MOVE IN OLD X BIT
         OR.B      D2,D0      INSERT NEW LOW DIGIT
         MOVE.W    SR,D1      COPY BACK WITH OLD X BIT
         RTS                  AND RETURN
 
* RRD
...RRD   MOVE.W    4(SP),A0   (HL)
         MOVE.B    D0,D2      COPY A
         ROR.W     #8,D2      A.L TO HIGH BYTE
         MOVE.B    (A0),D2    (HL) TO LOW BYTE
         MOVE.B    D2,D3      SAVE MEMORY LOW
         ROR.W     #4,D2      SHIFT
         MOVE.B    D2,(A0)    REPLACE MEMORY BACK SHIFTED
         AND.B     #$F0,D0    CLEAR LOW BITS IN A
         AND.B     D5,D2      CLEAR HIGH BITS IN TEMP
         MOVE.W    D1,CCR     MOVE IN OLD X BIT
         OR.B      D2,D0      INSERT NEW LOW DIGIT
         MOVE.W    SR,D1      COPY NEW FLAGS WITH OLD X BIT
         RTS                  AND RETURN
 
* CPIR
...CPIR  MOVE.W    4(SP),A0    LOAD HL
         MOVE.W    (A1),D2     LOAD BC
         SUB.W     #1,D2       SET FOR DBCC INDEX
         MOVE.W    D1,CCR      SET X BIT
...CPIR2 CMP.B     (A0)+,D0     COMPARE
         DBEQ      D2,...CPIR2 LOOP UNTIL DONE
         BEQ.S     ...CPIRE    BR IF EQUAL
...CPIRN MOVE.W    SR,D1       COPY CC WITH OLD X BIT
         AND.B     #$FD,D1     OFF V
         ADD.W     #1,D2       ADJUST BACK UP
         MOVE.W    D2,(A1)     REPLACE BC
         BEQ.S     ...CPIRR    BR FINISHED
         ADD.B     #2,D1       SHOW COUNT NOT ZERO
...CPIRR MOVE.W    A0,4(SP)    RESTORE HL
         RTS                   RETURN
...CPIRE MOVE.W    SR,D1       COPY CC WITH OLD X BIT
         MOVE.W    D2,(A1)     REPLACE BC
         BEQ.S     ...CPIRR    BR FINISHED
         ADD.B     #2,D1       SHOW COUNT IS NOT ZERO
         MOVE.W    A0,4(SP)    RESTORE HL
         RTS                   RETURN
 
* CPDR
...CPDR  MOVE.W    4(SP),A0    LOAD HL
         MOVE.W    (A1),D2     LOAD BC
         SUB.W     #1,D2       SET FOR DBCC INDEX
         ADD.W     #1,A0
         MOVE.W    D1,CCR      SETUP Z BIT
...CPDR2 CMP.B     -(A0),D0     COMPARE
         DBEQ      D2,...CPDR2 LOOP UNTIL DONE
         BEQ       ...CPIRE    BR IF EQUAL
         BRA       ...CPIRN    BR NOT EQUAL (EXHAUSTED)
 
* CPI
...CPI   MOVE.W    4(SP),A0    LOAD HL
         MOVE.W    D1,CCR      COPY X BIT TO CCR
         CMP.B     (A0)+,D0     COMPARE
         MOVE.W    SR,D1       RESTORE CCR COPY WITH OLD X
         BCLR.L    #1,D1       CLEAR V BIT (ASSUME BC=0)
         SUB.W     #1,(A1)     DECREMENT BC
         BNE.S     ...CPIE     BR EQUAL
         ADD.B     #2,D1       SHOW EQUAL
...CPIE  MOVE.W    A0,4(SP)    RESTORE HL
         RTS                   RETURN
 
* CPD
...CPD   MOVE.W    4(SP),A0    LOAD HL
         MOVE.W    D1,CCR      COPY OVER X BIT
         CMP.B     (A0),D0     COMPARE
         MOVE.W    SR,D1       RESTORE COPY WITH OLD X
         BCLR.L    #1,D1       TURN OFF V COPY (ASSUME BC=0)
         SUB.W     #1,(A1)     DECREMENT BC
         BEQ.S     ...CPDE     BR EQUAL
         ADD.B     #2,D1       SHOW BC NOT ZERO
...CPDE  MOVE.W    A0,4(SP)    RESTORE HL
         RTS                   RETURN
 
* LDIR
...LDIR  MOVE.W    4(SP),A0    LOAD HL
         MOVE.W    (A1),D2     LOAD BC
         MOVE.W    A1,-(SP)    SAVE A1 FOR OUR USE
         MOVE.W    (A3),A1     LOAD DE
         SUB.W     #1,D2       SET FOR DBCC INDEX
...LDIR2 MOVE.B    (A0)+,(A1)+ MOVE
         DBRA      D2,...LDIR2 LOOP UNTIL DONE
         MOVE.W    A0,4(SP)    RESTORE HL
         MOVE.W    A1,(A3)     RESTORE DE
         MOVE.W    (SP)+,A1    RESTORE B (BC) POINTER
         CLR.W     (A1)        SET BC TO ZERO
         BCLR      #1,D1       SET P/V TO ZERO
         RTS                   RETURN
 
* LDDR
...LDDR  MOVE.W    4(SP),A0    LOAD HL
         MOVE.W    (A1),D2     LOAD BC
         MOVE.W    A1,-(SP)    SAVE A1 FOR OUR USE
         MOVE.W    (A3),A1     LOAD DE
         SUB.W     #1,D2       SET FOR DBCC INDEX
         ADD.W     #1,A0       OFFSET FOR PREDECREMENT
         ADD.W     #1,A1       OFFSET FOR PREDECREMENT
...LDDR2 MOVE.B    -(A0),-(A1) MOVE DOWNWARD
         DBRA      D2,...LDDR2 LOOP UNTIL DONE
         MOVE.W    A0,4(SP)    RESTORE HL
         MOVE.W    A1,(A3)     RESTORE DE
         MOVE.W    (SP)+,A1    RESTORE B (BC) POINTER
         CLR.W     (A1)        SET BC TO ZERO
         BCLR.L    #1,D1       SET P/V TO ZERO
         RTS                   RETURN
 
* LDI
...LDI   MOVE.W    4(SP),A0    LOAD HL
         MOVE.B    (A0)+,D2    LOAD BYTE TO MOVE
         MOVE.W    A0,4(SP)    UPDATE HL
         MOVE.W    (A3),A0     LOAD DE
         MOVE.B    D2,(A0)+    STORE BYTE BACK
         MOVE.W    A0,(A3)     UPDATE DE
         BCLR.L    #1,D1       DEFAULT DONE
         SUB.W     #1,(A1)     BC = BC - 1
         BEQ.S     ...LDI2     BR DONE
         ADD.B     #2,D1       SET V FOR NOT DONE
...LDI2  RTS                   RETURN
 
* LDD
...LDD   MOVE.W    4(SP),A0    LOAD HL
         MOVE.B    (A0),D2     LOAD BYTE
         BCLR.L    #1,D1       DEFAULT DONE
         SUB.W     #1,4(SP)    DECREMENT HL
         MOVE.W    (A3),A0     LOAD DE
         MOVE.B    D2,(A0)     STORE BYTE
         SUB.W     #1,(A3)     DECREMENT DE
         SUB.W     #1,(A1)     BC = BC - 1
         BEQ.S     ...LDD2     BR DONE
         ADD.B     #2,D1       SET V FOR NOT DONE
...LDD2  RTS                   RETURN
 
* EX (SP),HL
...EXHL  MOVE.B    (A6)+,D2    FIRST BYTE
         MOVE.B    (A6),D3     SECOND BYTE
         MOVE.B    -1(A5),(A6) H TO SECOND BYTE
         MOVE.B    (A5),-(A6)  L TO FIRST BYTE
         MOVE.B    D2,(A5)     FIRST BYTE TO L
         MOVE.B    D3,-1(A5)   SECOND BYTE TO H
         RTS                   RETURN
 
* EX (SP),IY
...EXIY  MOVE.W    D7,-(SP)    SAVE IY ON STACK
         MOVE.B    1(A6),-(SP) LOW BYTE BECOMES HIGH IN COPY
         MOVE.B    (A6),1(SP)  HIGH BYTE ON STACK BECOMES LOW IN COPY
         MOVE.W    (SP)+,D7    RESTORE NEW IY
         MOVE.B    1(SP),(A6)  OLD IY LOW BECOMES STACK HIGH
         MOVE.B    (SP)+,1(A6) OLD IY HIGH BECOMES STACK LOW
         RTS                   RETURN
 
* EX (SP),IX
...EXIX  MOVE.W    D6,-(SP)    SAVE IX ON STACK
         MOVE.B    1(A6),-(SP) LOW BYTE BECOMES HIGH IN COPY
         MOVE.B    (A6),1(SP)  HIGH BYTE ON STACK BECOMES LOW IN COPY
         MOVE.W    (SP)+,D6    RESTORE NEW IX
         MOVE.B    1(SP),(A6)  OLD IX LOW BECOMES STACK HIGH
         MOVE.B    (SP)+,1(A6) OLD IX HIGH BECOMES STACK LOW
         RTS                   RETURN
 
* EXX
...EXX   MOVEM.L   (A1),D2/D3  SWAP BCDEHL
         MOVEM.L   ...PRIME,D4/A0
         MOVEM.L   D2/D3,...PRIME PUT BACK
         MOVEM.L   D4/A0,(A1)
         MOVE.L    #$10,D4 RESTORE X BIT MASK
         RTS       RETRN
 
* SET C BIT ONLY
...SETC  BCC.S     ...SETC2
         OR.B      D4,D1
         MOVE.W    D1,CCR
         RTS
...SETC2 AND.B     D5,D1
         MOVE.W    D1,CCR
         RTS
 
* SET SZV BITS ONLY (ALL BUT C)
...SETSZV MOVE.W  SR,D2                *****SHOULD BE CHANGED FOR MC68010*****
         AND.B   D4,D1
         AND.B   D5,D2
         OR.B    D2,D1
         MOVE.W  D1,CCR
         RTS
 
*********** END OF CONVERSION FRONT-END CODE***********
 
...START EQU       *         DEFAULT ENTRY TO PROGRAM IF NO END STMT OPERAND
 
         OPT       FRS       FORWARD REFERENCES 16-BITS
 
******** NEXT SHOULD BE THE CONVERTED PROGRAM *********
