1 / 23

Lecture 2 Basic Operations and Memory Addressing Modes

Lecture 2 Basic Operations and Memory Addressing Modes. Presented By Dr. Rajesh Palit Asst. Professor, EECS, NSU Originally Prepared By Dr. Shazzad Hosain , EECS, NSU. Road Map. Memory Addressing Real Mode and Protected Mode Basic Elements of Assembly Language

clarke-morton
Download Presentation

Lecture 2 Basic Operations and Memory Addressing Modes

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. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Lecture 2Basic Operations and Memory Addressing Modes Presented By Dr. Rajesh Palit Asst. Professor, EECS, NSU Originally Prepared By Dr. ShazzadHosain, EECS, NSU

  2. Road Map • Memory Addressing • Real Mode and • Protected Mode • Basic Elements of Assembly Language • Identifiers, Reserved words, Constants • MOV / XCHG • Addition, Subtraction • Input/Output • Array, Loop and Accessing Memory

  3. Real Mode Memory Addressing Segment n * * * • The first 1MB memory is Real memory or the Conventional memory 1MB Segment 2 offset 16 bit Segment registers Segment 1 CS DS SS 0000h 8000h A000h 1 MB requires 20 bit address Each segment is 64 KB Offset address is 16 bit or 2 byte Actual address = segment address + offset address

  4. Real Mode Memory Addressing • Real mode operation allows to address 1MB of memory space – even for the Pentium microprocessor • This first 1MB memory is called the real memory or the conventional memory • A combination of segment and offset address access the real memory • Segment registers contains the beginning address of any 64KB memory segment • The offset address selects the any location within the 64KB memory space

  5. Interpretation of Segment Address • A segment address is multiple of 2n • In real mode, n = 4 means when a segment register contains 2, the corresponding address in the physical memory is 32. • For example, DS = 66 (42H), means in physical memory it is 1056 (420H). 0 16 32 48 64 . . . . . . 16x . . .

  6. Segment Plus Offset Determines Address • To get the real address • Pad 0H at the end of segment register • Add the offset value CS = 1000H Offset = F000H DS = 1234H Offset = 245FH 10000H F000H 1F000H 12340H 245FH 1479FH Since each segment is 64 K, the offset address can take maximum of FFFFH Once, the beginning address is found in segment registers, ending address is calculated by adding FFFFH with the value of segment register after padding 0H after it. From Intel Microprocessor

  7. Default Segment and Offset Registers If CS = 1400H and IP/EIP = 1200 H The microprocessor access instruction from 14000 H+ 1200H = 15200H.

  8. Suppose 1000H bytes of code 190H bytes of data 200H bytes of stack Allows relocation Figure 2-4: A memory system showing the placement of four memory segments Figure 2-5

  9. Road Map • Memory Addressing • Real Mode and • Protected Mode – supports up to 4G bytes of memory – will be discussed later on. • Basic Elements of Assembly Language • Identifiers, Reserved words, Constants • MOV/ XCHG • Addition, Subtraction • Array, Loop and Accessing Memory

  10. Variables • Reserved Words • Instruction Mnemonics, such as MOV, ADD, MUL • Register Names, Directives • Operators, Predefined symbols • Identifiers • Not case sensitive • First character must be letter or _ • Not Reserved word

  11. Variable Declaration Data1 db 10H ; define byte – 1 byte Data2 dw 1234H ; define word – 2 bytes Data3 db 10 dup(0) ; array initialized with 0 Data4 db 20 dup(?) ; array uninitialized Data5 db 2, 4, 5, 6 Line db 5,4, 3 dup (7, 2 dup(0), 9) Line db 5,4,7,0,0,9,7,0,0,9,7,0,0,9

  12. Instruction: MOV / XCHG • MOV dest, source • MOV reg, reg • MOV mem, reg • MOV reg, mem • MOV mem, immi • MOV reg, immi • XCHG dest, source • XCHG reg, reg • XCHG reg, mem • XCHG mem, reg

  13. Data Addressing Modes

  14. Program: Data Addressing .model small .data Array db 20 dup (0) .code movax, @data ; .startup movds, ax ; movax, bx movch, 3Ah movbx, 0300h movbp, 0200h movsi, 0200h movax, 12AFH mov[1002h], ax mov[bx], al mov[bx+si], bp movcl, [bx+4] movArray[bx+si], dl movax, 4C00H ; .exit int21H ; end

  15. Instruction:Add / Sub / INC / DEC • ADD dest, source • SUB dest, source • Source can be reg/mem/immi • Dest can be reg/mem • source mem and destmem NOT allowed • INC dest or DEC dest • Reg or Mem location

  16. Input / Output • Single character Input • AH = 1 • Int 21H • The input char will be in AL • Single character output • AH = 2 • DL = output char • Int 21H • Outputting String • AH = 9 • DX = address of the string • string db 'NSU', 0DH, 0AH, '$'

  17. Array, Loop and Accessing Memory DATA DW 50 ; DATA is a word with value 50 DATA1 DW 50 DUP (?) ; array of 50 uninitialized words DATA2 DW 50 DUP (0) ; array of 50 words initialized with 0 DATA DATA1 DATA2 50 0 0 0 0 0 0 1 2 3 49 Accessing memory MOV AX, 1020h MOV AX, [1020h] MOV [AX], 20 MOV CX, 10 ; loop count XYZ: ; statements ; statements LOOP XYZ 1021h 1020h 1021h 0001h AX 0000h

  18. Example Program 1 Write a program that will initialize 50 bytes array with values 1 to 50 1 2 3 4 5 50 0 1 2 49 .MODEL SMALL .DATA mList DB 50 DUP (?) ; setup array of 50 bytes .CODE ; start of code segment .STARTUP ; start of program MOV AX, 1 MOV CX, 50 ; load counter with 50 MOV BX, OFFSET mList ; address of DATAS array AGAIN: MOV [BX], AX ; save values to array positions INC AX ; increment AX to next values INC BX ; increment BX to next elements LOOP AGAIN ; repeat 50 times .EXIT ; exit to DOS END ; end program

  19. Example Program 2 Write a program that will initialize 50 bytes array in the following form 50 49 47 1 0 1 2 49 .MODEL SMALL .DATA mList DB 50 DUP (?) ; setup array of 50 bytes .CODE ; start of code segment .STARTUP ; start of program MOV AX, 1 MOV CX, 50 ; load counter with 50 MOV BX, OFFSET mList ; address of DATAS array AGAIN: MOV [BX], AX ; save values to array positions INC AX ; increment AX to next values INC BX ; increment BX to next elements LOOP AGAIN ; repeat 50 times .EXIT ; exit to DOS END ; end program 50 DEC decrement

  20. Example Program 2, Alternate Way Write a program that will initialize 50 bytes array in the following form 50 49 47 1 0 1 2 49 .MODEL SMALL .DATA mList DB 50 DUP (?) ; setup array of 50 bytes .CODE ; start of code segment .STARTUP ; start of program MOV AX, 1 MOV DI, 49 MOV CX, 50 ; load counter with 50 MOV BX, OFFSET mList ; address of DATAS array AGAIN: MOV [BX+DI], AX ; save values to array positions INC AX ; increment AX to next values DEC DI ; decrement DI LOOP AGAIN ; repeat 50 times .EXIT ; exit to DOS END ; end program

  21. Example 3 Move array element 10H into array element 20H **** ***** *** 0 1 2 16 32 **** **** ARRAY 0 1 2 15 17 32 16 29H .MODEL SMALL .DATA Array DB 16 DUP (?) ; setup array DB 29H DB 30 DUP (?) .CODE .STARTUP ; start of program MOV BX, OFFSET ARRAY ; address of ARRAY MOV DI, 10H ; address element 10H MOV AL, [BX + DI] ; get element 10H MOV DI, 20H ; address element 20H MOV [BX+DI], AL ; save in element 20H .EXIT ; exit to DOS END ; end program Example 3-7: Intel Microprocessors - by Brey

  22. Example 3, Alternate Way Move array element 10H into array element 20H ARRAY **** **** 0 1 2 15 17 32 16 29H Example: 3-8, Brey

  23. References • Section 2-2, Intel Microprocessors – by Brey • Ch 3, Intel Microprocessors – by Brey • Ch 6, 10 Assembly Language Programming – by Charles Marut

More Related