# multiplication subroutine

How would I create a multiplication subroutine that On input R2 and R3 contain two non-negative integers a (multiplicand)
;and b (multiplier) respectively, and on return R1 and R0 contain
; non-negative numbers h and l such the R1,R0 together contain the product
; of a and b :
; a * b = 2^15 * h + l . No other registers should be affected.
; On return R2 is trashed and R3 contains an error flag, which in this case
; is set iff either a or b is negative.
;EXAMPLE: multiply #1000 by #2000 to obtain #2000000
; ld R2,M1000 ; address M1000 contains #1000
; add R3,R2,R2 ; R3 <-- #2000
; jsr mlt
; On return R3 is 0, R1 contains #61 and R0 contains #1152 since
; 2000000 = 2^15 * 61 + 1152

There are several algorithms for multiplication. One can be developed based on
the binary place value system and noting that doubling a number
(i.e.,adding it to itself) shifts the bits one place left.
A simpler algorithm is based on adding R2 to itself R3 times. In this case
it might be better to test the operands to make sure R2 contains the larger of a and b.
(Adding 1000 to itself 3 times is much faster than adding 3 to itself 1000 times).

The product of a and b need not fit into one word: Say you are adding R2 to R0.
Remembering that the operands are all positive, a negative sum signifies overflow,
so the msb must be cleared and R1 incremented; e.g.:

BRzp mlt_goon ; go on if no overflow
AND R0,R0,R4 ; R4 previously loaded with x7FFF = b0111111111111111
ADD R1,R1,#1 ; add in "carry" from R0
mlt_goon

to test this I have

;t_mlt.asm
;RDO fall 2003 for pa2 .

.orig x3000

; One the simulator, use
;Simulate>Set Value...>Location and pull down R2, and put 1000, click Apply
; Then pull down R3, and put 2000, then Apply, then click OK.
; Highlight x3001 (the HALT statement) and then click Simulate>Toggle Breakpoint
; Then run this program with your mlt procedure added.
; When the program breaks before the HALT, click
; File>Save Memory Contents...pa2.dat, using x3000 to x30020
; for the memory range. Be sure "Save Registers" is checked.

jsr mlt
HALT
; After the LC3 has halted click
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;
mlt
; On input R2 and R3 contain two non-negative integers a (multiplicand)
;and b (multiplier) respectively, and on return R1 and R0 contain
; non-negative numbers h and l such the R1,R0 together contain the product
; of a and b :
; a * b = 2^15 * h + l . No other registers should be affected.
; On return R2 is trashed and R3 contains an error flag, which in this case
; is set iff either a or b is negative.
;EXAMPLE: multiply #1000 by #2000 to obtain #2000000
; ld R2,M1000 ; address M1000 contains #1000
; add R3,R2,R2 ; R3 <-- #2000
; jsr mlt
; On return R3 is 0, R1 contains #61 and R0 contains #1152 since
; 2000000 = 2^15 * 61 + 1152
;********* YOUR CODE GOES HERE ***********

.end

• : How would I create a multiplication subroutine that On input R2 and R3 contain two non-negative integers a (multiplicand)
: ;and b (multiplier) respectively, and on return R1 and R0 contain
: ; non-negative numbers h and l such the R1,R0 together contain the product
: ; of a and b :
: ; a * b = 2^15 * h + l . No other registers should be affected.
: ; On return R2 is trashed and R3 contains an error flag, which in this case
: ; is set iff either a or b is negative.
: ;EXAMPLE: multiply #1000 by #2000 to obtain #2000000
: ; ld R2,M1000 ; address M1000 contains #1000
: ; add R3,R2,R2 ; R3 <-- #2000
: ; jsr mlt
: ; On return R3 is 0, R1 contains #61 and R0 contains #1152 since
: ; 2000000 = 2^15 * 61 + 1152
:
: There are several algorithms for multiplication. One can be developed based on
: the binary place value system and noting that doubling a number
: (i.e.,adding it to itself) shifts the bits one place left.
: A simpler algorithm is based on adding R2 to itself R3 times. In this case
: it might be better to test the operands to make sure R2 contains the larger of a and b.
: (Adding 1000 to itself 3 times is much faster than adding 3 to itself 1000 times).
:
: The product of a and b need not fit into one word: Say you are adding R2 to R0.
: Remembering that the operands are all positive, a negative sum signifies overflow,
: so the msb must be cleared and R1 incremented; e.g.:
:
: BRzp mlt_goon ; go on if no overflow
: AND R0,R0,R4 ; R4 previously loaded with x7FFF = b0111111111111111
: ADD R1,R1,#1 ; add in "carry" from R0
: mlt_goon
:
: to test this I have
:
: ;t_mlt.asm
: ;RDO fall 2003 for pa2 .
:
: .orig x3000
:
: ; One the simulator, use
: ;Simulate>Set Value...>Location and pull down R2, and put 1000, click Apply
: ; Then pull down R3, and put 2000, then Apply, then click OK.
: ; Highlight x3001 (the HALT statement) and then click Simulate>Toggle Breakpoint
: ; Then run this program with your mlt procedure added.
: ; When the program breaks before the HALT, click
: ; File>Save Memory Contents...pa2.dat, using x3000 to x30020
: ; for the memory range. Be sure "Save Registers" is checked.
:
: jsr mlt
: HALT
: ; After the LC3 has halted click
: ;
: ;;;;;;;;;;;;;;;;;;;;;;;;;;;
: mlt
: ; On input R2 and R3 contain two non-negative integers a (multiplicand)
: ;and b (multiplier) respectively, and on return R1 and R0 contain
: ; non-negative numbers h and l such the R1,R0 together contain the product
: ; of a and b :
: ; a * b = 2^15 * h + l . No other registers should be affected.
: ; On return R2 is trashed and R3 contains an error flag, which in this case
: ; is set iff either a or b is negative.
: ;EXAMPLE: multiply #1000 by #2000 to obtain #2000000
: ; ld R2,M1000 ; address M1000 contains #1000
: ; add R3,R2,R2 ; R3 <-- #2000
: ; jsr mlt
: ; On return R3 is 0, R1 contains #61 and R0 contains #1152 since
: ; 2000000 = 2^15 * 61 + 1152
: ;********* YOUR CODE GOES HERE ***********
:
: .end
:
:

