Chapter 6 Programming Adapted from slides provided by McGraw-Hill Companies Inc., modified by professors at University of Wisconsin-Madison

Slide Deck Info Content Slide Numbers Evaluate yourself 3 – 21 Lecture 22 – 56 Problems 57 – 68

Self Evaluation

Steps of Evaluation Step 1: Understand an instruction x3003 1011 0110 0000 0111 What does it do? R3 -> M[M[x300B]]

Steps of Evaluation Step 1: Understand an instruction Step 2: Execute an instruction

Execute an instruction x3003 1011 0110 0000 0111 R3 -> M[M[x300B]] Initial State R1 x0005 R3 x0006 R5 x0007 x300A x300B x300C x300D Final State R1 x0005 R3 x0006 R5 x0007 x300A x300B x300C x300D

Steps of Evaluation Step 1: Understand an instruction Step 2: Execute an instruction Step 3: Execute a program

Execute a program Address Memory Content x3000 x2805 ; R4 <- M[PC’+5] (LD R4, #5) x3001 x56E0 ; R3 <- 0 (AND R3, R3, #0) x3002 x16C2 ; R3 <- R3 + R2 (ADD R3, R3, R2) x3003 x193F ; R4 <- R4 – 1 (ADD R4, R4, -1) x3004 x03FD ; BR if P to PC’-3(BRp #-3) x3005 xF025 ; HALT x3006 x0003 Current State R2 0x0002 PC 0x3000

Execute a program Address Memory Content x3000 x2805 ; R4 <- M[PC’+5] (LD R4, #5) x3001 x56E0 ; R3 <- 0 (AND R3, R3, #0) x3002 x16C2 ; R3 <- R3 + R2 (ADD R3, R3, R2) x3003 x193F ; R4 <- R4 – 1 (ADD R4, R4, -1) x3004 x03FD ; BR if P to PC’-3(BRp #-3) x3005 xF025 ; HALT x3006 x0003 Current State R2 0x0002 R4 0x0003 PC 0x3001

Execute a program Address Memory Content x3000 x2805 ; R4 <- M[PC’+5] (LD R4, #5) x3001 x56E0 ; R3 <- 0 (AND R3, R3, #0) x3002 x16C2 ; R3 <- R3 + R2 (ADD R3, R3, R2) x3003 x193F ; R4 <- R4 – 1 (ADD R4, R4, -1) x3004 x03FD ; BR if P to PC’-3(BRp #-3) x3005 xF025 ; HALT x3006 x0003 Current State R2 0x0002 R4 0x0003 R3 0x0000 PC 0x3002

Execute a program Address Memory Content x3000 x2805 ; R4 <- M[PC’+5] (LD R4, #5) x3001 x56E0 ; R3 <- 0 (AND R3, R3, #0) x3002 x16C2 ; R3 <- R3 + R2 (ADD R3, R3, R2) x3003 x193F ; R4 <- R4 – 1 (ADD R4, R4, -1) x3004 x03FD ; BR if P to PC’-3(BRp #-3) x3005 xF025 ; HALT x3006 x0003 Current State R2 0x0002 R4 0x0003 R3 PC 0x3003

Execute a program Address Memory Content x3000 x2805 ; R4 <- M[PC’+5] (LD R4, #5) x3001 x56E0 ; R3 <- 0 (AND R3, R3, #0) x3002 x16C2 ; R3 <- R3 + R2 (ADD R3, R3, R2) x3003 x193F ; R4 <- R4 – 1 (ADD R4, R4, -1) x3004 x03FD ; BR if P to PC’-3(BRp #-3) x3005 xF025 ; HALT x3006 x0003 Current State R2 0x0002 R4 R3 PC 0x3004

Execute a program Address Memory Content x3000 x2805 ; R4 <- M[PC’+5] (LD R4, #5) x3001 x56E0 ; R3 <- 0 (AND R3, R3, #0) x3002 x16C2 ; R3 <- R3 + R2 (ADD R3, R3, R2) x3003 x193F ; R4 <- R4 – 1 (ADD R4, R4, -1) x3004 x03FD ; BR if P to PC’-3(BRp #-3) x3005 xF025 ; HALT x3006 x0003 Current State R2 0x0002 R4 R3 PC 0x3002

Execute a program Address Memory Content x3000 x2805 ; R4 <- M[PC’+5] (LD R4, #5) x3001 x56E0 ; R3 <- 0 (AND R3, R3, #0) x3002 x16C2 ; R3 <- R3 + R2 (ADD R3, R3, R2) x3003 x193F ; R4 <- R4 – 1 (ADD R4, R4, -1) x3004 x03FD ; BR if P to PC’-3(BRp #-3) x3005 xF025 ; HALT x3006 x0003 Current State R2 0x0002 R4 R3 0x0004 PC 0x3003

Execute a program Address Memory Content x3000 x2805 ; R4 <- M[PC’+5] (LD R4, #5) x3001 x56E0 ; R3 <- 0 (AND R3, R3, #0) x3002 x16C2 ; R3 <- R3 + R2 (ADD R3, R3, R2) x3003 x193F ; R4 <- R4 – 1 (ADD R4, R4, -1) x3004 x03FD ; BR if P to PC’-3(BRp #-3) x3005 xF025 ; HALT x3006 x0003 Current State R2 0x0002 R4 0x0001 R3 0x0004 PC 0x3004

And so on… Try out Problem 4 in the practice set

Steps of Evaluation Step 1: Understand an instruction Step 2: Execute an instruction Step 3: Execute a program Step 4: Write (1-2) instructions

Writing Instructions Type 1: Task specifies the instruction Example: Problem 3 To Do: R1 <- M[x3020] Given: R0 = x3030, M[x300A] = x3020 Address Instruction 0x3000 0010 001 000011111 = 0x221F 0x3001 1010 001 000001000 = 0xA208 0x3002 0110 001 000 110000 = 0x6230 0x3003 Cannot be done (LEA)

Writing Instructions Type 2: Find your own way Example: Problem 1 (2) of the HW To Do: R0 <- 2’s complement of R4 Example: Problem 1(3) of the HW To Do: R1 <- M[x0003]

Steps of Evaluation Step 1: Understand an instruction Step 2: Execute an instruction Step 3: Execute a program Step 4: Write (1-2) instructions Step 5: Write a program Topic of Chapter 6!

Things to keep in mind Hex arithmetic vs. Decimal Arithmetic Instructions and Data are one and the same. It is all about interpretation. Memory is one big sequence of values, each of which may be data or instruction. Try yourself: Write a program which stores an instruction and then executes it.

Chapter 6 Programming

Solving a problem Problem Solving We want to solve a problem using a computer Problem Solving Writing a program Debugging

Writing a program Start from the Problem statement From chapter 1: Problem statement is in a Natural language Ambiguous, cannot be understood by a computer Convert to Algorithm

Prob Stmt to Algorithm Process called “Systematic decomposition” or “Stepwise Refinement” Decompose a task into sub-tasks and even smaller sub-tasks

Running example "We wish to count the number of occurrences of a character in a string” Ambiguities Where is the string located? Where is the character to be counted? Where should the count be stored?

Assume the following String starts at memory location x4002 A null-terminated string Character to be counter at memory location x4001 Each memory location contains one ASCII character Count to be stored at location x4000

Three basic constructs Task Subtask 1 Subtask 2 Sequential Cond Subtask 1 Subtask 2 Conditional True False Cond Subtask 1 Iterative True False

Sequential Read the value at x4001 to R0, and set R1 to 0 Start Set the value of x4000 to the count of occurrences of a character, stored at x4001, in a null-terminated string, starting at x4002 Read each character of the string into R3, if R3 equal R0 increment R1 We are going to use specifics of LC-3, but the process can be used for any programming language Write R1 to x4000 Stop

Iterative Read first character into R3 False R3 ≠ null ? Read each character of the string into R2, if R2 equal R0 increment R1 True If R3 is equal to R0, increment R1 Read next character into R3

Conditional R3 = R0? True False If R3 == R0, increment R1 R1 = R1 + 1

Which to use When? A skill to develop! Tip1: Look at it as a puzzle or a word problem to solve in a Math class What is the starting state of the system? What is the desired ending state? How do we move from one state to another?

Which to use when Tip 2: Look for English words in your algorithm "do A then do B"  sequential "if G, then do H"  conditional "for each X, do Y"  iterative "do Z until W"  iterative

How to convert to LC-3 code? Sequential Instructions normally flow from one to the next Iterative and Conditional Use the BR instruction Create code to convert the condition to value of the CC register Example, to check if R1==R2, do (R1-R2) and check for Z

Code for Conditional

Code for Iterative

The complete flow chart Start R0 = M[x4001] M[x4000] = R1 R3=R0? R1 = 0 Stop R1 = R1 + 1 R2 = x4002 R2 = R2 + 1 R3 = M[R2] R3 = M[R2]

Let’s write some code!

Background: if-else Used to execute an operation only if a condition is satisfied, and some other operation if not. if(cond.) { … } else { if(R3 == R0) { R1 = R1 + 1 } else { <do nothing>

Background: Loop To perform an operation over and over again, until a condition becomes false. while(cond.) { … } while(R3!=0) { <check if R3 is equal to R0> <read next character> } LOOP: <Generate condition> if cond False: go to END <statements in loop> <go to LOOP> END: <statements after while>

The complete flow chart Start R0 = M[x4001] M[x4000] = R1 R3=R0? R1 = 0 Stop R1 = R1 + 1 R2 = x4002 R2 = R2 + 1 R3 = M[R2] R3 = M[R2]

Writing pseudo-code Pseudo-code: A textual way of representing the flowchart (or algorithm) Change conditional constructs to if-else Change iterative constructs to use “if” and “go to”

Writing LC-3 code Convert the pseudo-code/flowchart to LC-3 code All conditions to be converted to CC Fill in the PC offset values (for LD, LDI, ST, STI, LEA, BR) after you have completed the entire code. If you delete/add an instruction, revisit all your PC offsets All data required by the program are stored after HALT. Far away addresses can be stored as data values.

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.

Debugging operations Display values in memory and registers. Deposit values in memory and registers. Execute instruction sequence in a program. Stop execution when desired.

Types of errors Errors Syntax Logical Data

Types of Errors Syntax Errors Example: 1001 001 001 101111 Mostly the result of a typing error Not usually a problem with machine language (though can still happen!) Caught at compile time Example: 1001 001 001 101111

Types of Errors Logical Errors Outputs of your program don’t match your problem statement Solution: Trace the program to check against an expected output.

Types of Errors Data Errors Program works for most of the programs But for a few, they give an incorrect output. Identification is hard! Solution: Test your program for variety of inputs.

Tracing Options Tracing Execute the program piece-by-piece, examining the affected register and memory at each step. Tracing Single-stepping Breakpoints Watchpoints

Single Stepping Execute one instruction at a time + Most fine-grained approach to debugging. Can verify each instruction of your program. - Tedious. Almost impossible to do for large programs.

Breakpoints Tell the simulator to stop when it reaches a specific instruction. + Allows you to quickly execute a parts of the program you believe are correct, and concentrate on parts you believe are buggy. - Hard to know where to place the breakpoint unless you understand the program well.

Watchpoints Tells the simulator to stop when the value of a register or memory location changes. <Not available in PennSim>

Debug Example 1: Multiply This program is supposed to multiply the two unsigned integers in R4 and R5. clear R2 add R4 to R2 decrement R5 R5 = 0? HALT No Yes x3200 0101010010100000 x3201 0001010010000100 x3202 0001101101111111 x3203 0000011111111101 x3204 1111000000100101 Set R4 = 10, R5 =3. Run program.

Debugging Example 1 Logical Error Data Error Branch (at x3203) checks for N and P which leads to an extra iteration of the loop Data Error What is the result if R5 = 0?

Debug 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. R1 = 0 R4 = 10 R2 = x3100 x3000 0101001001100000 x3001 0101100100100000 x3002 0001100100101010 x3003 0010010011111100 x3004 0110011010000000 x3005 0001010010100001 x3006 0001001001000011 x3007 0001100100111111 x3008 0000001111111011 x3009 1111000000100101 R1 = R1 + M[R2] R2 = R2 + 1 R4 = R4 - 1 R4 = 0? No Yes HALT

Debugging Example 2 Logical Error Loading the value at address x3100 instead of the address x3100 into R2 by instruction at x3003 Change LD to LEA

Debugging: Lessons 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. Testing for data errors Be sure to test extreme cases (all ones, no ones, ...).

Problems

Problem 1 The program below checks to see if the value stored in R0 is greater than or equal to the value stored in R1. If R0 is smaller than R1, the value of R1 is copied to R0. Otherwise nothing is done. Insert the missing LC-3 machine language instructions. Address Instruction Comment x3000   x3001 0001 0100 1010 0001 x3002 0001 0110 0000 0010 x3003 x3004 0001 0000 0110 0000 x3005 1111 0000 0010 0101

Solution Address Instruction Comment x3000 1001 010 001 11111 R2 = NOT(R1) x3001 0001 0100 1010 0001 R2 = R2 + 1 x3002 0001 0110 0000 0010 R3 = R0 + R2 [R0-R1] x3003 0000 011 000000001 BR if Z or P to HALT x3004 0001 0000 0110 0000 R0 = R1 x3005 1111 0000 0010 0101 HALT

Problem 2 Complete the program corresponding to the flowchart shown below. Address Content Comment x3000   R2=M[x3006] x3001 R2 = R2 - 1 x3002 BR to HALT x3003 0001 0110 1100 0100 R3=R3+R4 x3004 x3005 1111 0000 0010 0101 Halt x3006 0000 0000 0000 1010 Data value

Solution Address Content Comment x3000 0010 010 000000101 R2=M[x3006] 0001 0100 1011 1111 R2 = R2 - 1 x3002 0000 100 000000010 BR to HALT x3003 0001 0110 1100 0100 R3=R3+R4 x3004 0000 111 111111100 BR to x3001 x3005 1111 0000 0010 0101 Halt x3006 0000 0000 0000 1010 Data value

Problem 3 If the conditional branch (at x3103) redirects control to location x3100, state what is known about R1 and R2 before the execution of the program.  Address Content x3100 1001 001 001 111111 x3101 0101 010 010 000001 x3102 1001 010 010 111111 x3103 0000 010 111 111100

Solution This is a problem where we have to “backtrack” the program: Branch is taken, implies the Z=1, N=P=0 This means the previous instruction which wrote to a register wrote the value 0 This implies after the instruction at x3002 was executes, the value written into R2 was 0. “If you haven’t done the problem, try to do it now. (keep using the above strategy)”

Solution Instruction at x3002 is [R2 = NOT(R2)]. If R2 was 0 after the execution of the instruction, R2 was 0xFFFF (or -1) before its execution. Instruction at x3001 is [R2 = R2 AND R1]. If R2 = 0xFFFF after execution of this instruction, then R1 and R2 should be 0xFFFF before its execution. Instruction at x3000 is [R1 = NOT(R1)]. If R1 is 0xFFFF after the execution of the instruction, R1 = 0 before its execution. So, R1 = 0, R2 = 0xFFFF

Problem 4 Assume that you need to store one of your favorite numbers, 0x3030, into R1 using an instruction placed at 0x3000. Do you think this can be done? If you agree, give a reason why it is not possible to do this. If you do not agree, then write the instruction (in hex) which stores the value 0x3030 into R1 using just one instruction placed at 0x3000. Note: You cannot assume the values of any of the registers or memory locations.

Solution Can be done with LEA: 1110 001 000101111

Problem 5 The following program increments R0 by 1, if R1 > R2. Fill in the missing instruction. Address Contents Comments x3000 1001 010 010 111111   x3001 0001 010 010 1 00001 x3002 0001 010 001 000 010 x3003 x3004 0001 000 000 1 00001 x3005 1111 0000 0010 0101

Solution Address Contents Comments x3000 1001 010 010 111111 R2 = NOT(R2) x3001 0001 010 010 1 00001 R2 = R2 + 1 x3002 0001 010 001 000 010 R2 = R2 + R1 x3003 0000 110 000000001 BR if N or Z to HALT x3004 0001 000 000 1 00001 R0 = R0 + 1 x3005 1111 0000 0010 0101 HALT