part 6 programming

PART 6Programming

1. Decomposition2. Three Constructs3. Counting Example4. Debugging

Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display.

6-2

Solving Problems using a ComputerMethodologies for creating computer programsthat perform a desired function.

Problem Solving• How do we figure out what to tell the computer to do?• Convert problem statement into algorithm,

using stepwise refinement.• Convert algorithm into LC-3 machine instructions.

Debugging• How do we figure out why it didn’t work?• Examining registers and memory, setting breakpoints, etc.

Time spent on the first can reduce time spent on the second!


6-3

Stepwise RefinementAlso known as systematic decomposition.

Start with problem statement: “We wish to count the number of occurrences of a character

in a file. The character in question is to be input fromthe keyboard; the result is to be displayed on the monitor.”

Decompose task into a few simpler subtasks.

Decompose each subtask into smaller subtasks,and these into even smaller subtasks, etc....until you get to the machine instruction level.


6-4

Problem StatementBecause problem statements are written in English,they are sometimes ambiguous and/or incomplete.

• Where is “file” located? How big is it, or how do I knowwhen I’ve reached the end?

• How should final count be printed? A decimal number?• If the character is a letter, should I count both

upper-case and lower-case occurrences?

How do you resolve these issues?• Ask the person who wants the problem solved, or• Make a decision and document it.


6-5

Three Basic ConstructsThere are three basic ways to decompose a task:

Task

Subtask 1

Subtask 2Subtask 1 Subtask 2

Testcondition

Subtask

Testcondition

Sequential Conditional Iterative

True

True

FalseFalse


6-6

SequentialDo Subtask 1 to completion,then do Subtask 2 to completion, etc.

Get characterinput fromkeyboard

Examine file andcount the numberof characters that

match

Print numberto the screen

Count and print theoccurrences of acharacter in a file


6-7

ConditionalIf condition is true, do Subtask 1;else, do Subtask 2.

Test character.If match, increment

counter.Count = Count + 1

file char= input?

True False


6-8

IterativeDo Subtask over and over, as long as the test condition is true.

Check each element ofthe file and count the

characters that match.

Check next char andcount if matches.

more charsto check?

True

False


6-9

Problem Solving SkillsLearn to convert problem statementinto step-by-step description of subtasks.

• Like a puzzle, or a “word problem” from grammar school math.What is the starting state of the system?What is the desired ending state?How do we move from one state to another?

• Recognize English words that correlate to three basic constructs:

“do A then do B” sequential“if G, then do H” conditional“for each X, do Y” iterative“do Z until W” iterative


6-10

LC-3 Control InstructionsHow do we use LC-3 instructions to encodethe three basic constructs?

Sequential• Instructions naturally flow from one to the next,

so no special instruction needed to gofrom one sequential subtask to the next.

Conditional and Iterative• Create code that converts condition into N, Z, or P.

Example:Condition: “Is R0 = R1?”Code: Subtract R1 from R0; if equal, Z bit will be set.

• Then use BR instruction to transfer control to the proper subtask.


6-11

Code for Conditional

GenerateCondition

InstructionA

0000B

Subtask 1

C

Subtask 2

NextSubtask

D

? C

0000 111 D

Subtask 1

TestCondition

True False

Subtask 2

NextSubtask

Exact bits dependon conditionbeing tested

PC offset toaddress C

PC offset toaddress D

Unconditional branchto Next Subtask

Assuming all addresses are close enough that PC-relative branch can be used.


6-12

Code for Iteration

GenerateCondition

InstructionA

0000

B

Subtask

CNext

Subtask

? C

0000 111 A

Subtask

TestCondition

True

False

NextSubtask

Exact bits dependon conditionbeing tested

PC offset toaddress C

PC offset toaddress A

Unconditional branchto retest condition

Assuming all addresses are on the same page.


6-13

Example: Counting Characters

Input a character. Thenscan a file, countingoccurrences of thatcharacter. Finally, displayon the monitor the numberof occurrences of thecharacter (up to 9).

START

STOP

Initialize: Put initial valuesinto all locations that will beneeded to carry out thistask.

- Input a character.- Set up a pointer to the firstlocation of the file that willbe scanned.- Get the first character fromthe file.- Zero the register that holdsthe count.

START

STOP

Scan the file, location bylocation, incrementing thecounter if the charactermatches.