• Well, this post is almost a year old to the day, but it still offends me, basically because this post is a OBVIOUSLY a request to do a programming assignment, mainly one which I give to my assembly language classes, for I am 'RDO' . 'Grizant' cut and pasted the assignment verbatim including some of my code, without my permission, of course.
I agree with an earlier post by Eric on this issue, in that I think it is good for students to ask questions of experienced programmers, and I would rather err on the side of liberality so as not to stifle such questions. Minimally, the asker must at least be able to paraphrase the problem in his or her own words, and show _some_ of their own clueless code.
On the whole, I trust the judgement and ethics of the real programmers on this list in responding to posts like this. Of course doing a student's assignment for them is not helping them or our profession in the long run, and charging students a _fee_ for producing code for school projects is a sign of predatory jaded cynicism or grave desparation.
We professors thank the members of this list for their cooperation in this. Students, keep the questions coming, but play fair.

unclebobobo
: How would I create a multiplication subroutine that On input R2 and R3 contain two non-negative integers a (multiplicand)
: ;and b (multiplier) respectively, and on return R1 and R0 contain
: ; non-negative numbers h and l such the R1,R0 together contain the product
: ; of a and b :
: ; a * b = 2^15 * h + l . No other registers should be affected.
: ; On return R2 is trashed and R3 contains an error flag, which in this case
: ; is set iff either a or b is negative.
: ;EXAMPLE: multiply #1000 by #2000 to obtain #2000000
: ; ld R2,M1000 ; address M1000 contains #1000
: ; add R3,R2,R2 ; R3 <-- #2000
: ; jsr mlt
: ; On return R3 is 0, R1 contains #61 and R0 contains #1152 since
: ; 2000000 = 2^15 * 61 + 1152
:
: There are several algorithms for multiplication. One can be developed based on
: the binary place value system and noting that doubling a number
: (i.e.,adding it to itself) shifts the bits one place left.
: A simpler algorithm is based on adding R2 to itself R3 times. In this case
: it might be better to test the operands to make sure R2 contains the larger of a and b.
: (Adding 1000 to itself 3 times is much faster than adding 3 to itself 1000 times).
:
: The product of a and b need not fit into one word: Say you are adding R2 to R0.
: Remembering that the operands are all positive, a negative sum signifies overflow,
: so the msb must be cleared and R1 incremented; e.g.:
:
: BRzp mlt_goon ; go on if no overflow
: AND R0,R0,R4 ; R4 previously loaded with x7FFF = b0111111111111111
: ADD R1,R1,#1 ; add in "carry" from R0
: mlt_goon
:
: to test this I have
:
: ;t_mlt.asm
: ;RDO fall 2003 for pa2 .
:
: .orig x3000
:
: ; One the simulator, use
: ;Simulate>Set Value...>Location and pull down R2, and put 1000, click Apply
: ; Then pull down R3, and put 2000, then Apply, then click OK.
: ; Highlight x3001 (the HALT statement) and then click Simulate>Toggle Breakpoint
: ; Then run this program with your mlt procedure added.
: ; When the program breaks before the HALT, click
: ; File>Save Memory Contents...pa2.dat, using x3000 to x30020
: ; for the memory range. Be sure "Save Registers" is checked.
:
: jsr mlt
: HALT
: ; After the LC3 has halted click
: ;
: ;;;;;;;;;;;;;;;;;;;;;;;;;;;
: mlt
: ; On input R2 and R3 contain two non-negative integers a (multiplicand)
: ;and b (multiplier) respectively, and on return R1 and R0 contain
: ; non-negative numbers h and l such the R1,R0 together contain the product
: ; of a and b :
: ; a * b = 2^15 * h + l . No other registers should be affected.
: ; On return R2 is trashed and R3 contains an error flag, which in this case
: ; is set iff either a or b is negative.
: ;EXAMPLE: multiply #1000 by #2000 to obtain #2000000
: ; ld R2,M1000 ; address M1000 contains #1000
: ; add R3,R2,R2 ; R3 <-- #2000
: ; jsr mlt
: ; On return R3 is 0, R1 contains #61 and R0 contains #1152 since
: ; 2000000 = 2^15 * 61 + 1152
: ;********* YOUR CODE GOES HERE ***********
:
: .end
:
: