Announcements

• Be sure to follow uiuc.class.ece291 newsgroup for useful information about homeworks and machine problems.

Todays Topics

• In-class Examples
• Program Organization
• Assembly and Debugging Techniques
• MASM Directives
• MP Grading
• Multiplication
• Division and Modulo arithmetic
• MACROs

In class examples

• Building Programs
  • Object: Dependencies
    Action
  • NMAKE to build programs
  • NMAKE CLEAN to remove OBJ, MAP, LST, EXE

• Building Programs
  • Assembling with MASM
  • Linking with ML
  • The code segment
  • Allocating Variables

• CodeView Debugging
  • Using symbolic reference
  • Setting Breakpoints
  • Saving your source code

Program Organization

1. Write pseudocode on paper first to get a clear concept of program control flow and data structures
2. Break the total program into logical procedures/macros
3. Use jumps, loops, etc. where appropriate
4. Use descriptive names for variables
   • noun_type for types
   • nouns for variables
   • verbs for procedures/functions

Assembly Debugging Techniques

1. General Techniques
   • Good program organization helps
   • Programs don't work the first time
   • Don't give up!

2. Divide and Conquer Strategy to find problems
   • Use DEBUG breakpoints to check program progress
     
   • Use COMMENT and ; to temporarily remove sections of code
     
   • "print" statments announce milestones in program
     

3. Test values/cases
   • Try forcing registers/variables to test output of a procedure
   • Use "print" statements to display critical data

4. Double-check your own logic (Did you miss a special case?)

5. Try a different algorithm, if all else fails...

ECE291 MP Grading Procedure

• Functionality: 70% - The program must work.
• Comments: 10% - The TAs must be able to understand your program.
• Style: 10% - No spaghetti code.
• I/O Specific: 5% - Subroutines follow required interface
• Modularity: 5% - Appropriate use of procedures and loops

Multiplication

• The result of a multiplication is twice as large as the numbers multiplied
  • (n-bit number) * (n-bit number) = (2n-bit number)
    • 0 <= x < 2^n
    • 0 <= y < 2^n
    • 0 <= x*y < 2^(2n)

  • (8-bit number) * (8-bit number) = (16-bit number)
    • Unsigned: (2^8-1) * (2^8-1) = 2^16 - 2*2^8 + 1 < 2^16-1
    • Signed: (-2^7) * (-2^7) = 2^14 < 2^15-1

  • (16-bit number) * (16-bit number) = (32-bit number)
    • Unsigned: (2^16-1) * (2^16-1) = 2^32 - 2*2^16 + 1 < 2^32-1
    • Signed: (-2^15) * (-2^15-1) = 2^30 < 2^31-1

  • Overflow cannot occur!

• Binary Multiplication

  Shifts and additions

  01100010 (98) x 00100101 (37) ========== 01100010 01100010-- + 01100010----- =============== 111000101010 (3626)

  Note: This method does NOT work for 2's complement numbers

