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

ECE291 Computer Engineering II Lecture 6 PowerPoint PPT Presentation


  • 58 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


Ece291 computer engineering ii lecture 6

ECE291Computer Engineering IILecture 6

Josh Potts

University of Illinois at Urbana- Champaign


Outline

Outline

  • Program organization

  • NASM directives

  • Multiplication

  • Division

  • Macros


Program organization

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

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

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

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 cont1

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

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

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 cont1

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 cont2

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 cont3

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

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

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

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 cont1

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


Multiplication1

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

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

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

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

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 cont1

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 cont2

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 cont3

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 (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 cont4

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