A legtöbb regiszter kiterjesztett, azaz van "e"-s változata [eax,ebx,ecx,edx,eip,esp,ebp] , kivétel a szegmensregiszterek, ezekből azonban van plusz 2 darab fs és gs . Ezeket ugyanúgy lehet használni, mint ds-t vagy es-t.
Kibővítették az általános cimzésmódokat:- Indirekt cimzés bázisregiszterrel :

    mov al,[ebx]            ;al  = ds:[ebx]     mov ax,[edx]            ;ax  = ds:[edx]     mov eax,[ecx]           ;eax = ds:[ecx]
- Indirekt cimzés bázis és indexregiszterrel.Ekkor a két regiszter összege adja a címet.
    mov  al,[ebx+edx]       ;al  = ds:[ebx+edx]     mov  ax,[ecx+eax]       ;ax  = ds:[ecx+eax]     mov eax,[edx+edx]       ;eax = ds:[edx+edx]                             ;lehet mindkettő u.a.
- Indirekt cimzés bázis és idexregiszterrel, eltolással.Ekkor a két regiszter összegéhez hozzáadhatunk egy állandó értéket.
    mov  al,[ebx+edx+144]       ;al  = ds:[ebx+edx+144]     mov  ax,[ecx+eax+16209]     ;ax  = ds:[ecx+eax+16209]     mov eax,[edx+edx+1542]      ;eax = ds:[edx+edx+1542]
Ha az offset -128..127 között van, akkor 8 bites értékként értelmezi a proci, függetlenül attól, hogy 16 vagy 32bites regisztereket használunk.

Ha az offset -32768..32767 között van, de a -128..127 tartományból kiesett, akkor 16 bites értékként értelmezi a proci, hiába használunk 32bites.

Ha 32bites cimzést szeretnénk használni, és az offset kiesik a -128..127-es tartományból, akkor 32bites értékként értelmezi a proci. Az offsetnek azonban a -2^31..2^31-1 tartományba kell esnie.
- Skálázás:Egy indexregisztert a []-n belül meg lehet szorozni 2/4/8-cal. Pl. : mov eax,[edx+ecx*4]

Még egy nagyon fontos utasítás van, ez pedig a LEA, mely segítségével egyszerű műveleteket gyorsan lehet elvégezni. Pl.:

    lea  eax,[ebx+ecx]          ; eax=ebx+ecx     lea  eax,[ebx*4+ecx]        ; eax=ebx*4+eax     lea  eax,[eax*2+eax]        ; eax=eax*3     lea  eax,[ebx+ecx-100]      ; eax=ebx+ecx-100
Tehát egyszerűen és gyorsan tudunk regisztereket összeadni, s 2,3,4,5,8,9-cel szorozni.

Még egy ügyes kis csel, amit gyakran kell használni, mégpedig a tört számok kezelésében. Ez úgy történik, hogy felszorozzuk a törtet kettő hatványával, számolunk vele, majd ha az egészrészre vagyunk kiváncsiak, akkor leosztjuk kettő hatványával, amivel felszoroztuk. Egy rövid pseudo-code:

  a=1; b=10; lepes=3;            ( 3 lépésben szeretnénk 1-ből                                    10-be jutni !)   x=a*65536;                     ( Ez a kezdőszám, felszorozva                                    2 hatványával )   osztott=(b-a)*65536 div lepes; ( "a"-ból szeretnénk "b"-be                                     eljutni lepes lépésben )   for i:=1 to lepes do {                        x=x+osztott;                        writeln(x div 65536);                        }
Remélem eddig elég érthető. Akkor ezt meg lehet asm-ban is írni :
a               dw  1 b               dw 10 osztott         dd  ? x               dd  ? lepes           dw  3         xor     eax,eax         mov     ax,[a]         shl     eax,16                 ; felszorozzuk a-t         mov     [x],eax         movsx   eax,[a]         movsx   ebx,[b]         sal     eax,16         cdq         idiv    ebx         mov     [osztott],eax          ; kiszámoljuk az                                        ; osztott-at         mov     cx,[lepes]         mov     ebp,[x] @ciklus:         add     ebp,[osztott]         mov     ebx,ebp         sar     ebx,16                 ; EBX-ben van az aktuális                                        ; tört egészrésze         loop    @ciklus