Ece291 computer engineering ii lecture 6
Sponsored Links
This presentation is the property of its rightful owner.
1 / 26

ECE291 Computer Engineering II Lecture 6 PowerPoint PPT Presentation


  • 61 Views
  • Uploaded on
  • Presentation posted in: General

ECE291 Computer Engineering II Lecture 6. Josh Potts University of Illinois at Urbana- Champaign. Outline. Program organization NASM directives Multiplication Division Macros. Program Organization.

Download Presentation

ECE291 Computer Engineering II Lecture 6

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


ECE291Computer Engineering IILecture 6

Josh Potts

University of Illinois at Urbana- Champaign


Outline

  • Program organization

  • NASM directives

  • Multiplication

  • Division

  • Macros


Program Organization

  • Create block structure and/or pseudocode on paper to get a clear concept of program control flow and data structures

  • Break the total program into logical procedures/macros

  • Use jumps, loops, etc. where appropriate

  • Use descriptive names for variables

    • noun_type for types

    • nouns for variables

    • verbs for procedures/functions


Debugging Hints

  • Good program organization helps

  • Programs do not work the first time

  • Strategy to find problems

    • Use DEBUG breakpoints to check program progress

    • Use COMMENT to temporarily remove sections of code

    • "print" statements announce milestones in program

  • Test values/cases

    • Try forcing registers/variables to test output of a procedure

    • Use "print" statements to display critical data

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

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


NASM Directives

  • Includes%include “drive:\path\filename”

  • Definitions

    • DB/RESB define/reserve byte (8bits)

    • DW/RESWdefine/reserve word (16 bits)

    • DD/RESDdefine/reserve double word (32 bits)

    • EQUnames a constant

  • Labels

    • “.” prefixed“local” to previous non-dotted label

    • “:” suffix(optional, not required)


NASM Directives(cont.)

  • Macros

    • Instead of using procedures, which require both stack and time resources, macros are fast and flexible

    • Advantages:

      • speed; no call instruction

      • readability - easier to understand program function

    • Drawbacks -

      • space using the macro multiple times duplicates the code

      • tricky to debug (in particular when you have nested macros)

  • Procedures

    • “name”

    • use “.” (local) labels inside procedure (helps keep labels unique)


NASM Directives (cont.)

  • References to procedures

    • EXTERN“name” – give you access to procedures/variables in other files

    • GLOBAL “name” – makes your procedures/variables available to other files

  • Segment definition

    • SEGMENT “name” [STACK]


Example Program Structure

; ECE291:MPXXX

; In this MP you will develop program which take input

; from the keyboard…………

;====== Constants=================================================

;ASCII values for common characters

CR EQU 13

LF EQU 10

ESCKEY EQU 27

;====== Externals=================================================

; -- LIB291 Routines

extern dspmsg, dspout, kbdin

extern rsave, rrest, binasc


Example Program Structure (cont.)

;==== LIBMPXXX Routines (Your code will replace calls to these functions)

extern LibKbdHandler

extern LibMouseHandler

extern LibDisplayResult

extern MPXXXXIT

;====== Stack =====================================================

stkseg segment stack ; *** STACK SEGMENT ***

resb 64*8 ; 64*8 = 512 Bytes of Stack

stacktop:

;====== Begin Code/Data============================================

segment CODE ; *** CODE SEGMENT ***


Example Program Structure (cont.)

;====== Variables=================================================

inputValid db 0 ; 0: InputBuffer is not ready

; 1: InputBuffer is ready

;-1: Esc key pressed

operandsStr db 'Operands: ','$'

OutputBuffer 16 times db 0 ; Contains formatted output

db ‘$’ ; (Should be terminated with '$')

MAXBUFLENGTH EQU 24

InputBuffer MAXBUFLENGTH times db 0 ; Contains one line of db ‘$’ ; user input

graphData%include “graphData.dat” ; data

GLOBAL OutputBuffer, inputValid, operandsStr

GLOBAL graphData


Example Program Structure (cont.)

;====== Procedures ===========================================

KbdHandler

<Your code here>

MouseHandler

<Your code here>

DisplayResult

<Your code here>

;====== Program Initialization ===============================

..start:

mov ax, cs; Use common code & data segment

mov ds, ax

mov ax, stkseg; Initialize stack

mov ss, ax

mov sp, stacktop


Example Program Structure (cont.)

;====== Main Procedure ========================================

MAIN:

MOV AX, 0B800h ;Use extra segment to access video screen

MOV ES, AX

<here comes your main procedure>

CALL MPXXXXIT ; Exit to DOS


