This "addressing mode" does not have an effective address, and is not considered to be an addressing mode on some computers. This addressing is the simplest form of addressing which operand is part of instruction.
This requires space in an instruction for quite a large address. It is often available on Complex instruction set computing (CISC) machines which have variable-length instructions, such as x86.
Address field contains address of operand
Effective address (EA) = address field (A)
Example:
ADD A
Add contents of cell A to accumulator
Look in memory at address A for operand
Single memory reference to access data
No additional calculations to work out effective address
Limited address space
Indirect Addressing
Any of the addressing modes mentioned in this article could have an extra bit to indicate indirect addressing. Indirect addressing may be used for code or data. It can make implementation of pointers or references or handles much easier, and can also make it easier to call subroutines which are not otherwise addressable. Indirect addressing does carry a performance penalty due to the extra memory access involved.
Memory cell pointed to by address field contains the address of (pointer to) the operand
EA = (A)
Look in A, find address (A) and look there for operand
Example: ADD (A)
Add contents of cell pointed to by contents of A to accumulator
Advantage:
For a word length of N an address space of 2N is now available
Disadvantage:
Instruction execution requires two memory references to fetch the operand
One to get its address and a second to get its value
May be nested, multilevel, cascaded
Example: EA = (((A)))
Disadvantage is that three or more memory references could be required to fetch an operand
Hence slower
Register Addressing
This "addressing mode" does not have an effective address and is not considered to be an addressing mode on some computers. Similar to direct addressing, the only difference is that the address field refers to a register rather than a main memory address.
Operand is held in register named in address filed
EA = R
Advantages:
Only a small address field is needed in the instruction
No time-consuming memory references are required
Disadvantage:
The address space is very limited
Register Indirect Addressing
The effective address for a Register indirect instruction is the address in the specified register.Similar to indirect addressing. The only difference is whether the address field refers to a memory location or a register
EA = (R)
Operand is in memory cell pointed to by contents of register R
Advantages and limitations:
-Basically same as indirect addressign
-Address space limitation of the address field is overcome by having that field refer to a word-length location containing an address
-Uses one less memory reference than indirect addressing
Relative Addressing
A version of displacement addressing. The effective address for a relative instruction address is the offset parameter added to the address of the next instruction. This offset is usually signed to allow reference to code both before and after the instruction.
R = Program counter, PC
EA = A + (PC)
i.e. get operand from A cells from current location pointed to by PC
c.f locality of reference & cache usage
Base-Register Addressing ( Displacement)
The base register could contain the start address of an array or vector, and the index could select the particular array element required. The processor may scale the index register to allow for the size of each array element. This could be used for accessing elements of an array passed as a parameter.
A- holds displacement
R- holds pointer to base address
R- may be explicit or implicit
Example: segment registers in 80x86
Indexed Addressing
This also requires space in an instruction for quite a large address. The address could be the start of an array or vector, and the index could select the particular array element required. The processor may scale the index register to allow for the size of each array element.
A = base
R = displacement
EA = A + R
Good for accessing arrays (iterative operations)
EA = A + R
R++ (increment R after each operation)
+------+-----+-----+--------------------------------+
| load | reg |index| address |
+------+-----+-----+--------------------------------+
(Effective address = address + contents of specified index register)
Stack Addressing
Operand is (implicitly) on top of stack
A stack is a reserved block of locations
e.g.
ADD
Pop top two items from stack and add
Instruction Formats
-Define the layout of the bits of an instruction, in terms of its constituent fields
-Must include an opcode and, implicitly or explicitly, indicate the addressing mode for each operand
-For most instruction sets more than one instruction format is used
For Instruction Length:
-Should be equal to the memory-transfer length or one should be a multiple of the other
-Should be a multiple of the character length, which is usually 8 bits, and of the length of fixed-point numbers
Instruction length can affected by : Memory size, Memory organization, Bus structure, CPU complexity, CPU ,speed .