Display the count on themonitor.

A

B

C

Initial refinement: Big task intothree sequential subtasks.


6-14

Refining B

Scan the file, location bylocation, incrementing thecounter if the charactermatches.

B

Test character. If a match,increment counter. Get nextcharacter.

B1

Done?

No

Yes

B

Refining B into iterative construct.


6-15

Refining B1

Refining B1 into sequential subtasks.

Test character. If a match,increment counter. Get nextcharacter.

B1

Done?

No

Yes

B

Get next character.

B1

Done?

No

Yes

Test character. If matches,increment counter.

B2

B3


6-16

Refining B2 and B3

R1 = M[R3]

Done?

No

Yes

B2

B3

R3 = R3 + 1

R1 = R0?

R2 = R2 + 1

NoYes

Get next character.

B1

Done?

No

Yes

Test character. If matches,increment counter.

B2

B3

Conditional (B2) and sequential (B3).Use of LC-2 registers and instructions.


6-17

The Last Step: LC-3 InstructionsUse comments to separate into modules and to document your code.

R1 = M[R3]

Done?

No

Yes

B2

B3

R3 = R3 + 1

R1 = R0?

R2 = R2 + 1

NoYes

; Look at each char in file.0001100001111100 ; is R1 = EOT?0000010xxxxxxxxx ; if so, exit loop; Check for match with R0.1001001001111111 ; R1 = -char00010010011000010001001000000001 ; R1 = R0 – char0000101xxxxxxxxx ; no match, skip incr0001010010100001 ; R2 = R2 + 1; Incr file ptr and get next char0001011011100001 ; R3 = R3 + 10110001011000000 ; R1 = M[R3]

Don’t knowPCoffset bits until

all the code is done


6-18

DebuggingYou’ve written your program and it doesn’t work.

Now what?

What do you do when you’re lost in a city?Drive around randomly and hope you find it?

Return to a known point and look at a map?

In debugging, the equivalent to looking at a mapis tracing your program.

• Examine the sequence of instructions being executed.• Keep track of results being produced.• Compare result from each instruction to the expected result.


6-19

Debugging OperationsAny debugging environment should provide means to:

1. Display values in memory and registers.

2. Deposit values in memory and registers.

3. Execute instruction sequence in a program.

4. Stop execution when desired.

Different programming levels offer different tools.• High-level languages (C, Java, ...)

usually have source-code debugging tools.• For debugging at the machine instruction level:

simulators operating system “monitor” tools in-circuit emulators (ICE)

– plug-in hardware replacements that give instruction-level control


6-20

LC-3 Simulator

set/displayregisters

and memory

executeinstruction

sequences

stop execution,set breakpoints


6-21

Types of ErrorsSyntax Errors

• You made a typing error that resulted in an illegal operation.• Not usually an issue with machine language,

because almost any bit pattern corresponds tosome legal instruction.

• In high-level languages, these are often caught during thetranslation from language to machine code.

Logic Errors• Your program is legal, but wrong, so

the results don’t match the problem statement.• Trace the program to see what’s really happening and

determine how to get the proper behavior.

Data Errors• Input data is different than what you expected.• Test the program with a wide variety of inputs.


6-22

Tracing the ProgramExecute the program one piece at a time,examining register and memory to see results at each step.

Single-Stepping• Execute one instruction at a time.

• Tedious, but useful to help you verify each step of your program.

Breakpoints• Tell the simulator to stop executing when it reaches

a specific instruction.

• Check overall results at specific points in the program. Lets you quickly execute sequences to get a

high-level overview of the execution behavior. Quickly execute sequences that your believe are correct.

Watchpoints• Tell the simulator to stop when a register or memory location changes

or when it equals a specific value.

• Useful when you don’t know where or when a value is changed.


6-23

Example 1: MultiplyThis program is supposed to multiply the two unsignedintegers in R4 and R5.

x3200 0101010010100000x3201 0001010010000100x3202 0001101101111111x3203 0000011111111101x3204 1111000000100101

clear R2

add R4 to R2

decrement R5

R5 = 0?

HALT

No

Yes

Set R4 = 10, R5 =3.Run program.

Result: R2 = 40, not 30.


6-24

Debugging the Multiply Program

PC R2 R4 R5

x3200 -- 10 3

x3201 0 10 3

