What is the minimum number of addressing modes necessary for computation?

Question

In x86 Assembler, given that you have

• Immediate addressing mode for allocating numbers
• Register addressing mode for registers
• Direct addressing mode for memory addresses,

why do you need Indexed and Base Pointer addressing modes? Each could be replaced by a loop as far as I know.

Also Indirect mode doesn't seem to be overly useful either, since you can simply use Direct mode instead to reference the memory address. What is the purpose of first accessing a register which then contains a pointer to a memory address?

In short, which addressing modes are really necessary?

Answer 1

Although in theory 'addressing mode' can be used to refer to the operand type, it's a bit confusing since it doesn't involve an address. The Intel manual uses 'addressing mode' to refer to memory addressing, and I will use this definition.

In assembly, an operand can be :

• An immediate value
• A register
• A value in memory (the operand here is the address)

In the x86 architecture, the "addressing mode" is only for the last type of operands : memory operands (addresses), and refers to the methods available to calculate the addresses. The addressing modes can be summarized in a single configurable addressing mode :

address = REG_base + REG_index*n + offset

REG_base, REG_index, n and offset are all configurable, and can all be omitted (but you need at least one, obviously).

address = offset is called immediate, direct or absolute addressing.
address = REG_base is called register indirect addressing.
address = REG_base + REG_index is called base plus index addressing.
Similarly, you can add an offset (offset) and a scale (n).

Strictly speaking, you only need one mode to do everything : register indirect addressing (address = REG). With that, if you need to access memory, you can calculate any address you want in a register, and use it to do the access. It can also replace direct register operands by using memory instead, and immediate operands by constructing values with arithmetic. However, for a practical instruction set, you would still immediate operands to load addresses effectively, and register operands are needed if you don't want pointer-only registers.

All the other addressing modes beside register indirect are here for convenience, and they are indeed really convenient :

• Immediate addressing saves you a register if you just have to access a fixed variable in memory.
• Base + offset is really useful for accessing object members : you can keep the base address in a register and access individual members with a fixed offset. No need for intermediate calculations or register to hold the member address.
• Similarly, indexed addressing is used for accessing arrays : you can just change an index register to access any value in the array.
• With a scale you can access multi-bytes variable (ex: int) arrays with no additional registers or calculations.
• A combination of everything can be used to access an array member in an object, still preserving the base pointer for potential access to other members in the object.

These addressing modes don't need much calculations from the CPU : only additions and shifts. Considering x86 can do a multiplication every cycle, those operations are trivial but still very convenient.