18.10.1 Istruzioni Byte Code di Python

Attualmente il compilatore Python genera le seguenti istruzioni bytecode.

STOP_CODE: Indica la fine del codice al compilatore, non viene utilizzato dall'interprete.

POP_TOP: Rimuove l'oggetto in cima alla pila (NdT: TOS, in Inglese: top-of-stack).

ROT_TWO: Scambia i 2 oggetti in cima alla pila.

ROT_THREE: Sposta gli oggetti al secondo e terzo posto della pila in alto di una posizione, sposta poi il primo oggetto alla terza posizione nella pila.

ROT_FOUR: Sposta gli oggetti al secondo, terzo e quarto posto della pila in alto di una posizione, sposta poi il primo oggetto alla quarta posizione nella pila.

DUP_TOP: Duplica il riferimento in cima alla pila.

Le operazioni unitarie prendono il primo oggetto della pila, applicano l'operazione e rimettono il risultato nella pila.

UNARY_POSITIVE: Implementa TOS = +TOS.

UNARY_NEGATIVE: Implementa TOS = -TOS.

UNARY_NOT: Implementa TOS = not TOS.

UNARY_CONVERT: Implementa TOS = `TOS`.

UNARY_INVERT: Implementa TOS = ~TOS.

GET_ITER: Implementa TOS = iter(TOS).

Le operazioni binarie rimuovono il primo (TOS) ed il secondo (TOS1) elemento dalla cima della pila. Effettuano l'operazione e rimettono il risultato sulla pila.

BINARY_POWER: Implementa TOS = TOS1 ** TOS.

BINARY_MULTIPLY: Implementa TOS = TOS1 * TOS.

BINARY_DIVIDE: Implementa TOS = TOS1 / TOS quando non è in attivo from __future__ import division.

BINARY_FLOOR_DIVIDE: Implementa TOS = TOS1 // TOS.

BINARY_TRUE_DIVIDE: Implementa TOS = TOS1 / TOS quando non è in attivo from __future__ import division.

BINARY_MODULO: Implementa TOS = TOS1 % TOS.

BINARY_ADD: Implementa TOS = TOS1 + TOS.

BINARY_SUBTRACT: Implementa TOS = TOS1 - TOS.

BINARY_SUBSCR: Implementa TOS = TOS1[TOS].

BINARY_LSHIFT: Implementa TOS = TOS1 << TOS.

BINARY_RSHIFT: Implementa TOS = TOS1 >> TOS.

BINARY_AND: Implementa TOS = TOS1 & TOS.

BINARY_XOR: Implementa TOS = TOS1 ^ TOS.

BINARY_OR: Implementa TOS = TOS1 | TOS.

Le operazioni sul posto sono come le operazioni binarie, in quanto rimuovono TOS e TOS1 e rimettono sulla pila il risultato, ma l'operazione viene fatta sul posto quando TOS1 lo supporta ed il TOS risultante può essere (ma non per forza) il TOS1 originale.

INPLACE_POWER: Implementa l'operazione sul posto TOS = TOS1 ** TOS.

INPLACE_MULTIPLY: Implementa l'operazione sul posto TOS = TOS1 * TOS.

INPLACE_DIVIDE: Implementa l'operazione sul posto TOS = TOS1 / TOS quando non è attivo from __future__ import division.

INPLACE_FLOOR_DIVIDE: Implementa l'operazione sul posto TOS = TOS1 // TOS.

INPLACE_TRUE_DIVIDE: Implementa l'operazione sul posto TOS = TOS1 / TOS quando non è attivo from __future__ import division.

INPLACE_MODULO: Implementa l'operazione sul posto TOS = TOS1 % TOS.

INPLACE_ADD: Implementa l'operazione sul posto TOS = TOS1 + TOS.

INPLACE_SUBTRACT: Implementa l'operazione sul posto TOS = TOS1 - TOS.

INPLACE_LSHIFT: Implementa l'operazione sul posto TOS = TOS1 << TOS.

INPLACE_RSHIFT: Implementa l'operazione sul posto TOS = TOS1 >> TOS.

INPLACE_AND: Implementa l'operazione sul posto TOS = TOS1 & TOS.

INPLACE_XOR: Implementa l'operazione sul posto TOS = TOS1 ^ TOS.

INPLACE_OR: Implementa l'operazione sul posto TOS = TOS1 | TOS.

I codici di operazione di affettamento accettano fino a tre parametri.

SLICE+0: Implementa TOS = TOS[:].

SLICE+1: Implementa TOS = TOS1[TOS:].

SLICE+2: Implementa TOS = TOS1[:TOS].

SLICE+3: Implementa TOS = TOS2[TOS1:TOS].

L'assegnazione delle slice necessita anche di un parametro addizionale. Come ogni istruzione, non mettono nulla sulla pila.

STORE_SLICE+0: Implementa TOS[:] = TOS1.

STORE_SLICE+1: Implementa TOS1[TOS:] = TOS2.

STORE_SLICE+2: Implementa TOS1[:TOS] = TOS2.

STORE_SLICE+3: Implementa TOS2[TOS1:TOS] = TOS3.

DELETE_SLICE+0: Implementa del TOS[:].

DELETE_SLICE+1: Implementa del TOS1[TOS:].

DELETE_SLICE+2: Implementa del TOS1[:TOS].

DELETE_SLICE+3: Implementa del TOS2[TOS1:TOS].

STORE_SUBSCR: Implementa TOS1[TOS] = TOS2.

DELETE_SUBSCR: Implementa del TOS1[TOS].

Codici di operazione vari.

PRINT_EXPR: Implementa l'istruzione di espressione per la modalità interattiva. Il TOS viene rimosso dalla pila e stampato. Nella modalità non interattiva, una dichiarazione di espressione finisce con POP_STACK.

PRINT_ITEM: Stampa il TOS nell'oggetto simile a file alla fine di sys.stdout. C'è un'istruzione del genere per ogni elemento nella dichiarazione print.

PRINT_ITEM_TO: Come PRINT_ITEM, ma stampa il secondo elemento dal TOS verso l'oggetto simile a file in TOS. Questo viene usato dall'istruzione print estesa.

PRINT_NEWLINE: Stampa una nuova riga in sys.stdout. Questa viene generata come ultima operazione di un'istruzione print, a meno che l'istruzione non finisca con una virgola.

PRINT_NEWLINE_TO: Come PRINT_NEWLINE, ma stampa la nuova riga nell'oggetto simile a file sul TOS. Questo viene usato dall'istruzione print estesa.

BREAK_LOOP: Esce da un ciclo a causa di un'istruzione break.

CONTINUE_LOOP target: Continua un ciclo a causa di un'istruzione continue. target è l'indirizzo in cui saltare(il quale dovrebbe essere una istruzione FOR_ITER).

LOAD_LOCALS: Mette un riferimento alle variabili locali dello spazio di visibilità (NdT: scope) corrente sulla pila. Questo viene usato nel codice per una definizione di classe: dopo che il corpo della classe viene valutato le variabili locali vengono passate alla definizione di classe.

RETURN_VALUE: Restituisce con il TOS al chiamante della funzione,

YIELD_VALUE: Rimuove il TOS e lo restituisce da un generatore.

IMPORT_STAR: Carica tutti i simboli che non iniziano con "_" direttamente dal modulo TOS nello spazio dei nomi locale. Il modulo viene rimosso dopo aver caricato tutti i nomi. Questo codice di operazione implementa from module import *.

EXEC_STMT: Implementa exec TOS2,TOS1,TOS. Il compilatore riempie i parametri facoltativi mancanti con None.

POP_BLOCK: Rimuove un blocco dallo pila dei blocchi. Per ogni frame, esiste una pila di blocchi, che indica cicli annidati, istruzioni try ed altro.

END_FINALLY: Termina una clausola finally. L'interprete ricorda se l'eccezione deve essere nuovamente sollevata, o se la funzione deve restituire e continua con il prossimo blocco esterno.