Multiplication

  • The product after a multiplication is always a double-width product, e.g,

    • if we multiply two 16-bit numbers , they generate a 32-bit product

    • unsigned: (216 - 1) * (216 - 1) = (232 - 2 * 216 + 1 < (232 - 1)

    • signed: (-215) * (-215) = 230 < (231 - 1)

    • overflow cannot occur

  • Modification of Flags

    • Most flags are undefined after multiplication

    • O and C flags clear to 0 if the result fit into half-size register

    • e.g., if the most significant 16 bits of the product are 0, both flags C and O clear to 0


Multiplication (cont.)

  • Two different instructions for multiplication

    • MULMultiply unsigned

    • IMULInteger Multiply (2’s complement)

  • Multiplication is performed on bytes, words, or double words

  • Which operation to perform depends on the size of the multiplier

  • The multiplier can be any register or any memory location

    mul cx; AX * CX (unsigned result in DX--AX);imul word [si] ; AX * [word content of memory location; addressed by SI] (signed productin DX--AX)


Multiplication(16 bit)

The use of the AX (and DX) registers is implied!!!!!

Multiplicand AX

Multiplier (16-bit register,

16-bit memory variable)

DX, AX = PRODUCT

(High word in DX : Low word in AX)


Multiplication (cont.)

  • 8086/8088 microprocessors do not allowto perform immediate multiplication

  • 80286, 80386, and 80486 allow the immediate multiplication by using a special version of the multiply instruction

  • Immediate multiplication must be signed multiplication and contains three operands

    • 16-bit destination register

    • register or memory location that contains 16-bit multiplicand

    • 8-bit or 16-bit immediate data used as a multiplier

      imulcx, dx, 12h ;multiplies 12h * DX and leaves ;16-bit signed product in CX


Multiplication

  • 8-bit multiplication

    Multiplicand AL

    Multiplier (8-bit register,

    8-bit memory variable)

    AX PRODUCT

  • 32-bit multiplication

    Multiplicand EAX

    Multiplier (32-bit register,

    32-bit memory variable)

    EDX, EAX PRODUCT (High word in EDX : Low word in EAX)

    • 32-bit multiplication is available only on 80386 and above


Binary Multiplication

  • Long Multiplication is done through shifts and additions

  • This works if both numbers are positive

  • To multiply a negative numbers, the CPU will store the sign bits of the numbers, make both numbers positive, compute the result, then negate the result if necessary

0 1 1 0 0 0 1 0 (98)

x 0 0 1 0 0 1 0 1 (37)

-------------------------

0 1 1 0 0 0 1 0

0 1 1 0 0 0 1 0 - -

0 1 1 0 0 0 1 0 - - - - - (3626)


Division

  • X / Y = Q; R

    X Dividend

    YDivisor

    QQuotient

    RRemainder

    Note: Remainder has the same

    sign as X (Dividend)

Examples

(Signed Integers)

X / YQR

9 / 4 2 1

-9 / 4-2-1

9 / -4-2 1

-9 / -4 2-1


Division (cont.)

  • Two different instructions for division

    • DIVDivision unsigned

    • IDIVInteger Division (2’s complement)

  • Division is performed on bytes, words, or double words

  • Which operation to perform depends on the size of the divisor

  • The dividend is always a double-width dividend that is divided by the operand (divisor)

  • The divisor can be any register or any memory location


Division(32-bit/16-bit)

The use of the AX (and DX) registers is implied!!!!!

Dividend DX, AX (high word in DX, low word in AX)

Divisor(16-bit register, 16-bit memory variable)

QuotientAX

RemainderDX


Division (cont.)

  • 16-bit/8-bit

    Dividend AX

    Divisor(8-bit register, 8-bit memory variable)

    QuotientAL

    RemainderAH

  • 64-bit/32-bit

    Dividend EDX, EAX (high double word in EDX, low double word in EAX)

    Divisor(32-bit register, 32-bit memory variable)

    QuotientEAX

    RemainderEDX

  • Available on 80386 and above


Division (cont.)

  • Division of two equally sized words

  • Prepare the dividend

    • Unsigned numbers: move zero into high order-word

    • Signed numbers: use signed extension (implicitly uses AL, AX, DX registers) to fill high-word with ones or zeros

    • CBW(convert byte to word)

      AX = xxxx xxxx snnn nnnn (before)

      AX = ssss ssss snnn nnnn (after)

    • CWD(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)

    • CWDE(convert double to double-word extended) - 80386 and above


Division (cont.)

  • Flag settings

    • none of the flag bits change predictably for a division

  • A division can result in two types of errors

    • divide by zero

    • divide overflow (a small number divides into a large number), e.g., 3000 / 2

      • AX = 3000;

      • Devisor is 2 => 8 bit division is performed

      • Quotient will be written to AL => but 1500 does not fit into AL

      • consequently we have divide overflow

      • in both cases microprocessor generates interrupt (interrupts are covered later in this course)


Division (Example)

Division of the byte contents of memory NUMB by the contents of NUMB1

Unsigned

MOVAL, [NUMB] ;get NUMB

MOVAH, 0 ;zero extend

DIVbyte [NUMB1]

MOV[ANSQ], AL ;save quotient

MOV[ANSR], AH ;save remainder

Signed

MOVAL, [NUMB] ;get NUMB

CBW ;signed-extend

IDIVbyte [NUMB1]

MOV[ANSQ], AL ;save quotient

MOV[ANSR], AH ;save remainder


Division (cont.)

  • What do we do with remainder after division?

    • use the remainder to round the result

    • drop the remainder to truncate the result

    • if the division is unsigned, rounding requires that remainder is compared with half the divisor to decide whether to round up the quotient

    • e.g., sequence of instructions that divide AX by BL and round the result

DIVBL

ADDAH, AH;double remainder

CMPAH, BL;test for rounding

JB.NEXT

INCAL

.NEXT:


  • Login