Chapter 10, Example 10
Example 6.3Write a 68000 assembly program at address $002000 to
clear 100 consecutive bytes to zero from LOW to HIGH addresses
starting at location $003000.
Solution
ORG
$2000
; STARTING ADDRESS
MOVEA.L #$3000,A0; LOAD A0 WITH $3000
MOVE.W #99,D0
; MOVE 99 INTO D0
LOOP CLR.B (A0)+
; CLEAR[3000H]+
DBF.W D0,LOOP ; DECREMENT AND
; BRANCH
FINISH JMP FINISH
; HALT
Code Used:
ORG$3000
DC.B$01,$02,$03,$04,$05
DC.B$06,$07,$08,$09,$10
DC.B$01,$02,$03,$04,$05
DC.B$06,$07,$08,$09,$10
DC.B$01,$02,$03,$04,$05
DC.B$06,$07,$08,$09,$10
DC.B$01,$02,$03,$04,$05
DC.B$06,$07,$08,$09,$10
DC.B$01,$02,$03,$04,$05
DC.B$06,$07,$08,$09,$10
DC.B$01,$02,$03,$04,$05
DC.B$06,$07,$08,$09,$10
DC.B$01,$02,$03,$04,$05
DC.B$06,$07,$08,$09,$10
DC.B$01,$02,$03,$04,$05
DC.B$06,$07,$08,$09,$10
DC.B$01,$02,$03,$04,$05
DC.B$06,$07,$08,$09,$10
DC.B$01,$02,$03,$04,$05
DC.B$06,$07,$08,$09,$10
ORG$2000
MOVEA.L #$3000,A0
;Load A0 with $3000
MOVE.W #99,D0
;Move 99 into D0
LOOPCLR.B(A0)+
;Clear [3000] and point to next address
DBF.WD0,LOOP
;Decrement and branch
FINISHJMPFINISH
;HaltExample 6.4
Write a 68000 assembly language program at address $4000 to move
a block of 16-bit data of length 10010 from the source block
starting at location 00200016 to the destination block starting at
location 00300016 from low to high addresses.
SolutionThe assembly language program is shown below:
ORG $4000
MOVEA.W #$2000,A4 ;LOAD A4 WITH SOURCE ADDR
MOVEA.W #$3000,A5 ;LOAD A5 WITH DEST ADDR
MOVE.W #99,D0 ;LOAD D0 WITH COUNT -1=99
START MOVE.W (A4)+,(A5)+;MOVE SOURCE DATA TO DEST
DBF.W D0,START ;BRANCH IF D0
STAY JMP STAY ;HALT
The above program is modified to move five 16-bit data as
follows:
ORG $2000
DC.W $0100,$0200,$0300,$0400,$0500
ORG $4000
MOVEA.W #$2000,A4
MOVEA.W #$3000,A5
MOVE.W #4,D0
START MOVE.W (A4)+,(A5)+
DBF.W D0,START
STAY JMP STAY
EXAMPLE 6.8
Write a 68000 assembly language program at address $3000 to add
two 64-bit numbers as follows:
[D0.L] [D1.L]
+ [D2.L] [D3.L]
-----------------------
[D2.L] [D3.L]Solution
ORG
$3000
ADD.LD1,D3 ; Add low 32 bits, store result in D3.L
ADDX.LD0,D2 ; Add with carry high 32 bits, store result
END JMP
END ; Halt
EXAMPLE 6.9Write a 68000 assembly language program at address
$2000 to add four 32-bit numbers stored in consecutive locations
from low to high addresses starting at address $3000. Store the
32-bit result onto the user stack. Assume that no carry is
generated due to addition of two consecutive 32-bit numbers and A7
is already initialized.
Solution
ORG
$3000
DC.L 1,2,3,4
ORG $2000
MOVEQ.L #3,D0 ; Move 3 into D0
MOVEA.L #$3000,A0;Initialize A0
CLR.L D1 ; Clear sum to 0
START ADD.L (A0)+,D1 ; Add
DBF.W D0,START; perform loop
MOVE.LD1,-(A7) ; push result
FINISH JMP FINISH
Numerical ExampleAssume data as 1,2,3,4. The final result , $A
(10 decimal) will be stored in D1.L.
Simulation ResultsThe following screen shot shows data ,
$00000001, $00000002, $00000003 and $00000004 in memory locations
starting at address $3000. The data are circled, each 4 bytes
long:
As the program is initializing values, the registers are being
changed accordingly:
After the first number ($00000001) is added to the sum in D1.L
during the first pass, register D1.L will contain the 32-bit SUM,
$00000001 as follows:
The following screen shots show how all the numbers are added,
and the 32-bit result ($0000000A) is pushed onto the user
stack:
A7 was $00010000 and storing the result of the sum, D1, using
predecrement addressing, A7 is FFFC and the data is pushed in to
the stack. A7 is decremented by 4 because a long word is stored.
D0.W = $FFFF indicating it is -1 to jump out of the loop. EXAMPLE
6.10
Write a 68000 assembly language program at address $2000 to add
ten 32-bit numbers stored in consecutive locations starting at
address $3000. Initialize A6 to $00200504 and use low 24 bits of A6
as the stack pointer to push the 32-bit result. Use only ADDX
instruction for adding two 32-bit numbers each time through the
loop. Assume that no carry is generated due to addition of two
consecutive 32-bit numbers; this will provide the 32-bit result.
This example illustrates use of the 68000 ADDX instruction.
SolutionThe assembly language program is shown below:
ORG $3000
DC.L 2,3,7,5,1,9,6,4,6,1
START_ADR EQU $3000
ORG $2000
COUNT EQU 9
MOVEA.L #START_ADR,A0 ; LOAD STARTING ADDRESS IN A0
MOVE.B #COUNT,D0
; USE D0 AS A COUNTER
MOVEA.L #$00200504,A6 ; USE A6 AS THE SP
CLR.L D1 ; CLEAR D1
ADDI.B #0,D6 ; CLEAR X BIT
AGAIN MOVE.L (A0)+,D3 ; MOVE A 32 BIT NUMBER IN D3
ADDX.L D3,D1 ;ADD NUMBERS USING ADDX
DBF.W D0,AGAIN ;REPEAT UNTIL D0 = -1 MOVE.L
D1,-(A6)
;PUSH 32-BIT RESULT ONTO STACK FINISH JMP FINISH
Example 6.11
Write a 68000 assembly program at address $2000 to multiply an
8-bit signed number in the low byte of D1 by a 16-bit signed number
in the high word of D5. Store the result in D3. Assume the number
is already stored in D1.B.
Solution
ORG
$2000
EXT.W
D1 ; SIGN EXTENDS LOW BYTE OF D1
SWAP.W D5 ; SWAP LOW WORD WITH HIGH WORD OF D5
MULS.W D1,D5 ; MULTIPLY D1 WITH D5, STORE RESULT
MOVE.L D5,D3 ; COPY RESULT IN D3
FINISH JMP FINISH
EXAMPLE 6.12
Write a 68000 assembly language program at address $2000 to
compute XiYi, where Xi s and Yi ,s are signed 16-bit numbers and N
= 100. Store the 32-bit result in D1. Assume that the starting
addresses of Xi and Yi are 300016 and 400016 respectively.
SolutionThe assembly language program is provided below:P
EQU
$3000
Q
EQU
$4000
ORG
$2000
MOVE.W #99,D0 ;MOVE 99 INTO DO
LEA.L
P,A0 ;LOAD ADDRESS P INTO A0
LEA.L
Q,A1 ;LOAD ADDRESS Q INTO A1
CLR.L
D1 ;INITIALIZE D1 TO ZERO
LOOP
MOVE.W (A0)+,D2 ;MOVE [X] TO D2
MULS.W (A1)+,D2 ;D2