BUILD_CLASS: Crea una nuovo oggetto classe. Il TOS è il dizionario dei metodi, il TOS1 è la tupla dei nomi delle classi base ed il TOS2 il nome della classe.

Tutti i codici di operazione seguenti si aspettano argomenti. Un argomento è di due byte, con l'ultimo byte più significativo.

STORE_NAME namei: Implementa name = TOS. namei è l'indice di name nell'attributo co_names dell'oggetto codice. Il compilatore prova ad usare, se è possibile, STORE_LOCAL o STORE_GLOBAL.

DELETE_NAME namei: Implementa del name, dove namei è l'indice nell'attributo co_names dell'oggetto codice.

UNPACK_SEQUENCE count: Spacchetta TOS in count valori individuali, che vengono inseriti sopra lo stack da destra verso sinistra.

DUP_TOPX count: Duplica count elementi, prendendoli nello stesso ordine. A causa di limiti implementativi, count dovrebbe essere tra 1 e 5 inclusi.

STORE_ATTR namei: Implementa TOS.name = TOS1, dove namei è l'indice di name in co_names.

DELETE_ATTR namei: Implementa del TOS.name, usando namei come indice in co_names.

STORE_GLOBAL namei: Funziona come STORE_NAME, ma registra il nome come globale.

DELETE_GLOBAL namei: Funziona come DELETE_NAME, ma cancella un nome globale.

LOAD_CONST consti: Inserisce "co_consts[consti]" in cima alla pila.

LOAD_NAME namei: Inserisce il valore associato con "co_names[namei]" in cima alla pila.

BUILD_TUPLE count: Crea una tupla consumando count elementi dalla pila ed inserendo la tupla risultante in cima alla pila.

BUILD_LIST count: Funziona come BUILD_TUPLE, ma crea una lista.

BUILD_MAP zero: Inserisce un nuovo oggetto dizionario vuoto in cima alla pila. L'argomento viene ignorato ed impostato a zero dal compilatore.

LOAD_ATTR namei: Sostituisce il TOS con getattr(TOS, co_names[namei]).

COMPARE_OP opname: Svolge un'operazione Booleana. Il nome dell'operazione può essere trovato in cmp_op[opname].

IMPORT_NAME namei: Importa il modulo co_names[namei]. L'oggetto modulo viene inserito in cima alla pila. Lo spazio dei nomi corrente non ne viene influenzato: per una dichiarazione import adeguata, una successiva istruzione STORE_FAST modifica lo spazio dei nomi.

IMPORT_FROM namei: Carica gli attributi co_names[namei] dal modulo trovato in TOS. L'oggetto risultante viene inserito in cima alla pila, per essere successivamente immagazzinato da una istruzione STORE_FAST.

JUMP_FORWARD delta: Incrementa il contatore del bytecode di delta.

JUMP_IF_TRUE delta: Se il TOS è vero, incrementa il contatore del bytecode di delta. Il TOS viene lasciato nella pila.

JUMP_IF_FALSE delta: Se il TOS è falso, incrementa il bytecode di delta. Il TOS non viene modificato.

JUMP_ABSOLUTE target: Imposta il contatore del bytecode a target.

