x86-32 Assembly - SIB med index 4

Min fråga är vad syftet med att man kan ha ett värde på 4 i index fieldet i ett SIB-byte med 32-bitarsstil. Det står ju att index*scale skippas! Vad är syftet med detta?

Tack på förhand

Jag är inte helt säker på min sak, men det här är vad jag antar efter några minuters kikande i Intels manualer:

Eftersom R/M-delen i en ModR/M-byte endast kan innehålla 8 olika värden och det finns åtta register man kan använda men samtidigt måste R/M kunna visa att en SIB-byte kommer efter (då MOD != 11B), kan man inte använda [esp] i R/M utan bara i en SIB-byte. Vill man då använda [esp] utan något index finns bara möjligheten att använda en SIB-byte med Index 100B (None).

Det är uppenbart att det blir en del redundans, eftersom alla instruktioner med ModR/M-byte som inte vill använda [esp] i R/M kan uttryckas på två olika sätt. (ebp är dock ett specialfall)

T.ex. "mov eax, [eax]" kan uttryckas som både
0x8b (mov r32,r/m32) 0x00 (REG = eax, MOD = 00B, R/M = eax)
och
0x8b (mov r32,r/m32) 0x04 (REG = eax, MOD = 00B, R/M = SIB) 0x20 (SS = 00B, Index = None, Base = eax)

Medan "mov eax, [esp]" bara kan uttryckas som
0x8b (mov r32,r/m32) 0x04 (REG = eax, MOD = 00B, R/M = SIB) 0x24 (SS = 00B, Index = None, Base = esp)

Eftersom Index i SIB har ett värde för att uttrycka att inget index ska användas är det även där ett register som försvinner; esp igen. Dock är det nog ganska ovanligt att vilja använda instruktioner som "mov eax, [ecx+esp*4]", där esp är index. Men instruktioner där [esp] används som R/M är ganska vanliga vid manipulering av stacken.

(Jag kan ha varit överdrivet utförlig i hopp om att även de som inte kan detaljerna i uppbyggnaden av x86-instruktioner kan lära sig något)

Tack för svaret.
Då kan man säga att t.ex
mov eax [eax] kan kodas på 16 olika sätt?

8B 00 mov eax, [eax]
8B 40 00 mov eax, [eax+0] (disp8)
8B 80 00 00 00 00 mov eax, [eax+0] (disp32)
8B 04 05 00 00 00 00 mov eax, [eax*1+0] (disp32)
8B 04 20 mov eax, [eax+none*1]
8B 04 60 mov eax, [eax+none*2]
8B 04 A0 mov eax, [eax+none*4]
8B 04 E0 mov eax, [eax+none*8]
8B 44 20 00 mov eax, [eax+none*1+0] (disp8)
8B 44 60 00 mov eax, [eax+none*2+0] (disp8)
8B 44 A0 00 mov eax, [eax+none*4+0] (disp8)
8B 44 E0 00 mov eax, [eax+none*8+0] (disp8)
8B 84 20 00 00 00 00 mov eax, [eax+none*1+0] (disp32)
8B 84 60 00 00 00 00 mov eax, [eax+none*2+0] (disp32)
8B 84 A0 00 00 00 00 mov eax, [eax+none*4+0] (disp32)
8B 84 E0 00 00 00 00 mov eax, [eax+none*8+0] (disp32)

Inte för att jag är jättefamiljär med Intels nyare adresseringsmetoder, men är det inte meningen att man skall använda denna typ för lookup tables?

Typ - Basadress * Tabell

Ungefär som kan göra med egna LPT's på 68K?