;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.:

ADD R0,R0,R2

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

It looks like you're new here. If you want to get involved, click one of these buttons!

- 140.8K All Categories
- 103.6K Programming Languages
- 6.4K Assembler Developer
- 401 Assembly Code Share
- 239 Getting started in assembly
- 4.6K x86 Assembly
- 1.9K Basic
- 97 Qbasic
- 39.9K C and C++
- 5.6K Beginner C/C++
- 330 C/C++ on Linux/Unix
- 450 C/C++ Windows API
- 522 C++ Builder
- 253 C++ Game Development
- 3.3K C++ MFC
- 103 C++.NET
- 404 Visual C++
- 2.9K C#
- 7.9K Delphi and Kylix
- 334 Advanced Delphi
- 360 Delphi beginners
- 4 Haskell
- 9.7K Java
- 56 Enterprise JavaBeans
- 1.3K Java Beginners
- 304 Java Server Pages
- 4.1K Pascal
- 1.3K Perl
- 11 Perl 6
- 2K PHP
- 546 Python
- 37 Ruby
- 4.4K VB.NET
- 258 Advanced VB.Net
- 1.6K VBA
- 20.8K Visual Basic
- 767 Access databases and VB
- 831 Advance Visual Basic
- 1.2K Beginner VB
- 2.6K Game programming
- 315 Console programming
- 90 DirectX Game dev
- 1 Minecraft
- 112 Newbie Game Programmers
- 2 Oculus Rift
- 9K Applications
- 1.8K Computer Graphics
- 279 3D Graphics
- 129 DirectX
- 125 OpenGL
- 740 Computer Hardware
- 9 Cooling & Overclocking
- 3.4K Database & SQL
- 1.1K Access
- 91 ADO Programming
- 288 MySQL
- 358 Oracle
- 440 SQL-Server
- 535 Electronics development
- 1.6K Matlab
- 628 Sound & Music
- 25 DirectSound
- 257 XML Development
- 3.3K Classifieds
- 200 Co-operative Projects
- 198 For sale
- 190 FreeLance Software City
- 1.9K Jobs Available
- 603 Jobs Wanted
- 209 Wanted
- 2.9K Microsoft .NET
- 1.8K ASP.NET
- 1.1K .NET General
- 22 .NET WEB-Services
- 129 .NET WinForms
- 14 .NET XML
- 50 ADO.NET
- 142 C# & VB.NET School Support
- 3.4K Miscellaneous
- 4 Join the Team
- 354 Comments on this site
- 69 Computer Emulators
- 2.1K General programming
- 187 New programming languages
- 621 Off topic board
- 200 Mobile & Wireless
- 72 Android
- 126 Palm Pilot
- 338 Multimedia
- 154 Demo programming
- 184 MP3 programming
- 0 Bash scripts
- 27 Cloud Computing
- 1 Witsbits Go Cloud
- 53 FreeBSD
- 1.7K LINUX programming
- 1 Awk scripting
- 332 Linux Support
- 0 Sed scripting
- 370 MS-DOS
- 0 Shell scripting
- 321 Windows CE & Pocket PC
- 4.1K Windows programming
- 177 COM/DCOM
- 61 Networking And Security
- 17 Windows 2003 Server
- 6 Windows Vista
- 176 Windows XP
- 940 Software Development
- 417 Algorithms
- 68 Object Orientation
- 24 RUP & UML
- 91 Project Management
- 95 Quality & Testing
- 268 Security
- 63 Evil Scripting
- 81 Hacking
- 7.7K WEB-Development
- 1.8K Active Server Pages
- 61 AJAX
- 4 Bootstrap Themes
- 55 CGI Development
- 28 ColdFusion
- 224 Flash development
- 1.4K HTML & WEB-Design
- 1.4K Internet Development
- 131 Mobile Internet & Messaging
- 211 Wireless development
- 2.2K JavaScript
- 37 JQuery
- 304 WEB Servers
- 153 Apache
- 79 IIS
- 150 WEB-Services / SOAP

## Comments

: ;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.:

:

: ADD R0,R0,R2

: 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.:

:

: ADD R0,R0,R2

: 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

:

: