CSE306

Processing Systems and StructuresII

Lockwood, Spring 2003

Introduction

Preliminary Procedure

1. Visit the CSE306 laboratory in the Urbauer 115 lab during any laboratory period [times shown in yellow]

2. Have a seat at any available computer in the laboratory. The machine should boot into Windows XP.

3. Enter your login and password. You should log in as the user 'cs306' and use the password given in class. Once in, you should next provide your personalized CEC login and password in order to access your own files.

4. Start a command shell. This can be done by clicking on the start button, navigating to Run, then type 'CMD' .

5. For the machines in the CSE306 lab, you will be using the following drive letters:

   Drive	Description	Purpose
   C:	Hard Drive (local)	Holds Windows XP, MASM, and other applications Do not store files here!
   H:	Your personal home directory (network)	This drive will be mounted each time you log in, and is accessible from any machine in the lab. (Store your MPs here!)

6. Download MP0.ZIP and extract the files to your H:\CSE306\MP0 directory.

7. Go into your private directory
   • Switch to your drive by typing
     H:
   • Switch to the mp0 directory by typing
     cd \cse306\mp0

8. From the desktop, click on My Computer. Navigate to your home drive (H:), open the cse306 directory, then browse to the mp0 folder

9. Double-click on the MP0 ASM file to edit the program. If you are working at home, you'll need to install your own text editor. The Irvine book includes the textpad editor, which offers context-aware text highlighting. Avoid using editors like Notepad and QuickEdit, as they are not designed for editing code. Scroll through the program, but don't make any changes yet.

   The code is broken into several sections to illustrate the various components in an assembly program. This is certainly not the only way to organize an assembly program, but it gives a good starting point. Again, you do not need to understand precisely what the statements are doing at this point, but notice the overall structure of the program. This will be a good reference for future machine problems.

   • Section 1 defines several constants to be used throughout the program. Each constant has a value that is associated with a particular name using the EQU statement.
   • Section 2 declares external procedures (meaning code that has already been written but is in a different file) that will be used in this program. External procedures are declared with the EXTRN statement.
   • Section 3 defines a special required structure called a stack segment. You will discover why a stack is necessary in the future. The stack segment is declared using the SEGMENT STACK ... ENDS statements.
   • Section 4 declares the beginning of the code segment - that part of the file which contains the program instructions. The code segment is declared using the SEGMENT PUBLIC ... ENDS statements. (The ENDS statement appears at the end of the code - - in section 6.)
   • Section 5 initializes several variables to be used. For this program, these variables are just sequences of characters called strings. Variables can be defined using the DB statement. It is important that variables are not defined in a part of your program that is executed.
   • Section 6 contains the code for the main procedure. Procedures are declared using the PROC ... ENDP statements. Execution begins with the MAIN procedure.

10. From the command window, Assemble and link MP0 by typing NMAKE. This command will read Makefile and invoke the following commands:
    MASM /Zi MP0,,;
    LINK /co MP0,,,lib306/map;
    At this point, you should have just created the executable program called MP0.EXE.

11. Run the program by just typing its name, MP0
    Try giving the program different input. Remember: this program is looking for upper-case letters!

12. Now examine your program by running the debugging tool CodeView (CV).
    CV /50 MP0
    Codeview will read your MP0.EXE program and allow you to step and trace through the program as it executes. The /50 provides you with a large (50-line) window to work in.
    • Navigate to the options menu, and select the Source1 Window.... Codeview allows you to view your program as either as raw assembled opcodes (DisplayMode=assembly) or referenced to your original source code. Select DisplayMode=source then hit OK.

    • If the reg window is not already open, open it. From CodeView's Windows pulldown menu, select the options to view Register. Resize and adjust the locations of the windows on the screen as necessary.

    • Click on the function key F10 to execute the first instruction of your program. Notice that register AX has changed value. The first instruction of the program (MOV AX, CSEG) puts the offset of CSEG into AX. Also notice that register IP, the instruction pointer, has changed value. It always specifies the offset of the next instruction to be executed. The instruction displayed is the next one to be executed.

    • Click F10 again to execute the second line of code. Notice that the DS register changes.

    • If the Memory1 window is not already open, open it. From CodeView's Windows pulldown menu, select the options to view Memory 1. Memory addresses are shown on the left in segment:offset format. Check that the memory segment matches the value of the DS. If not, you can enter the numeric value of DS directly in the memory window). Each data byte appears in hexadecimal. On the far right side of the screen are the characters whose ASCII codes are given by the bytes; the period "." appears when the corresponding character is unprintable. The ASCII contents of the memory should look familiar.

    • Click on F10 a few more times to step through your code. Stop stepping when you reach the input prompt.

    • From the program's grade prompt, select a letter grade. Use F10 to step through the rest of the program. You toggle between the debugger screen and program output by pressing F4.

    • Once the program has terminated; Select Restart from CodeView's Run menu. Run the program again a few times with different input until you understand how the program is executing.

    • Navigate to the options menu, and select the Source1 Window..., Select DisplayMode=assembly.

    • Again select Restart from CodeView's Run menu. Now, In CodeView's source window, you will see the machine code for the same program. In first column, you will see where each line of code is located in memory (in segment:offset format). In the second column, you will see the program bytes in hex. In the third column, you will see the human-readable opcodes of the program. Notice that text labels have been replaced with numeric values (pointers and constants) by the assembler and linker.

    • Again select Restart from CodeView's Run menu. Run the program again a few more times with different input.

    • To speed up the debugging process, CodeView allows the programmer to execute large sections of code between break-points. Double-click on the line at offset=00F4 to set a breakpoint in your program at the first compare statement.

    • Restart your program, then hit F5 to go through your code until the breakpoint.

    • When prompted for a grade, enter B then hit return. You should continue execution of the program.

    • Record the value in register AL.
      

      AL = ____

    • From the memory window, change the byte at offset=0 to 44 (hex). Continue running the program until it terminates. Notice that the output message is grossly incorrect.

    • In the space below, explain what the program is doing.
      

    • Quit Codeview and return to the DOS prompt.

13. Now return to your text editor (WinEdit) to modify MP0.ASM. You need to make the following changes:
    1. Put your name and the current date at the beginning of the program
    2. Add a feature to the program that prints a message of your choice when the grade C is selected.
       
    3. Assemble and test your program with all possible inputs. Debug with CodeView as necessary until the program works as expected.

14. Now return to your text editor and add a line to MP0.ASM.
    1. Add a new variable to your program called mystery that is initialized with the hex values of 0FEh,0C0h. (This is MASM's method of entering hex values). Declare this variable at the location in your code immediately after the input is read using the lib306 kbdine function.
    2. Re-Assemble your code and run CodeView.
    3. Run your program a few more times and observe what happens. Try Switching between DisplayMode=Source and DisplayMode=Assembly.
    4. Browse the source window in assembly mode and record what addresses the mystery bytes were stored in.
       

       Address= ______ : ______

    5. In the space below, explain how the program behaves differently and why.
       
    6. Finally, Move this variable declaration to where it belongs in the code.

Final Steps

1. Submit your MP0 Grading report (mp0gr) from the MP section of the CSE306 web pages.

2. Demonstrate your updated MP0.EXE to a TA or to the instructor. Review your solutions to the question with the TA. Be prepared to be quizzed by the TA with additional questions about your codeview debugging experiences. The TA will not allow you to submit your MP until he or she is satisified that you have mastered Codeview.

3. Have the TA run the electronic handin program

4. Log off by clicking on the start button and navigating to Shutdown then Log Off.

5. You are now finished!

MP0.ASM

Makefile