ECE291

Computer Engineering II

Lockwood, Spring 1998

Introduction

Preliminary Procedure

1. Visit the ECE291 laboratory in room 238 Everitt Lab. You will need an activated key card to open the door.

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

3. Enter your login and password. You can obtain your login information from the TAs in the lab in exchange for having your photo taken. You can change your windows password from the settings - control panel - windows password menu.

4. Start a DOS shell. This can be done by clicking on the start button, navigating to Programs, then releasing the mouse button on MS-DOS Prompt.

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

   Drive	Description	Purpose
   A:	3.5" Floppy	Portable media
   C:	Hard Drive (local)	Holds Windows95, MASM, and other applications Do not store files here
   I:	Class Drive (network)	Class material, libraries, example code
   F:	Your personal home directory (network)	Store your MPs here! This drive will be mounted each time you log in, and is accessible from any machine in the lab.

6. Copy the MP0 directory on the class drive to your private directory by typing:
   xcopy /s I:\ece291\mp0 F:\mp0
   When prompted, respond with D to copy the entire directory.

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

8. From the start menu, run Windows Explorer. Navigate to your F: drive, open 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. Avoid Notepad and QuickEdit like the Plague). 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 DOS window, Assemble and link MP0 by typing NMAKE. This command will read Makefile and invoke the following commands:
    MASM /Zi MP0,,;
    LINK /co MP0,,,lib291/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 lib291 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. Print a copy of the MP0 Grading report (mp0gr) from the MP section of the ECE291 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. Once approved, make a printout of MP0. This can be done in the ECE291 lab by printing from WinEdit or dragging the mp0.asm file to the printer icon. Make sure that your name appears on the printout.

4. Staple the MP0 grading report to the front of your modified MPO.ASM program. Give this to the same TA which approved your demonstration.

5. Have the TA run the electronic handin program from the floppy.

6. Log off by clicking on the start button and navigating to Shutdown.
   • If other students are waiting to use the computer, select Close all programs and log on as another user.
   • If you will be the last to use the computer, select Shutdown, wait for the computer to stop, then turn off the power for both the CPU and monitor.

7. You are now finished!

MP0.ASM

Makefile