1 / 34

CET 3510 - Microcomputer Systems Technology Lecture 10

CET 3510 - Microcomputer Systems Technology Lecture 10. Dr. José M. Reyes Álamo. The 80x86 Addressing Modes. The 80x86 memory addressing modes provide flexible access to memory, allowing you to easily access Variables Arrays Records Pointers Other complex data types .

tirza
Download Presentation

CET 3510 - Microcomputer Systems Technology Lecture 10

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. CET 3510 - Microcomputer Systems TechnologyLecture 10 Dr. José M. Reyes Álamo

  2. The 80x86 Addressing Modes • The 80x86 memory addressing modes provide flexible access to memory, allowing you to easily access • Variables • Arrays • Records • Pointers • Other complex data types

  3. 80x86 Register Addressing Modes • Most 80x86 instructions can operate on the 80x86’s general purpose register set • Registers are the best place to keep often used variables • Instructions using the registers are shorter and faster than those that access memory • The general addressing modes provided by the 80x86 family are: • displacement-only • base • displacement plus base • base plus indexed • displacement plus base plus indexed

  4. The Displacement Only Addressing Mode • Also known as direct addressing mode • Consists of a 32 bit constant that specifies the address of the target location • On the 80x86 processors, this displacement is an offset from the beginning of memory (address zero) • Examples are in bytes

  5. The Displacement Only Addressing Mode

  6. The Displacement Only Addressing Mode

  7. Register Indirect Addressing Modes • The operand is not the actual address, but rather, the operand’s value specifies the memory address to use • The register’s value is the memory location to access • Eight forms of indirect addressing mode: • mov( [eax], al ); • mov( [ebx], al ); • mov( [ecx], al ); • mov( [edx], al ); • mov( [edi], al ); • mov( [esi], al ); • mov( [ebp], al ); • mov( [esp], al );

  8. Register Indirect Addressing Modes • Requires a 32-bit register • Have to use the [ ] • Alternatively can use the load effective address (lea) command • In HLA can also use the & operator • mov( &J, ebx );// Load address of J into EBX. • mov( eax, [ebx] );// Store EAX into J. • Uses: • Access data referenced by a pointer, • Step through array data • To modify the address of a variable while your program is running. • To provide anonymous variables (you can read/write to/from it but do not know its name, only the address)

  9. Indexed Addressing Modes • Computes an effective address by adding the address of the specified variable to the value of the 32-bit register appearing inside the square brackets. • This sum is the actual address in memory that the instruction will access. • Syntax: • mov( VarName[ eax ], al ); • mov( VarName[ ebx ], al ); • mov( VarName[ ecx ], al ); • mov( VarName[ edx ], al ); • mov( VarName[ edi ], al ); • mov( VarName[ esi ], al ); • mov( VarName[ ebp ], al ); • mov( VarName[ esp ], al );

  10. Indexed Addressing Modes

  11. Variations on the Indexed Addressing Mode • Two syntactical variations of the indexed addressing mode • The first variant uses the following syntax: • mov( [ 32BitReg+ constant ], al ); • mov( [32BitReg - constant ], al ); • The second variant syntax: • mov( VarName[32BitReg + constant ], al ); • mov( VarName[32BitReg - constant ], al );

  12. Variations on the Indexed Addressing Mode

  13. Variations on the Indexed Addressing Mode • Uses: • If a 32-bit register contains the base address of a multi-byte object and you wish to access a memory location some number of bytes before or after that location • Accessing fields of a record (or structure) when you have a pointer to the record data

  14. Scaled Indexed Addressing Modes • Similar to the indexed addressing modes with two differences: • Allow you to combine two registers plus a displacement • Let you multiply the index register by a (scaling) factor of 1, 2, 4, or 8.

  15. Scaled Indexed Addressing Modes • Syntax • VarName[ IndexReg32*scale ] • VarName[ IndexReg32*scale + displacement ] • VarName[ IndexReg32*scale - displacement ] • [ BaseReg32 + IndexReg32*scale ] • [ BaseReg32 + IndexReg32*scale + displacement ] • [ BaseReg32 + IndexReg32*scale - displacement ] • VarName[ BaseReg32 + IndexReg32*scale ] • VarName[ BaseReg32 + IndexReg32*scale + displacement ] • VarName[ BaseReg32 + IndexReg32*scale - displacement ]

  16. Scaled Indexed Addressing Modes

  17. Scaled Indexed Addressing Modes • Uses: • To access elements of arrays whose elements are two, four, or eight bytes each. • Useful for accessing elements of an array when you have a pointer to the beginning of the array.

  18. Run-Time Memory Organization • The lowest memory addresses are reserved by the operating system. • Generally, applications are not allowed to access data or execute instructions at the lowest addresses in memory. • “general protection fault” error

  19. Run-Time Memory Organization

  20. The Code Section • The code section contains the machine instructions that appear in an HLA program. • HLA translates each machine instruction you write into a sequence of one or more byte values. • The CPU interprets these byte values as machine instructions during program execution. • In theory, you could write a program that stores data values into memory and then transfers control to the data it just wrote, producing a program that writes itself as it executes. • This produces romantic visions of Artificially Intelligent programs that modify themselves • In real life, the effect is usually a disaster and that’s why today’s operating systems operate in protected mode.

  21. The Static Sections • Is where you will typically declare your variables. • You can also embed lists of data into the static memory segment.

  22. The readonly Section • Holds constants, tables, and other data that your program • All readonly objects declarations must be initialized • Data here can be thought as constants

  23. The Storage Section • The storage is used to declare variables that are always uninitialized when the program begins running, as opposed to the readonly section where you initialize all objects you declare, and the static section that lets you optionally initialize objects. • Usually the operating system will initialize all storage objects to zero

  24. The var Section • Used to create automatic variables • Your program will allocate memory when a unit starts executing (usually a procedure), and will deallocate memory when the unit finishes execution. • These variables are usually located in the stack segment

  25. The Stack Segment and the Push and Pop Instructions • The stack is a dynamic data structure that grows and shrinks according to certain memory needs of the program. • The stack also stores important information about program including local variables, subroutine information, and temporary data. • The 80x86 controls its stack via the ESP (stack pointer) register. • Data is written to the stack segment by “pushing” data onto the stack and removed by “popping” or “pulling” data off of the stack.

  26. The Basic PUSH Instruction • Syntax: • push( reg16); • push( reg32); • push( memory16); • push( memory32 ); • pushw( constant ); • pushd( constant ); • Whenever you push data onto the stack, the 80x86 decrements the stack pointer by the size of the data you are pushing and then it copies the data to memory where ESP is then pointing • The stack pointer should always be an even multiple of four

  27. The Basic PUSH Instruction

  28. The basic POP instruction • Syntax • pop( reg16 ); • pop( reg32 ); • pop( memory16 ); • pop( memory32 ); • The POP instruction only supports 16-bit and 32-bit operands; you cannot pop an eight-bit value from the stack • You cannot POP a constant value • Popping a value does not erase the value in memory, it just adjusts the stack pointer so that it points at the next value above the popped value

  29. The basic POP instruction

  30. The Heap Segment • Although static and automatic variables are all simple programs may need, more sophisticated programs need the ability to allocate and deallocate storage dynamically (at run-time) under program control • These memory allocation routines let the programmer request how many bytes of storage to allocate, they return a pointer to the newly allocated storage, and they provide a facility for returning the storage to the system so the system can reuse it in a future allocation call • The heap segment of memory is used for those allocations

  31. The Heap Segment

  32. Accessing the Characters Within a String • To declare a string the syntax is static stringName:string; • Strings are pointers • First need to go to the address indicated by the pointer and then access the individual characters

  33. Accessing the Characters Within a String

  34. Accessing the Characters Within a String Get the nth character of string s in HLA, where n is an uns32 • mov( s, ebx );// Get address of string data into EBX. • mov( n, ecx );// Get desired offset into string. • mov( [ebx+ecx], al );// Get the desired character into AL. Caution: Need to check the index exist, otherwise might get an error Other code samples in the book

More Related