x3202 10 10 3

x3203 10 10 2

x3201 10 10 2

x3202 20 10 2

x3203 20 10 1

x3201 20 10 1

x3202 30 10 1

x3203 30 10 0

x3201 30 10 0

x3202 40 10 0

x3203 40 10 -1

x3204 40 10 -1

40 10 -1

PC and registersat the beginning

of each instruction PC R2 R4 R5

x3203 10 10 2

x3203 20 10 1

x3203 30 10 0

x3203 40 10 -1

40 10 -1

Single-stepping

Breakpoint at branch (x3203)

Executing loop one time too many.Branch at x3203 should be basedon Z bit only, not Z and P.

Should stop looping here!


6-25

Example 2: Summing an Array of NumbersThis program is supposed to sum the numbersstored in 10 locations beginning with x3100,leaving the result in R1.

R4 = 0?

HALT

No

Yes

R1 = 0R4 = 10

R2 = x3100

R1 = R1 + M[R2]R2 = R2 + 1

R4 = R4 - 1

x3000 0101001001100000x3001 0101100100100000x3002 0001100100101010x3003 0010010011111100x3004 0110011010000000x3005 0001010010100001x3006 0001001001000011x3007 0001100100111111x3008 0000001111111011x3009 1111000000100101


6-26

Debugging the Summing ProgramRunning the the data below yields R1 = x0024,but the sum should be x8135. What happened?

Address Contents

x3100 x3107

x3101 x2819

x3102 x0110

x3103 x0310

x3104 x0110

x3105 x1110

x3106 x11B1

x3107 x0019

x3108 x0007

x3109 x0004

PC R1 R2 R4

x3000 -- -- --

x3001 0 -- --

x3002 0 -- 0

x3003 0 -- 10

x3004 0 x3107 10

Start single-stepping program...

Should be x3100!

Loading contents of M[x3100], not address.Change opcode of x3003 from 0010 (LD) to 1110 (LEA).


6-27

Example 3: Looking for a 5This program is supposed to setR0=1 if there’s a 5 in one ten memory locations, starting at x3100.

Else, it should set R0 to 0.

R2 = 5?

HALT

No

Yes

R0 = 1, R1 = -5, R3 = 10R4 = x3100, R2 = M[R4]

R4 = R4 + 1R3 = R3-1

R2 = M[R4]

x3000 0101000000100000x3001 0001000000100001x3002 0101001001100000x3003 0001001001111011x3004 0101011011100000x3005 0001011011101010x3006 0010100000001001x3007 0110010100000000x3008 0001010010000001x3009 0000010000000101x300A 0001100100100001x300B 0001011011111111x300C 0110010100000000x300D 0000001111111010x300E 0101000000100000x300F 1111000000100101x3010 0011000100000000

R3 = 0?

R0 = 0

Yes

No


6-28

Debugging the Fives ProgramRunning the program with a 5 in location x3108results in R0 = 0, not R0 = 1. What happened?

Address Contents

x3100 9

x3101 7

x3102 32

x3103 0

x3104 -8

x3105 19

x3106 6

x3107 13

x3108 5

x3109 61

Perhaps we didn’t look at all the data?Put a breakpoint at x300D to seehow many times we branch back.

PC R0 R2 R3 R4

x300D 1 7 9 x3101

x300D 1 32 8 x3102

x300D 1 0 7 x3103

0 0 7 x3103 Didn’t branchback, eventhough R3 > 0?

Branch uses condition code set byloading R2 with M[R4], not by decrementing R3.Swap x300B and x300C, or remove x300C andbranch back to x3007.


6-29

Example 4: Finding First 1 in a WordThis program is supposed to return (in R1) the bit position of the first 1 in a word. The address of the word is in location x3009 (just past the end of the program). If thereare no ones, R1 should be set to –1.

R1 = 15R2 = data

R2[15] = 1?

decrement R1shift R2 left one bit

HALT

x3000 0101001001100000x3001 0001001001101111x3002 1010010000000110x3003 0000100000000100x3004 0001001001111111x3005 0001010010000010x3006 0000100000000001x3007 0000111111111100x3008 1111000000100101x3009 0011000100000000

R2[15] = 1?

Yes

Yes

No

No


6-30

Debugging the First-One ProgramProgram works most of the time, but if data is zero,it never seems to HALT.

