Bytecode Dalvik
Antes conviene leer «Formato DEX»
1. Qué es y por qué existe
Al compilar una app Android, el código Java o Kotlin no se convierte en instrucciones del procesador. Se convierte en bytecode Dalvik: un juego de instrucciones sencillas, igual en todos los móviles, que se guarda en los ficheros classes.dex del APK. En el teléfono, ART (el entorno de ejecución de Android) las interpreta o las traduce a código máquina con dex2oat (su compilador). Cada método guarda sus instrucciones en el array insns de su code_item, el bloque de datos que describe el código del método («Formato DEX → §11 · code_item»). Un decompilador tiene que remontar esas instrucciones hasta Java. Los términos técnicos de este documento están en el «Glosario».
Java/Kotlin → javac/kotlinc → .class → D8/R8 → classes.dex → ART
javac y kotlinc compilan a .class, el bytecode de la JVM (la máquina virtual de Java). D8 convierte los .class a DEX. R8 hace lo mismo y además reduce y ofusca el código («sección 1.2 · Qué compilador escribió el bytecode»).
Ojo: no siempre es toda la app. En las que usan un marco como Flutter, Unity o React Native, el código propio vive en otro sitio y el classes.dex es solo un envoltorio («sección 1.1 · Cuando el bytecode no es toda la app»). Y no son pocas: dos de cada tres apps del mercado chino llevan un marco así, y en F-Droid, una de cada seis. Un ejemplo es Block Puzzle Jewel 131.0 (APKPure), una app con un marco fuera del DEX.
Dalvik está basado en registros y no en pila. Cada método tiene un marco de registros de tamaño fijo, decidido al compilar: casillas numeradas v0, v1… Cada instrucción dice de cuáles lee y en cuál escribe. La JVM, en cambio, trabaja con una pila: apila los operandos y cada operación coge los de arriba y empuja el resultado. Se ve en el mismo código. Este método:
public static int f(int a, int b) { return a + b * 2; }
compilado a .class y volcado con javap -c, y luego pasado por d8 y volcado con
dexdump -d:
JVM (pila, 6 instrucciones) Dalvik (registros, 3 instrucciones)
0: iload_0 0000: mul-int/lit8 v1, v1, #int 2
1: iload_1 0002: add-int/2addr v0, v1
2: iconst_2 0003: return v0
3: imul
4: iadd
5: ireturn
Esto le cambia tres cosas a quien decompila:
- No hay pila que reconstruir, pero sí un grafo de definiciones y usos. El decompilador no tiene que simular una pila. Tiene que averiguar qué valor hay en cada registro en cada punto del método. Para ello da un nombre distinto a cada valor que se asigna, de modo que cada nombre se escribe una sola vez. Es la forma SSA (static single assignment, asignación única estática).
- Los registros se reutilizan.
v1puede ser uninten una parte del método y una referencia a un objeto en otra. Sindebug_info_itemno hay nombres ni tipos declarados («Formato DEX → §12 · debug_info_item»), y el tipo de cada registro se infiere del uso, exactamente como hace el verificador deART(«sección 10 · La verificación de bytecode de ART»). - Las constantes literales pequeñas se funden en la instrucción.
iconst_2+imulse convierten en un solomul-int/lit8. La estructura del código fuente se pierde antes que en la JVM.
El diseño se declara «pensado para imitar de forma aproximada arquitecturas reales y convenciones de llamada al estilo de C», y de ahí salen las reglas del modelo de registros.
1.1 Cuando el bytecode no es toda la app
Un classes.dex no siempre contiene la lógica de la app. Algunos marcos de desarrollo la guardan fuera del bytecode Dalvik y dejan en el DEX solo un envoltorio: unas pocas clases que arrancan el motor. Si abres el classes.dex de una app Flutter y solo ves clases io.flutter.embedding, no has hecho nada mal: el código de la app está en otro fichero.
| Marco | Dónde está el código de la app | F-Droid | Google Play (más instaladas) | Google Play (sorteo) | Mercado chino |
|---|---|---|---|---|---|
| Flutter | libapp.so (código nativo compilado) |
11 % | 5 % | 18 % | 17 % |
| React Native | index.android.bundle (JavaScript o bytecode de Hermes) |
2 % | 8 % | 10 % | 25 % |
| Unity (IL2CPP) | libil2cpp.so y global-metadata.dat |
0 % | 17 % | 23 % | 13 % |
| Xamarin / .NET | ensamblados .NET | 0 % | 0,2 % | 0,3 % | 0 % |
Cada celda es el porcentaje de apps de esa fuente que llevan el marco. IzzyOnDroid se parece a F-Droid: Flutter en el 11 %, React Native en el 1 %, Xamarin en el 0,6 % y Unity en ninguna. La columna «Dónde está el código» es conocimiento del marco, no una medición: lo único que hemos medido es el tamaño de esos ficheros.
El peso del DEX lo confirma. En una app Flutter de F-Droid, los classes*.dex son apenas el 3,9 % de los bytes sin comprimir (mediana); en una sin marco, el 60,4 %. En Google Play la diferencia es menor, pero se ve igual. Todas las apps Unity que hemos visto usan IL2CPP. Las de React Native llevan casi siempre el motor Hermes, salvo en el mercado chino, donde predomina JavaScriptCore. Un ejemplo de Unity con IL2CPP es com.JindoBlu.Antistress 11.4.3 (APKMirror). Para el código nativo, véase «Código nativo ELF».
1.2 Qué compilador escribió el bytecode
El mismo código fuente da bytecode distinto según la herramienta que lo convierte. Las dos actuales, D8 y R8, dejan una firma: una cadena ~~D8{…} o ~~R8{…} dentro del DEX, con la versión del compilador y el min-api (la API mínima de Android para la que compilan). Se ve con strings -a classes.dex | grep '~~'. dx y Jack, ya abandonados, no dejan marcador. Esto es lo que encontramos en los DEX de la pieza base o única de cada app y de sus splits de funcionalidad:
| Fuente | R8 | D8 | sin marcador |
|---|---|---|---|
| F-Droid | 58 % | 39 % | 3 % |
| IzzyOnDroid | 66 % | 32 % | 2 % |
| Google Play (más instaladas) | 62 % | 26 % | 12 % |
| Google Play (sorteo) | 43 % | 52 % | 5 % |
| Mercado chino | 28 % | 5 % | 67 % |
Dos lecturas útiles. En F-Droid, las apps sin marcador usan todas la versión 035 del DEX, la que escribían dx y Jack. En el mercado chino, en cambio, lo raro es llevar marcador. Allí APKiD (una herramienta que reconoce compiladores y protectores) ve en la mayoría la huella de dexlib, la biblioteca con la que se regenera un DEX (la de smali y apktool, que usan también varios protectores). Y en Google Play, las apps sin marcador no son todas de dx: más de la mitad tienen DEX 037 o 039, así que hay otra herramienta detrás, por ejemplo un protector que regeneró el DEX.
La versión del DEX casa con el min-api del marcador en casi todos: 035 por debajo de la API 24, 037 en la 24–25, 038 en la 26–27 y 039 desde la 28. Solo fallan 4 DEX de más de 7.000 en F-Droid e IzzyOnDroid; en Google Play y en el mercado chino casan todos. Dos ejemplos de F-Droid: com.looker.droidify 780 lleva ~~R8 {version 9.4.14, r8-mode full, min-api 23} y cabecera 035; com.termux 1022 lleva ~~R8 {version 2.2.71, r8-mode compatibility, min-api 24} y cabecera 037. Un ejemplo sin marcador, con cabecera 035, es ru.zxalexis.ugaday 15. Véase «R8 y ProGuard».
1.3 Cómo leer una línea de dexdump
Antes de entrar en los formatos, conviene saber leer una línea de la salida de dexdump -d. Esta es real, del classes.dex de com.termux 1022 (F-Droid), en el desplazamiento 0x188d92:
188d92: 6e30 bf4c 0201 |0011: invoke-virtual {v2, v0, v1}, L…;.setLogLevel:(L…/Context;I)V // method@4cbf
188d92es el desplazamiento de la instrucción dentro del ficheroclasses.dex, en hexadecimal.6e30 bf4c 0201son sus bytes, en el orden del fichero y agrupados de dos en dos. Cada grupo es una unidad de 16 bits («sección 2 · Reglas generales del modelo de ejecución»).0011es la dirección de la instrucción dentro del método, contada en unidades de 16 bits. Los saltos usan esta dirección, no el desplazamiento del fichero.invoke-virtual {v2, v0, v1}, …es la instrucción: el mnemónico, los registros que lleva y el método al que llama.// method@4cbfes el índice del método en la tablamethod_ids. La instrucción solo guarda ese número ydexdumplo traduce a texto («sección 9 · Los descriptores en las instrucciones»).
El resto del documento explica cómo se leen esos bytes: qué es el opcode, dónde van los registros y qué número de tabla es el índice.
2. Reglas generales del modelo de ejecución
- La unidad de almacenamiento del flujo de instrucciones es una cantidad de 16 bits sin
signo. Toda instrucción ocupa un número entero de esas unidades: 1, 2, 3, 4 o 5. La
longitud la da el primer dígito del identificador de formato («sección 4.1 · Cómo se lee el identificador»); las de cuatro
unidades son solo
45ccy4rcc—invoke-polymorphiceinvoke-polymorphic/range, opcodesfayfb, añadidas en la versión 038 delDEX— y la única de cinco es51l. - Los registros son de 32 bits cuando llevan valores de bits. Los de 64 bits usan pares
de registros adyacentes, y no hay requisito de alineación para esos pares:
vNyvN+1valen aunqueNsea impar. - Cuando llevan referencias a objeto, un registro es lo bastante ancho para contener
exactamente una. En representación de bits,
(Object) null == (int) 0. - Los marcos son de tamaño fijo desde su creación:
registers_sizedelcode_item. - Hay pools de constantes separados e indexados por separado para cadenas, tipos, campos y métodos. Los datos literales de bits van en línea en el flujo de instrucciones.
- Las instrucciones no están limitadas a un tipo sin necesidad: las que mueven 32 bits sin
interpretarlos no distinguen
intdefloat. - El orden de los argumentos es destino primero, fuentes después.
- Existen pseudoinstrucciones que solo transportan datos de longitud variable
(
packed-switch-payload,sparse-switch-payload,fill-array-data-payload, «sección 8 · Los payloads»). Nunca deben alcanzarse en el flujo normal de ejecución y deben estar alineadas a 4 bytes, para lo cual el generador inserta unnopde relleno si hiciera falta.
3. Modelo de registros
Un método dispone de registers_size registros, numerados v0 a v(registers_size − 1).
La regla que lo gobierna todo es:
Los N argumentos de un método caen en los últimos N registros del marco, en orden. Los argumentos anchos consumen dos registros. A los métodos de instancia se les pasa una referencia
thiscomo primer argumento.
De ahí los tres campos del code_item:
| Campo | Qué cuenta |
|---|---|
registers_size |
Total de registros del marco: locales más argumentos |
ins_size |
Palabras de argumento de entrada. Incluye el this implícito y cuenta 2 por cada argumento ancho |
outs_size |
Palabras de argumento de salida: el ancho del mayor invoke-* que aparece en el cuerpo. Es 0 si el método no invoca a nadie |
Los registros de locales son entonces v0 … v(registers_size − ins_size − 1), y los de
argumentos, los ins_size últimos.
La sintaxis smali da a esos últimos un segundo nombre: p0, p1, … pN, donde p0
es el primer argumento —el this en un método de instancia— y así sucesivamente. Es un
alias, no otro registro, pN = v(registers_size − ins_size + N):
método LMyObject;->callMe(II)V con .registers 5
v0 ────────── primera local
v1 ────────── segunda local
v2 ═══ p0 ═══ referencia this
v3 ═══ p1 ═══ primer parámetro int
v4 ═══ p2 ═══ segundo parámetro int
Las dos directivas de smali que declaran el tamaño del marco cuentan cosas distintas:
.registers da el total y .locals da solo los no parámetros. Confundirlas es el
error clásico al editar smali a mano, y produce un code_item con registers_size
insuficiente que la verificación de ART rechaza («sección 10 · La verificación de bytecode de ART»). Las dos notaciones y las dos
directivas, con los tipos anchos, están en las secciones «3.4» y «3.5» de
«Desensambladores smali».
3.1 Cómo cuadran los números en métodos reales
Los tres primeros métodos son de com.termux 1022 (F-Droid) y los campos salen de dexdump -d sobre su classes.dex. El cuarto, Sum.f, lo compilamos aparte («sección 11 · Correspondencia con smali») y no es del muestrario.
com.termux.app.TermuxApplication.onCreate:()V (desplazamiento 0x188ca4) es un método de instancia sin parámetros: registers: 6, ins: 1, outs: 3. Es decir: v0 a v4 son locales y v5 es el único argumento de entrada, o sea p0, o sea this. En efecto, la primera instrucción del cuerpo es invoke-super {v5}, Landroid/app/Application;.onCreate:()V.
com.termux.app.TermuxApplication.setLogConfig:(Landroid/content/Context;)V (0x188d60) es estático con un parámetro: registers: 3, ins: 1, outs: 3. v0 y v1 son locales y v2 es p0, el Context. No hay this, porque el método es estático.
androidx.core.graphics.TypefaceCompatUtil.closeQuietly:(Ljava/io/Closeable;)V (0x0e48cc) es estático con un parámetro y ninguna local: registers: 1, ins: 1, outs: 1. v0 es el único registro y es el parámetro, p0.
Sum.f(II)I, estático con dos parámetros, da registers: 2, ins: 2, outs: 0. v0 = a = p0, v1 = b = p1, y outs vale 0 porque el método no llama a nadie.
Los campos de un classes.dex los puedes repetir con python3 -I scripts/muestrario/cifras/dex_y_bytecode_1.py --registros classes.dex (resumen) y con dexdump -d (los campos de un método).
3.2 Por qué existen las variantes /from16, /16 y /range
Pocos métodos necesitan más de 16 registros, y por eso muchas instrucciones solo pueden
direccionar los 16 primeros (campos de 4 bits). ¿Cuántos son pocos? En el classes.dex de com.termux 1022, menos del 1 % de los métodos con código pasa de 16 registros; en el de com.looker.droidify 780, el 3,5 %, y ninguno pasa de 256. Aun así, casi todo classes.dex tiene algún método grande: más del 90 % de los DEX con código tiene alguno con más de 16 registros. Que haya uno no quiere decir que haya muchos. Cuando es razonable, el formato admite hasta 256
(campos de 8 bits). Y unas pocas variantes llegan al rango completo v0–v65535. Si una
operación necesita un registro alto y su instrucción no lo alcanza, el compilador emite un move
de copia antes o después. Son dos instrucciones del classes.dex de com.termux 1022:
0x188cba: 6e10 f100 0500 invoke-virtual {v5}, …getApplicationContext() ← 35c: registro de 4 bits
0x08f206: 0509 1400 move-wide/from16 v9, v20 ← 22x: destino de 8 bits, origen de 16
La primera es de TermuxApplication.onCreate. La segunda es de TwilightCalculator.calculateTwilight, que tiene 22 registros: v20 no cabe en los cuatro bits de move-wide, y por eso el compilador usa /from16.
Esas copias no son raras: las variantes /from16 y /16 de move son entre el 1,3 % y el 2 % de todas las instrucciones, según la fuente. Casi todas son /from16, y sobre todo move-object/from16; las /16 apenas aparecen. El recuento no dice por qué el compilador emitió cada move. Las copias por registro alto son la explicación habitual, pero /from16 también aparece en código con muchos locales por otras razones. En el classes.dex de com.termux 1022 hay 55 move-wide/from16.
4. Formatos de instrucción
4.1 Cómo se lee el identificador
Un identificador de formato tiene tres caracteres —dos dígitos y una letra— y se lee así:
- Primer dígito: número de unidades de 16 bits que ocupa la instrucción.
- Segundo dígito: número máximo de registros que el formato contiene. La letra
ren su lugar significa que se codifica un rango de registros. - Letra final: de forma semimnemónica, el tipo de dato extra que lleva.
Así, 21t es de dos unidades, contiene una referencia a registro y lleva además un
destino de salto.
Hay también identificadores de cuatro caracteres acabados en s o i (22cs, 35ms,
35mi…). La especificación los llama formatos sugeridos de enlazado estático o inline.
Son historia: los usaba una optimización que reescribía el bytecode al instalar la app
(quickening), primero en Dalvik, que producía los .odex, y después en ART hasta Android
11. Desde Android 12 esos opcodes están sin usar y nunca aparecen en un APK, así que se pueden
ignorar. Ningún ART actual los emite, no aparecen en un DEX distribuido y su implementación
no es obligatoria. Las versiones de Android y los rangos de opcodes concretos están en las
fuentes 7 y 8.
En el muestrario no hay ninguna de esas instrucciones: ningún classes*.dex lleva un opcode
sin asignar (y ahí entran los de la antigua optimización quick), ni en F-Droid, ni en IzzyOnDroid, ni en Google Play, ni en el mercado chino. Tampoco hay ficheros
.odex, .vdex, .oat ni .art en ninguna pieza. El recuento recorre los insns de todos
los code_item y salta los payloads. No cubre los .dex de assets/ ni las .so, así que un
protector que cifre el DEX real fuera de la raíz queda fuera.
| Letra | Tamaño en bits | Significado |
|---|---|---|
b |
8 | Byte inmediato con signo |
c |
16, 32 | Índice de pool de constantes |
f |
16 | Constantes de interfaz (solo en formatos enlazados estáticamente) |
h |
16 | «Hat» inmediato con signo: los bits altos de un valor de 32 o 64 bits, con los bajos a 0 |
i |
32 | Entero inmediato con signo, o float de 32 bits |
l |
64 | long inmediato con signo, o double de 64 bits |
m |
16 | Constantes de método (solo en formatos enlazados estáticamente) |
n |
4 | Nibble inmediato con signo |
s |
16 | short inmediato con signo |
t |
8, 16, 32 | Destino de salto |
x |
0 | Sin datos adicionales |
En la sintaxis, vX es un registro, #+X un literal, +X un desplazamiento relativo de
dirección y kind@X un índice de pool, donde kind es string, type, field, meth,
proto, method_handle o site.
4.2 Layout de bits
Cada «palabra» separada por espacios es una unidad de 16 bits. Cada carácter representa
cuatro bits, leídos de los altos a los bajos; op marca el opcode de ocho bits y ØØ un
nibble que debe valer cero. Las letras nombran los campos.
Cómo leer los volcados. Cada unidad de 16 bits se guarda con el byte bajo primero
(little-endian). dexdump y xxd muestran los bytes en el orden del fichero, así que 6e30
es la unidad 0x306e: el byte bajo, 6e, es el opcode, y el alto, 30, lleva los operandos. En
los layouts de abajo, B|A|op se lee de los bits altos a los bajos: op en el byte bajo, A
en los cuatro bits siguientes y B en los cuatro más altos. Cuatro bits son un nibble, medio
byte. Por ejemplo, 6e30 bf4c 0201 son tres unidades: 0x306e, 0x4cbf y 0x0102. Es una
instrucción de com.termux 1022, en el desplazamiento 0x188d92 de su classes.dex.
layout id sintaxis
─────────────────────────────────────────────────────────────────────────────
(ninguno) 00x pseudoformato de los opcodes sin usar
ØØ|op 10x op
B|A|op 12x op vA, vB
B|A|op 11n op vA, #+B
AA|op 11x op vAA
AA|op 10t op +AA
ØØ|op AAAA 20t op +AAAA
AA|op BBBB 22x op vAA, vBBBB
AA|op BBBB 21t op vAA, +BBBB
AA|op BBBB 21s op vAA, #+BBBB
AA|op BBBB 21h op vAA, #+BBBB0000 | #+BBBB000000000000
AA|op BBBB 21c op vAA, type@BBBB · field@BBBB · string@BBBB
· proto@BBBB · method_handle@BBBB
AA|op CC|BB 23x op vAA, vBB, vCC
AA|op CC|BB 22b op vAA, vBB, #+CC
B|A|op CCCC 22t op vA, vB, +CCCC
B|A|op CCCC 22s op vA, vB, #+CCCC
B|A|op CCCC 22c op vA, vB, type@CCCC · field@CCCC
ØØ|op AAAAlo AAAAhi 30t op +AAAAAAAA
ØØ|op AAAA BBBB 32x op vAAAA, vBBBB
AA|op BBBBlo BBBBhi 31i op vAA, #+BBBBBBBB
AA|op BBBBlo BBBBhi 31t op vAA, +BBBBBBBB
AA|op BBBBlo BBBBhi 31c op vAA, string@BBBBBBBB
A|G|op BBBB F|E|D|C 35c [A=5] op {vC,vD,vE,vF,vG}, meth@BBBB · site@BBBB
· type@BBBB; A=0..5 fija cuántos se usan
AA|op BBBB CCCC 3rc op {vCCCC .. vNNNN}, meth@BBBB
NNNN = CCCC+AA-1; AA es la cuenta (0..255)
A|G|op BBBB F|E|D|C HHHH 45cc op {vC..vG}, meth@BBBB, proto@HHHH
AA|op BBBB CCCC HHHH 4rcc op {vCCCC..vNNNN}, meth@BBBB, proto@HHHH
AA|op BBBBlo BBBB BBBB BBBBhi 51l op vAA, #+BBBBBBBBBBBBBBBB
El resto de identificadores que aparecen en la especificación —22cs, 35ms, 35mi,
3rms, 3rmi— son los formatos sugeridos de enlazado que se mencionan en 4.1. 20bc es
aparte: la especificación lo da como «suggested format for statically determined
verification errors».
La rareza de 35c merece explicación: las letras no van en orden de bits. A es la
cuenta de palabras de argumento y está en el nibble alto de la primera unidad; G es el
quinto registro y está en el nibble bajo del byte alto; y C, D, E y F van en la tercera
unidad, de los bits bajos a los altos. Se hizo así para que la cuenta y el índice de referencia
lleven la misma letra que en 3rc.
Volvamos a la instrucción de 1.3, de com.termux 1022 (classes.dex, desplazamiento 0x188d92):
6e30 bf4c 0201. 6e es el opcode. 3 es la cuenta de palabras de argumento (A) y 0 es el
quinto registro (G, que aquí no se usa). bf4c es la unidad 0x4cbf, el índice del método.
0201 es la unidad 0x0102, con C=2, D=0, E=1, F=0, o sea {v2, v0, v1}.
4.3 Cómo se empaquetan, con instrucciones reales del muestrario
11x 0f00 → return v0
byte0 = 0f = opcode byte1 = 00 = AA = 0 → vAA = v0
11n 1201 → const/4 v1, #int 0
byte0 = 12 = opcode byte1 = 01: A = nibble bajo = 1 → vA = v1
B = nibble alto = 0 → #+0
12x b010 → add-int/2addr v0, v1
byte0 = b0 = opcode byte1 = 10: A = 0 → v0 B = 1 → v1
21t 3900 0300 → if-nez v0, +0003
unidad0 = 0x0039: op = 39, AA = 00 → v0
unidad1 = 0x0003: BBBB = +3
21c 1f01 ea01 → check-cast v1, type@01ea
unidad0 = 0x011f: op = 1f, AA = 01 → v1
unidad1 = 0x01ea: BBBB = índice 0x01ea en type_ids
22b da01 0102 → mul-int/lit8 v1, v1, #int 2
unidad0 = 0x01da: op = da, AA = 01 → vAA = v1
unidad1 = 0x0201: BB = byte bajo = 01 → vBB = v1
CC = byte alto = 02 → #+2
22c 5b01 941f → iput-object v1, v0, field@1f94
unidad0 = 0x015b: op = 5b, byte1 = 01: A = 1 → v1, B = 0 → v0
unidad1 = 0x1f94: CCCC = índice 0x1f94 en field_ids
35c 6e30 0b4b 1002 → invoke-virtual {v0, v1, v2}, meth@4b0b
unidad0 = 0x306e: op = 6e, A = 3 (tres palabras), G = 0
unidad1 = 0x4b0b: BBBB = meth@4b0b
unidad2 = 0x0210: C = 0, D = 1, E = 2, F = 0 → se usan C, D y E
3rc 7406 210f 0100 → invoke-virtual/range {v1 .. v6}, meth@0f21
unidad0 = 0x0674: op = 74, AA = 06 → seis registros
unidad1 = 0x0f21: BBBB = meth@0f21
unidad2 = 0x0001: CCCC = 1 → v1 .. v(1+6-1) = v6
51l 1801 00da 626d dc00 0000 → const-wide v1, #000000dc6d62da00
unidad0 = 0x0118: op = 18, AA = 01 → v1
unidades 1..4, de la baja a la alta: 0xda00 0x6d62 0x00dc 0x0000
5. Sufijos de las instrucciones
Hay dos clases de sufijo y se distinguen por el separador.
Sufijos de tipo, unidos con guion. Marcan sobre qué opera la instrucción:
| Sufijo | Significado |
|---|---|
| (ninguno) | Opcode genérico de 32 bits: no distingue int de float |
-wide |
Opcode genérico de 64 bits: usa pares de registros |
-object |
Referencia a objeto |
-boolean, -byte, -char, -short, -int, -long, -float, -double |
El tipo concreto |
-string, -class, -void |
El tipo concreto, en las instrucciones donde aplica |
Que move y move-object sean instrucciones distintas aunque muevan los mismos 32 bits no
es redundancia: el verificador necesita saber si el registro destino pasa a contener una
referencia, y el recolector de basura necesita saber qué registros escanear.
Sufijos de variante, unidos con barra. No cambian la semántica, cambian la codificación. Existen «sobre todo para que haya una correspondencia uno a uno con las constantes estáticas del código que genera e interpreta ejecutables». La tabla tiene una fila por sufijo; la columna «Qué cambia» dice qué cambia en la instrucción al añadirlo.
| Sufijo | Qué cambia | Ejemplo |
|---|---|---|
/from16 y /16 |
Amplían el ancho de una referencia a registro | move/from16 v0, v300 |
/32 y /jumbo |
Amplían el ancho de un literal o de un índice | const-string/jumbo |
/range |
Cambia una lista de registros por un rango | invoke-virtual/range {v1 .. v6}, … |
/lit8 y /lit16 |
Fijan el ancho de una constante dentro de la instrucción | add-int/lit8 v0, v1, 5 |
/2addr |
El destino es también el primer operando fuente | add-int/2addr v0, v1 ⇒ v0 = v0 + v1 |
6. La tabla de opcodes
Los 256 valores del opcode, agrupados por familia. (sin usar) marca los rangos reservados.
Es la tabla con la que arranca cualquier desensamblador: el opcode da el formato, y el primer
dígito del formato («sección 4.1 · Cómo se lee el identificador»), la longitud de la instrucción en unidades de 16 bits. La
excepción que hay que conocer es 00: si el byte alto de esa unidad vale 01, 02 o 03, no
es un nop sino el principio de un payload, y su longitud sale de su propia cabecera
(«sección 8 · Los payloads»). La tabla agrupa por familias; el formato de cada opcode está en la «sección 6.1 · Formato de cada opcode».
| Opcodes | Formato | Mnemónicos | Qué hace la familia |
|---|---|---|---|
00 |
10x |
nop |
Gasta ciclos. También etiqueta las pseudoinstrucciones de datos («sección 8 · Los payloads») |
01–09 |
12x, 22x, 32x |
move, move/from16, move/16, move-wide, move-wide/from16, move-wide/16, move-object, move-object/from16, move-object/16 |
Copia entre registros; tres anchos de referencia a registro por cada tipo |
0a–0d |
11x |
move-result, move-result-wide, move-result-object, move-exception |
Recogen el resultado del invoke-* o del filled-new-array inmediatamente anterior, o la excepción capturada. Solo son válidos en esa posición exacta |
0e–11 |
10x, 11x |
return-void, return, return-wide, return-object |
Retorno |
12–19 |
11n, 21s, 31i, 21h, 51l |
const/4, const/16, const, const/high16, const-wide/16, const-wide/32, const-wide, const-wide/high16 |
Constantes numéricas. /high16 carga los 16 bits altos y rellena el resto de ceros |
1a–1c |
21c, 31c |
const-string, const-string/jumbo, const-class |
Referencias a cadena y a clase. jumbo es el único índice de 32 bits del juego |
1d–1e |
11x |
monitor-enter, monitor-exit |
Bloqueo. Es como se implementa synchronized en un método no nativo |
1f–20 |
21c, 22c |
check-cast, instance-of |
Comprobación de tipo |
21, 23–26 |
12x, 22c, 35c, 3rc, 31t |
array-length, new-array, filled-new-array, filled-new-array/range, fill-array-data |
Arrays: longitud, creación y relleno |
22 |
21c |
new-instance |
Reserva la instancia; el constructor se llama aparte con invoke-direct |
27 |
11x |
throw |
Lanza la excepción del registro |
28–2a |
10t, 20t, 30t |
goto, goto/16, goto/32 |
Salto incondicional. El desplazamiento no puede ser 0 salvo en goto/32 |
2b–2c |
31t |
packed-switch, sparse-switch |
Salto por tabla; los datos van en un payload aparte («sección 8 · Los payloads») |
2d–31 |
23x |
cmpl-float, cmpg-float, cmpl-double, cmpg-double, cmp-long |
Comparación de tres valores: 0, 1 o −1. Si alguno de los dos es NaN, cmpl-* devuelve −1 y cmpg-* devuelve 1. El compilador elige uno u otro según la comparación que venga detrás |
32–37 |
22t |
if-eq, if-ne, if-lt, if-ge, if-gt, if-le |
Salto condicional comparando dos registros |
38–3d |
21t |
if-eqz, if-nez, if-ltz, if-gez, if-gtz, if-lez |
Salto condicional comparando con cero |
3e–43 |
— | (sin usar) | |
44–51 |
23x |
aget, aget-wide, aget-object, aget-boolean, aget-byte, aget-char, aget-short, y los siete aput-* correspondientes |
Lectura y escritura de elemento de array: valor, array, índice |
52–5f |
22c |
iget…iget-short, iput…iput-short |
Campo de instancia; el operando es field@CCCC |
60–6d |
21c |
sget…sget-short, sput…sput-short |
Campo estático; el operando es field@BBBB |
6e–72 |
35c |
invoke-virtual, invoke-super, invoke-direct, invoke-static, invoke-interface |
Invocación con lista de hasta cinco registros («sección 7 · Las instrucciones de invocación») |
73 |
— | (sin usar) | |
74–78 |
3rc |
Los cinco invoke-*/range |
Invocación con rango de hasta 255 registros |
79–7a |
— | (sin usar) | |
7b–8f |
12x |
neg-int, not-int, neg-long, not-long, neg-float, neg-double, y las quince conversiones int-to-long … int-to-short |
Operaciones unarias y conversión de tipo |
90–af |
23x |
add/sub/mul/div/rem/and/or/xor/shl/shr/ushr-int, ídem -long, y add/sub/mul/div/rem -float y -double |
Binarias con tres registros |
b0–cf |
12x |
Las mismas con sufijo /2addr |
Binarias donde el destino es el primer operando |
d0–d7 |
22s |
add-int/lit16, rsub-int, mul-int/lit16, div-int/lit16, rem-int/lit16, and-int/lit16, or-int/lit16, xor-int/lit16 |
Binarias contra literal de 16 bits |
d8–e2 |
22b |
add-int/lit8 … xor-int/lit8, shl-int/lit8, shr-int/lit8, ushr-int/lit8 |
Binarias contra literal de 8 bits |
e3–f9 |
— | (sin usar) | |
fa–fd |
45cc, 4rcc, 35c, 3rc |
invoke-polymorphic, invoke-polymorphic/range, invoke-custom, invoke-custom/range |
Desde v038 («sección 7.2 · invoke-polymorphic e invoke-custom») |
fe–ff |
21c |
const-method-handle, const-method-type |
Desde v039 |
const-string/jumbo. Hace falta cuando el DEX tiene más de 65.536 cadenas: las de índice alto no caben en los 16 bits de const-string. Todos los DEX que hemos visto con más de 65.536 cadenas lo usan, sea cual sea la fuente. Y un DEX así no es raro: lo lleva alguna app en el 12 % de las de F-Droid y en casi la mitad de las del mercado chino. El DEX con más cadenas tiene 121.750 (mercado chino). También se usa sin necesidad, en DEX con 65.536 cadenas o menos. Es una elección del compilador (o de una herramienta anterior), y no hemos comprobado cuál. Un const-string/jumbo no prueba, por tanto, que el DEX sea grande. Dos ejemplos: dev.xero.paper 1 (IzzyOnDroid) lleva 69.277 cadenas en su classes.dex y lo necesita. name.seguri.android.getforegroundactivity 3 (F-Droid) lleva 8 con solo 179 cadenas y sin marcador de compilador, por ejemplo 000d28: 1b01 5d00 0000 const-string/jumbo v1, "android.settings.ACCESSIBILITY_SETTINGS" // string@0000005d.
Qué versiones del DEX circulan. La cabecera de cada DEX declara su versión. La 035 es la base. La 037 añadió los métodos default de interfaz. La 038 añadió invoke-polymorphic e invoke-custom. La 039 añadió const-method-handle y const-method-type. Las versiones 040 y 041 no aparecen en el muestrario. La tabla cuenta ficheros classes*.dex de la raíz de las piezas de código.
| Fuente | 035 | 037 | 038 | 039 |
|---|---|---|---|---|
| F-Droid | 44 % | 24 % | 21 % | 11 % |
| IzzyOnDroid | 42 % | 25 % | 22 % | 12 % |
| Google Play (más instaladas) | 33 % | 31 % | 14 % | 22 % |
| Google Play (sorteo) | 33 % | 50 % | 9 % | 8 % |
| Mercado chino | 77 % | 19 % | 2 % | 1 % |
La versión no depende de quien publica la app sino del min-api con que se compiló: D8 y R8 escriben 035 por debajo de la API 24, 037 en la 24–25, 038 en la 26–27 y 039 desde la 28 («sección 1.2 · Qué compilador escribió el bytecode»). Por eso el mercado chino, con muchas apps que aún apuntan a Android antiguo, se queda sobre todo en 035: 685 de 890 DEX. Los opcodes fa–ff casi nadie los usa, y cuando aparecen es en DEX de la versión que los admite: ningún DEX 035 o 037 lleva uno. invoke-polymorphic está en 60 DEX, invoke-polymorphic/range en 9 e invoke-custom en 1. invoke-custom/range, const-method-handle y const-method-type no aparecen ni una vez. Por apps, no llega al 2 % en ninguna fuente.
Dos detalles que se olvidan y producen bugs. shl-long, shr-long y ushr-long, así
como sus variantes /2addr, toman un par de registros para el valor a desplazar pero un
solo registro para la distancia de desplazamiento, al contrario que el resto de operaciones
-long. Y rsub-int no lleva sufijo porque es el opcode principal de su familia: resta
al revés, resultado = literal − registro.
6.1 Formato de cada opcode
Esta tabla da el formato de los 256 opcodes. Si todos los de un rango comparten formato, aparece
una vez. Si no, se listan uno a uno con su nombre. Coincide con la especificación y con
dex_instruction_list.h de android-17.0.0_r1.
| Opcodes | Formato |
|---|---|
00 |
10x |
01–09 |
01 move 12x · 02 move/from16 22x · 03 move/16 32x · 04 move-wide 12x · 05 move-wide/from16 22x · 06 move-wide/16 32x · 07 move-object 12x · 08 move-object/from16 22x · 09 move-object/16 32x |
0a–0d |
11x |
0e–11 |
0e return-void 10x · 0f return 11x · 10 return-wide 11x · 11 return-object 11x |
12–19 |
12 const/4 11n · 13 const/16 21s · 14 const 31i · 15 const/high16 21h · 16 const-wide/16 21s · 17 const-wide/32 31i · 18 const-wide 51l · 19 const-wide/high16 21h |
1a–1c |
1a const-string 21c · 1b const-string/jumbo 31c · 1c const-class 21c |
1d–1e |
11x |
1f–20 |
1f check-cast 21c · 20 instance-of 22c |
21–26 |
21 array-length 12x · 22 new-instance 21c · 23 new-array 22c · 24 filled-new-array 35c · 25 filled-new-array/range 3rc · 26 fill-array-data 31t |
27 |
11x |
28–2a |
28 goto 10t · 29 goto/16 20t · 2a goto/32 30t |
2b–2c |
31t |
2d–31 |
23x |
32–37 |
22t |
38–3d |
21t |
3e–43 |
10x (sin usar) |
44–51 |
23x |
52–5f |
22c |
60–6d |
21c |
6e–72 |
35c |
73 |
10x (sin usar) |
74–78 |
3rc |
79–7a |
10x (sin usar) |
7b–8f |
12x |
90–af |
23x |
b0–cf |
12x |
d0–d7 |
22s |
d8–e2 |
22b |
e3–f9 |
10x (sin usar) |
fa–fd |
fa invoke-polymorphic 45cc · fb invoke-polymorphic/range 4rcc · fc invoke-custom 35c · fd invoke-custom/range 3rc |
fe–ff |
21c |
Los opcodes sin usar llevan 10x tanto en la especificación como en ART, que los declara
k10x con kVerifyError y los rechaza al verificar; el 00x de la «sección 4.2 · Layout de bits» es el nombre
que la página de formatos da a ese pseudoformato. Para los operandos, la semántica y las
excepciones de cada instrucción, la referencia es la propia especificación,
«Dalvik bytecode format».
6.2 Qué instrucciones aparecen de verdad
La tabla de arriba lista 256 opcodes, pero en la práctica unos pocos hacen casi todo el trabajo. Quince instrucciones suman entre el 64 % y el 71 % de todas las que hay en los DEX, según la fuente (el 64 % en F-Droid e IzzyOnDroid, el 71 % en el mercado chino). Hablamos de miles de millones de instrucciones (3.300.976.257 en F-Droid). La tabla da el peso de las diez primeras de F-Droid y su valor en Google Play más instaladas, como porcentaje de todas las instrucciones de los DEX:
| Instrucción | F-Droid | Google Play |
|---|---|---|
invoke-virtual |
11,0 % | 10,7 % |
move-result-object |
6,7 % | 8,3 % |
invoke-static |
5,7 % | 6,4 % |
const/4 |
5,1 % | 4,6 % |
iget-object |
5,0 % | 6,3 % |
move-result |
4,9 % | 4,3 % |
invoke-direct |
3,7 % | 4,2 % |
if-eqz |
3,2 % | 3,4 % |
goto |
2,8 % | 2,7 % |
const-string |
2,7 % | 3,7 % |
La llamada y la recogida de su resultado (invoke-* y move-result*) son la mitad de la lista: el bytecode es, sobre todo, llamadas a métodos. Esto cuenta instrucciones presentes en el código, no ejecutadas.
Un método típico es corto: unas 35 unidades de 16 bits de media en todas las fuentes, unas 18 instrucciones. Muy pocos métodos de la app son native (menos del 1 %) y en torno al 5 % son abstractos; ni unos ni otros llevan instrucciones. Los métodos de más de 10.000 unidades son rarísimos, aunque existen: el más grande mide 133.042 unidades en F-Droid y 244.415 en Google Play. Cuidado con las medias: const/high16 es el 2,5 % de las instrucciones de F-Droid, pero su mediana por DEX es el 0,28 %. Unos pocos DEX con tablas de constantes enormes inflan el total.
Un ejemplo de método corto: el close() de OnBackPressedDispatcher$$ExternalSyntheticLambda1, en el classes.dex de com.looker.droidify 780, mide 8 unidades (ese classes.dex tiene 30.460 métodos con código).
7. Las instrucciones de invocación
7.1 Las cinco clásicas
Todas comparten el formato 35c, donde A es el número de palabras de argumento —no de
argumentos: uno ancho cuenta dos— y BBBB es el índice en method_ids. La variante
/range (3rc) cambia la lista de hasta cinco registros por un rango vCCCC … vNNNN con
NNNN = CCCC + AA − 1, lo que permite hasta 255 palabras. El resultado, si lo hay, se
recoge con un move-result* inmediatamente después.
| Instrucción | Cuándo se usa |
|---|---|
invoke-virtual |
Método virtual normal: ni estático, ni privado, ni constructor |
invoke-super |
La versión de la superclase más cercana, en vez de la del method_id de la clase llamante. Desde la versión 037 del DEX, si el method_id apunta a un método de interfaz, invoca la versión más específica no sobrescrita de esa interfaz —el mecanismo de los métodos default—. Antes de 037 un method_id de interfaz aquí era ilegal e indefinido |
invoke-direct |
Método directo no estático: instancia privada o constructor. Es el único que puede llamar a un método cuyo nombre empieza por < |
invoke-static |
Método estático, que siempre se considera directo |
invoke-interface |
Método de interfaz sobre un objeto cuya clase concreta no se conoce |
El par new-instance + invoke-direct <init> es la huella de un new de Java, y aparece
separado porque la reserva y la construcción son dos pasos distintos en el bytecode.
7.2 invoke-polymorphic e invoke-custom
invoke-polymorphic (fa, formato 45cc) y su /range (fb, 4rcc) sirven para llamar
a través de un MethodHandle, una especie de puntero a método de Java. Suelen llamar a
MethodHandle.invoke o MethodHandle.invokeExact, con los tipos que se pasan en ese momento.
Llevan dos índices: meth@BBBB, el método, y proto@HHHH, el prototipo que describe los
tipos de los argumentos realmente pasados y el retorno esperado. El primer registro es el
receptor. Existen desde la versión 038 del DEX.
invoke-custom (fc, formato 35c) y su /range (fd, 3rc) son la versión Dalvik del
invokedynamic de Java: una llamada cuyo destino no se decide al compilar. Su operando es
call_site@BBBB, un índice en call_site_ids, la tabla de call sites (sitios de llamada).
Se ejecuta en dos fases. En la resolución, la primera vez, ART comprueba si el call site
ya tiene un java.lang.invoke.CallSite asociado. Si no, llama al método de arranque
(bootstrap linker) con los argumentos que trae el call_site_item del DEX, y deja el
resultado apuntado en el call site. En la invocación, que se repite cada vez, se llama al
MethodHandle objetivo del CallSite resuelto, como si fuera un invoke-polymorphic. Si el
bootstrap falla, devuelve null o el MethodHandle no es del tipo pedido, se lanza
java.lang.BootstrapMethodError.
En un APK real esto es raro de ver: D8 desazucara las lambdas a clases sintéticas por
defecto, incluso con --min-api 26 (lo comprobamos con las build-tools 37.0.0). Desazucarar es
sustituir una construcción nueva del lenguaje por código más antiguo. De los 16.158 ficheros
classes*.dex del «muestrario», solo uno lleva
invoke-custom: el classes.dex de com.droidheat.musicplayer 35 (IzzyOnDroid), compilado con D8 1.4,
con cabecera 038 y 24 instrucciones invoke-custom. Ninguna otra app lleva un solo
call_site_ids; ni com.termux 1022 ni com.looker.droidify 780 la llevan. Lo que sí se ve es la huella
del desazucarado: alguna clase $$ExternalSyntheticLambda en más de un tercio de las apps de F-Droid y en la mitad de las más instaladas de Google Play. El nombre antiguo
también existe: el classes.dex de com.termux 1022, compilado con R8 2.2.71, tiene 69 clases -$$Lambda$…
y ninguna $$ExternalSyntheticLambda; el de com.looker.droidify 780, con R8 9.4.14, tiene 504 de estas y ninguna
-$$Lambda$. Una invoke-custom real, de la app de arriba: fc00 0000 0000 invoke-custom {}, call_site@0000, con A = 0 (ningún argumento), BBBB = 0x0000 y la tercera unidad a cero
porque no hay registros. Está en el desplazamiento 0x18a5ec del classes.dex, en
androidx.constraintlayout.core.motion.parse.KeyParser.parseAttributes.
invoke-polymorphic es más frecuente, pero también raro: no llega al 2 % de las apps en ninguna fuente. Un caso real, de
org.nsh07.wikireader 53 (F-Droid), en scala.runtime.Null$.releaseFence
del classes2.dex (versión 038, desplazamiento 0x1811d0): fa10 3126 0000 f907 invoke-polymorphic {v0}, Ljava/lang/invoke/MethodHandle;.invoke:([Ljava/lang/Object;)Ljava/lang/Object;, ()V // method@2631, proto@07f9. Es de la biblioteca de ejecución de Scala; no hemos mirado qué biblioteca la emite en
los otros 59 DEX con esta instrucción.
Se puede producir una invoke-custom a propósito. Este ejemplo lo compilamos aparte y no es del
muestrario. El fuente (Demo.java):
import java.util.function.IntSupplier;
public class Demo {
static int run() {
IntSupplier s = () -> 42;
return s.getAsInt();
}
}
Se compila y se pasa a DEX así:
BT=~/Library/Android/sdk/build-tools/37.0.0
javac --release 8 Demo.java
$BT/d8 --min-api 26 --no-desugaring --output . Demo.class
$BT/dexdump -d classes.dex
0001a8: fc00 0000 0000 |0000: invoke-custom {}, call_site@0000
0001ae: 0c00 |0003: move-result-object v0
0001b0: 7210 0500 0000 |0004: invoke-interface {v0}, L…/IntSupplier;.getAsInt:()I
0001b6: 0a00 |0007: move-result v0
0001b8: 0f00 |0008: return v0
…
Method handle #0: type: invoke-static target: LDemo; lambda$run$0 target_type: ()I
Method handle #1: type: invoke-static target: LambdaMetafactory metafactory
Call site #0:
link_argument[0] : 1 (MethodHandle) ← el bootstrap: LambdaMetafactory.metafactory
link_argument[1] : getAsInt (String) ← el nombre a resolver
link_argument[2] : ()Ljava/util/function/IntSupplier; (MethodType)
link_argument[3] : ()I (MethodType)
link_argument[4] : 0 (MethodHandle) ← la implementación: Demo.lambda$run$0
link_argument[5] : ()I (MethodType)
La codificación de la instrucción es fc00 0000 0000: op = fc, A = 0 (cero argumentos),
BBBB = 0x0000 (call_site@0000) y la tercera unidad a cero porque no hay registros. Se ve
también que el desugaring de D8 es lo que hace desaparecer el call_site_ids de un
APK normal: sin --no-desugaring, el mismo fuente produce una clase sintética LDemo$0;
que implementa IntSupplier y un invoke-static corriente.
8. Los payloads
Tres pseudoinstrucciones transportan datos de longitud variable. Se identifican por una
primera unidad de 16 bits cuyo byte bajo es 00 —el opcode nop— y cuyo byte alto indica de
qué payload se trata. Deben estar alineadas a 4 bytes y nunca deben alcanzarse en el flujo
normal de ejecución; en la práctica los generadores las colocan al final del método.
En el muestrario ninguna incumple la alineación: ni un solo DEX con un payload desalineado, en ninguna fuente. Cuando el payload caería en una unidad impar, el compilador inserta un nop de relleno. Un ejemplo está en com.looker.droidify 780 (F-Droid): en el classes.dex, el método run de androidx.appcompat.widget.Toolbar$$ExternalSyntheticLambda0 acaba en 0019: nop // spacer, en el desplazamiento 0x1239a6, y el packed-switch-data empieza en 001a, en el 0x1239a8, alineado a 4 bytes. Ese switch es sobre $r8$classId: son lambdas que R8 fusionó en una sola clase, un uso real de packed-switch que no es el de un switch de Java. Entre los payloads, el más común es packed-switch, seguido de fill-array-data; sparse-switch es mucho menos frecuente. Lo que no hemos medido es que los generadores los pongan detrás de la última instrucción ejecutable; los dos ejemplos reales de este documento sí lo cumplen.
packed-switch-payload sparse-switch-payload fill-array-data-payload
├── ident ushort = 0x0100 ├── ident ushort = 0x0200 ├── ident ushort = 0x0300
├── size ushort ├── size ushort ├── element_width ushort
├── first_key int ├── keys int[size] ├── size uint
└── targets int[size] └── targets int[size] └── data ubyte[]
unidades = (size * 2) + 4 unidades = (size * 4) + 2 unidades =
(size*element_width+1)/2+4
En packed-switch las claves son consecutivas desde first_key; en sparse-switch van
explícitas y ordenadas de menor a mayor. En ambos, los destinos son relativos a la
dirección del opcode del switch, no a la de la tabla, que es el error más común al
implementar el desensamblador.
Un packed-switch-payload real de androidx.appcompat.widget.DrawableUtils.parseTintMode, en com.termux 1022 (classes.dex: método en 0x0aa428, packed-switch en 0x0aa44c y payload en 0x0aa478, múltiplo de 4):
0aa44c: 2b01 1600 0000 |000a: packed-switch v1, 00000020 // +00000016
…
0aa478: 0001 0300 0e00 0000 0a00 0000 0700 0000 0400 0000
ident=0x0100 size=3 first_key=14 targets = 10, 7, 4
Diez unidades de 16 bits, que es 3 × 2 + 4. Los destinos se suman a 0x000a, la dirección del packed-switch: la clave 14 salta a 0x0014, la 15 a 0x0011 y la 16 a 0x000e, que es exactamente donde el desensamblado coloca los sget-object de MULTIPLY, SCREEN y ADD. El payload empieza en 0x0020, que es 0x000a + 0x16. Los mismos bytes se ven con xxd -s 0xaa478 -l 20 classes.dex.
9. Los descriptores en las instrucciones
Los operandos type@, field@, meth@ y string@ son índices, no texto: la instrucción
solo lleva el número, y el desensamblador lo resuelve contra las tablas del DEX. Los
descriptores son los mismos que documenta «Formato DEX → §7 · Descriptores de tipo y shorty» —I
para int, [I para un array de int, Lcom/foo/Bar; para una clase—, y dexdump los
imprime ya resueltos detrás de un comentario con el índice original:
1f01 ec01 check-cast v1, Landroidx/activity/Cancellable; // type@01ec
5b01 3901 iput-object v1, v0, L…$1;.this$0:Landroidx/activity/ComponentActivity; // field@0139
6e10 f100 0500 invoke-virtual {v5}, Landroid/app/Application;.getApplicationContext:()L…; // method@00f1
1a00 c026 const-string v0, "Termux" // string@26c0
Esa doble salida —forma legible más índice— es lo que hace de dexdump un buen oráculo: se
puede comprobar la resolución de índices de un parser propio comparando ambas columnas.
Las cuatro líneas son del classes.dex de com.termux 1022 (F-Droid), en los desplazamientos 0x0853e8, 0x084790, 0x188cba y 0x188d70.
10. La verificación de bytecode de ART
Antes de ejecutar, ART verifica. Hay que saber tres cosas:
- Cuándo. La verificación va por clases, no por instrucciones. La hace
dex2oatal compilar. Si una clase no quedó verificada entonces, la hace el runtime la primera vez que la usa, y esa vez puede llegar mucho después del arranque de la app. - Si falla del todo. Se rechaza la clase entera con un fallo de carga, típicamente un
VerifyErrorque nombra la clase. Por eso unDEXeditado a mano que no supera la verificación produce un fallo de carga de la clase y no un comportamiento erróneo en ejecución. - Si falla un poco (un método o un campo que no se resuelve, un acceso no permitido): la clase no se rechaza. La excepción salta al ejecutar esa instrucción.
Es una diferencia importante para diagnosticar. Que la aplicación arranque y el método falle al llamarlo no descarta la verificación. Lo que la delata es un VerifyError que nombra la clase.
El verificador trabaja en dos pasadas, tal como las describe el propio código de AOSP.
Estática, instrucción a instrucción, con las comprobaciones heredadas de la
especificación de la JVM: que el destino de cada salto y de cada switch sea válido; que los
operandos que referencian entradas del pool de constantes sean válidos; que los operandos de
instanceof, checkcast y new sean válidos; que new-array no pase de 255 dimensiones;
que no se use new sobre una clase de array; que los índices de registro caigan dentro del
rango asignado; que los saltos caigan dentro del array de código; que todo destino de
control de flujo sea el principio de una instrucción; que el código no acabe en mitad de
una instrucción; que la ejecución no se salga por el final; y que, para cada handler de
excepción, el área try empiece y acabe en el principio de una instrucción y el handler
empiece en una instrucción válida.
De flujo de datos, que es la cara. Sigue todos los caminos posibles del método y anota qué
tipo de valor hay en cada registro en cada punto. Para ello marca la primera instrucción como
«cambiada», la procesa, propaga los tipos a sus sucesores, los fusiona en los puntos de
confluencia y repite hasta que nada cambia. Lo que comprueba es que los registros contengan
los tipos correctos de valores, que los métodos se invoquen con los argumentos adecuados, que
a los campos se les asignen valores del tipo apropiado y que los opcodes reciban en sus registros
de operando los tipos que esperan. ART comprueba también que no se vuelva a ejecutar un mismo
new-instance mientras el objeto que creó la vez anterior sigue sin su constructor. La JVM evita
ese caso prohibiendo los saltos hacia atrás con objetos a medio construir.
De ahí salen los errores típicos de un DEX editado a mano, todos con la misma causa
—romper una invariante que el compilador mantenía sin que el editor se diera cuenta—:
| Síntoma | Causa habitual |
|---|---|
| «register index out of range» | Se añadieron instrucciones que usan un registro nuevo sin subir .registers |
| «wide register index out of range» | Se usó vN como par de 64 bits siendo N+1 el último registro |
| Tipo incorrecto en un registro | Se reutilizó un registro que en esa rama traía una referencia, o al revés |
| «branch offset of zero not allowed» | Se dejó un salto a sí mismo al borrar instrucciones |
| «target dex pc … is not at instruction start» | Se editaron bytes sin recalcular offsets, o se olvidó que los desplazamientos van en unidades de 16 bits |
| «unaligned table» | Un payload dejó de estar alineado a 4 bytes al insertar o quitar una instrucción y falta el nop de relleno |
| «copyRes1 v…<- result0 type=…», o «invalid use of move-result as branch target at …» si un salto cae en él | Se insertó algo entre el invoke-* y su move-result |
Los textos entrecomillados de la columna izquierda están literalmente en
runtime/verifier/method_verifier.cc de android-17.0.0_r1, salvo «copyRes1», que está en
register_line.cc (los números de línea están en la fuente 4). Todos fallan con
VERIFY_ERROR_BAD_CLASS_HARD, que rechaza la clase entera. En el mensaje real llevan detrás los
valores concretos, con la forma «register index out of range (5 >= 5)». En el del destino de
salto, el opcode sale con su mnemónico (move-result, move-result-wide, move-result-object
o move-exception), porque lo imprime Instruction::Name. La fila del tipo incorrecto describe
el síntoma, no cita un mensaje. No los hemos reproducido en un dispositivo. Qué hace ClassLinker
con cada clase de fallo, con fichero y línea en android-17.0.0_r1, está en la «sección 7 de
Qué rechaza cada lector · ClassLinker y el verificador de bytecode».
Con targetSdk por debajo de 32 el diagnóstico cambia. (targetSdk es la versión de Android para la que la app declara estar preparada.) Si la clase la verifica el runtime y no dex2oat, un fallo leve (un método, un campo o una clase que no se resuelven, un acceso no permitido) hace que el verificador dé esa instrucción por perdida y no revise lo que va detrás. Un error grave en ese código no rechaza la clase. Si se llega a ejecutar, lo que salta es la excepción del fallo leve, por ejemplo un NoSuchMethodError. Con targetSdk 32 o más, ese código se analiza y el mismo error grave rechaza la clase con VerifyError.
Y no es cosa solo del mercado chino, aunque allí sea lo normal (61 de 100 apps). También declara un targetSdk por debajo de 32 una de cada cinco apps de F-Droid. En Google Play, en cambio, es raro.
10.1 El bytecode de una app protegida
Un protector comercial (Bangcle/SecNeo, Ijiami, Jiagu 360, Tencent Legu, NetEase…) esconde el código real de la app. Lo que queda a la vista en classes.dex es un cargador: pocas clases, algún método native (escrito en código nativo, no en bytecode) y mucho peso que no es DEX. Es casi exclusivo del mercado chino: allí llevan un protector (sin contar PairIP) 38 de 100 apps, más de la mitad de ellas Bangcle/SecNeo. En Google Play es raro, y en F-Droid e IzzyOnDroid no hay ninguna. Casi un tercio de las apps chinas tienen menos de 1.000 clases sumando todos sus DEX.
El ejemplo es cn.cj.pe 202608010 (tienda 360, mercado chino, Bangcle/SecNeo). Su classes.dex pesa 72.478.240 bytes y declara solo 40 clases: 35 generadas por la biblioteca de rutas ARouter y 5 del paquete com.secneo.apkwrapper, entre ellas AW, que extiende Application. Los 11 métodos native están en dos de esas cinco (H, 9, y AW, 2). La parte del fichero que dexdump entiende acaba en el desplazamiento 44.544, donde termina el map_list. Los 72.433.696 bytes restantes, el 99,9 %, vienen detrás y no pertenecen a ninguna sección del DEX. Los 126 métodos con código suman solo 4.133 unidades de 16 bits (unos 8 KB). Tener bytes después de la sección de datos es raro: lo vemos en un 3 % de los DEX del mercado chino y casi en ningún otro sitio. Se mide así, sobre el classes.dex extraído:
python3 -I -c 'import struct,sys; d=open(sys.argv[1],"rb").read(); m=struct.unpack_from("<I",d,0x34)[0]; n=struct.unpack_from("<I",d,m)[0]; f=m+4+12*n; print(len(d), struct.unpack_from("<I",d,0x60)[0], f, len(d)-f)' classes.dex
dexdump -d classes.dex | grep -c NATIVE
dexdump -d classes.dex | grep 'Class descriptor' | grep -c -e arouter -e secneo
No hemos descifrado ni abierto ese resto del fichero: solo medimos su tamaño y su posición. Que sea el código cifrado es una lectura, no una medición.
No todos los protegidos son así. Seis de las 38 apps del mercado chino con protector conservan un DEX grande (3.181 clases o más). Por ejemplo com.cmbchina.ccd.pluto.cmbActivity 160 (tienda 360), Bangcle/SecNeo, con 7.529 clases y libDexHelper.so. En el otro extremo, cn.com.cmbc.newmbank 102100 (tienda 360) deja 275 clases. PairIP tampoco vacía el DEX: añade clases com.pairip… a un DEX normal. Solo aparece en Google Play: en el 7 % de las más instaladas y en más de una de cada cuatro del sorteo.
Dos hallazgos más. Ningún DEX que hemos visto, ni los de las apps protegidas, tiene un opcode sin asignar. Y baksmali 3.0.7 los desensambla sin error: los 205 DEX de una submuestra de 20 apps del mercado chino, que incluye apps protegidas, y los 13 de las cinco apps de protectores. Más sobre estos productos en «Packers y protectores».
11. Correspondencia con smali
smali es la sintaxis de texto del bytecode Dalvik y baksmali el desensamblador que la
produce; ver «Desensambladores smali». Los
tres niveles del mismo método, Sum.f(II)I, el de la «sección 1 · Qué es y por qué existe». No es del muestrario: lo
compilamos aparte con javac --release 8 Sum.java y d8 --release --min-api 21 --output . Sum.class
de build-tools 37.0.0, y lo desensamblamos con baksmali 3.0.7 (baksmali d -o out classes.dex):
hexadecimal dexdump -d baksmali
─────────────────────────────────────────────────────────────────────────────────
da01 0102 0000: mul-int/lit8 v1, v1, #int 2 mul-int/lit8 p1, p1, 0x2
b010 0002: add-int/2addr v0, v1 add-int/2addr p0, p1
0f00 0003: return v0 return p0
La diferencia de notación entre las dos columnas no es cosmética. dexdump numera todos
los registros como vN; baksmali llama pN a los que contienen un parámetro a la entrada del
método, con la correspondencia de la «sección 3 · Modelo de registros».
En static f(II)I con registers_size = 2 e ins = 2 no queda ningún registro local, así
que v0 y v1 de dexdump son exactamente p0 y p1. En cuanto hay un local dejan de
coincidir, y ahí es donde una lectura descuidada se equivoca de registro. Un método de
instancia real está en el classes.dex de com.looker.droidify 780 (F-Droid), con registers_size = 2 e ins = 1 (solo
this). Es el close() de una clase sintética de lambda que R8 generó, en el desplazamiento
0x0fab60. Lo mostramos con las directivas .line quitadas para que se lea:
.method public final close()V
.registers 2
iget-object v0, p0, Landroidx/activity/OnBackPressedDispatcher$$ExternalSyntheticLambda1;->f$0:Landroidx/lifecycle/LifecycleRegistry;
iget-object p0, p0, Landroidx/activity/OnBackPressedDispatcher$$ExternalSyntheticLambda1;->f$1:Landroidx/lifecycle/DefaultLifecycleObserverAdapter;
invoke-virtual {v0, p0}, Landroidx/lifecycle/LifecycleRegistry;->removeObserver(Landroidx/lifecycle/LifecycleObserver;)V
return-void
.end method
p0 es v1 y el local es v0. Quien lea el mismo método en dexdump verá v1 donde aquí pone p0: iget-object v0, v1, …f$0, iget-object v1, v1, …f$1 e invoke-virtual {v0, v1}, …removeObserver. La segunda instrucción escribe sobre p0: ya no hace falta this, y el compilador reutiliza el registro. Con -l, baksmali escribiría .locals 1 en lugar de .registers 2. El mismo classes.dex, byte a byte, está en la copia de IzzyOnDroid de esta app («sección 12.1 · Comprobar si dos APK llevan el mismo código»).
La notación p es la opción por defecto de baksmali y se apaga con
--parameter-registers=false; con -l escribe .locals en vez de .registers («sección 6.3
de Desensambladores smali · Opciones principales»).
Las tres diferencias sistemáticas entre las dos vistas:
dexdumpimprime la dirección de cada instrucción en unidades de 16 bits al principio de la línea;smalino, y usa etiquetas (:cond_9,:goto_1e,:try_start_0, con el número en hexadecimal de la dirección a la que apuntan; «sección 3.3 de Desensambladores smali · Directivas de método») como destinos simbólicos de salto, lo que permite insertar y borrar instrucciones sin recalcular desplazamientos a mano. Es la razón principal por la que se edita ensmaliy no en hexadecimal.dexdumpimprime los literales en decimal con el hexadecimal en un comentario (#int 2 // #02);smalilos escribe en hexadecimal (0x2).- Los bloques
try/catchson estructura ensmali(una etiqueta:try_start_…, otra:try_end_…y una directiva.catch), mientras que en elDEXson la tablatry_itemde fuera del array de instrucciones («Formato DEX → §11 · code_item»).
11.1 Un método escrito en Kotlin
Llevan clases Kotlin (lo vemos por la anotación kotlin.Metadata que el compilador escribe en cada clase) dos de cada tres apps de Google Play, una de cada dos en el mercado chino y una de cada tres en F-Droid e IzzyOnDroid. El compilador de Kotlin añade comprobaciones propias. En Termux, la más frecuente es una llamada a Intrinsics.checkNotNullParameter por cada parámetro que no admite null. Este es el método androidx.window.SidecarCompat$FirstAttachAdapter.onViewDetachedFromWindow de com.termux 1022 (classes.dex, desplazamiento 0x14e76c, registers: 3, ins: 2, outs: 2, 6 unidades):
14e76c: |[14e76c] androidx.window.SidecarCompat$FirstAttachAdapter.onViewDetachedFromWindow:(Landroid/view/View;)V
14e77c: 1a00 1569 |0000: const-string v0, "view" // string@6915
14e780: 7120 d555 0200 |0002: invoke-static {v2, v0}, Lkotlin/jvm/internal/Intrinsics;.checkNotNullParameter:(Ljava/lang/Object;Ljava/lang/String;)V // method@55d5
14e786: 0e00 |0005: return-void
El método tiene registers: 3 e ins: 2: v1 es this, v2 es el parámetro view y v0 guarda su nombre para el mensaje de error.
No todas las apps conservan estas comprobaciones. El classes.dex de com.termux 1022 tiene 344 llamadas a checkNotNull*, la mayoría a checkNotNullParameter. El de com.looker.droidify 780, compilado con R8 9.4.14 en modo full, no tiene ninguna, aunque es una app Kotlin: tiene 1.633 llamadas a Intrinsics.areEqual y 17 clases $WhenMappings, las que Kotlin genera para un when sobre un enum. Es posible que R8 en modo full quite esas comprobaciones, pero no lo hemos comprobado. Son recuentos de dos apps, no de población. Se repiten con:
dexdump -d classes.dex > classes.dex.txt
grep -c 'Intrinsics;.checkNotNull' classes.dex.txt
grep -c 'invoke-static.*Intrinsics;.areEqual' classes.dex.txt
grep -c 'Class descriptor.*WhenMappings' classes.dex.txt
No hemos medido qué porcentaje de DEX de la población lleva llamadas a Intrinsics.
12. Receta: dexdump -d comentado instrucción a instrucción
De cuál de las piezas sacar el DEX. En un .apk suelto, classes.dex está en la raíz. Un .apkm, un .xapk o una carpeta de adb traen varios APK, y el DEX no está en todos. Los de configuración (split_config.*, de idioma, densidad o arquitectura) no lo llevan nunca: ninguno de los 7.846 que hemos visto. Mira base.apk y, si existen, los splits de funcionalidad, que a menudo traen el suyo; los nombres llegan hasta classes33.dex. Afecta a pocas apps: en torno al 6 % de las más instaladas de Google Play, y fuera de Google Play a ninguna. Un ejemplo de split de funcionalidad con DEX: la pieza split_df_a_dex.apk del .apkm de TikTok (com.zhiliaoapp.musically 47.4.16, APKMirror). Un .apkm o un .xapk son ZIP: se saca primero el APK y de él los DEX. En una carpeta de adb los APK ya están sueltos y se salta el primer paso:
unzip -o -q app.apkm base.apk -d $DEXDIR
unzip -o -q $DEXDIR/base.apk 'classes*.dex' -d $DEXDIR/dex
La receta, sobre un .apk suelto:
BT=~/Library/Android/sdk/build-tools/37.0.0
DEXDIR=$(mktemp -d)
unzip -o -q com.termux_1022.apk classes.dex -d $DEXDIR
$BT/dexdump -d $DEXDIR/classes.dex
El APK es com.termux 1022 (F-Droid). Salida real para com.termux.app.TermuxApplication.setLogConfig:(Landroid/content/Context;)V, recortada a lo esencial:
registers : 3
ins : 1
outs : 3
insns size : 21 16-bit code units
188d60: |[188d60] com.termux.app.TermuxApplication.setLogConfig:(L…/Context;)V
188d70: 1a00 c026 |0000: const-string v0, "Termux" // string@26c0
188d74: 7110 da4a 0000 |0002: invoke-static {v0}, L…/Logger;.setDefaultLogTag:(L…/String;)V
188d7a: 7110 a94c 0200 |0005: invoke-static {v2}, L…/TermuxAppSharedPreferences;.build:(L…/Context;)L…;
188d80: 0c02 |0008: move-result-object v2
188d82: 3902 0300 |0009: if-nez v2, 000c // +0003
188d86: 0e00 |000b: return-void
188d88: 1200 |000c: const/4 v0, #int 0 // #0
188d8a: 6e10 b24c 0200 |000d: invoke-virtual {v2}, L…;.getLogLevel:()I
188d90: 0a01 |0010: move-result v1
188d92: 6e30 bf4c 0201 |0011: invoke-virtual {v2, v0, v1}, L…;.setLogLevel:(L…/Context;I)V
188d98: 0e00 |0014: return-void
positions :
0x0002 line=78
0x0005 line=81
0x000d line=83
Lectura instrucción a instrucción:
| Dir. | Instrucción | Qué ocurre |
|---|---|---|
0000 |
const-string v0, "Termux" |
Formato 21c, índice string@26c0 en string_ids. v0 es un local |
0002 |
invoke-static {v0}, …setDefaultLogTag(String)V |
Formato 35c con A = 1 |
0005 |
invoke-static {v2}, …build(Context) |
registers 3 e ins 1 ⇒ v2 es el único argumento, o sea p0, el Context. El método es estático: no hay this |
0008 |
move-result-object v2 |
Recoge la referencia devuelta. Tiene que ir aquí: entre un invoke-* y su move-result no cabe nada. Sobrescribe v2, que pasa de Context a TermuxAppSharedPreferences. Reutilizar el registro con otro tipo es legal; es el verificador quien lleva la cuenta |
0009 |
if-nez v2, 000c |
Formato 21t: AA = 02 → v2, BBBB = +3. Salto relativo a esta dirección: 0x0009 + 3 = 0x000c |
000b |
return-void |
La rama del null |
000c |
const/4 v0, #int 0 |
Formato 11n, una sola unidad: cabe un literal de 4 bits. Este 0 es el null que se pasa como Context |
000d |
invoke-virtual {v2}, …getLogLevel()I |
|
0010 |
move-result v1 |
Sin -object: el resultado es un int |
0011 |
invoke-virtual {v2, v0, v1}, …setLogLevel(Context, I)V |
Tres palabras de argumento. De aquí sale outs 3: es la mayor llamada del método |
0014 |
return-void |
Y de la tabla positions sale la correspondencia con el fuente: 0x0002 es la línea 78, 0x0005 la 81 y 0x000d la 83. No hemos mirado el fuente de Termux: son los números del volcado. Sin debug_info_item esa tabla estaría vacía y el decompilador no podría dar números de línea («Formato DEX → §12 · debug_info_item»).
Esto no vale para todas las apps. En las compiladas con R8 y sus posiciones reducidas, cada «línea» es solo la posición de la instrucción más uno, y hace falta el fichero de mapeo para recuperar la línea del fuente. Por ejemplo, el close() de la «sección 11 · Correspondencia con smali», de com.looker.droidify 780, dice 0x0000 line=1, 0x0001 line=2… hasta 0x0007 line=8. Con ese perfil está cerca de la mitad de las apps de F-Droid y de las más instaladas de Google Play, y una de cada cinco del mercado chino. (La clasificación usa los umbrales de «Formato DEX → §12 · debug_info_item»: sin depuración si el 90 % o más de los code_item no tienen debug_info_item, con nombres si el 10 % o más de los debug_info_item nombran parámetros o variables, y posiciones de R8 si la mitad o más de los que tienen depuración usan línea = posición + 1.) Termux, en cambio, trae las líneas reales: no representa a la mitad de las apps.
También es raro que una app guarde nombres de variables de forma general: lo hace menos del 3 % en F-Droid y casi ninguna en Google Play. Si basta un solo debug_info_item con nombres, la cifra sube a una de cada cuatro o cinco. Apps sin ningún debug_info_item hay muy pocas. Contando métodos y no apps, falta el debug_info_item en entre una sexta y una cuarta parte de los métodos con código, según la fuente. python3 -I scripts/muestrario/cifras/dex_y_bytecode_1.py --depuracion classes.dex lo repite sobre un classes.dex suelto.
12.1 Comprobar si dos APK llevan el mismo código
El bytecode depende de la herramienta que lo compila y no solo del fuente. Se ve bien cuando una app está a la vez en F-Droid y en IzzyOnDroid. De los paquetes que están en los dos con el mismo nombre de fichero (paquete_versionCode.apk), dos de cada tres son idénticos (mismo SHA-256). En los 134 restantes los ficheros difieren, pero en la mayoría (104) los DEX tienen el mismo aspecto: mismos nombres, versión, tamaño, recuentos de tablas y orden del map_list (no comparamos los bytes). En 30, no.
com.looker.droidify 780 en F-Droid es de los primeros. La copia de IzzyOnDroid mide lo mismo, 5.997.579 bytes, pero tiene otro SHA-256. Sus dos classes*.dex son idénticos byte a byte a los de F-Droid. Lo que cambia es la firma (META-INF/BF5286D4.* en F-Droid, META-INF/DROIDIFY.* en IzzyOnDroid), el MANIFEST.MF y cuatro libdatastore_shared_counter.so, cuyo CRC es distinto. Se comprueba con:
unzip -p fdroid/com.looker.droidify_780.apk classes.dex | shasum -a 256
unzip -p izzyondroid/com.looker.droidify_780.apk classes.dex | shasum -a 256
Los dos dan 986e3bf13f3484417adaac710178135e3e651a1b8044d41938dd98bc6cb6d43a. Para classes2.dex el SHA-256 común es 1a7babe64a3fecae0c79eacfda2698b179402cc15d1d460cb67c2d12258dced5. Otro ejemplo de DEX con el mismo aspecto: app.olauncher 113, en F-Droid y en IzzyOnDroid. Y uno con DEX distintos: app.easy.launcher 33 (R8 8.11.18 en la copia de F-Droid), también en las dos. No hemos mirado por qué difieren los 30 casos más allá de esos dos ejemplos.
Fuentes
- Dalvik bytecode format — https://source.android.com/docs/core/runtime/dalvik-bytecode
Consultado el 12 de agosto de 2026 («Last updated 2025-01-07 UTC»). De aquí salen el
diseño general del modelo de ejecución («sección 2 · Reglas generales del modelo de ejecución»), los sufijos («sección 5 · Sufijos de las instrucciones»), la tabla
completa de opcodes («sección 6 · La tabla de opcodes»), la descripción de las instrucciones de invocación
(«sección 7 · Las instrucciones de invocación») y los tres formatos de payload («sección 8 · Los payloads»). Reconsultado el 18 de octubre de 2026
(«Last updated 2026-10-09 UTC») para la marca de los payloads en el byte alto de un
nop(«sección 6 · La tabla de opcodes») y, en la misma consulta, para la tabla resumen de la que sale el formato de cada opcode de la «sección 6.1 · Formato de cada opcode», con10xpara los sin usar. - Dalvik executable instruction formats —
https://source.android.com/docs/core/runtime/instruction-formats
Consultado el 12 de agosto de 2026 («Last updated 2024-08-26 UTC»). De aquí salen la
nomenclatura de los identificadores de formato, la tabla de letras de tipo y la tabla
completa de layouts de bits («sección 4 · Formatos de instrucción»). Reconsultado el 18 de octubre de 2026 («Last
updated 2026-10-09 UTC»): la página sigue llamando a los formatos con sufijo
soi«suggested static linking formats» y «suggested "inline" linking formats» («sección 4.1 · Cómo se lee el identificador»), y de ella sale que el primer dígito del formato es la longitud en unidades de 16 bits («sección 6 · La tabla de opcodes») y que00xes el «pseudo-format used for unused opcodes» («sección 6.1 · Formato de cada opcode»). - Dalvik executable format — https://source.android.com/docs/core/runtime/dex-format
Consultado el 12 de agosto de 2026 («Last updated 2025-10-03 UTC»). De aquí salen los
campos
registers_size,ins_sizeyouts_sizedelcode_item(«sección 3 · Modelo de registros») y los descriptores de tipo («sección 9 · Los descriptores en las instrucciones»). - AOSP
art/runtime/verifier/method_verifier.cc— https://android.googlesource.com/platform/art/+/refs/tags/android-17.0.0_r1/runtime/verifier/method_verifier.cc Consultado el 25 de septiembre de 2026. De aquí sale íntegra la «sección 10 · La verificación de bytecode de ART»: los comentarios deVerifyInstructionyCodeFlowVerifyMethodenumeran las comprobaciones estáticas y de flujo de datos, y los mensajes deFail(VERIFY_ERROR_BAD_CLASS_HARD)son los de la tabla de errores típicos; el decopyRes1está enregister_line.cc, en el mismo directorio. Reconsultado el 18 de octubre de 2026: «invalid use of … as branch target» está enFailBranchTargetIsMoveResultOrMoveException(líneas 826-834) y sale con el mnemónico del opcode, porque eloperator<<deInstruction::CodeimprimeInstruction::Name(libdexfile/dex/dex_instruction.cc, líneas 446-448); «copyRes1» está en la línea 117 deregister_line.cc; y contargetSdkpor debajo de 32 (SdkVersion::kS_V2) y fuera dedex2oat, un fallo blando marca la instrucción como si lanzara y deja sin analizar el código que la sigue (PotentiallyMarkRuntimeThrow, líneas 5684-5711; llamadas en las 6049-6068; «Elevating opcode flags», líneas 4282-4289) («sección 10 · La verificación de bytecode de ART»). Los mensajes de la tabla de errores típicos están en las líneas 718, 723, 809, 819-823, 826-834 y 838 demethod_verifier.cc; «copyRes1» está en la línea 117 deregister_line.cc(«sección 10 · La verificación de bytecode de ART»). - Registers · wiki del proyecto smali — https://github.com/JesusFreke/smali/wiki/Registers
Consultado el 12 de agosto de 2026. De aquí salen la notación
p, la correspondenciapN→vNdel diagrama de la «sección 3 · Modelo de registros» y la diferencia entre.registersy.locals. La wiki no ha migrado con el proyecto:smalisigue engoogle/smali, que no tiene wiki (https://github.com/google/smali/wiki redirige al repositorio), yJesusFreke/smaliestá archivado con la wiki todavía en línea; comprobado el 18 de octubre de 2026. - TypesMethodsAndFields · wiki del proyecto smali —
https://github.com/JesusFreke/smali/wiki/TypesMethodsAndFields
Consultado el 12 de agosto de 2026. De aquí sale la sintaxis de descriptores, métodos y
campos usada en el bloque
smalide la «sección 11 · Correspondencia con smali». Es la misma wiki sin migrar de la fuente 5. - AOSP —
art/libdexfile/dex/dex_instruction_list.hydex_instruction.h, etiquetasandroid-11.0.0_r1,android-12.0.0_r1yandroid-17.0.0_r1— https://android.googlesource.com/platform/art/+/refs/tags/android-11.0.0_r1/libdexfile/dex/dex_instruction_list.h Consultado el 18 de octubre de 2026. De aquí sale que enandroid-11.0.0_r1los opcodese3–f2soniget-quick,invoke-virtual-quicky compañía, con índiceskIndexFieldOffsetykIndexVtableOffset«for static linked» campos y métodos (dex_instruction_list.h, líneas 249-264;dex_instruction.h, líneas 136-137), y que enandroid-12.0.0_r1yandroid-17.0.0_r1las líneas 249-271 sonunused-e3aunused-f9(«sección 4.1 · Cómo se lee el identificador»). Cotejado además el 18 de octubre de 2026, enandroid-17.0.0_r1, opcode a opcode con la tabla de la «sección 6.1 · Formato de cada opcode»: los 256 formatos coinciden con la especificación, y los sin usar sonk10xconkVerifyError(por ejemplounused-3e, línea 84), quemethod_verifier.ccrechaza como fallo duro (líneas 2168-2171 y 4264-4271). - AOSP —
dalvik/libdex/DexOpcodes.h,libdex/InstrUtils.cppyvm/analysis/Optimize.cpp, etiquetaandroid-4.4.4_r1— https://android.googlesource.com/platform/dalvik/+/refs/tags/android-4.4.4_r1/vm/analysis/Optimize.cpp Consultado el 18 de octubre de 2026. De aquí salenOP_EXECUTE_INLINE,OP_IGET_QUICKyOP_INVOKE_VIRTUAL_QUICK(DexOpcodes.h, líneas 309-322), los formatoskFmt22cs,kFmt35ms,kFmt3rms,kFmt35miykFmt3rmimarcados «[opt]» (InstrUtils.cpp, líneas 359-360 y 558-636) y que esa optimización, «chiefly "quickening" of opcodes» (Optimize.cpp, líneas 17-20), es la que aplicaDexPrepare.cppal preparar el.odex(«sección 4.1 · Cómo se lee el identificador»). - El muestrario — «El muestrario».
De ahí salen las cifras de este documento: unas 7.000 apps de F-Droid, IzzyOnDroid, Google
Play y el mercado chino, descargadas entre el 19 y el 27 de octubre de 2026. Sobre un solo
classes.dexya extraído puedes repetir parte de las medidas conpython3 -I scripts/muestrario/cifras/dex_y_bytecode_1.py --registros classes.dex(registros,insyoutsde cada método),--mapa,--checksumy--depuracion.