Questa pagina è stata tradotta dall'API Cloud Translation.

Formato bytecode Dalvik

Design generale

Il modello di macchina e le convenzioni di chiamata hanno lo scopo di imitare approssimativamente le architetture reali comuni e le convenzioni di chiamata in stile C:
- La macchina è basata su registri e le dimensioni dei frame sono fisse al momento della creazione. Ogni frame è costituito da un determinato numero di registri (specificati dal metodo) e da eventuali dati aggiuntivi necessari per l'esecuzione del metodo, come (a titolo esemplificativo) il contatore del programma e un riferimento al file .dex contenente il metodo.
- Se utilizzati per valori in bit (ad esempio numeri interi e in virgola mobile), i registri sono considerati di 32 bit. Per i valori a 64 bit vengono utilizzate coppie di registri adiacenti. Non è richiesto alcun requisito di allineamento per le coppie di registri.
- Se utilizzati per i riferimenti agli oggetti, i registri sono considerati sufficientemente ampi per contenere esattamente un riferimento di questo tipo.
- In termini di rappresentazione a bit, (Object) null == (int) 0.
- Gli N argomenti di un metodo vengono inseriti nell'ordine negli ultimi N registri del frame di chiamata del metodo. Gli argomenti ampi occupano due registri. Ai metodi di istanza viene passato un riferimento this come primo argomento.
L'unità di archiviazione nello stream di istruzioni è una quantità non firmata di 16 bit. Alcuni bit in alcune istruzioni vengono ignorati / devono essere pari a zero.
Le istruzioni non sono limitate inutilmente a un determinato tipo. Ad esempio, le istruzioni che spostano i valori dei registri a 32 bit senza interpretazione non devono specificare se stanno spostando interi o valori in virgola mobile.
Esistono pool di costanti enumerati e indicizzati separatamente per i riferimenti a stringhe, tipi, campi e metodi.
I dati letterali a livello di bit sono rappresentati in linea nello stream di istruzioni.
Poiché, in pratica, è raro che un metodo abbia bisogno di più di 16 registri e poiché la necessità di più di otto registri è ragionevolmente comune, molte istruzioni sono limitate all'indirizzamento solo dei primi 16 registri. Ove ragionevolmente possibile, le istruzioni consentono di fare riferimento fino ai primi 256 registri. Inoltre, alcune istruzioni hanno varianti che consentono conteggi di registri molto più grandi, inclusa una coppia di istruzioni move generiche che possono indirizzare i registri nell'intervallo v0-v65535. Nei casi in cui non sia disponibile una variante di istruzione per indirizzare un registro desiderato, è previsto che i contenuti del registro vengano spostati dal registro originale a un registro basso (prima dell'operazione) e/o da un registro del risultato basso a un registro alto (dopo l'operazione).
Esistono diverse "pseudo-istruzioni" utilizzate per memorizzare payload di dati di lunghezza variabile, a cui fanno riferimento le istruzioni regolari (ad esempio fill-array-data). Queste istruzioni non devono mai essere incontrate durante il normale flusso di esecuzione. Inoltre, le istruzioni devono trovarsi su offset del bytecode con numeri pari (ovvero allineati a 4 byte). Per soddisfare questo requisito, gli strumenti di generazione di dex devono emettere un'istruzione nop aggiuntiva come separatore se questa istruzione non fosse allineata. Infine, anche se non è obbligatorio, è previsto che la maggior parte degli strumenti scelga di emettere queste istruzioni alla fine dei metodi, poiché in caso contrario è probabile che siano necessarie istruzioni aggiuntive per eseguire il branching.
Quando vengono installate su un sistema in esecuzione, alcune istruzioni potrebbero essere alterate, cambiandone il formato, come ottimizzazione del collegamento statico in fase di installazione. In questo modo, l'esecuzione sarà più rapida una volta noto il collegamento. Consulta il documento relativo ai formati didattici associato per le varianti suggerite. La parola "suggerito" è usata con cautela; non è obbligatorio implementarli.
Sintassi e mnemoni simili a quelle umane:
- Ordine destinazione-poi-origine per gli argomenti.
- Alcuni opcode hanno un suffisso del nome per distinguere i tipi su cui operano:
  - Le opzioni di codice di 32 bit di tipo generale non sono contrassegnate.
  - Le opzioni di codice a 64 bit di tipo generico hanno il suffisso -wide.
  - Le opzioni di codice macchina specifiche per tipo sono seguite dal loro tipo (o da un'abbreviazione semplice), uno dei seguenti: -boolean -byte -char -short -int -long -float -double -object -string -class -void.
- Alcuni opcode hanno un suffisso per distinguere operazioni apparentemente identiche che hanno layout o opzioni di istruzioni diversi. Questi suffissi sono separati dai nomi principali da una barra diagonale ("/") ed esistono principalmente per creare un mappatura uno a uno con costanti statiche nel codice che genera e interpreta gli eseguibili (ovvero per ridurre l'ambiguità per le persone).
- Nelle descrizioni riportate di seguito, la larghezza di un valore (che indica, ad esempio, l'intervallo di una costante o il numero di registri eventualmente indirizzati) è evidenziata dall'uso di un carattere per quattro bit di larghezza.
- Ad esempio, nell'istruzione "move-wide/from16 vAA, vBBBB":
  - "move" è l'opcode di base, che indica l'operazione di base (sposta il valore di un registro).
  - "wide" è il suffisso del nome, che indica che opera su dati ampi (64 bit).
  - "from16" è il suffisso dell'opcode, che indica una variante che ha un riferimento a un registro a 16 bit come origine.
  - "vAA" è il registro di destinazione (implicito nell'operazione; di nuovo, la regola è che gli argomenti di destinazione vengono sempre prima), che deve essere compreso nell'intervallo v0-v255.
  - "vBBBB" è il registro di origine, che deve rientrare nell'intervallo v0-v65535.
Consulta il documento relativo ai formati delle istruzioni per ulteriori dettagli sui vari formati delle istruzioni (elencati in "Op & Format") e sulla sintassi dell'opcode.
Per ulteriori dettagli su dove si inserisce il bytecode nel quadro più ampio, consulta il documento sul formato del file .dex.

Riepilogo dell'insieme di bytecode

Op & Format	Mnemonico / sintassi	Argomenti	Descrizione
00 10x	nop		Cicli di rifiuti. Nota: le pseudo-istruzioni contenenti dati sono contrassegnate con questo codice operativo, nel qual caso il byte di ordine superiore dell'unità di codice operativo indica la natura dei dati. Consulta le sezioni "Formato `packed-switch-payload`", "Formato `sparse-switch-payload`" e "Formato `fill-array-data-payload`" di seguito.
01 12x	move vA, vB	`A:` registro di destinazione (4 bit) `B:` registro di origine (4 bit)	Sposta i contenuti di un registro non oggetto in un altro.
02 22x	move/from16 vAA, vBBBB	`A:` registro di destinazione (8 bit) `B:` registro di origine (16 bit)	Sposta i contenuti di un registro non oggetto in un altro.
03 32x	move/16 vAAAA, vBBBB	`A:` registro di destinazione (16 bit) `B:` registro di origine (16 bit)	Sposta i contenuti di un registro non oggetto in un altro.
04 12x	move-wide vA, vB	`A:` coppia di registri di destinazione (4 bit) `B:` coppia di registri di origine (4 bit)	Sposta i contenuti di una coppia di registri in un'altra. Nota: è consentito passare da `vN` a `vN-1` o `vN+1`, pertanto le implementazioni devono prevedere la lettura di entrambe le metà di una coppia di registri prima di scrivere qualsiasi cosa.
05 22x	move-wide/from16 vAA, vBBBB	`A:` Coppia di registri di destinazione (8 bit) `B:` Coppia di registri di origine (16 bit)	Sposta i contenuti di una coppia di registri in un'altra. Nota: le considerazioni sull'implementazione sono le stesse di `move-wide`, sopra.
06 32x	move-wide/16 vAAAA, vBBBB	`A:` Coppia di registri di destinazione (16 bit) `B:` Coppia di registri di origine (16 bit)	Sposta i contenuti di una coppia di registri in un'altra. Nota: le considerazioni sull'implementazione sono le stesse di `move-wide`, sopra.
07 12x	move-object vA, vB	`A:` registro di destinazione (4 bit) `B:` registro di origine (4 bit)	Sposta i contenuti di un registro contenente oggetti in un altro.
08 22x	move-object/from16 vAA, vBBBB	`A:` registro di destinazione (8 bit) `B:` registro di origine (16 bit)	Sposta i contenuti di un registro contenente oggetti in un altro.
09 32x	move-object/16 vAAAA, vBBBB	`A:` registro di destinazione (16 bit) `B:` registro di origine (16 bit)	Sposta i contenuti di un registro contenente oggetti in un altro.
0a 11x	move-result vAA	`A:` registro di destinazione (8 bit)	Sposta il risultato non oggetto di una sola parola del `invoke-kind` più recente nel registro indicato. Questo deve essere fatto come istruzione immediatamente dopo un `invoke-kind` il cui risultato (una parola, non un oggetto) non deve essere ignorato; in qualsiasi altro punto non è valido.
0b 11x	move-result-wide vAA	Coppia di registri di destinazione `A:` (8 bit)	Sposta il risultato a due parole dell'`invoke-kind` più recente nella coppia di registri indicata. Questa istruzione deve essere eseguita immediatamente dopo un `invoke-kind` il cui risultato (a due parole) non deve essere ignorato; in qualsiasi altro punto non è valida.
0c 11x	move-result-object vAA	`A:` registro di destinazione (8 bit)	Sposta il risultato dell'oggetto dell'`invoke-kind` più recente nel registro indicato. Questa istruzione deve essere eseguita immediatamente dopo un `invoke-kind` o un `filled-new-array` il cui risultato (oggetto) non deve essere ignorato. In qualsiasi altro punto non è valida.
0d 11x	move-exception vAA	`A:` registro di destinazione (8 bit)	Salva un'eccezione appena rilevata nel registro specificato. Deve essere la prima istruzione di qualsiasi gestore delle eccezioni la cui eccezione rilevata non deve essere ignorata e deve verificarsi soltanto come prima istruzione di un gestore delle eccezioni. In qualsiasi altro punto non è valida.
0 e 10 volte	return-void		Torna da un metodo `void`.
0 di 11x	return vAA	Registro del valore restituito `A:` (8 bit)	Ritorna da un metodo che restituisce un valore non oggetto di larghezza singola (32 bit).
10 11x	vAA a livello di ritorno	`A:` coppia di registri del valore restituito (8 bit)	Ritorna da un metodo che restituisce un valore a doppia larghezza (64 bit).
11 11x	return-object vAA	Registro del valore restituito `A:` (8 bit)	Ritorna da un metodo che restituisce un oggetto.
12 11n	const/4 vA, #+B	`A:` registro di destinazione (4 bit) `B:` int firmato (4 bit)	Sposta il valore letterale specificato (con segno esteso a 32 bit) nel registro specificato.
13 21	const/16 vAA, #+BBBB	`A:` registro di destinazione (8 bit) `B:` int con segno (16 bit)	Sposta il valore della stringa specificato (con segno esteso a 32 bit) nel registro specificato.
14 31i	const vAA, #+BBBBBBBB	`A:` registro di destinazione (8 bit) `B:` costante arbitraria a 32 bit	Sposta il valore letterale specificato nel registro specificato.
15 21h	const/high16 vAA, #+BBBB0000	`A:` registro di destinazione (8 bit) `B:` int con segno (16 bit)	Sposta il valore letterale specificato (esteso a 32 bit a destra con zero) nel registro specificato.
16 21	const-wide/16 vAA, #+BBBB	`A:` registro di destinazione (8 bit) `B:` int con segno (16 bit)	Sposta il valore letterale specificato (con segno esteso a 64 bit) nella coppia di registri specificata.
17 31i	const-wide/32 vAA, #+BBBBBBBB	`A:` registro di destinazione (8 bit) `B:` int firmato (32 bit)	Sposta il valore letterale specificato (con segno esteso a 64 bit) nella coppia di registri specificata.
18 51l	const-wide vAA, #+BBBBBBBBBBBBBBBB	`A:` registro di destinazione (8 bit) `B:` costante arbitraria a doppia larghezza (64 bit)	Sposta il valore letterale specificato nella coppia di registri specificata.
19 21h	const-wide/high16 vAA, #+BBBB000000000000	`A:` registro di destinazione (8 bit) `B:` int con segno (16 bit)	Sposta il valore letterale specificato (esteso a destra a 64 bit) nella coppia di registri specificata.
1a 21c	const-string vAA, string@BBBB	`A:` registro di destinazione (8 bit) `B:` indice di stringa	Sposta un riferimento alla stringa specificata dall'indice specificato nel registro specificato.
1b 31c	const-string/jumbo vAA, string@BBBBBBBB	`A:` registro di destinazione (8 bit) `B:` indice di stringa	Sposta un riferimento alla stringa specificata dall'indice specificato nel registro specificato.
1c 21c	const-class vAA, type@BBBB	`A:` registro di destinazione (8 bit) `B:` indice di tipo	Sposta un riferimento alla classe specificata dall'indice specificato nel registro specificato. Se il tipo indicato è primitivo, verrà memorizzato un riferimento alla classe degenere del tipo primitivo.
1 giorno 11x	monitor-enter vAA	`A:` registro con riferimento (8 bit)	Acquisisci il monitor per l'oggetto indicato.
1e 11x	monitor-exit vAA	`A:` registro con riferimento (8 bit)	Rilascia il monitoraggio per l'oggetto indicato. Nota: se questa istruzione deve generare un'eccezione, deve farlo come se il PC avesse già superato l'istruzione. Potrebbe essere utile pensare che l'istruzione venga eseguita correttamente (in un certo senso) e che l'eccezione venga lanciata dopo l'istruzione, ma prima che l'istruzione successiva abbia la possibilità di essere eseguita. Questa definizione consente a un metodo di utilizzare un valore generico per la pulizia del monitor (ad es. `finally`) come pulizia del monitor per il blocco stesso, per gestire le eccezioni arbitrarie che potrebbero essere lanciate a causa dell'implementazione storica di `Thread.stop()`, mantenendo al contempo un'igiene del monitor adeguata.
1f 21c	check-cast vAA, type@BBBB	`A:` registro di riferimento (8 bit) `B:` indice di tipo (16 bit)	Lancia un `ClassCastException` se il riferimento nel register specificato non può essere sottoposto a conversione al tipo indicato. Nota: poiché `A` deve sempre essere un riferimento (e non un valore primitivo), l'operazione non andrà a buon fine obbligatoriamente in fase di runtime (ovvero verrà generata un'eccezione) se `B` fa riferimento a un tipo primitivo.
20 22c	instance-of vA, vB, type@CCCC	`A:` registro di destinazione (4 bit) `B:` registro di riferimento (4 bit) `C:` indice di tipo (16 bit)	Memorizza nel registro di destinazione specificato `1` se il riferimento indicato è un'istanza del tipo specificato, oppure `0` in caso contrario. Nota: poiché `B` deve sempre essere un riferimento (e non un valore primitivo), `0` verrà sempre memorizzato se `C` fa riferimento a un tipo primitivo.
21 12x	array-length vA, vB	`A:` registro di destinazione (4 bit) `B:` registro contenente il riferimento all'array (4 bit)	Memorizza nel registro di destinazione specificato la lunghezza dell'array indicato, in voci
22 21c	new-instance vAA, type@BBBB	`A:` registro di destinazione (8 bit) `B:` indice di tipo	Costruisci una nuova istanza del tipo indicato, memorizzando un riferimento nella destinazione. Il tipo deve fare riferimento a una classe non array.
23 22c	new-array vA, vB, type@CCCC	`A:` registro di destinazione (4 bit) `B:` registro della dimensione `C:` indice del tipo	Costruisci un nuovo array del tipo e delle dimensioni indicati. Il tipo deve essere un tipo di array.
24 35c	array-nuovo-completo {vC, vD, vE, vF, vG}, tipo@BBBB	`A:` dimensione dell'array e numero di parole degli argomenti (4 bit) `B:` indice di tipo (16 bit) `C..G:` registri degli argomenti (4 bit ciascuno)	Costruisci un array del tipo e delle dimensioni specificati, riempiendolo con i contenuti forniti. Il tipo deve essere un tipo di array. I contenuti dell'array devono essere costituiti da una sola parola (ovvero non devono essere presenti array di `long` o `double`, ma sono accettabili i tipi di riferimento). L'istanza costruita viene memorizzata come "risultato" nello stesso modo in cui le istruzioni di chiamata del metodo memorizzano i risultati, pertanto l'istanza costruita deve essere spostata in un registro con un'istruzione `move-result-object` immediatamente successiva (se deve essere utilizzata).
25 3rc	array/intervallo nuovo e completo {vCCCC .. vNNNN}, tipo@BBBB	`A:` dimensione dell'array e numero di parole dell'argomento (8 bit) `B:` indice di tipo (16 bit) `C:` registro primo argomento (16 bit) `N = A + C - 1`	Costruisci un array del tipo e delle dimensioni specificati, compilandolo con i contenuti forniti. I chiarimenti e le limitazioni sono gli stessi di `filled-new-array`, descritti sopra.
26 31t	fill-array-data vAA, +BBBBBBBB (con i dati supplementari specificati di seguito in "Formato `fill-array-data-payload`")	`A:` Riferimento all'array (8 bit) `B:` Pseudo-istruzione di offset "branch" firmato ai dati della tabella (32 bit)	Compila l'array specificato con i dati indicati. Il riferimento deve essere a un array di elementi primitivi e la tabella di dati deve avere lo stesso tipo e non deve contenere più elementi di quelli che possono essere inseriti nell'array. In altre parole, l'array potrebbe essere più grande della tabella e, in questo caso, vengono impostati solo gli elementi iniziali dell'array, lasciando invariato il resto.
27 11x	throw vAA	`A:` registro con eccezioni (8 bit)	Genera l'eccezione indicata.
28 10t	goto +AA	`A:` offset del ramo con segno (8 bit)	Passa incondizionatamente all'istruzione indicata. Nota: l'offset del ramo non deve essere `0`. Un loop girato può essere costruito legalmente con `goto/32` o includendo un `nop` come target prima del ramo.
29 20t	goto/16 +AAAA	`A:` offset del ramo con segno (16 bit)	Passa incondizionatamente all'istruzione indicata. Nota: l'offset del ramo non deve essere `0`. Un loop girato può essere costruito legalmente con `goto/32` o includendo un `nop` come target prima del ramo.
2a 30t	goto/32 +AAAAAAAA	`A:` offset del ramo con segno (32 bit)	Passa incondizionatamente all'istruzione indicata.
2b 31t	packed-switch vAA, +BBBBBBBB (con dati supplementari come specificato di seguito in "Formato `packed-switch-payload`")	`A:` register to test `B:` offset "branch" firmato per pseudo-istruzione di dati di tabella (32 bit)	Passa a una nuova istruzione in base al valore nel registro specificato, utilizzando una tabella di offset corrispondenti a ciascun valore in un determinato intervallo di numeri interi, oppure passa all'istruzione successiva se non c'è corrispondenza.
2c 31t	sparse-switch vAA, +BBBBBBBB (con dati supplementari come specificato di seguito in "Formato `sparse-switch-payload`")	`A:` register to test `B:` offset "branch" firmato per pseudo-istruzione di dati di tabella (32 bit)	Vai a una nuova istruzione in base al valore nel registro specificato, utilizzando una tabella ordinata di coppie di valori e offset oppure vai all'istruzione successiva se non c'è corrispondenza.
2d..31 23x	cmpkind vAA, vBB, vCC 2d: cmpl-float (lt bias) 2e: cmpg-float (gt bias) 2f: cmpl-double (lt bias) 30: cmpg-double (gt bias) 31: cmp-long	`A:` registro di destinazione (8 bit) `B:` prima coppia o primo registro di origine `C:` seconda coppia o secondo registro di origine	Esegui il confronto indicato con numeri in virgola mobile o `long`, impostando `a` su `0` se `b == c`, su `1` se `b > c` o su `-1` se `b < c`. Il "bias" elencato per le operazioni in virgola mobile indica come vengono trattati i confronti `NaN`: le istruzioni "gt bias" restituiscono `1` per i confronti `NaN`, mentre le istruzioni "lt bias" restituiscono `-1`. Ad esempio, per verificare se il numero in virgola mobile è uguale a `x < y`, è consigliabile utilizzare `cmpg-float`. Un risultato pari a `-1` indica che il test è stato vero e gli altri valori indicano che è stato falso a causa di un confronto valido o perché uno dei valori era `NaN`.
32..37 22t	if-test vA, vB, +CCCC 32: if-eq 33: if-ne 34: if-lt 35: if-ge 36: if-gt 37: if-le	`A:` primo registro da testare (4 bit) `B:` secondo registro da testare (4 bit) `C:` offset del ramo con segno (16 bit)	Esegui il branch alla destinazione specificata se i valori dei due registri specificati corrispondono come specificato. Nota: l'offset del ramo non deve essere `0`. Un loop girato può essere costruito legalmente tramite un ramo intorno a un `goto` a ritroso o includendo un `nop` come target prima del ramo.
38..3d 21t	if-testz vAA, +BBBB 38: if-eqz 39: if-nez 3a: if-ltz 3b: if-gez 3c: if-gtz 3d: if-lez	`A:` registro per il test (8 bit) `B:` offset del ramo con segno (16 bit)	Esegui il branch alla destinazione specificata se il valore del registro specificato viene confrontato con 0 come specificato. Nota: l'offset del ramo non deve essere `0`. Un loop girato può essere costruito legalmente tramite un ramo intorno a un `goto` a ritroso o includendo un `nop` come destinazione prima del ramo.
3e..43 10x	(non utilizzato)		(non utilizzato)
44..51 23x	arrayop vAA, vBB, vCC 44: aget 45: aget-wide 46: aget-object 47: aget-boolean 48: aget-byte 49: aget-char 4a: aget-short 4b: aput 4c: aput-wide 4d: aput-object 4e: aput-boolean 4f: aput-byte 50: aput-char 51: aput-short	`A:` registro o coppia di valori; può essere di origine o di destinazione (8 bit) `B:` registro array (8 bit) `C:` registro di indice (8 bit)	Esegui l'operazione sull'array identificata nell'indice identificato della matrice specificata, caricando o memorizzando nel registro dei valori.
52,5 f 22 °C	iinstanceop vA, vB, field@CCCC 52: iget 53: iget-wide 54: iget-object 55: iget-boolean 56: iget-byte 57: iget-char 58: iget-short 59: iput 5a: iput-wide 5b: iput-object 5c: iput-boolean 5d: iput-byte 5e: iput-char 5f: iput-short	`A:` registro o coppia di valori; può essere source o dest (4 bit) `B:` registro oggetto (4 bit) `C:` indice di riferimento del campo dell'istanza (16 bit)	Esegui l'operazione sul campo dell'istanza dell'oggetto identificato con il campo identificato, caricandolo o memorizzandolo nel registro dei valori. Nota: questi opcode sono candidati ragionevoli per il collegamento statico, modificando l'argomento del campo in modo che sia un offset più diretto.
60..6d 21c	sstaticop vAA, field@BBBB 60: sget 61: sget-wide 62: sget-object 63: sget-boolean 64: sget-byte 65: sget-char 66: sget-short 67: sput 68: sput-wide 69: sput-object 6a: sput-boolean 6b: sput-byte 6c: sput-char 6d: sput-short	`A:` registro o coppia di valori; può essere source o dest (8 bit) `B:` indice di riferimento del campo statico (16 bit)	Esegui l'operazione sul campo statico dell'oggetto identificato con il campo statico identificato, caricandolo o memorizzandolo nel registro del valore. Nota: questi opcode sono candidati ragionevoli per il collegamento statico, modificando l'argomento del campo in modo che sia un offset più diretto.
6e..72 35c	invoke-kind {vC, vD, vE, vF, vG}, meth@BBBB 6e: invoke-virtual 6f: invoke-super 70: invoke-direct 71: invoke-static 72: invoke-interface	`A:` numero di parole dell'argomento (4 bit) `B:` indice di riferimento al metodo (16 bit) `C..G:` registri degli argomenti (4 bit ciascuno)	Chiama il metodo indicato. Il risultato (se presente) può essere memorizzato con una variante `move-result` appropriata come istruzione immediatamente successiva. `invoke-virtual` viene utilizzato per invocare un normale metodo virtuale, ovvero un metodo diverso da `static`, `private` o un costruttore. Quando `method_id` fa riferimento a un metodo di una classe non di interface, `method_id` viene utilizzato per invocare il metodo virtuale della superclasse più vicina (anziché quello con lo stesso `method_id` nella classe chiamante).`invoke-super` Si applicano le stesse limitazioni del metodo per `invoke-virtual`. Nei file Dex della versione `037` o successive, se `method_id` fa riferimento a un metodo dell'interfaccia, `invoke-super` viene utilizzato per richiamare la versione più specifica e non sostituita del metodo definito in quell'interfaccia. valgono le stesse limitazioni per i metodi previste per `invoke-virtual`. Nei file Dex precedenti alla versione `037`, l'interfaccia `method_id` è illegale e non definita. `invoke-direct` viene utilizzato per invocare un metodo non diretto`static` (ovvero un metodo di istanza che per sua natura non è sovrascrivibile, ovvero un metodo di istanza `private` o un costruttore). `invoke-static` viene utilizzato per invocare un metodo `static` (che è sempre considerato un metodo diretto). `invoke-interface` viene utilizzato per invocare un metodo `interface`, ovvero su un oggetto la cui classe concreta non è nota, utilizzando un `method_id` che fa riferimento a un `interface`. Nota:* questi opcode sono candidati ragionevoli per il collegamento statico, modificando l'argomento del metodo in modo che sia un offset più diretto (o una coppia di questi).
73 10x	(non utilizzato)		(non utilizzato)
74..78 3rc	invoke-kind/range {vCCCC .. vNNNN}, meth@BBBB 74: invoke-virtual/range 75: invoke-super/range 76: invoke-direct/range 77: invoke-static/range 78: invoke-interface/range	`A:` numero di parole dell'argomento (8 bit) `B:` indice di riferimento al metodo (16 bit) `C:` registro primo argomento (16 bit) `N = A + C - 1`	Chiama il metodo indicato. Per dettagli, avvertimenti e suggerimenti, consulta la prima `invoke-kind` descrizione sopra.
79..7a 10x	(non utilizzato)		(non utilizzato)
7b..8f 12x	unop vA, vB 7b: neg-int 7c: not-int 7d: neg-long 7e: not-long 7f: neg-float 80: neg-double 81: int-to-long 82: int-to-float 83: int-to-double 84: long-to-int 85: long-to-float 86: long-to-double 87: float-to-int 88: float-to-long 89: float-to-double 8a: double-to-int 8b: double-to-long 8c: double-to-float 8d: int-to-byte 8e: int-to-char 8f: int-to-short	`A:` coppia o registro di destinazione (4 bit) `B:` coppia o registro di origine (4 bit)	Esegui l'operazione unaria identificata sul registro di origine, memorizzando il risultato nel registro di destinazione.
90..af 23x	binop vAA, vBB, vCC 90: add-int 91: sub-int 92: mul-int 93: div-int 94: rem-int 95: and-int 96: or-int 97: xor-int 98: shl-int 99: shr-int 9a: ushr-int 9b: add-long 9c: sub-long 9d: mul-long 9e: div-long 9f: rem-long a0: and-long a1: or-long a2: xor-long a3: shl-long a4: shr-long a5: ushr-long a6: add-float a7: sub-float a8: mul-float a9: div-float aa: rem-float ab: add-double ac: sub-double ad: mul-double ae: div-double af: rem-double	`A:` coppia o registro di destinazione (8 bit) `B:` coppia o registro di origine 1 (8 bit) `C:` coppia o registro di origine 2 (8 bit)	Esegui l'operazione binaria identificata sui due registri di origine, memorizzando il risultato nel registro di destinazione. Nota: a differenza di altre operazioni matematiche `-long` (che accettano coppie di registri sia per la prima che per la seconda origine), `shl-long`, `shr-long` e `ushr-long` accettano una coppia di registri per la prima origine (il valore da spostare), ma un singolo registro per la seconda origine (la distanza di spostamento).
b0..cf 12x	binop/2addr vA, vB b0: add-int/2addr b1: sub-int/2addr b2: mul-int/2addr b3: div-int/2addr b4: rem-int/2addr b5: and-int/2addr b6: or-int/2addr b7: xor-int/2addr b8: shl-int/2addr b9: shr-int/2addr ba: ushr-int/2addr bb: add-long/2addr bc: sub-long/2addr bd: mul-long/2addr be: div-long/2addr bf: rem-long/2addr c0: and-long/2addr c1: or-long/2addr c2: xor-long/2addr c3: shl-long/2addr c4: shr-long/2addr c5: ushr-long/2addr c6: add-float/2addr c7: sub-float/2addr c8: mul-float/2addr c9: div-float/2addr ca: rem-float/2addr cb: add-double/2addr cc: sub-double/2addr cd: mul-double/2addr ce: div-double/2addr cf: rem-double/2addr	`A:` coppia o registro di destinazione e prima origine (4 bit) `B:` coppia o registro di seconda origine (4 bit)	Esegui l'operazione binaria identificata sui due registri di origine, memorizzando il risultato nel primo registro di origine. Nota: a differenza di altre operazioni matematiche `-long/2addr` (che richiedono coppie di registri sia per la destinazione/la prima fonte sia per la seconda fonte), `shl-long/2addr`, `shr-long/2addr` e `ushr-long/2addr` richiedono una coppia di registri per la destinazione/la prima fonte (il valore da compensare), ma un singolo registro per la seconda fonte (la distanza di compensazione).
d0..d7 22s	binop/lit16 vA, vB, #+CCCC d0: add-int/lit16 d1: rsub-int (sottrazione inversa) d2: mul-int/lit16 d3: div-int/lit16 d4: rem-int/lit16 d5: and-int/lit16 d6: or-int/lit16 d7: xor-int/lit16	`A:` registro di destinazione (4 bit) `B:` registro di origine (4 bit) `C:` costante int firmata (16 bit)	Esegui l'operazione binaria indicata sul registro indicato (primo argomento) e sul valore letterale (secondo argomento), memorizzando il risultato nel registro di destinazione. Nota: `rsub-int` non ha un suffisso poiché questa versione è l'opcode principale della relativa famiglia. Inoltre, di seguito sono riportati i dettagli sulla sua semantica.
d8..e2 22b	binop/lit8 vAA, vBB, #+CC d8: add-int/lit8 d9: rsub-int/lit8 da: mul-int/lit8 db: div-int/lit8 dc: rem-int/lit8 dd: and-int/lit8 de: or-int/lit8 df: xor-int/lit8 e0: shl-int/lit8 e1: shr-int/lit8 e2: ushr-int/lit8	`A:` registro di destinazione (8 bit) `B:` registro di origine (8 bit) `C:` costante int con segno (8 bit)	Esegui l'operazione binaria indicata sul registro indicato (primo argomento) e sul valore letterale (secondo argomento), memorizzando il risultato nel registro di destinazione. Nota:di seguito sono riportati i dettagli sulla semantica di `rsub-int`.
e3..f9 10x	(non utilizzato)		(non utilizzato)
fa 45cc	invoke-polymorphic {vC, vD, vE, vF, vG}, meth@BBBB, proto@HHHH	`A:` numero di parole degli argomenti (4 bit) `B:` indice di riferimento al metodo (16 bit) `C:` ricevitore (4 bit) `D..G:` registri degli argomenti (4 bit ciascuno) `H:` indice di riferimento al prototipo (16 bit)	Richiama il metodo polimorfo della firma indicato. Il risultato (se presente) può essere memorizzato con una variante `move-result*` appropriata come istruzione immediatamente successiva. Il riferimento al metodo deve essere a un metodo polimorfo con firma, ad esempio `java.lang.invoke.MethodHandle.invoke` o `java.lang.invoke.MethodHandle.invokeExact`. Il destinatario deve essere un oggetto che supporta il metodo di firma polimorfa invocato. Il riferimento al prototipo descrive i tipi di argomenti forniti e il tipo di ritorno previsto. Il bytecode `invoke-polymorphic` potrebbe sollevare eccezioni durante l'esecuzione. Le eccezioni sono descritte nella documentazione dell'API per il metodo polimorfo della firma invocato. Presente nei file Dex a partire dalla versione `038`.
fb 4rcc	invoke-polymorphic/range {vCCCC .. vNNNN}, meth@BBBB, proto@HHHH	`A:` numero di parole degli argomenti (8 bit) `B:` indice di riferimento al metodo (16 bit) `C:` ricevitore (16 bit) `H:` indice di riferimento al prototipo (16 bit) `N = A + C - 1`	Richiama l'handle del metodo indicato. Per informazioni dettagliate, consulta la descrizione di `invoke-polymorphic`. Presente nei file Dex a partire dalla versione `038`.
fc 35c	invoke-custom {vC, vD, vE, vF, vG}, call_site@BBBB	`A:` numero di parole degli argomenti (4 bit) `B:` indice di riferimento del sito di chiamata (16 bit) `C..G:` registri degli argomenti (4 bit ciascuno)	Risolve e richiama il sito di chiamata indicato. Il risultato dell'invocazione (se presente) può essere archiviato con una variante `move-result*` appropriata come istruzione immediatamente successiva. Questa istruzione viene eseguita in due fasi: risoluzione del sito di chiamata e chiamata del sito di chiamata. La risoluzione del sito di chiamata verifica se il sito di chiamata indicato ha un'istanza `java.lang.invoke.CallSite` associata. In caso contrario, il metodo del linker di bootstrap per il sito di chiamata indicato viene invocato utilizzando gli argomenti presenti nel file DEX (vedi call_site_item). Il metodo del linker di bootstrap restituisce un'istanza `java.lang.invoke.CallSite` che verrà poi associata al sito di chiamata indicato se non esiste alcuna associazione. È possibile che un altro thread abbia già eseguito l'associazione per primo. In questo caso, l'esecuzione dell'istruzione continua con la prima istanza `java.lang.invoke.CallSite` associata. Viene eseguita l'invocazione del sito di chiamata sul `java.lang.invoke.MethodHandle` target dell'istanza `java.lang.invoke.CallSite` risolta. Il target viene invocato come se si eseguisse `invoke-polymorphic` (descritto sopra) utilizzando l'handle metodo e gli argomenti dell'istruzione `invoke-custom` come argomenti di un'invocazione dell'handle metodo esatto. Le eccezioni sollevate dal metodo del linker di bootstrap sono racchiuse in un `java.lang.BootstrapMethodError`. Un `BootstrapMethodError` viene visualizzato anche se: Il metodo del linker di bootstrap non restituisce un'istanza `java.lang.invoke.CallSite`. Il `java.lang.invoke.CallSite` restituito ha un `null` metodo di gestione del target. Il target dell'handle del metodo non è del tipo richiesto. Presente nei file Dex a partire dalla versione `038`.
fd 3rc	invoke-custom/range {vCCCC .. vNNNN}, call_site@BBBB	`A:` numero di parole dell'argomento (8 bit) `B:` indice di riferimento del sito di chiamata (16 bit) `C:` registro primo argomento (16 bit) `N = A + C - 1`	Risolvi e richiama un sito di chiamata. Per informazioni dettagliate, consulta la descrizione di `invoke-custom`. Presente nei file Dex a partire dalla versione `038`.
fe 21c	const-method-handle vAA, method_handle@BBBB	`A:` registro di destinazione (8 bit) `B:` indice dell'handle metodo (16 bit)	Sposta un riferimento all'handle del metodo specificato dall'indice dato nel registro specificato. Presente nei file Dex a partire dalla versione `039`.
ff 21c	const-method-type vAA, proto@BBBB	`A:` registro di destinazione (8 bit) `B:` riferimento al prototipo del metodo (16 bit)	Sposta un riferimento al prototipo del metodo specificato dall'indice dato nel registro specificato. Presente nei file Dex a partire dalla versione `039`.

Formato del payload del pacchetto di switch

Nome	Formato	Descrizione
ident	ushort = 0x0100	Identificazione di pseudo-opcode
dimensioni	ushort	numero di voci nella tabella
first_key	int	primo (e più basso) valore della condizione di switch
target	int[]	Elenco di `size` target di ramo relativi. I target sono relativi all'indirizzo dell'opcode di switch, non di questa tabella.

Nota: il numero totale di unità di codice per un'istanza di questa tabella è (size * 2) + 4.

Formato sparse-switch-payload

Nome	Formato	Descrizione
ident	ushort = 0x0200	Identificazione di pseudo-opcode
dimensioni	ushort	numero di voci nella tabella
chiavi	int[]	elenco di valori chiave `size`, ordinati dal più basso al più alto
target	int[]	elenco di `size` target di ramo relativi, ciascuno corrispondente al valore della chiave nello stesso indice. I target sono relativi all'indirizzo dell'opcode di switch, non di questa tabella.

Nota: il numero totale di unità di codice per un'istanza di questa tabella è (size * 4) + 2.

formato del payload dei dati dell'array di completamento

Nome	Formato	Descrizione
ident	ushort = 0x0300	Identificazione di pseudo-opcode
element_width	ushort	numero di byte in ogni elemento
dimensioni	uint	numero di elementi nella tabella
di dati	ubyte[]	valori dei dati

Nota: il numero totale di unità di codice per un'istanza di questa tabella è (size * element_width + 1) / 2 + 4.

Dettagli dell'operazione matematica

Nota: le operazioni in virgola mobile devono rispettare le regole IEEE 754, utilizzando il metodo di arrotondamento al numero più vicino e il sottoflusso graduale, salvo diversa indicazione.

Opcode	Semantica del linguaggio C	Note
neg-int	int32 a; int32 result = -a;	Complemento a due unario.
not-int	int32 a; int32 result = ~a;	Unario a complemento a 1.
neg-long	int64 a; int64 result = -a;	Complemento a due unario.
not-long	int64 a; int64 result = ~a;	Unario a complemento a 1.
neg-float	float a; float result = -a;	Negazione a virgola mobile.
neg-double	double a; double result = -a;	Negazione a virgola mobile.
int-to-long	int32 a; int64 result = (int64) a;	Firma l'estensione di `int32` in `int64`.
int-to-float	int32 a; float result = (float) a;	Conversione di `int32` in `float` con arrotondamento al numero intero più vicino. In questo modo si perde precisione per alcuni valori.
int-to-double	int32 a; double result = (double) a;	Conversione di `int32` in `double`.
long-to-int	int64 a; int32 result = (int32) a;	Troncamento di `int64` in `int32`.
long-to-float	int64 a; float result = (float) a;	Conversione di `int64` in `float` con arrotondamento al numero intero più vicino. In questo modo si perde precisione per alcuni valori.
long-to-double	int64 a; double result = (double) a;	Conversione di `int64` in `double` con arrotondamento al numero intero più vicino. In questo modo si perde precisione per alcuni valori.
float-to-int	float a; int32 result = (int32) a;	Conversione di `float` in `int32` con arrotondamento per difetto. `NaN` e `-0.0` (zero negativo) vengono convertiti nell'intero `0`. Gli infiniti e i valori con un valore assoluto troppo elevato per essere rappresentato vengono convertiti in `0x7fffffff` o `-0x80000000` a seconda del segno.
float-to-long	float a; int64 result = (int64) a;	Conversione di `float` in `int64` con arrotondamento per difetto. Qui si applicano le stesse regole per i casi speciali valide per `float-to-int`, tranne per il fatto che i valori fuori intervallo vengono convertiti in `0x7fffffffffffffff` o `-0x8000000000000000` a seconda del segno.
float-to-double	float a; double result = (double) a;	Conversione di `float` in `double`, mantenendo esattamente il valore.
double-to-int	double a; int32 result = (int32) a;	Conversione di `double` in `int32` con arrotondamento per difetto. Valgono le stesse regole per i casi speciali valide per `float-to-int`.
double-to-long	double a; int64 result = (int64) a;	Conversione di `double` in `int64` con arrotondamento per difetto. Valgono le stesse regole per i casi speciali valide per `float-to-long`.
double-to-float	double a; float result = (float) a;	Conversione di `double` in `float` con arrotondamento al numero intero più vicino. In questo modo si perde precisione per alcuni valori.
int-to-byte	int32 a; int32 result = (a << 24) >> 24;	Troncamento di `int32` a `int8`, segno che estende il risultato.
int-to-char	int32 a; int32 result = a & 0xffff;	Troncamento di `int32` a `uint16`, senza estensione del segno.
int-to-short	int32 a; int32 result = (a << 16) >> 16;	Troncamento di `int32` a `int16`, segno che estende il risultato.
add-int	int32 a, b; int32 result = a + b;	Somma con il complemento a due.
sub-int	int32 a, b; int32 result = a - b;	Sottrazione con il complemento a due.
rsub-int	int32 a, b; int32 result = b - a;	Sottrazione inversa con il complemento a due.
mul-int	int32 a, b; int32 result = a * b;	Moltiplicazione con il complemento a due.
div-int	int32 a, b; int32 result = a / b;	Divisione con il complemento a due, arrotondata per difetto (ovvero troncata a numero intero). Viene generato un errore `ArithmeticException` se `b == 0`.
rem-int	int32 a, b; int32 result = a % b;	Resto del complemento a due dopo la divisione. Il segno del risultato è uguale a quello di `a` ed è definito con maggiore precisione come `result == a - (a / b) * b`. Viene generato un `ArithmeticException` se `b == 0`.
and-int	int32 a, b; int32 result = a & b;	E a livello di bit.
or-int	int32 a, b; int32 result = a \| b;	O a livello di bit.
xor-int	int32 a, b; int32 result = a ^ b;	XOR a livello di bit.
shl-int	int32 a, b; int32 result = a << (b & 0x1f);	Spostamento a sinistra a livello di bit (con argomento mascherato).
shr-int	int32 a, b; int32 result = a >> (b & 0x1f);	Spostamento a destra con segno a livello di bit (con argomento mascherato).
ushr-int	uint32 a, b; int32 result = a >> (b & 0x1f);	Spostamento a destra senza segno a livello di bit (con argomento mascherato).
add-long	int64 a, b; int64 result = a + b;	Somma con il complemento a due.
sottolunghezza	int64 a, b; int64 result = a - b;	Sottrazione con il complemento a due.
mul-long	int64 a, b; int64 result = a * b;	Moltiplicazione con il complemento a due.
div-long	int64 a, b; int64 result = a / b;	Divisione con il complemento a due, arrotondata per difetto (ovvero troncata a numero intero). Viene generato un errore `ArithmeticException` se `b == 0`.
rem-long	int64 a, b; int64 result = a % b;	Resto del complemento a due dopo la divisione. Il segno del risultato è uguale a quello di `a` ed è definito con maggiore precisione come `result == a - (a / b) * b`. Viene generato un `ArithmeticException` se `b == 0`.
and-long	int64 a, b; int64 result = a & b;	E a livello di bit.
or-long	int64 a, b; int64 result = a \| b;	O a livello di bit.
xor-long	int64 a, b; int64 result = a ^ b;	XOR a livello di bit.
shl-long	int64 a; int32 b; int64 result = a << (b & 0x3f);	Spostamento a sinistra a livello di bit (con argomento mascherato).
shr-long	int64 a; int32 b; int64 result = a >> (b & 0x3f);	Spostamento a destra con segno a livello di bit (con argomento mascherato).
ushr-long	uint64 a; int32 b; int64 result = a >> (b & 0x3f);	Spostamento a destra senza segno a livello di bit (con argomento mascherato).
add-float	float a, b; float result = a + b;	Somma con virgola mobile.
sotto-float	float a, b; float result = a - b;	Sottrazione con virgola mobile.
mul-float	float a, b; float result = a * b;	Moltiplicazione in virgola mobile.
div-float	float a, b; float result = a / b;	Divisione con virgola mobile.
rem-float	float a, b; float result = a % b;	Resto in virgola mobile dopo la divisione. Questa funzione è diversa dal resto IEEE 754 ed è definita come `result == a - roundTowardZero(a / b) * b`.
add-double	double a, b; double result = a + b;	Somma con virgola mobile.
doppia mini	double a, b; double result = a - b;	Sottrazione con virgola mobile.
mul-double	double a, b; double result = a * b;	Moltiplicazione in virgola mobile.
div-double	double a, b; double result = a / b;	Divisione con virgola mobile.
rem-double	double a, b; double result = a % b;	Resto in virgola mobile dopo la divisione. Questa funzione è diversa dal resto IEEE 754 ed è definita come `result == a - roundTowardZero(a / b) * b`.