PC R1

x3007 14

x3007 13

x3007 12

x3007 11

x3007 10

x3007 9

x3007 8

x3007 7

x3007 6

x3007 5

Breakpoint at backwards branch (x3007)

PC R1

x3007 4

x3007 3

x3007 2

x3007 1

x3007 0

x3007 -1

x3007 -2

x3007 -3

x3007 -4

x3007 -5

If no ones, then branch to HALTnever occurs!This is called an “infinite loop.”Must change algorithm to either(a) check for special case (R2=0), or(b) exit loop if R1 < 0.


6-31

Debugging: Lessons LearnedTrace program to see what’s going on.

• Breakpoints, single-stepping

When tracing, make sure to notice what’s really happening, not what you think should happen.

• In summing program, it would be easy to not noticethat address x3107 was loaded instead of x3100.

Test your program using a variety of input data.• In Examples 3 and 4, the program works for many data sets.• Be sure to test extreme cases (all ones, no ones, ...).


Illustration 1• Suppose we have 3 integers placed in memory

sequentially, starting at x3050. Please write a program, starting at x3000, to count the number of positive integers, the number of zeros, and the number of negative integers, and to put the numbers in R0, R1, and R2, respectively.

6-32


Illustration 1• .ORIG x3000

• x3000 1110 011 001001111 ; LEA LEA R3, DATA

• x3001 0101 000 000 1 00000 ; AND AND R0, R0, #0

• x3002 0101 001 001 1 00000 ; AND AND R1, R1, #0

• x3003 0101 010 010 1 00000 ; AND AND R2, R2, #0

• x3004 0101 100 100 1 00000 ; AND AND R4, R4, #0

• x3005 0001 100 100 1 00011 ; ADD ADD R4, R4, #3

• x3006 0000 010 000001011 ; BR AGAIN AND BRZ FINISH

• x3007 0110 110 011 000000 ; LDR LDR R6, R3, #0

• x3008 0000 001 000000011 ; BR BRp POS

• x3009 0000 100 000000100 ; BR BRn NEG

• x300A 0001 001 001 1 00001 ; ADD ADD R1, R1, #1

6-33


Illustration 1• x300B 0000 111 000000011 ; BR BRnzp NEXT

• x300C 0001 000 000 1 00001 ; ADD POS ADD R0, R0, #1

• x300D 0000 111 000000001 ; BR BRnzp NEXT

• x300E 0001 010 010 1 00001 ; ADD NEG ADD R2, R2, #1

• x300F 0001 011 011 1 00001 ; ADD NEXT ADD R3, R3, #1

• x3010 0001 100 100 1 11111 ; ADD ADD R4,R4, #-1

• x3011 0000 111 111110100 ; BR BRnzp AGAIN

• x3012 1111 0000 00100101 ;HALT FINISH HALT

• .BLKW x3D

• x3050 1000000000000001 DATA .FILL x8001

• X3051 0000000000000000 .FILL x0000

• X3052 1111000000000000 .FILL xF000

.END

6-34



sequentially, starting at x4050. Please write a program, starting at x4000, to count the number of the occurrences of 6 in these integers. Put this number in R0 when it is done.

6-35


Illustration 2 .ORIG x4000

• x4000 1110 011 001001111 ; LEA LEA R3, DATA

• x4001 0101 000 000 1 00000 ; AND AND R0, R0, #0

• x4002 0101 100 100 1 00000 ; AND AND R4, R4, #0

• x4003 0001 100 100 1 00101 ; ADD AND R4, R4, #5

• x4004 0000 010 000000111 ; BR AGAIN BRz FINISH

• x4005 0110 110 011 000000 ; LDR LDR R6, R3, #0

• x4006 0001 110 110 1 11010 ; ADD ADD R6, R6, #-6

• x4007 0000 101 000000001 ; BR BRnp NEXT

• x4008 0001 000 000 1 00001 ; ADD ADD R0, R0, #1

6-36


Illustration 2• x4009 0001 011 011 1 00001 ; ADD NEXT ADD R3, R3, #1

• x400A 0001 100 100 1 11111 ; ADD ADD R4, R4, #-1

• x400B 0000 111 111111000 ; BR BRnzp AGAIN

• x400C 1111 0000 00100101 ;HALT FINISH HALT

