IA-32

Con IA-32 (Intel Architecture 32 bit), a volte i386, si definisce l'architettura o l'instruction set dei microprocessori prodotti da Intel, AMD e altre compagnie minori per il mercato desktop a partire dal 1985, e che è presente nella grandissima maggioranza dei personal computer esistenti al mondo. Spesso viene definita un'architettura CISC, ma queste distinzioni stanno sempre più perdendo significato con l'avanzare della tecnologia.

Il termine fu coniato per distinguere il set di istruzioni per le CPU compatibili con il processore Intel 80386 da quelli per serie incompatibili come Itanium. Il set IA-32 viene implementato in tutte le CPU della grande famiglia x86 successive all'80386, ovvero quelle a 32 bit. I programmi che sono utilizzati con uno di questi processori possono girare in modalità protetta, usare memoria maggiore di 640K, disporre di memoria virtuale e ambiente multitasking. Inoltre essi possono accedere ad uno spazio di memoria lineare di circa 4 GB.

L'IA-32 supporta tre modalità di funzionamento: la modalità reale, la modalità protetta e la modalità 8086 virtuale. In modalità protetta i programmi possono sfruttare appieno il processore e tutta la memoria disponibile sulla macchina, mentre in modalità reale e in modalità 8086 virtuale il software ha a disposizione un solo megabyte di RAM e il processore si comporta come un semplice 8086.

La CPU 80386 (e tutti i suoi successori) ha 4 registri ad uso generico a 32 bit e 6 registri di segmento, più il registro dei flag, due registri indice e due registri per la gestione dello stack. A questi registri di uso comune si aggiungono alcuni destinati a compiti particolari: ci sono 4 Control Register, 6 Debug Register e 4 Test Register, oltre naturalmente ai registri descrittori di segmento necessari per l'implementazione dei meccanismi di memoria virtuale. Il coprocessore matematico 80387 aggiungeva al sistema altri 8 registri in virgola mobile. I processori seguenti hanno incorporato il coprocessore matematico e introdotto altri registri per le istruzioni SIMD, come l'MMX, il 3DNow! e l'SSE, ma senza abbandonare mai il gruppo di registri originario del 386.

I registri ad uso generico x86 non sono realmente destinati all'uso generico come indicherebbe la definizione, a causa di alcuni processi specifici che possono spesso essere eseguiti impiegando solo uno o due di questi registri. In altre architetture i registri ad uso generico sono impiegabili in modo assolutamente indistinto, mentre i registri x86 sono suddivisi tra specifici per i dati e specifici per gli indirizzi.

Inoltre molte operazioni possono essere svolte o in un registro o direttamente nella RAM, senza necessità di caricare i dati in un registro. Questo comportamento dimostra i trent'anni di età di quest'architettura.

Nota: con l'arrivo dell'estensione AMD64 all'architettura x86 questa caratteristica è stata eliminata, almeno in modalità a 64 bit: ora i registri ad uso generico sono realmente ad uso generico, senza distinzioni. Questo non influenza comunque l'architettura IA-32.

È inoltre possibile l'accesso ad ulteriori set di registri a 8 e 16 bit. Per esempio, si può accedere ai 16 bit inferiori del registro a 32 bit EAX chiamandoli AX. Alcuni registri a 16 bit possono essere divisi ulteriormente in registri a 8 bit: la metà superiore del registro a 16 bit AX visto sopra è chiamata AH e l'inferiore AL. Allo stesso modo, il registro a 32 bit EBX si divide in BX (16 bit), ulteriormente diviso in BH (8 bit) e BL (8 bit).

Tutti i seguenti registri possono essere impiegati per uso generico, ma anche per processi specializzati; ognuno di essi può essere suddiviso in registri a 16 o 8 bit.

• EAX - accumulatore (specializzato per le istruzioni aritmetiche)
• EBX - base register (usato per indirizzare il dato nel segmento di memoria)
• ECX - contatore (specializzato per i cicli)
• EDX - data register

Usati solo per l'indirizzamento. Possono essere divisi in registri a 16 bit ma non a 8 bit.

