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 *********