x86 can't do much without registers, so I don't think you can get rid of the register "addressing mode". Some very different architectures might not use registers, and just have a stack or memory,memory instructions. IDK how they implement pointers; maybe such architectures can do memory[memory]
(C array notation).
Immediate isn't needed for computation to be possible. You can construct any value, using multiple registers. Start with a zero (xor eax, eax
), inc
it to get a 1, left-shift it to whatever position you want, inc
that to set the low bit, left-shift that, etc. So it takes at worst 2*popcount(N)
instructions to get N
into a register. Note that immediate shift counts won't be available, though, so the obvious method of repeated shifting by one (shl eax
, yes there is a separate encoding for shift-by-one, or just use add eax, eax
) will just depend on the position of the highest set bit. So log2(N) + popcount(N)
for the obvious shift and inc.
Absolute (what you call direct) memory addressing is not the most useful addressing mode. We can emulate it by constructing addresses with a sequence of instructions (see above), and using [register]
. If we're trying to cut down, we want to ditch it. As Jester pointed out, keeping absolute addressing as our only form would be terribly inconvenient (or maybe impossible?) to use.
Index is obviously available for performance, not necessity: you can shift and add with separate instructions.
Displacements are also just for performance, so we can get rid of them and force code to add any displacement manually. See the Immediate paragraph for how.
I believe x86 would still be arbitrarily programmable with just register
and [register]
addressing modes.
With register
, [register]
, and immediate
, performance should be not much worse than full x86.
If implicit access to memory doesn't count as an addressing mode, you can of course emulate [register]
with lodsd
and stosd
, but you wouldn't be able to do atomic read-modify-write operations. That feels like a cheat, though.
There's also the stack (push/pop
): I don't know if a stack+registers machine is Turing-complete, but it certainly isn't programmable in the usual sense. Of course, if you modify e/rsp
, you can again emulate [register]
, but with less choice of operand-size than lodsb/w/d/q
/ stosb/w/d/q
.
x86 has quite a lot of space to store things in registers if you include the 16 ymm registers. Although I can't think of a way to move data between integer registers and the high 128b of a ymm without using either memory or immediate operands (for vextractf128
), so in practice you have more like sixteen 16B vector-register slots for stashing local state other than the stack. Still, it's limited size, which probably means that 8 GP registers in the 32bit 386 ISA vs. all the integer/mmx/ymm registers in the 64bit AVX2 ISA isn't relevant for whether the machine is turing-complete with only push/pop, registers, and no modification of the stack pointer other than by push/pop.
inc
orsub
if you haveadd
. Indirect mode, however, is not easily replaced unless you use self-modifying code. Try to implement pointers without it. – Jester