• EBP - base pointer (contiene l'indirizzo dello stack frame attualmente impiegato)
• ESI - source index (usato per le stringhe)
• EDI - destination index (usato per le stringhe)
• ESP - stack pointer (contiene il primo indirizzo di uno stack)
• EIP - instruction pointer (contiene l'indirizzo dell'istruzione successiva)

Fin dall'introduzione dell'80486 sono presenti 8 registri x87 in virgola mobile, numerati da ST(0) a ST(7). Ogni registro contiene 80 bit e immagazzina numeri nel formato "precisione doppia estesa" dello standard IEEE 754. A questi registri non si può accedere direttamente, ma come uno stack LIFO. Il numero del registro non è fisso, ma si riferisce alla cima dello stack: ST(0) è il registro in cima allo stack, ST(1) è quello inferiore, ST(2) è ancora inferiore e così via. Questo significa che un dato è sempre spinto verso il basso, e che le operazioni vengono sempre effettuate con l'operando contenuto in cima allo stack: non è possibile accedere ad un dato registro in modo casuale, ma solo in ordine.

I registri di segmento vengono utilizzati dall'80386 per generare un indirizzo lineare da un indirizzo logico. L'indirizzo logico è dato dalla coppia registro di segmento:offset (l'offset può essere una costante, un registro di base, di indice o la combinazione dei tre, con alcune regole/eccezioni). L'indirizzo lineare viene quindi trasformato in indirizzo fisico dal meccanismo di paging del processore. I registri di segmento sono 6:

• CS - code segment (viene implicitamente utilizzato dal processore, in coppia con il registro EIP, per prelevare la prossima istruzione)
• DS - data segment (viene utilizzato, implicitamente, nell'accesso alla memoria da parte di un'istruzione)
• SS - stack segment (utilizzato in coppia con ESP per gestire lo stack)
• ES - extra segment (utilizzato come ulteriore registro per dati, simile al data segment)
• FS - extra segment (segmento extra per i dati, ad uso generico)
• GS - extra segment (segmento extra per i dati, ad uso generico)

Nota: I registri FS e GS furono aggiunti nell'80386 (nei processori precedenti non erano presenti) e il loro nome è una semplice continuazione dell'alfabeto dalla E di ES.

Nota: Quando si vuole far riferimento ad un indirizzo di memoria nell'architettura IA-32, viene utilizzata la forma <SEGMENTO>:<OFFSET>. Il segmento è espresso mediante uno dei 6 registri di segmento (anche se in alcuni casi è possibile esprimerlo con un valore costante) mentre l'offset indica lo scostamento all'interno del segmento. Le istruzioni, ad esempio, vengono sempre prelevate nella memoria all'indirizzo puntato dalla coppia CS:EIP.

L'80386 dispone di un registro dei flags, chiamato EFLAG. Sebbene non sia direttamente accedibile mediante un nome (come EAX, ad esempio) è possibile in qualche modo leggerlo e scriverlo. Sono necessarie solo un paio di istruzioni:

 /* Lettura dello stato del registro dei flags */
 PUSHFD       ;Salva lo stato dei flags nello stack
 POP EAX      ;Estrae dallo stack e salva in EAX (o qualunque altro registro generale)

Per modificare, invece, lo stato dei flags sono necessarie le seguenti due istruzioni:

 /* Modifica dello stato dei flags */
 PUSH EAX     ;Salva il registro EAX sullo stack (o qualunque altro registro generale)
 POPFD        ;Estrae dallo stack e memorizza nel registro dei flags

Le istruzioni precedenti salvano e ripristinano lo stato di EFLAG (versione a 32-bit dei flags dell'80386). È possibile salvare/ripristinare solo i 16 bit meno significativi utilizzando PUSHF/POP AX e PUSH AX/POPF rispettivamente. La dimensione (16 o 32 bit) utilizzata dipende dalla dimensione dell'operando. Il prefisso di forzatura operando (op-code 0x66) permette di variare la dimensione all'interno del contesto corrente: se utilizzato in modo 16-bit farà trattare al microprocessore l'istruzione come a 32-bit e viceversa.

Il registro dei flags è un registro a 16 bit dove ad alcuni bit (o raggruppamento di essi) è assegnato un significato preciso ed indica lo stato del processore. Se il bit è posto ad 1 il flag è impostato (set), se posto a 0 si dice che è resettato (reset o clear).

I numeri indicano la posizione in bit le sigle indicano il nome simbolico del flag.

31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	09	08	07	06	05	04	03	02	01	00
														V8	RF		NT	PL	PL	OF	DF	IF	TF	SF	ZF		AF		PF		CF

Significato dei flags:

• V8 - Virtual 86 mode (se impostato indica che si è in modalità Virtual-8086)
• RF - Resume Flag (se impostato abilita le eccezioni in modo debug)
• NT - Nested Task Flag (se impostato indica che il codice in esecuzione non deve essere interrotto dal multi-tasking in quanto routine di un servizio di interrupt)
• PL - Priviledged Level Flag (2 bits) (se impostato permette di eseguire istruzioni di I/O, in caso è resettato, l'esecuzione di istruzioni di I/O genera un'eccezione di protezione).
• OF - Overflow Flag (se impostato indica che l'ultima operazione aritmetica ha generato un overflow)
• DF - Direction Flag (indica alla cpu quale direzione utilizzare negli incrementi automatici delle istruzioni che operano su stringhe.
• IF - Interrupt Flag (se impostato indica alla cpu di rispondere agli interrupt. L'NMI-Non Maskable Interrupt non viene influenzato da questo flag)
• TF - Trap Flag (se impostato indica alla cpu di generare una INT 0 dopo ogni istruzione)
• SF - Sign Flag (se impostato indica che l'ultima istruzione aritmetica ha generato un numero negativo).
• ZF - Zero Flag (se impostato indica che l'ultima operazione logico/aritmetica ha generato uno 0)
• AF - Auxiliary Carry Flag (se impostato indica che l'ultima operazione aritmetica ha generato un riporto sui 4 bit inferiori di AL, usato nell'aritmetica BCD)
• PF - Parity Flag (se impostato indica che l'ultima operazione aritmetica ha generato un risultato formato da un numero dispari di bit posti ad 1)
• CF - Carry Flag (se impostato indica che l'ultima operazione aritmetica ha generato un riporto)

I restanti bit non sono utilizzati e vengono riservati ad uso futuro; il loro valore non dovrebbe essere modificato e, se letto, non dovrebbe essere preso in considerazione.

Gli instruction set MMX, 3DNow!, e SSE possiedono propri registri, in aggiunta a quelli standard IA-32.

L'MMX possiede 8 registri, chiamati da MM0 a MM7 (da qui in poi MMn), che però sono fisicamente gli stessi registri x87 per il calcolo in virgola mobile della FPU, per cui è impossibile usare contemporaneamente le istruzioni MMX e quelle in virgola mobile: prima di usare il set di istruzioni MMX deve essere disabilitata la FPU, con una istruzione apposita.

Ognuno dei registri MMn contiene un intero a 64 bit, ma una delle caratteristiche fondamentali di questo instruction set è il concetto di vettore, formato da più dati simili tra loro: potevano quindi essere immagazzinate due parole di 32 bit l'una, quattro di 16 o otto di 8.

Sempre perché i registri MMn sono in "coabitazione fisica" con i registri x87, che contengono 80 bit l'uno, nell'esecuzione delle MMX i primi 16 bit del registro vanno sprecati: vengono quindi tutti impostati a 1, in modo che i dati presenti vengano riconosciuti come "NaN" o come infiniti da un'applicazione in virgola mobile, e rendendo facile riconoscere se vengano usati dati in virgola mobile o MMX.

Il 3DNow! fu progettato come un'estensione naturale delle istruzioni MMX per il calcolo in virgola mobile; usa quindi le stesse denominazioni dei registri MMn, ma invece di immagazzinarvi parole di 64 bit, vi introduce numeri in virgola mobile a precisione singola.

Il vantaggio di usare i registri x87 anche in questo caso è che essi sono già dedicati al calcolo in virgola mobile, e quindi le istruzioni x87 possono essere usate per compiere le operazioni analoghe di salvataggio dei registri anche nel codice 3DNow!: ne consegue che non sono richieste modifiche al sistema operativo per usare questa tecnologia.

Con l'SSE le istruzioni SIMD furono rese completamente indipendenti dai registri x87. Ma questo significò anche allontanarsi definitivamente dagli altri instruction set SIMD, come MMX; sforzo giustificato dalla possibilità di usare registri più grandi, liberi dai limiti della virgola mobile. Furono creati otto registri a 128 bit, chiamati da XMM0 a XMM7 (nota: nell'architettura AMD64 i registri sono stati aumentati a 16).

Lo svantaggio consiste nel dover inserire nel sistema operativo il nuovo set di istruzioni. Intel creò quindi una nuova versione della modalità protetta, chiamata "Enhanced mode", che permette l'utilizzo delle istruzioni SSE, disabilitate nella normale modalità protetta: un sistema operativo che include le istruzioni SSE accede alla nuova modalità, mentre uno più vecchio o che comunque non le includa tenterà l'accesso solo alla normale modalità protetta.

L'SSE è un instruction set che opera solo su dati in virgola mobile, come 3DNow!, ma a differenza di questo non usa i registri stack della FPU ma un proprio set di registri separato, in grado di contenere il doppio di numeri a precisione singola. Mentre il primo SSE era limitato ai numeri a precisione singola, con l'SSE2 fu possibile trattare anche numeri a precisione doppia. Per il 3DNow! questo non era possibile, dato che un unico numero in questa precisione occuperebbe l'intero registro a 64 bit, mentre i registri XMMn sono a 128 bit: l'SSE2 è quindi molto più adatto ad applicazioni scientifiche rispetto ai due predecessori.

• Le estensioni MMX furono il primo grande aggiornamento: erano istruzioni SIMD adatte solo per il calcolo intero. Esse furono introdotte insieme da Intel e AMD nei propri Pentium MMX e K6 nel 1997. Condivideva i registri con la FPU x87, così il sistema operativo non doveva essere modificato per adoperare queste istruzioni se supportava il salvataggio dello stato x87.
• L'MMX fu aggiornato con le estensioni 3DNow!, che supportavano la virgola mobile, da parte di AMD nel 1999 col K6-2. Anche queste sfruttavano i registri x87. Intel non considerò mai questa tecnologia.
• Intel introdusse le istruzioni SSE, con supporto per dati in virgola mobile a precisione singola, col processore Pentium III nel 1999. A differenza del 3DNow!, non erano un'estensione delle MMX e non sfruttavano i registri della FPU x87, e richiedevano modifiche al sistema operativo per essere sfruttate, ma erano libere dalle limitazioni imposte dai registri x87. Queste istruzioni e le sue successive estensioni furono adottate anche da AMD a partire dagli Athlon XP, e questa non sviluppò ulteriormente il 3DNow!.
• L'SSE2 fu introdotto col Pentium 4 all'inizio del 2001; costituiva un ulteriore miglioramento delle SSE, con l'aggiunta del supporto per i numeri a precisione doppia.
• L'SSE3, introdotto col Pentium 4 Prescott nel 2004, forniva aggiunte secondarie alle SSE2.

La struttura di una generica istruzione IA-32 è variabile a seconda dello specifico opcode, e può essere preceduta da dei prefissi (fino a quattro) che ne modificano il comportamento: una descrizione generale è data nella tabella qui sotto.

Prefissi				Istruzione
Istruzione	Dimensione operando	Dimensione indirizzo	sostituzione segmento	Opcode	Mode R/M	SIB	Spostamento	Immediato
1 byte	1 byte	1 byte	1 byte	1 o 2 byte	1 byte	1 byte	1, 2 o 4 byte	1, 2 o 4 byte
Opz.	Opz.	Opz.	Opz.	OBBLIGATORIO	Opz.	Opz.	Opz.	Opz.

Il byte Mode R/M specifica ulteriormente l'operando dell'istruzione e può contenere un supplemento di opcode, mentre il byte SIB (Scale Index Base) specifica sempre un registro a 32 bit (EAX, EBX ecc.) ed è caratteristico dei processori IA-32.

Byte Mode R/M
Mode	Reg/Opcode	R/M
2 bit	3 bit	3 bit

Byte SIB
Scale	Index	Base
2 bit	3 bit	3 bit

Nella tabella seguente sono elencate le istruzioni IA-32, organizzate per ordine alfabetico in base al loro codice mnemonico assembly. Vengono riportati anche gli opcodes esadecimali e, in cicli di clock, i tempi di esecuzione per un 80386. Se al posto dell'opcode c'è un asterisco è perché l'istruzione ha molti opcode diversi a seconda delle varie forme; anche i tempi di esecuzione sono variabili a seconda dello stato in cui si trova il processore: in modo protetto molti accessi alla memoria "costano" cicli di clock in più, e un eventuale context switch può alzare di molto i tempi. I flag impostati a valori predefiniti sono contrassegnati con il valore 0 o 1 che assumono; se vengono modificati in accordo con il risultato dell'operazione sono contrassegnati con un asterisco; se vengono modificati, ma in modo non definito sono contrassegnati con un punto interrogativo.

Assembly	Opcode (esadecimale)	Cicli di clock	Flag modificati	Descrizione
AAA	37	4	oditszapc ?  ??*?*	Regolazione ASCII dopo l'addizione (per aritmetica BCD)
AAD	D5 0A	19	oditszapc ?  ??*?*	Regolazione ASCII prima della divisione (per aritmetica BCD)
AAM	D4 0A	17	oditszapc ?  ??*?*	Regolazione ASCII dopo la moltiplicazione (per aritmetica BCD)
AAS	3F	4	oditszapc ?  ??*?*	Regolazione ASCII dopo la sottrazione (per aritmetica BCD)
ADC	*	2-7	oditszapc * *****	Somma con carry.
ADD	*	2-7	oditszapc * *****	Somma.
AND	*	2-7	oditszapc 0 **?*0	Esegue l'AND logico bit a bit fra i due operandi, di cui uno può essere implicitamente il registro AL/AX/EAX.
ARPL	63	21	oditszapc *	Regolazione del campo RPL del selettore di segmento. Si usa nei sistemi operativi, per assicurarsi che un programma non chiami una subroutine che abbia un privilegio superiore a quello del programma stesso.
BOUND	62	10	oditszapc	Controlla che l'operando sia entro determinati limiti. Serve ad evitare di indirizzare per errore zone al di fuori di un array: di solito, per motivi di efficienza, si usa soltanto nelle versioni di debug di un programma.
BSF	0F BC	*	oditszapc *	Scansione in avanti dei bit dell'operando.
BSR	0F BD	*	oditszapc *	Scansione all'indietro dei bit dell'operando.
BT	*	3-12	oditszapc *	Test del bit specificato dell'operando
BTC	*	6-13	oditszapc *	Test del bit specificato dell'operando e sua negazione
BTR	*	6-13	oditszapc *	Test del bit specificato dell'operando e sua impostazione a 0
BTS	*	6-13	oditszapc *	Test del bit specificato dell'operando e sua impostazione a 1
CALL	*	7-98+	oditszapc tutti	Chiamata di procedura o subroutine
CBW	98	3	oditszapc	Conversione da byte a word
CDQ	99	2	oditszapc	Conversione da doubleword a quadword
CLC	F8	2	oditszapc 0	Azzeramento del flag di Carry
CLD	FC	2	oditszapc 0	Azzeramento del flag di Direzione
CLI	FA	3	oditszapc 0	Azzeramento del flag di Interrupt
CLTS	0F 06	5	oditszapc (nota 1)	Azzeramento del flag di cambio task (TS) nel registro speciale CR0
CMC	F5	2	oditszapc *	Negazione del flag di Carry
CMP	*	2-6	oditszapc * *****	Confronto fra due operandi
CMPS*	*	10	oditszapc * *****	Confronto fra due stringhe di memoria i cui indirizzi relativi sono memorizzati nei registri indice SI (o ESI) e DI (o EDI): entrambi i registri vengono decrementati di uno. A seconda se si devono considerare byte, word o doubleword sono disponibili le varianti CMPS, CMPSB, CMPSW e CMPSD. Molto spesso questa istruzione viene usata con prefissi REP* in modo da confrontare automaticamente intere zone di memoria.
CWD	99	2	oditszapc	Conversione da word a doubleword
CWDE	98	2	oditszapc	Conversione da word a doubleword
DAA	27	4	oditszapc ? *****	Regolazione decimale dopo l'addizione (per aritmetica BCD)
DAS	2F	4	oditszapc ? *****	Regolazione decimale dopo la sottrazione (per aritmetica BCD)
DEC	*	2-6	oditszapc * ****	Decrementa di uno l'operando specificato
DIV	*	38-41	oditszapc ?  ?????	Divisione senza segno.
ENTER	*	10-	oditszapc	Creazione dello stack frame necessario per le chiamate di procedura dei linguaggi ad alto livello.
HLT	F4	5	oditszapc	Ferma il processore. Dopo un HLT non vengono eseguite nuove istruzioni finché non si verifica un interrupt o un reset: in caso di interrupt, dopo la routine di servizio il processore riprende l'esecuzione dall'istruzione successiva alla HLT. Di solito si usa questa istruzione a fini di sincronizzazione o di risparmio energetico.
IDIV	*	19-43	oditszapc ?  ?????	Divisione con segno.
IMUL	*	9-41	oditszapc *  ????*	Moltiplicazione con segno
IN	*	12+	oditszapc	Lettura di un byte o di una word dalla porta di I/O specificata nell'operando.
INC	*	2-6	oditszapc * ****	Incrementa l'operando di uno.
INS*	*	15-29	oditszapc	Lettura di un byte o di una word dalla porta di I/O specificata nella stringa specificata dal registro indice DI (o EDI). Si usa spesso con prefissi REP* per leggere automaticamente interi vettori di dati.
INT	*	33-119	oditszapc 00	Interrompe l'esecuzione corrente ed esegue la subroutine di interrupt specificata dall'operando.
INTO	CE	59-119	oditszapc	Interrompe l'esecuzione corrente ed esegue la subroutine di interrupt dedicata agli overflow. È sinonimo di INT 4.
IRET/IRETD	CF	22-82	oditszapc TUTTI	Ritorno da una subroutine di interrupt.
Jcc	*	7+	oditszapc	Salto condizionato. Il salto all'indirizzo specificato viene eseguito solo se determinati flag hanno un determinato valore: altrimenti l'esecuzione continua normalmente con l'istruzione successiva. Esistono numerosi tipi di salti condizionati.
JMP	*	7-49+	oditszapc	Salto ad altra locazione. L'esecuzione del programma continua a partire dalla locazione indicata dall'argomento del salto: se l'argomento non dovesse puntare ad una istruzione valida, viene generata una eccezione e il programma si ferma.
LAHF	9F	2	oditszapc	Copia il registro dei flag nel registro AH
LAR	0F 02	16	oditszapc *	Carica il byte dei diritti di accesso nel descrittore di segmento. Questa istruzione serve ad impostare i privilegi di un determinato segmento: è una istruzione privilegiata e viene usata solo dal sistema operativo.
LEA	8D	2	oditszapc	Caricamento dell'offset dell'indirizzo effettivo.
LEAVE	C9	4	oditszapc	Uscita da una procedura di un linguaggio ad alto livello: è l'istruzione simmetrica di ENTER e provvede a distruggere lo stack frame della procedura terminata.
LGDT	0F 01 /2	11	oditszapc	Caricamento del registro della tabella dei descrittori globali dei segmenti: questa istruzione è usata soltanto dai sistemi operativi, un programma utente non ha nessun motivo di usarla.
LIDT	0F 01 /3	11	oditszapc	Caricamento del registro della tabella degli interrupt. Questa operazione viene fatta una volta per tutte all'avvio dal sistema operativo.
L*S	*	7-25	oditszapc	Caricamento di un puntatore completo segmento: offset. Le varie forme dell'istruzione (LGS, LFS, LDS, LES, LSS) specificano quale registro di segmento conterrà la parte segmento del puntatore.
LLDT	0F 00 /2	20	oditszapc	Caricamento del registro della tabella del descrittore locale. Come tutte le istruzioni sui descrittori di segmento, anche questa è usata solo dai sistemi operativi.
LMSW	0F 01 /6	10-13	oditszapc	Caricamento della parola di stato della macchina (Machine Status Word)
LODS*	*	5	oditszapc	Caricamento di un operando stringa. L'operando puntato dal registro SI (o ESI) viene caricato in AL/AX/EAX, a seconda di quale versione dell'istruzione viene usata (LODS, LODSB, LODSW, LODSD)
LOOP*	*	11+	oditszapc	Salto condizionato in base al valore del registro CX/ECX. Dopo il salto, CX/ECX viene decrementato di uno: quando il registro è zero, il salto non viene più eseguito.
LSL	0F 03	20-26	oditszapc *	Carica il limite del segmento nel relativo descrittore, specificato nell'operando. È di esclusivo uso del sistema operativo.
LTR	0F 00 /3		oditszapc	Carica il registro del task con il registro o locazione di memoria specificata dall'operando. Anche questa istruzione è privilegiata e usata soltanto dai sistemi operativi.
MOV	*	2-4	oditszapc	Copia il secondo operando nel primo.
MOVS*	*	7	oditszapc	Copia il valore corrente in una certa posizione di una stringa nella corrispondente posizione della seconda. Si usa spesso con prefissi REP*.
MOVSX	0F BE	3-6	oditszapc	Copia il secondo operando nel primo e ne estende il segno.
MOVZX	*	3-6	oditszapc	Copia il secondo operando nel primo e azzera il resto del primo operando.
MUL	*	9-41	oditszapc *  ????*	Moltiplicazione senza segno di AL o AX
NEG	*	2-6	oditszapc * *****	Negazione dell'operando in complemento a due
NOP	90	3	oditszapc	Nessuna operazione. Sinonimo di XCHG AX, AX (vedi).
NOT	*	2-6	oditszapc	Negazione logica dell'operando
OR	*	2-7	oditszapc 0 **?*0	Or logico inclusivo di due operandi.
OUT	*	10-25	oditszapc	Scrittura di un byte o di una word nella porta di I/O specificata dall'operando.
OUTS*	*	8-28	oditszapc	Scrittura di un byte o di una word di una stringa nella porta di I/O specificata dall'operando.
POP*	*	5-24	oditszapc *********	Caricamento dallo stack di alcuni registri. Il valore del puntatore alla cima dello stack, lo Stack Pointer SP, viene decrementato di tante unità quanti byte sono stati letti.
PUSH*	*	2-18	oditszapc	Scrittura nello stack di alcuni registri. Il valore del puntatore alla cima dello stack, lo Stack Pointer SP, viene decrementato di tante unità quanti byte sono stati scritti.
RCL	*	9-10	oditszapc * *	Rotazione a sinistra dell'operando con carry: tutti i bit dell'operando vengono spostati di una posizione a sinistra e in quella rimasta libera viene copiato il valore del flag di carry, che assume il valore del bit uscito da destra.
RCR	*	9-10	oditszapc * *	Rotazione a destra dell'operando con carry: tutti i bit dell'operando vengono spostati di una posizione a destra e in quella rimasta libera viene copiato il valore del flag di carry, che assume il valore del bit uscito da sinistra.
RET	*	10-68	oditszapc	Ritorno da una subroutine o da una procedura a basso livello.
ROL	*	3-7	oditszapc * *	Rotazione a sinistra dell'operando: tutti i bit dell'operando vengono spostati di una posizione a sinistra e quello uscito all'estrema sinistra viene copiato nella posizione liberatasi a destra.
ROR	*	3-7	oditszapc * *	Rotazione a destra dell'operando: tutti i bit dell'operando vengono spostati di una posizione a destra e quello uscito all'estrema destra viene copiato nella posizione liberatasi a sinistra.
SAHF	9E	3	oditszapc *********	Scrittura del contenuto di AH nel registro dei flag.
SAL	*	3-7	oditszapc * **?**	Spostamento dei bit dell'operando N volte a sinistra: i bit fuoriusciti da sinistra vengono persi. Se nessun bit viene perso, questa operazione equivale ad una moltiplicazione per 2N.
SAR	*	3-7	oditszapc * **?**	Spostamento dei bit dell'operando N volte a destra: i bit fuoriusciti da destra vengono persi. Questa operazione equivale ad una divisione per 2N senza resto.
SBB	*	2-7	oditszapc * *****	Sottrazione intera con riporto.
SCAS*	*	7	oditszapc * *****	Confronto di stringhe. Le posizioni di memoria puntate dai registri SI e DI (o ESI ed EDI) vengono confrontate e i due registri incrementati/decrementati di uno a seconda del valore del flag D. Questa istruzione si usa spesso con prefissi REP*.
SETcc	*	4-5	oditszapc	Impostazione del byte in base alla condizione specificata. In modo analogo alle istruzioni Jcc, se i valori dei flag sono quelli imposti dalla particolare versione di SETcc usata, nel byte operando viene scritto il valore 1.
SGDT	0F 01 /0	9	oditszapc	Memorizzazione della tabella del descrittore globale. Ad esclusivo uso e consumo dei sistemi operativi.
SHL	*	3-7	oditszapc * **?**	Spostamento a sinistra dei bit dell'operando: il bit fuoriuscito da sinistra è perso. Se era zero, l'operazione equivale ad una moltiplicazione per 2.
SHLD	*	3-7	oditszapc ? **?**	Spostamento a sinistra dei bit dell'operando in doppia precisione. Come SHL, ma coinvolge anche un secondo registro, concatenato al primo.
SHR	*	3-7	oditszapc * **?**	Spostamento a destra dei bit dell'operando: il bit fuoriuscito da destra è perso. L'operazione equivale ad una divisione per 2 senza resto.
SIDT	0F 01 /1	9	oditszapc	Memorizzazione della tabella degli interrupt in modalità protetta. Ad esclusivo uso e consumo dei sistemi operativi.
SHRD	*	3-7	oditszapc ? **?**	Spostamento a destra dei bit dell'operando in doppia precisione. Come SHR, ma coinvolge anche un secondo registro, concatenato al primo.
SLDT	0F 00 /0	2	oditszapc	Carica il registro della tabella del descrittore locale. Usata soltanto nei sistemi operativi.
SMSW	0F 01 /4	2-3	oditszapc	Memorizzazione della parola di stato della macchina (Machine Status Word)
STC	F9	2	oditszapc 1	Imposta a uno il flag di Carry
STD	FD	2	oditszapc 1	Imposta a uno il flag di Direzione
STI	FB	3	oditszapc 1	Imposta a uno il flag di Interrupt
STOS*	*	4	oditszapc	Memorizza il valore di AL/AX/EAX nella posizione di una stringa puntata da DI (o EDI). Dopodiché il valore di (E)DI viene incrementato/decrementato a seconda del valore del flag D.
STR	0F 00 /1	23-27	oditszapc	Memorizza il registro dei task. Utile solo ai sistemi operativi.
SUB	*	2-7	oditszapc * *****	Sottrazione intera.
TEST	*	2-5	oditszapc 0 **?*0	Confronto logico non distruttivo di due operandi. Viene eseguito l'AND logico fra i due, ma il risultato non viene memorizzato: vengono modificati soltanto i flag.
VERR	0F 00 /4	10-11	oditszapc *	Verifica di accesso in lettura di un segmento: se sì, il flag Zero viene posto a 1, altrimenti viene azzerato.
VERW	0F 00 /5	15-16	oditszapc *	Verifica di accesso in scrittura di un segmento: se sì, il flag Zero viene posto a 1, altrimenti viene azzerato.
WAIT	9B	6	oditszapc	Il processore si ferma finché il segnale esterno BUSY# (proveniente dal coprocessore matematico) non si disattiva: si usa per sincronizzare i calcoli del coprocessore con quelli della CPU principale.
XCHG	*	3-5	oditszapc	Scambia i valori dei due operandi.
XLAT/XLATB	D7	5	oditszapc	Trasformazione con tabella di consultazione. Il valore corrente di AL viene sostituito con quello nella cella di memoria della tabella puntata da DS:BX + AL stesso.
XOR	*	2-7	oditszapc 0 **?*0	OR logico esclusivo fra due operandi.

Questo è il set completo di istruzioni del processore 80386. La nuova architettura Intel IA-64 non è direttamente compatibile con le istruzioni IA-32.

• x86 - Famiglia di processori Intel
• AMD64 - Architettura a 64 bit di AMD
• IA-64 - Architettura a 64 bit di Intel per processori Itanium
• EM64T - Architettura a 64 bit di Intel per processori x86

• (EN) Denis Howe, IA32, in Free On-line Dictionary of Computing. Disponibile con licenza GFDL