FOR_ITER delta: TOS è un iteratore. Viene chiamato il suo metodo next(). Se questo genera un nuovo valore, lo inserisce sopra la pila (lasciando l'iteratore sotto di esso). Se l'iteratore che lo indica è esaurito il TOS viene rimosso ed il contatore del bytecode viene incrementato di delta.

LOAD_GLOBAL namei: Carica l'attributo globale chiamato co_names[namei] sopra la pila.

SETUP_LOOP delta: Mette un blocco per un ciclo sopra la pila dei blocchi. Il blocco si estende dalla istruzione corrente con la misura di delta byte.

SETUP_EXCEPT delta: Mette un blocco try da una clausola try-except sulla pila dei blocchi. delta punta al primo blocco except.

SETUP_FINALLY delta: Mette un blocco try da una clausola try-except sulla pila dei blocchi. delta punta al blocco finally.

LOAD_FAST var_num: Mette un riferimento al co_varnames[var_num] locale sopra la pila.

STORE_FAST var_num: Immagazzina il TOS nel co_varnames[var_num] locale.

DELETE_FAST var_num: Cancella il co_varnames[var_num] locale.

LOAD_CLOSURE i: Mette un riferimento alla cella contenuta nello slot i della cella e libera la variabile memorizzata. Il nome della variabile è co_cellvars[i] se i è minore della lunghezza di co_cellvars. Altrimenti assume il valore co_freevars[i - len(co_cellvars)].

LOAD_DEREF i: Carica la cella contenuta nello slot i della cella e libera la variabile memorizzata. Inserisce un riferimento per l'oggetto cella contenuto nella pila.

STORE_DEREF i: Immagazzina il TOS nella cella contenuta nello slot i della cella e libera la variabile memorizzata.

SET_LINENO lineno: Questo codice di operazione è obsoleto.

RAISE_VARARGS argc: Solleva un'eccezione. argc indica il numero di parametri per l'istruzione raise, con un intervallo da 0 a 3. Il gestore troverà la traceback come TOS2, il parametro come TOS1, e l'eccezione come TOS.

CALL_FUNCTION argc: Chiama una funzione. Il byte meno significativo di argc indica il numero di parametri posizionali, il byte più significativo il numero dei parametri a parola chiave. Sopra la pila, il codice di operazione trova prima i parametri a parola chiave. Per ogni argomento a parola chiave, il valore si trova all'inizio della chiave. Sotto i parametri a parola chiave, si trovano i parametri posizionali, con in cima il parametro più a destra. Sotto i parametri si trova l'oggetto funzione da chiamare.

MAKE_FUNCTION argc: Mette un nuovo oggetto funzione sopra la pila. TOS è il codice associato con quella funzione. L'oggetto funzione viene definito per avere argc parametri predefiniti, che si trovano sotto il TOS.

MAKE_CLOSURE argc: Crea una nuovo oggetto funzione, imposta il suo slot func_closure e lo mette sopra la pila. TOS è il codice associato con la funzione. Se l'oggetto codice possiede N variabili libere, i prossimi N elementi sulla pila sono le celle per queste variabili. La funzione ha anche argc parametri predefiniti, che si trovano prima delle celle.

BUILD_SLICE argc: Mette un oggetto fetta sopra lo stack. argc deve essere 2 o 3. Se è 2, viene inserito slice(TOS1, TOS); se è 3 viene inserito slice(TOS2, TOS1, TOS). Vedete la funzione built-in slice() per maggiori informazioni.

EXTENDED_ARG ext: Applica un prefisso ad ogni codice di operazione che ha un argomento troppo grande per adattarsi nei due byte predefiniti. ext contiene due byte addizionali che, presi insieme all'argomento seguente del codice di operazione, comprende un argomento a 4 byte, ext rappresenta i due byte più significativi.

CALL_FUNCTION_VAR argc: Chiama una funzione. argc viene interpretato come in CALL_FUNCTION. L'elemento in cima alla pila contiene l'elenco degli argomenti a variabile, seguito dagli argomenti a parola chiave e da quelli posizionali.

CALL_FUNCTION_KW argc: Chiama una funzione. argc viene interpretato come in CALL_FUNCTION. L'elemento in cima alla pila contiene il dizionario degli argomenti a parola chiave seguito dagli argomenti a parola chiave esplicita e da quelli posizionali.

CALL_FUNCTION_VAR_KW argc: Chiama una funzione. argc viene interpretato come in CALL_FUNCTION. L'elemento in cima alla pila contiene il dizionari degli argomenti a parola chiave seguito dalla tupla degli argomenti a variabile, ulteriormente seguito dagli argomenti a parola chiave esplicita e da quelli posizionali.

Vedete Circa questo documento... per informazioni su modifiche e suggerimenti.