Scribd Logo
Upload

Welcome to Scribd!

  • 411 views

    Assembly Language Programming - CS401 Power Point Slides Lecture 08

    Uploaded by

    Mohammad Bilal Mirza
    This document discusses addressing modes and conditional jumps in assembly language programming. It describes several addressing modes including offset, base, index, base+offset, index+offset, base+index, and base+index+offset addressing. It also explains how to calculate physical addresses from effective addresses. The document concludes by covering conditional jump instructions like JZ, JNZ, JC, JNC, and JCXZ that allow branching based on status flag values.

    Copyright:

    © All Rights Reserved
    Download as PPT, PDF, TXT or read online from Scribd

    Assembly Language Programming - CS401 Power Point Slides Lecture 08

    Uploaded by

    Mohammad Bilal Mirza
    411 views27 pages
    This document discusses addressing modes and conditional jumps in assembly language programming. It describes several addressing modes including offset, base, index, base+offset, index+offset, base+index, and base+index+offset addressing. It also explains how to calculate physical addresses from effective addresses. The document concludes by covering conditional jump instructions like JZ, JNZ, JC, JNC, and JCXZ that allow branching based on status flag values.

    Original Description:

    Assembly Language Programming - CS401 Power Point Slides Lecture 08

    Original Title

    Assembly Language Programming - CS401 Power Point Slides Lecture 08.ppt

    Copyright

    © © All Rights Reserved

    Available Formats

    PPT, PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    This document discusses addressing modes and conditional jumps in assembly language programming. It describes several addressing modes including offset, base, index, base+offset, index+offset, base+index, and base+index+offset addressing. It also explains how to calculate physical addresses from effective addresses. The document concludes by covering conditional jump instructions like JZ, JNZ, JC, JNC, and JCXZ that allow branching based on status flag values.

    Copyright:

    © All Rights Reserved
    Download as PPT, PDF, TXT or read online from Scribd
    Download as ppt, pdf, or txt
    411 views27 pages

    Assembly Language Programming - CS401 Power Point Slides Lecture 08

    Uploaded by

    Mohammad Bilal Mirza
    This document discusses addressing modes and conditional jumps in assembly language programming. It describes several addressing modes including offset, base, index, base+offset, index+offset, base+index, and base+index+offset addressing. It also explains how to calculate physical addresses from effective addresses. The document concludes by covering conditional jump instructions like JZ, JNZ, JC, JNC, and JCXZ that allow branching based on status flag values.

    Copyright:

    © All Rights Reserved
    Download as PPT, PDF, TXT or read online from Scribd
    Download as ppt, pdf, or txt
    of 27

    CS-401

    Computer Architecture & Assembly


    Language Programming
    Lecture-8
    Addressing Modes
    Branching

    In the Last Lecture

    We discussed memory addresses

    Addressing Modes
    Offset Addressing
    ; Default segment = ds
    mov ax, [0x1234]
    ; word move
    mov ah, [0x1234]
    ; byte move
    mov byte[0x1234], 10
    mov word[0x1234], 10

    Addressing Modes
    Base Addressing
    ; Default segment = ds
    mov ax, [bx]
    mov byte [bx], 10
    mov word [bx], 10
    ; Default segment = ss
    mov ax, [bp]
    mov byte [bp], 10
    mov word [bp], 10

    Addressing Modes
    Index Addressing
    ; Default segment = ds
    mov ax, [si]
    mov byte [di], 10
    mov word [si], 10

    Addressing Modes
    Base + Offset Addressing
    ; Default segment = ds
    mov ax, [bx+0x0100]
    mov byte [bx+0x100], 10
    mov word [bx+0x100], 10
    ; Default segment = ss
    mov byte [bp+0x10], 10
    mov word [bp+0x100], 10

    Addressing Modes
    Index + Offset Addressing
    ; Default segment = ds
    mov ax, [si+0x0100]
    mov byte [di+0x100], 10
    mov word [di+0x100], 10
    mov byte [si+0x10], 10
    mov word [si+0x0100], 10

    Addressing Modes
    Base + Index Addressing
    ; Default segment = ds
    mov ax, [bx+si]
    mov byte [bx+si], 10
    mov word [bx+di], 10
    ; Default segment = ss
    mov byte [bp+si], 10
    mov word [bp+di], 10

    Addressing Modes
    Base + Index + Offset Addressing
    ; Default segment = ds
    mov ax, [bx+si+0x0100]
    mov byte [bx+si+0x0100], 10
    mov word [bx+di+0x0100], 10
    ; Default segment = ss
    mov byte [bp+si+0x0100], 10
    mov word [bp+di+0x0100], 10

    Addressing Modes
    General Form
    [base + index + offset]

    Illegal Addressing
    Example
    mov al, [bl]
    be 8-bit

    ; Address cannot
    ; has to be 16-bit

    Illegal addressing

    Illegal Addressing
    Example
    mov ax, [bx-si]
    be
    subtracted

    ; Registers cannot
    ;

    Illegal Addressing
    Example
    mov ax, [bx+bp] ; Two bases cannot
    be
    ; used in
    one addressing

    Illegal Addressing
    Example
    mov ax, [si+di] ; Two indices
    cannot be
    ; used in
    one addressing

    Physical Address Calculation


    [cs:bx+si+0x0700]

    BX = 0x0100
    SI = 0x0200
    CS = 0x1000

    Effective Address =
    EA
    = Base + Index + Offset
    EA
    = 0x0100 + 0x0200 + 0x0700
    = 0x0A00
    Physical Address = Segment*0x10+EA
    = 0x1000*0x10+0xA00
    = 0x10A00

    Physical Address Calculation


    [bx+0x7000]

    BX = 0x9100
    DS = 0x1500

    Effective Address =
    EA
    = Base
    =
    0x07000
    =
    =
    wrap
    around

    + Index + Offset
    0x9100 + 0x0000 +
    0x10100 ; 17-bits !
    0x0100 ; Segment
    ;

    Physical Address Calculation


    [bx+0x7000]

    BX = 0x9100
    DS = 0x1500
    Effective Address =
    EA = 0x0100 ; Segment wrap
    ; around
    Physical Address = Segment*0x10+EA
    = 0x1500*0x10+0x100
    = 0x15100

    Physical Address Calculation


    [bx+0x0100]

    BX = 0x0100

    DS = 0xFFF0
    Effective Address =
    EA
    = Base + Index + Offset
    = 0x0100 + 0x0000 + 0x0100
    = 0x0200
    Physical Address = Segment*0x10+EA
    = 0xFFF0*0x10+0x0200
    = 0x100100 ; 21-bits !
    = 0x00100
    ; memory wrap
    ; around

    CMP

    Subtracts the source (src) from


    destination (dest)
    Does not change contents of src
    or dest.
    Affects AF,CF,OF,PF,SF and ZF.
    The relation is of destination to
    source.

    Conditional Jumps
    jz ;jump if zero
    Jnz ;jump if not zero
    [ZF=0]
    Example
    cmp ax, bx
    jz label1

    [ZF=1]

    Conditional Jumps
    je ;jump if equal
    jz]
    Jne ;jump if not equal
    jnz]

    [same as
    [same as

    Conditional Jumps
    jc ;jump if carry
    Jnc ;jump if not carry
    Example
    add ax, bx
    jc label1
    sub ax, bx
    jnc label1

    [CF=1]
    [CF=0]

    Conditional Jumps
    ja ;jump if above [ZF = 0 and CF=0]
    jb ;jump if below[CF=1]
    unsigned integers

    jl ;jump if less [SF <> OF=0]


    jg ;jump if greater
    [ZF = 0 and
    SF=OF]
    signed integers

    Conditional Jumps
    jae
    jbe
    jge
    jle
    jno
    jns

    ;jump if above or equal


    ;jump if below or equal
    ;jump if greater or equal
    ;jump if less or equal
    ;Jump if not overflow
    ; Jump if not sign

    Renamed Conditional Jumps


    JNBE
    JNB
    JNAE
    JNA
    JZ
    JNLE
    JNL
    JNGE
    JNG
    JNZ
    JPO
    JPE

    JA
    JAE
    JB
    JBE
    JE
    JG
    JGE
    JL
    JLE
    JNE
    JNP
    JP

    Conditional Jumps
    jcxz
    ;jump if the cx register is
    zero
    [cx=0]

    You might also like