• There are two different commands for multiplication:
  • MUL - Multiply (unsigned)

  • IMUL - Integer Multiply (2's complement)

• The 80x86 can multiply 8-bit, 16-bit, or 32-bit words

  The use of the AX (and DX) registers is implied!
  Which operation you perform depends on the size of the multiplier

  • 16-bit: MUL X

    
    

    • AX = Multiplicand
    • X = Multiplier (16-bit-register or 16-bit-memory-variable)
    • DX,AX = Result (High word in DX, Low word in AX)

    • DX,AX = AX * X

    • Example:

      VarW DW 513 ResultH DW ? ResultL DW ? MOV AX,54 MUL VarW MOV ResultH, DX MOV ResultL, AX

  • 8-bit: MUL X
    
    
    • AL = Multiplicand
    • X = Multiplier (8-bit-register or 8-bit-memory-variable)
    • AX = Result

    • AX = AL * X

    • Example:

      VarB DB 23 Result1 DW ? MOV AL, 6 MUL VarB MOV Result1,AX

  • 32-bit: MUL X
    • 32-bit multiplication available only on 80386 & above

    • EAX = Multiplicand
    • X = Multiplier (32-bit-register or 32-bit-memory-variable)
    • EDX,EAX = Result (High word in EDX, Low word in EAX)

    • EDX,EAX = EAX * X

• Modification to Flags
  • Most flags are undefined after MUL or IMUL ! (unlike ADD/SUB)
  • The OF and CF flags are reset if result fit in 1/2-size register(s).
    • Useful iff you want to calculate: (n-bit) * (n-bit) == (n-bit)

• In-class Quiz
  • Dog Age

Division and Modulo Arithmetic

• X / Y = Q , R
  • Inputs
    • X = Dividend
    • Y = Divisor
  • Outputs
    • Q = Quotient
    • R = Remainder
  • Notes
    • X = Q*Y + R
    • 0 <= |R| < |Y|
    • R has same sign as X

  • Examples (Signed Integers)

    Operation X / Y	Q	R
    9 / 4	2	1
    -9 / 4	-2	-1
    9 / -4	-2	1
    -9 / -4	2	-1

• There are two different commands for division:
  • DIV - Division (unsigned)

  • IDIV - Integer Division (2's complement)

• The 80x86 can divide 16-bit/8-bit, 32-bit/16-bit, or 64-bit/32-bit words

  Again, The use of the AX (and DX) registers is implied!
  Which operation you perform depends on the size of the divisor.

  • 32-bit/16-bit: DIV Y
    
    
    • DX,AX = Dividend (High word in DX, low word in AX)
    • Y = Divisor (16-bit register or 16-bit memory variable)
    • AX = Quotient
    • DX = Remainder

  • 16-bit/8-bit: DIV Y
    
    
    • AX = Dividend
    • Y = Divisor (8-bit register or 8-bit memory variable)
    • AL = Quotient
    • AH = Remainder

  • 64-bit/32-bit: DIV Y
    
    • Only available on 80386 and above

    • EDX,EAX = 64-bit (quadword) Dividend (High word in EDX, low word in EAX)
    • Y = Divisor (16-bit register or 16-bit memory variable)
    • EAX = Quotient
    • EDX = Remainder

• How to divide: (n-bit) / (n-bit)
  • Recall that dividend is twice as larger as divisor.
  • But if you want to divide to equally-sized words, you must prepare the dividend.
    • Unsigned: Move zero into high-word
    • Signed: Use Sign-extension to Fill high-word with ones or zeros (depending on sign of low byte/word/double).
      Implictly Uses AL,AX,DX registers
      • CBW: 8-bit to 16-bit. (Convert Byte to Word)
        • AX = xxxx,xxxx,snnn,nnnn (Before)
        • AX = ssss,ssss,snnn,nnnn (After)
          x=don't care, s=value of sign bit, n=number

      • CWD: 16-bit to 32-bit. (Convert Word to Double)
        • DX:AX = xxxx,xxxx,xxxx,xxxx:snnn,nnnn,nnnn,nnnn (Before)
        • DX:AX = ssss,ssss,ssss,ssss:snnn,nnnn,nnnn,nnnn (After)
          x=don't care, s=value of sign bit, n=number

      • CDQ: 32-bit to 64-bit. (Convert Double to Quadword):
        80386 and above only

• Modular Arithmetic
  • A is congruent to Y modulo N
    If X mod N = Y mod N
  • Maps same result to set S = {0,1,2,..,N-1}
  • Examples
    • 1pm
    • 4*2 MOD 5
    • 5*3 MOD 5
    • 64*64 MOD 256
    • 9 MOD 4
  • Application
    • Encryption (MP2)

• Modification to Flags
  • All flags are undefined after DIV or IDIV !
  • Overflow CAN OCCUR! (but how do you detect it? - The answer is below)
    • Divide Overflow is a Special case. It triggers Interrupt 0 (INT 0)
      We will cover interrupts later in this course.

• In-class Quiz
  • Dog Age
  • Amperage

MACROs

• Text substitutions made at compile time
• NOT a procedure -- Code is literally dumped into program
• Parameter names are substituted
• Useful for tedious programming tasks
• Defined before code segment (near EQU's),
  Instantiated within code segment.

• General Format
  • %macro MACRO_NAME NumParams
  • Your Code ...
  • ... %{1} ...
  • ... %{2} ...
  • Your Code ...
  • JMP %%MyLocalLabel
  • Your Code ...
  • %%MyLocalLabel:
  • ... %{N} ...
  • Your Code ...
  • %endmacro

• Example: %macro DIV16 3
  ; Use as: DIV16 Result,X,Y
  ; Store into Result the signed result of X / Y

  %macro DIV16 3 ; Use as: DIV16 Result,X,Y ; Calculate Result = X / Y ; (all 16-bit signed integers) ; Destroys Registers AX,DX MOV AX, %{2} ; Load AX with Dividend CWD ; Extend Sign into DX IDIV %{3} ; Signed Division MOV %{1}, AX ; Store Quotient %endmacro

• Example: Using the macro in your program

  ; Variable Section varX1 DW 20 varX2 DW 4 varR DW 0 ; Code Section DIV16 word [varR],word [varX1],word [varX2]

• Will Actually Generate the following code:
  You won't actually see this unless you debug your program.

  MOV AX, word [varX1] CWD IDIV word [varX2] MOV word [varR], AX

• In-class Quiz
  • Avoid division by 0

Return to ECE291 Lecture Index