IA-32

Da Wikipedia, l'enciclopedia libera.

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.

Storia[modifica | modifica sorgente]

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.

Modalità di operazione dei processori IA-32[modifica | modifica sorgente]

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.

Registri[modifica | modifica sorgente]

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.

Registri ad uso generico[modifica | modifica sorgente]

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.

Registri a 8 e 16 bit[modifica | modifica sorgente]

È 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).

Registri generici dei dati[modifica | modifica sorgente]

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

Registri generici degli indirizzi[modifica | modifica sorgente]

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)

Registri stack per la virgola mobile[modifica | modifica sorgente]

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.

Registri di segmento[modifica | modifica sorgente]

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.

Registro dei flag[modifica | modifica sorgente]

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.

Registri SIMD[modifica | modifica sorgente]

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

Registri MMX[modifica | modifica sorgente]

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.

Registri 3DNow![modifica | modifica sorgente]

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.

Registri SSE[modifica | modifica sorgente]

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.

Set di istruzioni aggiuntivi SIMD[modifica | modifica sorgente]

  • 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.

Formato delle istruzioni IA-32[modifica | modifica sorgente]

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 Assembler. Vengono riportati anche gli opcpdes 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.

Assembler 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.

Voci correlate[modifica | modifica sorgente]

  • 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
informatica Portale Informatica: accedi alle voci di Wikipedia che trattano di informatica