• .BLKW x43

• x4050 1000000000000001 DATA .FILL x8001

• X4051 0000000000000110 .FILL x0006

• X4052 1111000000000000 .FILL xF000

• X4053 0000000000000110 .FILL x0006

• X4054 0000000000000110 .FILL x0006

.END

6-37



sequentially, starting at x4050. Please write a program, starting at x4000, to count the number of the occurrences of 64 in these integers. Put this number in R0 when it is done.

6-38



• x4000 1110 011 001001111 ; LEA LEA R3, DATA

• x4001 0010 111 001001101 ; LD LD R7, MATCH

• x4002 0101 000 000 1 00000 ; AND AND R0, R0, #0

• x4003 0101 100 100 1 00000 ; AND AND R4, R4, #0

• x4004 0001 100 100 0 00101 ; ADD ADD R4, R4, #5

• x4005 0000 010 000000111 ; BR AGAIN BRz FINISH

• x4006 0110 110 011 000000 ; LDR LDR R6, R3, #0

• x4007 0001 110 110 1 11010 ; ADD ADD R6, R6, #-6

• x4008 0000 101 000000001 ; BR BRnp NEXT

• x4009 0001 000 000 1 00001 ; ADD ADD R0, R0, #1

6-39


Illustration 3• x400A 0001 011 011 1 00001 ; ADD NEXT ADD R3, R3, #1

• x400B 0001 100 100 1 11111 ; ADD ADD R4, R4, #-1

• x400C 0000 111 111111000 ; BR BRnzp AGAIN

• x400D 1111 0000 00100101 ;HALT FINISH HALT

.BLKW #41

• x404F 1111111111000000 MATCH .FILL #-64

• x4050 1000000000000001 DATA .FILL x8001

• X4051 0000000001000000 .FILL x0040

• X4052 1111000000000000 .FILL xF000

• X4053 0000000001000000 .FILL x0040

• X4054 0000000001000000 .FILL x0040

• .END

6-40


Illustration 4• Write a program, starting at x3000, which is supposed

to sum the numbers stored in 3 locations beginning with x3100, leaving the result in R1.

6-41


Illustration 4• .ORIG x3000• x3000 0101 001 001 1 00000 ;AND AND R1, R1, #0• x3001 0101 100 100 1 00000 ;AND AND R4, R4, #0• x3002 0001 100 100 1 00011 ;ADD AND R4, R4, #3• x3003 1110 010 011111100 ;LEA LEA R2, FINISH• x3004 0110 011 010 000000 ;LDR AGAIN LDR R3, R2, #0• x3005 0001 001 001 000 011 ;ADD ADD R1, R1, R3• x3006 0001 010 010 1 00001 ;ADD ADD R2, R2, #1• x3007 0001 100 100 1 11111 ;ADD ADD R4, R4, #-1

• x3008 0000 001 111111011 ;BR BRp AGAIN

• x3009 1111 0000 00100101 ;HALT HALT• .BLKW xF6• x3100 0000 0000 0000 0001 FIRST .FILL x0001• x3101 0000 0000 0000 1010 .FILL x000A• x3102 1111 1111 1111 1101 .FILL xFFFD• .END

6-42


Illustration 5• Write a program, starting at x3200, to multiply the two

positive numbers contained at memory locations x3300 and x3301, respectively. Store the result at memory location x3302.

6-43



• x3200 0010 100 011111111 ;LD LD R4, DATA1

• x3201 0010 101 011111111 ;LD LD R5, DATA2

• x3202 0101 010 010 1 00000 ;AND AND R2, R2, #0

• x3203 0001 010 010 000 100 ;ADD AGAIN ADD R2, R2, R4

• x3204 0001 101 101 1 11111 ;ADD ADD R5, R5, #-1

• x3205 0000 001 111111101 ;BR BRp AGAIN

• x3206 0011 010 011111011 ;ST ST R2, RESULT

• x3207 1111 0000 00100101 ;HALT HALT

• .BLKW xF8

• x3300 0000 0000 0000 0010 DATA1 .FILL #2

• x3301 0000 0000 0000 0011 DATA2 .FILL #3

• x3302 RESULT .FILL #0

• .END

6-44


Exercise 6• 6.2• 6.4• 6.7• 6.14• 6.16• 6.17

6-45

part 6 programming

Documents