Assembly Language Addressing Modes

Introduction CISC processors usually supports more addressing modes than RISC processors. –RISC processors use the load/store architecture. –Operands are usually stored the processor’s registers. The Pentium processors support the following addressing modes –Register Addressing Mode The input operands and results are stored back in registers. Since –Immediate Addressing Mode: The operand value is encoded as part of the instruction. The operand is available as soon as the instruction is read. –Memory Addressing Modes: The operand is in memory and access via several modes. The logical address is specified to determine the location of a memory operand. Memory addressing modes differ in how they specify the effective address.

Addressing Modes 16 bit addressing modes

Addressing Modes 32 bit addressing modes

Memory Addressing Modes Different addressing modes can efficiently support high-level language constructs and data structures. The memory addressing modes depend on the address size Segment + Base + (Index * Scale) + displacement CS EAX EAX 1 No displacement SS EBX EBX 2 8-bit displacement DS ECX ECX 4 32-bit displacement ES EDX EDX 8 FS ESI ESI GS EDI EDI EBP ESP

16 and 32 bit Addressing Modes In a code segment, the D bit and specifies the default size for operands and offsets. –D = 0 the operands and offsets are 16 bits; otherwise they are 32-bit. D bit in the CS segment descriptor to determine if the address is 16 or 32 bits long It is also possible to override these defaults.

Based Addressing One of the registers is used as the base register in computing the effective address of an operand. The effective address is computed by –Adding the contents of the base register with –A signed displacement value given as part of the instruction. For 16-bit addresses –The signed displacement is either an 8- or a 16-bit number. For 32-bit addresses, –The signed displacement is either an 8- or a 32-bit number. Based addressing –Is convenient to access individual elements of a structure. –It useful for accessing arrays whose element size is not 2, 4, or 8 bytes.

Example

Indexed Addressing The effective address is computed as (Index * scale factor) + signed displacement. Scaling factor –no scaling factor is allowed for 16-bit addresses –2, 4, or 8 can be specified for 32-bit adrresses. Example: add EAX,[EDI+20] mov EAX,[marks_table+ESI*4] add EAX,[table1+ESI]

Based-Indexed Addressing Based-Indexed with No Scale Factor Base + Index + signed displacement. The displacement can be –A signed 8- or 16-bit number for 16-bit addresses –An 8- or 32-bit number for 32-bit addresses. Ex. EBX points to table1, which consists of four-byte elements mov EAX,[EBX+ESI] cmp EAX,[EBX+ESI+4] Based-Indexed with Scale Factor Base + (Index * scale factor) + signed displacement. Provides an efficient indexing mechanism into a 2D array –When the element size is 2, 4, or 8 bytes.

Code Example Sorting an integer array using the insertion sort. %include "io.mac".DATA MAX_SIZE EQU 100 input_prompt db "Please enter input array: " db "(negative number terminates input)",0 out_msg db "The sorted array is:",0.UDATA array resd MAX_SIZE.CODE.STARTUP PutStr input_prompt ; request input array mov EBX, array mov ECX, MAX_SIZE array_loop: GetLInt EAX ; read an array number cmp EAX, 0 ; negative number? jl exit_loop ; if so, stop reading numbers mov [EBX], EAX ; otherwise, copy into array add EBX,4 ; increment array address loop array_loop ; iterates a maximum of MAX_SIZE exit_loop:

Code Example Sorting an integer array using the insertion sort. mov EDX, EBX ; EDX keeps the actual array size sub EDX, array ; EDX = array size in bytes shr EDX, 2 ; divide by 4 to get array size push EDX ; push array size & array pointer push array call insertion_sort PutStr out_msg ; display sorted array newline mov ECX, EDX mov EBX, array display_loop: PutLInt [EBX] newline add EBX,4 loop display_loop done:.EXIT

Code Example Sorting an integer array using the insertion sort. ; This procedure receives a pointer to an array of integers and the array size ; via the stack. The array is sorted by using insertion sort. %define SORT_ARRAY EBX insertion_sort: pushad ; save registers mov EBP, ESP mov EBX, [EBP+36] ; copy array pointer mov ECX,[EBP+40] ; copy array size mov ESI, 4 ; array left of ESI is sorted for_loop: mov EDX,[SORT_ARRAY+ESI] ; temp = array[i] mov EDI, ESI ; j = i-1 sub EDI, 4 while_loop: cmp EDX, [SORT_ARRAY+EDI] ; temp < array[j] jge exit_while_loop ; array[j+1] = array[j] mov EAX,[SORT_ARRAY+EDI] mov [SORT_ARRAY+EDI+4],EAX sub EDI,4 ; j = j-1 cmp EDI,0 ; j >= 0 jge while_loop

Code Example Sorting an integer array using the insertion sort. exit_while_loop: ; array[j+1] = temp mov [SORT_ARRAY+EDI+4],EDX add ESI,4 ; i = i+1 dec ECX cmp ECX,1 ; if ECX = 1, we are done jne for_loop sort_done: popad ; restore registers ret 8

Arrays One dimensional arrays –displacement = subscript * element size in bytes. Example: test_marks[5] uses displacement 5 * 4 = 20

Arrays Multidimensional arrays –Row-major ordering row-by-row, starts with the first row –Column major ordering column-by-column, starts with the first column. Displacement displacement = (i * COLS + j) * ELEM_SIZE array[3,1] is at displacement (3*3+1)*4=40. array