1. PART 6 Programming 1.Decomposition 2.Three Constructs 3.Counting Example 4.Debugging

2. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 6-2 Solving Problems using a Computer Methodologies for creating computer programs that 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!

3. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 6-3 Stepwise Refinement Also 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 from the 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.

4. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 6-4 Problem Statement Because 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 know when 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.

5. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 6-5 Three Basic Constructs There are three basic ways to decompose a task:

6. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 6-6 Sequential Do Subtask 1 to completion, then do Subtask 2 to completion, etc.

7. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 6-7 Conditional If condition is true, do Subtask 1; else, do Subtask 2.

8. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 6-8 Iterative Do Subtask over and over, as long as the test condition is true.

9. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 6-9 Problem Solving Skills Learn to convert problem statement into 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

10. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 6-10 LC-3 Control Instructions How do we use LC-3 instructions to encode the three basic constructs? Sequential Instructions naturally flow from one to the next, so no special instruction needed to go from 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.

11. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 6-11 Code for Conditional Exact bits depend on condition being tested PC offset to address C PC offset to address D Unconditional branch to Next Subtask Assuming all addresses are close enough that PC-relative branch can be used.

12. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 6-12 Code for Iteration Exact bits depend on condition being tested PC offset to address C PC offset to address A Unconditional branch to retest condition Assuming all addresses are on the same page.

13. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 6-13 Example: Counting Characters Initial refinement: Big task into three sequential subtasks.

14. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 6-14 Refining B Refining B into iterative construct.

15. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 6-15 Refining B1 Refining B1 into sequential subtasks.

16. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 6-16 Refining B2 and B3 Conditional (B2) and sequential (B3). Use of LC-2 registers and instructions.

17. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 6-17 The Last Step: LC-3 Instructions Use comments to separate into modules and to document your code. ; Look at each char in file. 0001100001111100 ; is R1 = EOT? 0000010xxxxxxxxx ; if so, exit loop ; Check for match with R0. 1001001001111111 ; R1 = -char 0001001001100001 0001001000000001 ; R1 = R0 – char 0000101xxxxxxxxx ; no match, skip incr 0001010010100001 ; R2 = R2 + 1 ; Incr file ptr and get next char 0001011011100001 ; R3 = R3 + 1 0110001011000000 ; R1 = M[R3] Don’t know PCoffset bits until all the code is done

18. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 6-18 Debugging You’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 map is 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.

19. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 6-19 Debugging Operations Any 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

20. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 6-20 LC-3 Simulator set/display registers and memory execute instruction sequences stop execution, set breakpoints

21. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 6-21 Types of Errors Syntax 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 to some legal instruction. In high-level languages, these are often caught during the translation 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.

22. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 6-22 Tracing the Program Execute 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.

23. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 6-23 Example 1: Multiply This program is supposed to multiply the two unsigned integers in R4 and R5. x3200 0101010010100000 x3201 0001010010000100 x3202 0001101101111111 x3203 0000011111111101 x3204 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.

24. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 6-24 Debugging the Multiply Program PCR2R4R5 x3200--103 x32010103 x320210 3 x320310 2 x320110 2 x320220102 x320320101 x320120101 x320230101 x320330100 x320130100 x320240100 x32034010 x32044010 4010 PC and registers at the beginning of each instruction PCR2R4R5 x320310 2 x320320101 x320330100 x32034010 4010 Single-stepping Breakpoint at branch (x3203) Executing loop one time too many. Branch at x3203 should be based on Z bit only, not Z and P. Should stop looping here!

25. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 6-25 Example 2: Summing an Array of Numbers This program is supposed to sum the numbers stored in 10 locations beginning with x3100, leaving the result in R1. R4 = 0? HALT No Yes R1 = 0 R4 = 10 R2 = x3100 R1 = R1 + M[R2] R2 = R2 + 1 R4 = R4 - 1 x3000 0101001001100000 x3001 0101100100100000 x3002 0001100100101010 x3003 0010010011111100 x3004 0110011010000000 x3005 0001010010100001 x3006 0001001001000011 x3007 0001100100111111 x3008 0000001111111011 x3009 1111000000100101

26. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 6-26 Debugging the Summing Program Running the the data below yields R1 = x0024, but the sum should be x8135. What happened? AddressContents x3100x3107 x3101x2819 x3102x0110 x3103x0310 x3104x0110 x3105x1110 x3106x11B1 x3107x0019 x3108x0007 x3109x0004 PCR1R2R4 x3000-- x30010-- x30020--0 x30030--10 x30040x310710 Start single-stepping program... Should be x3100! Loading contents of M[x3100], not address. Change opcode of x3003 from 0010 (LD) to 1110 (LEA).

27. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 6-27 Example 3: Looking for a 5 This program is supposed to set R0=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 = 10 R4 = x3100, R2 = M[R4] R4 = R4 + 1 R3 = R3-1 R2 = M[R4] x3000 0101000000100000 x3001 0001000000100001 x3002 0101001001100000 x3003 0001001001111011 x3004 0101011011100000 x3005 0001011011101010 x3006 0010100000001001 x3007 0110010100000000 x3008 0001010010000001 x3009 0000010000000101 x300A 0001100100100001 x300B 0001011011111111 x300C 0110010100000000 x300D 0000001111111010 x300E 0101000000100000 x300F 1111000000100101 x3010 0011000100000000 R3 = 0? R0 = 0 Yes No

28. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 6-28 Debugging the Fives Program Running the program with a 5 in location x3108 results in R0 = 0, not R0 = 1. What happened? AddressContents x31009 x31017 x310232 x31030 x3104-8 x310519 x31066 x310713 x31085 x310961 Perhaps we didn’t look at all the data? Put a breakpoint at x300D to see how many times we branch back. PCR0R2R3R4 x300D179x3101 x300D1328x3102 x300D107x3103 007 Didn’t branch back, even though R3 > 0? Branch uses condition code set by loading R2 with M[R4], not by decrementing R3. Swap x300B and x300C, or remove x300C and branch back to x3007.

29. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 6-29 Example 4: Finding First 1 in a Word This 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 there are no ones, R1 should be set to –1. R1 = 15 R2 = data R2[15] = 1? decrement R1 shift R2 left one bit HALT x3000 0101001001100000 x3001 0001001001101111 x3002 1010010000000110 x3003 0000100000000100 x3004 0001001001111111 x3005 0001010010000010 x3006 0000100000000001 x3007 0000111111111100 x3008 1111000000100101 x3009 0011000100000000 R2[15] = 1? Yes No

30. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 6-30 Debugging the First-One Program Program works most of the time, but if data is zero, it never seems to HALT. PCR1 x300714 x300713 x300712 x300711 x300710 x30079 8 7 6 5 Breakpoint at backwards branch (x3007) PCR1 x30074 3 2 1 0 x3007-2 x3007-3 x3007-4 x3007-5 If no ones, then branch to HALT never 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.

31. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 6-31 Debugging: Lessons Learned Trace 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 notice that 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,...).

32. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 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

33. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. Illustration 1.ORIG x3000 x30001110 011 001001111; LEA LEA R3, DATA x30010101 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 BR Z FINISH x3007 0110 110 011 000000; LDR LDR R6, R3, #0 x3008 0000 001 000000011; BR BR p POS x3009 0000 100 000000100; BR BR n NEG x300A 0001 001 001 1 00001; ADD ADD R1, R1, #1 6-33

34. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. Illustration 1 x300B 0000 111 000000011; BR BR nzp NEXT x300C 0001 000 000 1 00001; ADD POS ADD R0, R0, #1 x300D 0000 111 000000001; BR BR nzp 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 BR nzp AGAIN x30121111 0000 00100101;HALT FINISH HALT.BLKW x3D x30501000000000000001 DATA.FILL x8001 X30510000000000000000.FILL x0000 X30521111000000000000.FILL xF000.END 6-34

35. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. Illustration 2 Suppose we have 5 integers placed in memory 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

36. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. Illustration 2.ORIG x4000 x40001110 011 001001111; LEA LEA R3, DATA x40010101 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 BR z FINISH x4005 0110 110 011 000000; LDR LDR R6, R3, #0 x4006 0001 110 110 1 11010; ADD ADD R6, R6, #-6 x40070000 101 000000001; BR BR np NEXT x40080001 000 000 1 00001; ADD ADD R0, R0, #1 6-36

37. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 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 BR nzp AGAIN x400C1111 0000 00100101;HALT FINISH HALT.BLKW x43 x40501000000000000001 DATA.FILL x8001 X40510000000000000110.FILL x0006 X40521111000000000000.FILL xF000 X40530000000000000110.FILL x0006 X40540000000000000110.FILL x0006.END 6-37

38. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. Illustration 3 Suppose we have 5 integers placed in memory 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

39. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. Illustration 3.ORIG x4000 x40001110 011 001001111; LEA LEA R3, DATA x40010010 111 001001101; LD LD R7, MATCH x40020101 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 BR z FINISH x4006 0110 110 011 000000; LDR LDR R6, R3, #0 x4007 0001 110 110 1 11010; ADD ADD R6, R6, #-6 x40080000 101 000000001; BR BR np NEXT x40090001 000 000 1 00001; ADD ADD R0, R0, #1 6-39

40. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 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 BR nzp AGAIN x400D1111 0000 00100101;HALT FINISH HALT.BLKW #41 x404F1111111111000000 MATCH.FILL #-64 x40501000000000000001 DATA.FILL x8001 X40510000000001000000.FILL x0040 X40521111000000000000.FILL xF000 X40530000000001000000.FILL x0040 X40540000000001000000.FILL x0040.END 6-40

41. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 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

42. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. Illustration 4.ORIG x3000 x30000101 001 001 1 00000;AND AND R1, R1, #0 x30010101 100 100 1 00000;AND AND R4, R4, #0 x30020001 100 100 1 00011;ADD AND R4, R4, #3 x30031110 010 011111100;LEA LEA R2, FINISH x30040110 011 010 000000;LDR AGAIN LDR R3, R2, #0 x30050001 001 001 000 011;ADD ADD R1, R1, R3 x30060001 010 010 1 00001;ADD ADD R2, R2, #1 x30070001 100 100 1 11111;ADD ADD R4, R4, #-1 x30080000 001 111111011;BR BR p AGAIN x30091111 0000 00100101;HALT HALT.BLKW xF6 x31000000 0000 0000 0001 FIRST.FILL x0001 x31010000 0000 0000 1010.FILL x000A x31021111 1111 1111 1101.FILL xFFFD.END 6-42

43. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 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

44. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. Illustration 5.ORIG x3000 x32000010 100 011111111;LD LD R4, DATA1 x32010010 101 011111111;LD LD R5, DATA2 x32020101 010 010 1 00000;AND AND R2, R2, #0 x32030001 010 010 000 100;ADD AGAIN ADD R2, R2, R4 x32040001 101 101 1 11111;ADD ADD R5, R5, #-1 x32050000 001 111111101;BR BR p AGAIN x32060011 010 011111011;ST ST R2, RESULT x32071111 0000 00100101;HALT HALT.BLKW xF8 x33000000 0000 0000 0010 DATA1.FILL #2 x33010000 0000 0000 0011 DATA2.FILL #3 x3302 RESULT.FILL #0.END 6-44

45. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display. Exercise 6 6.2 6.4 6.7 6.14 6.16 6.17 6-45