En este documento, se describen el diseño y el contenido de los archivos .dex
, que se usan para contener un conjunto de definiciones de clase y sus datos complementarios asociados.
Guía de tipos
Name | Descripción |
---|---|
byte | Número entero de 8 bits con signo |
ubyte | int sin signo de 8 bits |
short | Número entero de 16 bits con signo, little-endian |
ushort | int sin signo de 16 bits, little-endian |
int | Número entero de 32 bits con signo, little-endian |
uint | int sin signo de 32 bits, little-endian |
long | Número entero de 64 bits con signo, little-endian |
ulong | Número entero de 64 bits sin firma, little-endian |
sleb128 | LEB128 firmado, longitud variable (consulta a continuación) |
uleb128 | LEB128 sin signo, longitud variable (consulta a continuación) |
uleb128p1 | LEB128 sin signo más 1 , longitud variable (consulta a continuación) |
LEB128
LEB128 ("Little-Endian Base 128") es una codificación de longitud variable para cantidades de números enteros arbitrarios con o sin signo. El formato se tomó prestado de la especificación DWARF3. En un archivo .dex
, LEB128 solo se usa para codificar cantidades de 32 bits.
Cada valor codificado en LEB128 consta de uno a cinco bytes, que juntos representan un solo valor de 32 bits. Cada byte tiene su bit más significativo establecido, excepto el byte final de la secuencia, que tiene su bit más significativo desactivado. Los siete bits restantes de cada byte son la carga útil, con los siete bits menos significativos de la cantidad en el primer byte, los siguientes siete en el segundo byte, y así sucesivamente. En el caso de un LEB128 firmado (sleb128
), el bit de carga útil más significativo del byte final de la secuencia se extiende con el signo para producir el valor final. En el caso de los números sin signo (uleb128
), los bits que no se representan de forma explícita se interpretan como 0
.
Diagrama bit a bit de un valor LEB128 de dos bytes | |||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Primer byte | Segundo byte | ||||||||||||||
1 |
bit6 | bit5 | bit4 | bit3 | bit2 | bit1 | bit0 | 0 |
bit13 | bit12 | bit11 | bit10 | bit9 | bit8 | bit7 |
La variante uleb128p1
se usa para representar un valor con signo, en el que la representación es del valor más uno codificado como un uleb128
. Esto hace que la codificación de -1
(que también se puede considerar como el valor sin signo 0xffffffff
), pero no de ningún otro número negativo, sea de un solo byte, y es útil exactamente en aquellos casos en los que el número representado debe ser no negativo o -1
(o 0xffffffff
), y en los que no se permiten otros valores negativos (o en los que es poco probable que se necesiten valores sin signo grandes).
Estos son algunos ejemplos de los formatos:
Secuencia codificada | Como sleb128 |
Como uleb128 |
Como uleb128p1 |
---|---|---|---|
00 | 0 | 0 | -1 |
01 | 1 | 1 | 0 |
7f | -1 | 127 | 126 |
80 7f | -128 | 16256 | 16255 |
Diseño de archivo
Name | Formato | Descripción |
---|---|---|
encabezado | header_item | el encabezado |
string_ids | string_id_item[] | Es una lista de identificadores de cadenas. Son identificadores de todas las cadenas que usa este archivo, ya sea para la asignación de nombres internos (p.ej., descriptores de tipo) o como objetos constantes a los que se hace referencia en el código. Esta lista debe ordenarse según el contenido de la cadena, con valores de puntos de código UTF-16 (no de forma sensible a la configuración regional) y no debe contener entradas duplicadas. |
type_ids | type_id_item[] | Es una lista de identificadores de tipo. Son identificadores para todos los tipos (clases, matrices o tipos primitivos) a los que se hace referencia en este archivo, ya sea que se definan en el archivo o no. Esta lista debe ordenarse por índice string_id y no debe contener entradas duplicadas.
|
proto_ids | proto_id_item[] | Es una lista de identificadores de prototipos de métodos. Son identificadores para todos los prototipos a los que se hace referencia en este archivo. Esta lista debe ordenarse primero por tipo de devolución (por índice type_id ) y, luego, por lista de argumentos (orden lexicográfico, argumentos individuales ordenados por índice type_id ). La lista no debe contener entradas duplicadas.
|
field_ids | field_id_item[] | Es una lista de identificadores de campos. Son identificadores de todos los campos a los que se hace referencia en este archivo, ya sea que estén definidos en el archivo o no. Esta lista debe estar ordenada, donde el tipo de definición (por índice type_id ) es el orden principal, el nombre del campo (por índice string_id ) es el orden intermedio y el tipo (por índice type_id ) es el orden secundario. La lista no debe contener entradas duplicadas.
|
method_ids | method_id_item[] | Lista de identificadores de métodos. Son identificadores de todos los métodos a los que se hace referencia en este archivo, ya sea que estén definidos en el archivo o no. Esta lista debe estar ordenada, en la que el tipo de definición (por índice type_id ) es el orden principal, el nombre del método (por índice string_id ) es el orden intermedio y el prototipo del método (por índice proto_id ) es el orden secundario. La lista no debe contener entradas duplicadas.
|
class_defs | class_def_item[] | Lista de definiciones de clases. Las clases deben ordenarse de manera que la superclase y las interfaces implementadas de una clase determinada aparezcan en la lista antes que la clase de referencia. Además, no es válido que una definición para la clase con el mismo nombre aparezca más de una vez en la lista. |
call_site_ids | call_site_id_item[] | Es una lista de identificadores de sitios de llamadas. Son identificadores de todos los sitios de llamada a los que se hace referencia en este archivo, ya sea que estén definidos en el archivo o no. Esta lista debe ordenarse de forma ascendente según call_site_off .
|
method_handles | method_handle_item[] | Lista de identificadores de métodos. Es una lista de todos los identificadores de métodos a los que se hace referencia en este archivo, ya sea que estén definidos en el archivo o no. Esta lista no está ordenada y puede contener duplicados que corresponderán lógicamente a diferentes instancias de identificadores de métodos. |
datos | ubyte[] | Área de datos, que contiene todos los datos de asistencia para las tablas mencionadas anteriormente. Los diferentes elementos tienen diferentes requisitos de alineación, y se insertan bytes de padding antes de cada elemento si es necesario para lograr una alineación adecuada. |
link_data | ubyte[] | datos que se usan en archivos vinculados de forma estática. El formato de los datos en esta sección no se especifica en este documento. Esta sección está vacía en los archivos no vinculados, y las implementaciones del tiempo de ejecución pueden usarla como consideren adecuado. |
Formato del contenedor
La versión 41 introduce un nuevo formato de contenedor para los datos DEX con el objetivo de ahorrar espacio. Este formato de contenedor permite combinar varios archivos DEX lógicos en un solo archivo físico. El nuevo formato es, en su mayoría, una concatenación simple de archivos en el formato anterior, con algunas diferencias:
- El valor de
file_size
es el tamaño del archivo lógico, no del archivo físico. Se puede usar para iterar sobre todos los archivos lógicos del contenedor. - Los archivos dex lógicos pueden hacer referencia a cualquier dato posterior en el contenedor (pero no a los anteriores). Esto permite que los archivos dex compartan datos, como cadenas, entre sí.
- Todos los desplazamientos son relativos al archivo físico. Ningún desplazamiento es relativo al encabezado. Esto garantiza que las secciones con desplazamientos se puedan compartir entre archivos lógicos.
- El encabezado agrega dos campos nuevos para describir los límites del contenedor. Esta es una verificación de coherencia adicional que facilita la portabilidad del código al nuevo formato.
data_size
ydata_off
ya no se usan. Los datos pueden distribuirse en varios archivos lógicos y no tienen que ser contiguos.
Definiciones de campos de bits, cadenas y constantes
DEX_FILE_MAGIC
Se incorpora en header_item
El array o la cadena constantes DEX_FILE_MAGIC
son la lista de bytes que deben aparecer al comienzo de un archivo .dex
para que se lo reconozca como tal. El valor contiene intencionalmente un carácter de nueva línea ("\n"
o 0x0a
) y un byte nulo ("\0"
o 0x00
) para ayudar a detectar ciertas formas de corrupción. El valor también codifica un número de versión de formato como tres dígitos decimales, que se espera que aumente de forma monotónica con el tiempo a medida que evoluciona el formato.
ubyte[8] DEX_FILE_MAGIC = { 0x64 0x65 0x78 0x0a 0x30 0x33 0x39 0x00 } = "dex\n039\0"
Nota: La compatibilidad con la versión 041
del formato se agregó en el lanzamiento de Android 16, que admite el formato de contenedor.
Nota: La compatibilidad con la versión 040
del formato se agregó en el lanzamiento de Android 10.0, que extendió el conjunto de caracteres permitidos en SimpleNames.
Nota: Se agregó compatibilidad con la versión 039
del formato en el lanzamiento de Android 9.0, que introdujo dos nuevos bytecodes, const-method-handle
y const-method-type
. (Cada uno de estos se describe en la tabla Resumen del conjunto de bytecode). En Android 10, la versión 039
extiende el formato de archivo DEX para incluir información de la API oculta que solo se aplica a los archivos DEX en la ruta de clases de inicio.
Nota: Se agregó compatibilidad con la versión 038
del formato en el lanzamiento de Android 8.0. La versión 038
agregó nuevos códigos de bytes (invoke-polymorphic
y invoke-custom
) y datos para los identificadores de métodos.
Nota: Se agregó compatibilidad con la versión 037
del formato en la versión de Android 7.0. Antes de la versión 037
, la mayoría de las versiones de Android usaban la versión 035
del formato. La única diferencia entre las versiones 035
y 037
es la incorporación de métodos predeterminados y el ajuste de invoke
.
Nota: Al menos un par de versiones anteriores del formato se usaron en versiones de software públicas ampliamente disponibles. Por ejemplo, la versión 009
se usó para las versiones M3 de la plataforma de Android (noviembre-diciembre de 2007), y la versión 013
se usó para las versiones M5 de la plataforma de Android (febrero-marzo de 2008). En varios aspectos, estas versiones anteriores del formato difieren significativamente de la versión que se describe en este documento.
ENDIAN_CONSTANT y REVERSE_ENDIAN_CONSTANT
Se incorpora en header_item
La constante ENDIAN_CONSTANT
se usa para indicar el orden de bytes del archivo en el que se encuentra. Si bien el formato .dex
estándar es little-endian, las implementaciones pueden optar por realizar un intercambio de bytes. Si una implementación encuentra un encabezado cuyo endian_tag
es REVERSE_ENDIAN_CONSTANT
en lugar de ENDIAN_CONSTANT
, sabrá que se intercambiaron los bytes del archivo con respecto a la forma esperada.
uint ENDIAN_CONSTANT = 0x12345678; uint REVERSE_ENDIAN_CONSTANT = 0x78563412;
NO_INDEX
Se incorporan en class_def_item y debug_info_item
La constante NO_INDEX
se usa para indicar que falta un valor de índice.
Nota: Este valor no se define como 0
, ya que, de hecho, suele ser un índice válido.
El valor elegido para NO_INDEX
se puede representar como un solo byte en la codificación uleb128p1
.
uint NO_INDEX = 0xffffffff; // == -1 if treated as a signed int
Definiciones de access_flags
Incorporado en class_def_item, encoded_field, encoded_method y InnerClass
Los campos de bits de estos parámetros se usan para indicar la accesibilidad y las propiedades generales de las clases y los miembros de las clases.
Name | Valor | Para clases (y anotaciones de InnerClass ) |
Para campos | Para métodos |
---|---|---|---|---|
ACC_PUBLIC | 0x1 | public : Visible en todas partes |
public : Visible en todas partes |
public : Visible en todas partes |
ACC_PRIVATE | 0x2 | private : Solo visible para la clase de definición
|
private : Solo es visible para la clase de definición. |
private : Solo es visible para la clase de definición. |
ACC_PROTECTED | 0x4 | protected : Visible para el paquete y las subclases
|
protected : Visible para el paquete y las subclases |
protected : Visible para el paquete y las subclases |
ACC_STATIC | 0x8 | static : No se construye con una referencia this externa. |
static : Global para definir la clase |
static : No toma un argumento this |
ACC_FINAL | 0x10 | final : No se puede crear una subclase. |
final : Es inmutable después de la construcción. |
final : No se puede anular. |
ACC_SYNCHRONIZED | 0x20 | synchronized : El bloqueo asociado se adquiere automáticamente alrededor de la llamada a este método. Nota: Solo es válido establecer este parámetro cuando también se establece |
||
ACC_VOLATILE | 0x40 | volatile : Reglas de acceso especiales para ayudar con la seguridad de los subprocesos |
||
ACC_BRIDGE | 0x40 | método puente, agregado automáticamente por el compilador como un puente con seguridad de tipos | ||
ACC_TRANSIENT | 0x80 | transient : No se debe guardar con la serialización predeterminada. |
||
ACC_VARARGS | 0x80 | El compilador debe tratar el último argumento como un argumento "rest". | ||
ACC_NATIVE | 0x100 | native : Se implementa en código nativo. |
||
ACC_INTERFACE | 0x200 | interface : Clase abstracta con varias implementaciones |
||
ACC_ABSTRACT | 0x400 | abstract : No se puede crear una instancia directamente. |
abstract : No implementado por esta clase |
|
ACC_STRICT | 0x800 | strictfp : Reglas estrictas para la aritmética de punto flotante |
||
ACC_SYNTHETIC | 0x1000 | no se define directamente en el código fuente | no se define directamente en el código fuente | no se define directamente en el código fuente |
ACC_ANNOTATION | 0x2000 | Se declara como una clase de anotación | ||
ACC_ENUM | 0x4000 | Se declara como un tipo enumerado. | declarado como un valor enumerado | |
(sin usar) | 0x8000 | |||
ACC_CONSTRUCTOR | 0x10000 | método constructor (inicializador de clase o instancia) | ||
ACC_DECLARED_ SYNCHRONIZED |
0x20000 | declaró synchronized . Nota: Esto no tiene ningún efecto en la ejecución (más allá de la reflexión de esta marca, en sí). |
InnerClass
y nunca debe estar activado en un class_def_item
.
Codificación UTF-8 modificada
Como concesión para facilitar la compatibilidad con versiones heredadas, el formato .dex
codifica sus datos de cadena en un formato UTF-8 modificado estándar de facto, al que nos referiremos en adelante como MUTF-8. Esta forma es idéntica a UTF-8 estándar, excepto por lo siguiente:
- Solo se usan las codificaciones de uno, dos y tres bytes.
- Los puntos de código en el rango
U+10000
…U+10ffff
se codifican como un par sustituto, cada uno de los cuales se representa como un valor codificado de tres bytes. - El punto de código
U+0000
se codifica en formato de dos bytes. - Un byte nulo simple (valor
0
) indica el final de una cadena, como es la interpretación estándar del lenguaje C.
Los dos primeros elementos anteriores se pueden resumir de la siguiente manera: MUTF-8 es un formato de codificación para UTF-16, en lugar de ser un formato de codificación más directo para los caracteres Unicode.
Los dos últimos elementos anteriores permiten incluir simultáneamente el punto de código U+0000
en una cadena y seguir manipulándola como una cadena terminada en nulo de estilo C.
Sin embargo, la codificación especial de U+0000
significa que, a diferencia de UTF-8 normal, el resultado de llamar a la función estándar de C strcmp()
en un par de cadenas MUTF-8 no siempre indica el resultado firmado correctamente de la comparación de cadenas desiguales.
Cuando el orden (no solo la igualdad) es un problema, la forma más sencilla de comparar cadenas en MUTF-8 es decodificarlas carácter por carácter y comparar los valores decodificados. (Sin embargo, también son posibles implementaciones más inteligentes).
Consulta The Unicode Standard para obtener más información sobre la codificación de caracteres. En realidad, MUTF-8 se acerca más a la codificación CESU-8 (relativamente menos conocida) que a UTF-8 en sí.
Codificación de encoded_value
Se incorpora en annotation_element y encoded_array_item
Un encoded_value
es una parte codificada de datos estructurados jerárquicamente (casi) arbitrarios. La codificación debe ser compacta y fácil de analizar.
Name | Formato | Descripción |
---|---|---|
(value_arg << 5) | value_type | ubyte | Es un byte que indica el tipo de value inmediatamente posterior, junto con un argumento aclaratorio opcional en los tres bits de orden superior.
A continuación, se incluyen las distintas definiciones de value .
En la mayoría de los casos, value_arg codifica la longitud del value inmediatamente posterior en bytes, como (size - 1) , p.ej., 0 significa que el valor requiere un byte, y 7 significa que requiere ocho bytes. Sin embargo, hay excepciones, como se indica a continuación.
|
valor | ubyte[] | Son bytes que representan el valor, tienen una longitud variable y se interpretan de manera diferente para los distintos bytes de value_type , aunque siempre son little-endian. Consulta las diferentes definiciones de valores a continuación para obtener más detalles.
|
Formatos de valores
Nombre del tipo | value_type |
Formato value_arg |
Formato value |
Descripción |
---|---|---|---|---|
VALUE_BYTE | 0x00 | (ninguno; debe ser 0 ) |
ubyte[1] | Valor de número entero de un byte con signo |
VALUE_SHORT | 0x02 | size: 1 (0…1) | ubyte[size] | Valor de número entero de dos bytes firmado, con extensión de signo |
VALUE_CHAR | 0x03 | size: 1 (0…1) | ubyte[size] | Valor de número entero de dos bytes sin signo, con extensión de ceros |
VALUE_INT | 0x04 | size: 1 (0…3) | ubyte[size] | valor entero de cuatro bytes con signo, con extensión de signo |
VALUE_LONG | 0x06 | size: 1 (0…7) | ubyte[size] | valor de número entero de ocho bytes con signo, con extensión de signo |
VALUE_FLOAT | 0x10 | size: 1 (0…3) | ubyte[size] | Patrón de bits de cuatro bytes, con ceros agregados a la derecha y se interpreta como un valor de punto flotante IEEE754 de 32 bits |
VALUE_DOUBLE | 0x11 | size: 1 (0…7) | ubyte[size] | Patrón de bits de ocho bytes, con ceros agregados a la derecha y se interpreta como un valor de punto flotante IEEE754 de 64 bits |
VALUE_METHOD_TYPE | 0x15 | size: 1 (0…3) | ubyte[size] | Valor entero de cuatro bytes sin signo (con extensión de ceros),
interpretado como un índice en la sección proto_ids y que representa un valor de tipo de método
|
VALUE_METHOD_HANDLE | 0x16 | size: 1 (0…3) | ubyte[size] | Valor de número entero de cuatro bytes sin signo (con extensión de ceros),
interpretado como un índice en la sección method_handles y que representa un valor de identificador de método
|
VALUE_STRING | 0x17 | size: 1 (0…3) | ubyte[size] | Valor de número entero de cuatro bytes sin signo (con extensión de ceros),
interpretado como un índice en la sección string_ids y que representa un valor de cadena
|
VALUE_TYPE | 0x18 | size: 1 (0…3) | ubyte[size] | Valor de número entero de cuatro bytes sin signo (con extensión de ceros),
interpretado como un índice en
la sección type_ids y que representa un valor de tipo o clase reflexivo
|
VALUE_FIELD | 0x19 | size: 1 (0…3) | ubyte[size] | Valor de número entero de cuatro bytes sin signo (con extensión de ceros),
interpretado como un índice en la sección field_ids y que representa un valor de campo reflectivo
|
VALUE_METHOD | 0x1a | size: 1 (0…3) | ubyte[size] | Valor de número entero de cuatro bytes sin signo (con extensión de ceros),
interpretado como un índice en
la sección method_ids y que representa un valor de método reflectivo
|
VALUE_ENUM | 0x1b | size: 1 (0…3) | ubyte[size] | Valor de número entero de cuatro bytes sin signo (con extensión de ceros),
interpretado como un índice en la sección field_ids y que representa el valor de
una constante de tipo enumerado
|
VALUE_ARRAY | 0x1c | (ninguno; debe ser 0 ) |
encoded_array | Un array de valores, en el formato especificado por "formato encoded_array " a continuación. El tamaño de value está implícito en la codificación.
|
VALUE_ANNOTATION | 0x1d | (ninguno; debe ser 0 ) |
encoded_annotation | una subanotación, en el formato especificado por "formato de encoded_annotation " a continuación El tamaño de value está implícito en la codificación.
|
VALUE_NULL | 0x1e | (ninguno; debe ser 0 ) |
(ninguno) | Valor de referencia de null |
VALUE_BOOLEAN | 0x1f | booleano (0 a 1) | (ninguno) | Valor de un bit; 0 para false y 1 para true . El bit se representa en value_arg .
|
Formato de encoded_array
Name | Formato | Descripción |
---|---|---|
size | uleb128 | Cantidad de elementos del array |
valores | encoded_value[size] | Una serie de secuencias de bytes size encoded_value en el formato especificado en esta sección, concatenadas de forma secuencial.
|
Formato de encoded_annotation
Name | Formato | Descripción |
---|---|---|
type_idx | uleb128 | Es el tipo de anotación. Debe ser un tipo de clase (no un array ni un tipo primitivo). |
size | uleb128 | Cantidad de asignaciones de nombre-valor en esta anotación |
elementos | annotation_element[size] | elementos de la anotación, representados directamente en línea (no como desplazamientos). Los elementos deben ordenarse de forma creciente según el índice string_id .
|
Formato de annotation_element
Name | Formato | Descripción |
---|---|---|
name_idx | uleb128 | Nombre del elemento, representado como un índice en la sección string_ids . La cadena debe cumplir con la sintaxis de MemberName, definida anteriormente.
|
valor | encoded_value | valor del elemento |
Sintaxis de cadenas
Hay varios tipos de elementos en un archivo .dex
que, en última instancia, hacen referencia a una cadena. Las siguientes definiciones de estilo BNF indican la sintaxis aceptable para estas cadenas.
SimpleName
Un SimpleName es la base de la sintaxis de los nombres de otras cosas. El formato .dex
permite una gran cantidad de libertad aquí (mucho más que la mayoría de los idiomas fuente comunes). En resumen, un nombre simple consta de cualquier carácter alfabético o dígito ASCII bajo, algunos símbolos ASCII bajos específicos y la mayoría de los puntos de código que no son ASCII y que no son caracteres de control, espacio o especiales. A partir de la versión 040
, el formato también permite caracteres de espacio (categoría Unicode Zs
). Ten en cuenta que los puntos de código suplentes (en el rango de U+d800
a U+dfff
) no se consideran caracteres de nombre válidos, pero los caracteres suplementarios de Unicode sí son válidos (que se representan con la alternativa final de la regla para SimpleNameChar) y deben representarse en un archivo como pares de puntos de código suplentes en la codificación MUTF-8.
SimpleName → | ||
SimpleNameChar (SimpleNameChar)* | ||
SimpleNameChar → | ||
'A' … 'Z' |
||
| | 'a' … 'z' |
|
| | '0' … '9' |
|
| | ' ' |
desde la versión 040 de DEX |
| | '$' |
|
| | '-' |
|
| | '_' |
|
| | U+00a0 |
desde la versión 040 de DEX |
| | U+00a1 … U+1fff |
|
| | U+2000 … U+200a |
desde la versión 040 de DEX |
| | U+2010 … U+2027 |
|
| | U+202f |
desde la versión 040 de DEX |
| | U+2030 … U+d7ff |
|
| | U+e000 … U+ffef |
|
| | U+10000 … U+10ffff |
MemberName
Se usa en field_id_item y method_id_item.
Un MemberName es el nombre de un miembro de una clase, y los miembros son campos, métodos y clases internas.
MemberName → | |
SimpleName | |
| | '<' SimpleName '>' |
FullClassName
Un FullClassName es un nombre de clase completamente calificado, que incluye un especificador de paquete opcional seguido de un nombre obligatorio.
FullClassName → | |
OptionalPackagePrefix SimpleName | |
OptionalPackagePrefix → | |
(SimpleName '/' )* |
TypeDescriptor
Se usa en type_id_item
Un TypeDescriptor es la representación de cualquier tipo, incluidos los tipos primitivos, las clases, los arrays y void
. A continuación, se explica el significado de las distintas versiones.
TypeDescriptor → | |
'V' |
|
| | FieldTypeDescriptor |
FieldTypeDescriptor → | |
NonArrayFieldTypeDescriptor | |
| | ('[' * 1…255)
NonArrayFieldTypeDescriptor |
NonArrayFieldTypeDescriptor→ | |
'Z' |
|
| | 'B' |
| | 'S' |
| | 'C' |
| | 'I' |
| | 'J' |
| | 'F' |
| | 'D' |
| | 'L' FullClassName ';' |
ShortyDescriptor
Usado por proto_id_item
Un ShortyDescriptor es la representación abreviada de un prototipo de método, incluidos los tipos de parámetros y de devolución, excepto que no hay distinción entre los distintos tipos de referencia (clase o matriz). En cambio, todos los tipos de referencia se representan con un solo carácter 'L'
.
ShortyDescriptor → | |
ShortyReturnType (ShortyFieldType)* | |
ShortyReturnType → | |
'V' |
|
| | ShortyFieldType |
ShortyFieldType → | |
'Z' |
|
| | 'B' |
| | 'S' |
| | 'C' |
| | 'I' |
| | 'J' |
| | 'F' |
| | 'D' |
| | 'L' |
Semántica de TypeDescriptor
Este es el significado de cada una de las variantes de TypeDescriptor.
Sintaxis | Significado |
---|---|
V | void ; solo es válido para los tipos de datos que se devuelven |
Z | boolean |
B | byte |
S | short |
C | char |
I | int |
J | long |
F | float |
D | double |
Lfully/qualified/Name; | la clase fully.qualified.Name |
[descriptor | Es un array de descriptor , que se puede usar de forma recursiva para arrays de arrays, aunque no es válido tener más de 255 dimensiones.
|
Elementos y estructuras relacionadas
En esta sección, se incluyen definiciones para cada uno de los elementos de nivel superior que pueden aparecer en un archivo .dex
.
header_item
Aparece en la sección del encabezado
Alineación: 4 bytes
Name | Formato | Descripción |
---|---|---|
mágico | ubyte[8] = DEX_FILE_MAGIC | valor mágico. Consulta el debate anterior en "DEX_FILE_MAGIC " para obtener más detalles.
|
suma de comprobación | uint | Suma de verificación adler32 del resto del archivo (todo excepto magic y este campo); se usa para detectar daños en el archivo
|
firma | ubyte[20] | Firma (hash) SHA-1 del resto del archivo (todo excepto magic , checksum y este campo); se usa para identificar archivos de forma única
|
file_size | uint |
tamaño de todo el archivo (incluido el encabezado), en bytes (v40 o versiones anteriores) distancia en bytes desde el inicio de este encabezado hasta el siguiente o hasta el final de todo el archivo (el contenedor). (v41 o posterior) |
header_size | uint |
Tamaño del encabezado (toda esta sección), en bytes. Esto permite, al menos, una cantidad limitada de compatibilidad con versiones anteriores o posteriores sin invalidar el formato. debe ser de 0x70 (112) bytes (v40 o anterior) debe ser de 0x78 (120) bytes (v41 o posterior) |
endian_tag | uint = ENDIAN_CONSTANT | etiqueta de endianness. Consulta el debate anterior en "ENDIAN_CONSTANT y REVERSE_ENDIAN_CONSTANT " para obtener más detalles.
|
link_size | uint | tamaño de la sección de vínculos o 0 si este archivo no está vinculado de forma estática |
link_off | uint | Desplazamiento desde el inicio del archivo hasta la sección del vínculo, o 0 si es link_size == 0 . Si el desplazamiento no es cero, debe ser un desplazamiento hacia la sección link_data . El formato de los datos a los que apunta este campo de encabezado no se especifica en este documento, y este campo (y el anterior) se dejan como enlaces para que los usen las implementaciones de tiempo de ejecución.
|
map_off | uint | Es el desplazamiento desde el inicio del archivo hasta el elemento del mapa. El desplazamiento, que no debe ser cero, debe ser un desplazamiento hacia la sección data , y los datos deben estar en el formato especificado por "map_list " a continuación.
|
string_ids_size | uint | Recuento de cadenas en la lista de identificadores de cadenas |
string_ids_off | uint | Desplazamiento desde el inicio del archivo hasta la lista de identificadores de cadenas, o 0 si string_ids_size == 0 (un caso límite extraño, sin duda). Si el desplazamiento no es cero, debe ser hacia el inicio de la sección string_ids .
|
type_ids_size | uint | Cantidad de elementos en la lista de identificadores de tipo, como máximo 65535 |
type_ids_off | uint | Desplazamiento desde el inicio del archivo hasta la lista de identificadores de tipo, o 0 si type_ids_size == 0 (un caso límite extraño, sin duda). Si el desplazamiento no es cero, debe ser hacia el inicio de la sección type_ids .
|
proto_ids_size | uint | Es el recuento de elementos en la lista de identificadores de prototipos, con un máximo de 65,535. |
proto_ids_off | uint | Desplazamiento desde el inicio del archivo hasta la lista de identificadores de prototipos, o 0 si proto_ids_size == 0 (un caso límite extraño, sin duda). Si el desplazamiento no es cero, debe ser hacia el inicio de la sección proto_ids .
|
field_ids_size | uint | Cantidad de elementos en la lista de identificadores de campo |
field_ids_off | uint | Desplazamiento desde el inicio del archivo hasta la lista de identificadores de campo, o 0 si es field_ids_size == 0 . Si no es cero, el desplazamiento debe ser hacia el inicio de la sección field_ids . |
method_ids_size | uint | Cantidad de elementos en la lista de identificadores de métodos |
method_ids_off | uint | Desplazamiento desde el inicio del archivo hasta la lista de identificadores de métodos, o 0 si es method_ids_size == 0 . Si no es cero, el desplazamiento debe ser hacia el inicio de la sección method_ids . |
class_defs_size | uint | Cantidad de elementos en la lista de definiciones de clase |
class_defs_off | uint | Es el desplazamiento desde el inicio del archivo hasta la lista de definiciones de clase, o bien 0 si class_defs_size == 0 (sin duda, un caso límite extraño). Si el desplazamiento no es cero, debe ser hacia el inicio de la sección class_defs .
|
data_size | uint |
Tamaño de la sección Sin usar (v41 o versiones posteriores) |
data_off | uint |
Desplazamiento desde el inicio del archivo hasta el inicio de la sección Sin usar (v41 o versiones posteriores) |
container_size | uint |
Este campo no existe. Se puede suponer que es igual a Tamaño de todo el archivo (incluidos otros encabezados dex y sus datos). (v41 o posterior) |
header_offset | uint |
Este campo no existe. Se puede suponer que es igual a Es el desplazamiento desde el inicio del archivo hasta el inicio de este encabezado. (v41 o posterior) |
map_list
Aparece en la sección de datos
Se hace referencia desde header_item
Alineación: 4 bytes
Es una lista de todo el contenido de un archivo, en orden. Contiene cierta redundancia con respecto a header_item
, pero está diseñado para ser un formulario fácil de usar para iterar en un archivo completo. Un tipo determinado debe aparecer como máximo una vez en un mapa, pero no hay restricciones sobre el orden en que pueden aparecer los tipos, más allá de las restricciones que implica el resto del formato (p. ej., una sección header
debe aparecer primero, seguida de una sección string_ids
, etcétera). Además, las entradas del mapa deben ordenarse según el desplazamiento inicial y no deben superponerse.
Name | Formato | Descripción |
---|---|---|
size | uint | Tamaño de la lista, en entradas |
list | map_item[size] | elementos de la lista |
Formato de map_item
Name | Formato | Descripción |
---|---|---|
tipo | ushort | Tipo de los elementos (consulta la tabla a continuación) |
Sin usar | ushort | (sin usar) |
size | uint | Recuento de la cantidad de elementos que se encontrarán en el desplazamiento indicado |
desplazamiento | uint | Desplazamiento desde el inicio del archivo hasta los elementos en cuestión |
Códigos de tipo
Tipo de elemento | Constante | Valor | Tamaño del elemento en bytes |
---|---|---|---|
header_item | TYPE_HEADER_ITEM | 0x0000 | 0x70 |
string_id_item | TYPE_STRING_ID_ITEM | 0x0001 | 0x04 |
type_id_item | TYPE_TYPE_ID_ITEM | 0x0002 | 0x04 |
proto_id_item | TYPE_PROTO_ID_ITEM | 0x0003 | 0x0c |
field_id_item | TYPE_FIELD_ID_ITEM | 0x0004 | 0x08 |
method_id_item | TYPE_METHOD_ID_ITEM | 0x0005 | 0x08 |
class_def_item | TYPE_CLASS_DEF_ITEM | 0x0006 | 0x20 |
call_site_id_item | TYPE_CALL_SITE_ID_ITEM | 0x0007 | 0x04 |
method_handle_item | TYPE_METHOD_HANDLE_ITEM | 0x0008 | 0x08 |
map_list | TYPE_MAP_LIST | 0x1000 | 4 + (item.size * 12) |
type_list | TYPE_TYPE_LIST | 0x1001 | 4 + (item.size * 2) |
annotation_set_ref_list | TYPE_ANNOTATION_SET_REF_LIST | 0x1002 | 4 + (item.size * 4) |
annotation_set_item | TYPE_ANNOTATION_SET_ITEM | 0x1003 | 4 + (item.size * 4) |
class_data_item | TYPE_CLASS_DATA_ITEM | 0x2000 | implícito; se debe analizar |
code_item | TYPE_CODE_ITEM | 0x2001 | implícito; se debe analizar |
string_data_item | TYPE_STRING_DATA_ITEM | 0x2002 | implícito; se debe analizar |
debug_info_item | TYPE_DEBUG_INFO_ITEM | 0x2003 | implícito; se debe analizar |
annotation_item | TYPE_ANNOTATION_ITEM | 0x2004 | implícito; se debe analizar |
encoded_array_item | TYPE_ENCODED_ARRAY_ITEM | 0x2005 | implícito; se debe analizar |
annotations_directory_item | TYPE_ANNOTATIONS_DIRECTORY_ITEM | 0x2006 | implícito; se debe analizar |
hiddenapi_class_data_item | TYPE_HIDDENAPI_CLASS_DATA_ITEM | 0xF000 | implícito; se debe analizar |
string_id_item
Aparece en la sección string_ids
Alineación: 4 bytes
Name | Formato | Descripción |
---|---|---|
string_data_off | uint | Desplazamiento desde el inicio del archivo hasta los datos de la cadena de este elemento. El desplazamiento debe ser hacia una ubicación en la sección data , y los datos deben estar en el formato especificado por "string_data_item " a continuación.
No hay requisitos de alineación para el desplazamiento.
|
string_data_item
Aparece en la sección de datos
Alineación: Ninguna (alineada por bytes)
Name | Formato | Descripción |
---|---|---|
utf16_size | uleb128 | Tamaño de esta cadena, en unidades de código UTF-16 (que es la "longitud de la cadena" en muchos sistemas). Es decir, esta es la longitud decodificada de la cadena. (La longitud codificada se deduce de la posición del byte 0 ). |
datos | ubyte[] | una serie de unidades de código MUTF-8 (también conocidas como octetos o bytes)
seguida de un byte con el valor 0 . Consulta "Codificación UTF-8 modificado (MUTF-8)" más arriba para obtener detalles y un análisis sobre el formato de datos.
Nota: Se acepta tener una cadena que incluya unidades de código suplente UTF-16 (es decir, |
type_id_item
Aparece en la sección type_ids
Alineación: 4 bytes
Name | Formato | Descripción |
---|---|---|
descriptor_idx | uint | Índice en la lista string_ids para la cadena del descriptor de este tipo. La cadena debe cumplir con la sintaxis de TypeDescriptor, definida anteriormente.
|
proto_id_item
Aparece en la sección proto_ids
Alineación: 4 bytes
Name | Formato | Descripción |
---|---|---|
shorty_idx | uint | Índice en la lista string_ids para la cadena de descriptor de formato corto de este prototipo. La cadena debe cumplir con la sintaxis de ShortyDescriptor, definida anteriormente, y debe corresponderse con el tipo de devolución y los parámetros de este elemento.
|
return_type_idx | uint | Índice en la lista type_ids para el tipo de datos que se muestra de este prototipo
|
parameters_off | uint | Desplazamiento desde el inicio del archivo hasta la lista de tipos de parámetros de este prototipo, o 0 si este prototipo no tiene parámetros. Si este desplazamiento no es cero, debe estar en la sección data , y los datos allí deben estar en el formato especificado por "type_list" a continuación. Además, no debería haber ninguna referencia al tipo void en la lista.
|
field_id_item
Aparece en la sección field_ids
Alineación: 4 bytes
Name | Formato | Descripción |
---|---|---|
class_idx | ushort | Índice en la lista type_ids para el definidor de este campo. Debe ser un tipo de clase, no un array ni un tipo primitivo.
|
type_idx | ushort | índice en la lista type_ids para el tipo de este campo
|
name_idx | uint | Indexa la lista string_ids para obtener el nombre de este campo. La cadena debe cumplir con la sintaxis de MemberName, definida anteriormente.
|
method_id_item
Aparece en la sección method_ids
Alineación: 4 bytes
Name | Formato | Descripción |
---|---|---|
class_idx | ushort | Índice en la lista type_ids para el definidor de este método. Debe ser un tipo de clase o array, y no un tipo primitivo.
|
proto_idx | ushort | Índice en la lista proto_ids para el prototipo de este método
|
name_idx | uint | Índice en la lista string_ids para el nombre de este método. La cadena debe cumplir con la sintaxis de MemberName, definida anteriormente.
|
class_def_item
Aparece en la sección class_defs
Alineación: 4 bytes
Name | Formato | Descripción |
---|---|---|
class_idx | uint | Índice en la lista type_ids para esta clase.
Debe ser un tipo de clase, no un array ni un tipo primitivo.
|
access_flags | uint | Son las marcas de acceso para la clase (public , final , etc.). Consulta "Definiciones de access_flags " para obtener más detalles.
|
superclass_idx | uint | Índice en la lista type_ids para la superclase o el valor constante NO_INDEX si esta clase no tiene superclase (es decir, es una clase raíz como Object ). Si está presente, debe ser un tipo de clase, no un array o un tipo primitivo.
|
interfaces_off | uint | Desplazamiento desde el inicio del archivo hasta la lista de interfaces, o 0 si no hay ninguna. Este desplazamiento debe estar en la sección data , y los datos allí deben tener el formato especificado por "type_list " a continuación. Cada uno de los elementos de la lista debe ser un tipo de clase (no un array o un tipo primitivo), y no debe haber duplicados.
|
source_file_idx | uint | Índice en la lista string_ids para el nombre del archivo que contiene el código fuente original de (al menos, la mayor parte de) esta clase, o el valor especial NO_INDEX para representar la falta de esta información. El debug_info_item de cualquier método determinado puede anular este archivo fuente, pero se espera que la mayoría de las clases solo provengan de un archivo fuente.
|
annotations_off | uint | Desplazamiento desde el inicio del archivo hasta la estructura de anotaciones
para esta clase, o 0 si no hay anotaciones en
esta clase. Si este desplazamiento no es cero, debe estar en la sección data , y los datos allí deben estar en el formato especificado por "annotations_directory_item " a continuación, con todos los elementos que se refieran a esta clase como el definidor.
|
class_data_off | uint | Desplazamiento desde el inicio del archivo hasta los datos de la clase asociados a este elemento, o 0 si no hay datos de la clase para esta clase. (Este puede ser el caso, por ejemplo, si esta clase es una interfaz de marcador). Si el desplazamiento no es cero, debe estar en la sección data , y los datos allí deben estar en el formato especificado por "class_data_item " a continuación, con todos los elementos que se refieran a esta clase como el definidor.
|
static_values_off | uint | Desplazamiento desde el inicio del archivo hasta la lista de valores iniciales para los campos static , o 0 si no hay ninguno (y todos los campos static se deben inicializar con 0 o null ). Este desplazamiento debe estar en la sección data , y los datos allí deben estar en el formato especificado por "encoded_array_item " a continuación. El tamaño del array no debe ser mayor que la cantidad de campos static declarados por esta clase, y los elementos deben corresponder a los campos static en el mismo orden en que se declaran en el field_list correspondiente. El tipo de cada elemento del array debe coincidir con el tipo declarado de su campo correspondiente.
Si hay menos elementos en el array que campos static , los campos restantes se inicializan con un 0 o un null adecuados para el tipo.
|
call_site_id_item
Aparece en la sección call_site_ids
Alineación: 4 bytes
Name | Formato | Descripción |
---|---|---|
call_site_off | uint | Es el desplazamiento desde el inicio del archivo hasta la definición del sitio de llamada. El desplazamiento debe estar en la sección de datos, y los datos allí deben tener el formato especificado por "call_site_item" a continuación. |
call_site_item
Aparece en la sección de datos
Alineación: Ninguna (alineada por bytes)
El call_site_item es un encoded_array_item cuyos elementos corresponden a los argumentos proporcionados a un método de vinculador de arranque. Los primeros tres argumentos son los siguientes:
- Es un identificador de método que representa el método de vinculación de arranque (VALUE_METHOD_HANDLE).
- Nombre de un método que el vinculador de arranque debe resolver (VALUE_STRING).
- Es un tipo de método que corresponde al tipo del nombre del método que se resolverá (VALUE_METHOD_TYPE).
Los argumentos adicionales son valores constantes que se pasan al método de vinculador de arranque. Estos argumentos se pasan en orden y sin ningún tipo de conversión.
El identificador de método que representa el método de vinculador de arranque debe tener el tipo de datos que se muestra java.lang.invoke.CallSite
. Los primeros tres tipos de parámetros son los siguientes:
java.lang.invoke.Lookup
java.lang.String
java.lang.invoke.MethodType
Los tipos de parámetros de los argumentos adicionales se determinan a partir de sus valores constantes.
method_handle_item
Aparece en la sección method_handles
Alineación: 4 bytes
Name | Formato | Descripción |
---|---|---|
method_handle_type | ushort | Tipo del identificador de método; consulta la tabla a continuación |
Sin usar | ushort | (sin usar) |
field_or_method_id | ushort | Es el ID del campo o del método, según si el tipo de identificador de método es un invocador de métodos o un descriptor de acceso. |
Sin usar | ushort | (sin usar) |
Códigos de tipos de identificadores de métodos
Constante | Valor | Descripción |
---|---|---|
METHOD_HANDLE_TYPE_STATIC_PUT | 0x00 | El identificador de método es un establecedor (accesorio) de campo estático. |
METHOD_HANDLE_TYPE_STATIC_GET | 0x01 | El identificador de método es un getter (accesorio) de campo estático |
METHOD_HANDLE_TYPE_INSTANCE_PUT | 0x02 | El identificador de método es un setter (accesorio) de campo de instancia |
METHOD_HANDLE_TYPE_INSTANCE_GET | 0x03 | El identificador de método es un getter (descriptor de acceso) de un campo de instancia |
METHOD_HANDLE_TYPE_INVOKE_STATIC | 0x04 | El identificador de método es un invocador de método estático |
METHOD_HANDLE_TYPE_INVOKE_INSTANCE | 0x05 | El identificador de método es un invocador de método de instancia |
METHOD_HANDLE_TYPE_INVOKE_CONSTRUCTOR | 0x06 | El identificador de método es un invocador de método constructor |
METHOD_HANDLE_TYPE_INVOKE_DIRECT | 0x07 | El identificador de método es un invocador de método directo |
METHOD_HANDLE_TYPE_INVOKE_INTERFACE | 0x08 | El identificador de método es un invocador de métodos de interfaz |
class_data_item
Se hace referencia desde class_def_item
Aparece en la sección de datos
Alineación: Ninguna (alineada por bytes)
Name | Formato | Descripción |
---|---|---|
static_fields_size | uleb128 | Cantidad de campos estáticos definidos en este elemento |
instance_fields_size | uleb128 | Cantidad de campos de instancia definidos en este elemento |
direct_methods_size | uleb128 | Cantidad de métodos directos definidos en este elemento |
virtual_methods_size | uleb128 | Cantidad de métodos virtuales definidos en este elemento |
static_fields | encoded_field[static_fields_size] | Los campos estáticos definidos, representados como una secuencia de elementos codificados. Los campos deben ordenarse por field_idx en orden ascendente.
|
instance_fields | encoded_field[instance_fields_size] | Son los campos de instancia definidos, representados como una secuencia de
elementos codificados. Los campos deben ordenarse por field_idx en orden ascendente.
|
direct_methods | encoded_method[direct_methods_size] | Los métodos directos definidos (cualquiera de static , private o constructor), representados como una secuencia de elementos codificados. Los métodos deben ordenarse por method_idx en orden creciente.
|
virtual_methods | encoded_method[virtual_methods_size] | Los métodos virtuales definidos (ninguno de static , private ni constructor), representados como una secuencia de elementos codificados. Esta lista no debe incluir métodos heredados, a menos que la clase que representa este elemento los anule. Los métodos deben ordenarse por method_idx en orden ascendente.
El method_idx de un método virtual no debe ser el mismo que el de ningún método directo.
|
Nota: Todas las instancias de field_id
y method_id
de los elementos deben hacer referencia a la misma clase definitoria.
Formato de encoded_field
Name | Formato | Descripción |
---|---|---|
field_idx_diff | uleb128 | Índice en la lista field_ids para la identidad de este campo (incluye el nombre y el descriptor), representado como una diferencia del índice del elemento anterior en la lista. El índice del primer elemento de una lista se representa directamente.
|
access_flags | uleb128 | Marcas de acceso para el campo (public , final , etcétera). Consulta "Definiciones de access_flags " para obtener más detalles.
|
Formato de encoded_method
Name | Formato | Descripción |
---|---|---|
method_idx_diff | uleb128 | Índice en la lista method_ids para la identidad de este método (incluye el nombre y el descriptor), representado como una diferencia con respecto al índice del elemento anterior en la lista. El índice del primer elemento de una lista se representa directamente.
|
access_flags | uleb128 | Son las marcas de acceso para el método (public , final , etc.). Consulta "Definiciones de access_flags " para obtener más detalles.
|
code_off | uleb128 | Desplazamiento desde el inicio del archivo hasta la estructura de código de este método, o 0 si este método es abstract o native . El desplazamiento debe ser hacia una ubicación en la sección data . El formato de los datos se especifica con "code_item " a continuación.
|
type_list
Se hace referencia desde class_def_item y proto_id_item
Aparece en la sección de datos
Alineación: 4 bytes
Name | Formato | Descripción |
---|---|---|
size | uint | Tamaño de la lista, en entradas |
list | type_item[size] | elementos de la lista |
Formato de type_item
Name | Formato | Descripción |
---|---|---|
type_idx | ushort | Índice en la lista type_ids |
code_item
Referencia de encoded_method
Aparece en la sección de datos
Alineación: 4 bytes
Name | Formato | Descripción |
---|---|---|
registers_size | ushort | La cantidad de registros que usa este código |
ins_size | ushort | la cantidad de palabras de los argumentos entrantes al método para el que se escribe este código |
outs_size | ushort | Es la cantidad de palabras del espacio de argumentos salientes que requiere este código para la invocación del método. |
tries_size | ushort | Es la cantidad de try_item para esta instancia. Si no es cero, aparecen como el array tries justo después de insns en esta instancia.
|
debug_info_off | uint | Es el desplazamiento desde el inicio del archivo hasta la secuencia de información de depuración (números de línea + información de variables locales) para este código, o 0 si simplemente no hay información. Si el desplazamiento no es cero, debe apuntar a una ubicación en la sección data . El formato de los datos se especifica con "debug_info_item " a continuación.
|
insns_size | uint | Tamaño de la lista de instrucciones, en unidades de código de 16 bits |
insns | ushort[insns_size] | array real de bytecode. El formato del código en un array insns se especifica en el documento complementario Código de bytes de Dalvik. Ten en cuenta que, aunque se define como un array de ushort , hay algunas estructuras internas que prefieren la alineación de cuatro bytes. Además, si se trata de un archivo con intercambio de endianness, el intercambio se realiza solo en instancias ushort individuales y no en las estructuras internas más grandes.
|
relleno | ushort (opcional) = 0 | Dos bytes de padding para que tries esté alineado con cuatro bytes.
Este elemento solo está presente si tries_size no es cero y insns_size es impar.
|
trata | try_item[tries_size] (opcional) | Es un array que indica dónde se detectan las excepciones en el código y cómo controlarlas. Los elementos del array no deben superponerse en el rango y deben estar ordenados de la dirección más baja a la más alta. Este elemento solo está presente si tries_size no es cero.
|
controladores | encoded_catch_handler_list (opcional) | Son bytes que representan una lista de listas de tipos de captura y direcciones de controladores asociadas. Cada try_item tiene un desplazamiento de bytes en esta estructura. Este elemento solo está presente si tries_size no es cero.
|
Formato de try_item
Name | Formato | Descripción |
---|---|---|
start_addr | uint | Es la dirección de inicio del bloque de código que abarca esta entrada. La dirección es un recuento de unidades de código de 16 bits hasta el inicio de la primera instrucción cubierta. |
insn_count | ushort | Cantidad de unidades de código de 16 bits que abarca esta entrada. La última unidad de código cubierta (inclusive) es start_addr + insn_count - 1 .
|
handler_off | ushort | Es el desplazamiento en bytes desde el inicio del encoded_catch_hander_list asociado hasta el encoded_catch_handler de esta entrada. Debe ser un desplazamiento al inicio de un encoded_catch_handler .
|
Formato de encoded_catch_handler_list
Name | Formato | Descripción |
---|---|---|
size | uleb128 | Tamaño de esta lista, en entradas |
list | encoded_catch_handler[handlers_size] | Lista real de listas de controladores, representada directamente (no como desplazamientos) y concatenada de forma secuencial |
Formato de encoded_catch_handler
Name | Formato | Descripción |
---|---|---|
size | sleb128 | Es la cantidad de tipos de capturas en esta lista. Si no es positivo, este es el negativo de la cantidad de tipos de captura, y las capturas son seguidas por un controlador de captura general. Por ejemplo, un size de 0 significa que hay una captura general, pero no capturas con tipos explícitos.
Un size de 2 significa que hay dos capturas con tipo explícito y ninguna captura general. Un size de -1 significa que hay una captura con tipo junto con una captura general.
|
controladores | encoded_type_addr_pair[abs(size)] | Flujo de elementos codificados abs(size) , uno para cada tipo capturado, en el orden en que se deben probar los tipos.
|
catch_all_addr | uleb128 (opcional) | Es la dirección de código de bytes del controlador genérico. Este elemento solo está presente si size no es positivo.
|
Formato de encoded_type_addr_pair
Name | Formato | Descripción |
---|---|---|
type_idx | uleb128 | Índice en la lista type_ids para el tipo de excepción que se detectará
|
addr | uleb128 | dirección de bytecode del controlador de excepciones asociado |
debug_info_item
Se hace referencia desde code_item
Aparece en la sección de datos
Alineación: Ninguna (alineada por bytes)
Cada debug_info_item
define una máquina de estados codificada en bytes inspirada en DWARF3 que, cuando se interpreta, emite la tabla de posiciones y (posiblemente) la información de variables locales para un code_item
. La secuencia comienza con un encabezado de longitud variable (cuya longitud depende de la cantidad de parámetros del método), continúa con los códigos de bytes de la máquina de estados y finaliza con un byte DBG_END_SEQUENCE
.
La máquina de estados consta de cinco registros. El registro address
representa el desplazamiento de la instrucción en el insns_item
asociado en unidades de código de 16 bits. El registro address
comienza en 0
al principio de cada secuencia debug_info
y solo debe aumentar de forma monotónica.
El registro line
representa el número de línea de origen que se debe asociar con la próxima entrada de la tabla de posiciones que emite la máquina de estados. Se inicializa en el encabezado de la secuencia y puede cambiar en direcciones positivas o negativas, pero nunca debe ser inferior a 1
. El registro source_file
representa el archivo fuente al que hacen referencia las entradas de número de línea. Se inicializa con el valor de source_file_idx
en class_def_item
.
Las otras dos variables, prologue_end
y epilogue_begin
, son marcas booleanas (inicializadas en false
) que indican si la siguiente posición emitida debe considerarse un prólogo o un epílogo del método. La máquina de estados también debe hacer un seguimiento del nombre y el tipo de la última variable local activa en cada registro para el código DBG_RESTART_LOCAL
.
El encabezado es el siguiente:
Name | Formato | Descripción |
---|---|---|
line_start | uleb128 | Es el valor inicial del registro line de la máquina de estados.
No representa una entrada de posiciones real.
|
parameters_size | uleb128 | Es la cantidad de nombres de parámetros que se codifican. Debe haber uno por parámetro de método, excepto el this de un método de instancia, si corresponde.
|
parameter_names | uleb128p1[parameters_size] | Índice de cadena del nombre del parámetro del método. Un valor codificado de NO_INDEX indica que no hay ningún nombre disponible para el parámetro asociado. El descriptor de tipo y la firma se infieren del descriptor y la firma del método.
|
Los valores del código de bytes son los siguientes:
Name | Valor | Formato | Argumentos | Descripción |
---|---|---|---|---|
DBG_END_SEQUENCE | 0x00 | (ninguno) | finaliza una secuencia de información de depuración para un code_item |
|
DBG_ADVANCE_PC | 0x01 | uleb128 addr_diff | addr_diff : Es la cantidad que se agregará al registro de direcciones. |
Avanza el registro de direcciones sin emitir una entrada de posiciones. |
DBG_ADVANCE_LINE | 0x02 | sleb128 line_diff | line_diff : Cantidad en la que se debe cambiar el registro de línea |
Avanza el registro de línea sin emitir una entrada de posiciones. |
DBG_START_LOCAL | 0x03 | uleb128 register_num uleb128p1 name_idx uleb128p1 type_idx |
register_num : Registro que contendrá ellocal name_idx : Índice de cadena del nombretype_idx : Índice de tipo del tipo
|
Introduce una variable local en la dirección actual. name_idx o type_idx pueden ser NO_INDEX para indicar que ese valor es desconocido.
|
DBG_START_LOCAL_EXTENDED | 0x04 | uleb128 register_num uleb128p1 name_idx uleb128p1 type_idx uleb128p1 sig_idx |
register_num : Registro que contendrá ellocal name_idx : Índice de cadena del nombretype_idx : Índice de tipo del tiposig_idx : Índice de cadena de la firma de tipo
|
Introduce una variable local con una firma de tipo en la dirección actual.
Cualquiera de name_idx , type_idx o sig_idx puede ser NO_INDEX para indicar que ese valor es desconocido. (Sin embargo, si sig_idx es -1 , los mismos datos se podrían representar de manera más eficiente con el código de operación DBG_START_LOCAL ).
Nota: Consulta el debate en " |
DBG_END_LOCAL | 0x05 | uleb128 register_num | register_num : Es el registro que contenía la información local. |
marca una variable local activa actualmente como fuera del alcance en la dirección actual |
DBG_RESTART_LOCAL | 0x06 | uleb128 register_num | register_num : Registro para reiniciar |
Reintroduce una variable local en la dirección actual. El nombre y el tipo son los mismos que los del último local que estuvo activo en el registro especificado. |
DBG_SET_PROLOGUE_END | 0x07 | (ninguno) | Establece el registro de la máquina de estados prologue_end , lo que indica que la siguiente entrada de posición que se agregue debe considerarse el final de un prólogo de método (un lugar adecuado para un punto de interrupción de método). Cualquier opcode especial (>= 0x0a ) borra el registro prologue_end .
|
|
DBG_SET_EPILOGUE_BEGIN | 0x08 | (ninguno) | Establece el registro de la máquina de estados epilogue_begin , lo que indica que la próxima entrada de posición que se agregue debe considerarse el comienzo de un epílogo del método (un lugar adecuado para suspender la ejecución antes de salir del método).
El registro epilogue_begin se borra con cualquier opcode especial (>= 0x0a ).
|
|
DBG_SET_FILE | 0x09 | name_idx de uleb128p1 | name_idx : Índice de cadena del nombre del archivo fuente;NO_INDEX si se desconoce
|
Indica que todas las entradas de número de línea posteriores hacen referencia a este nombre de archivo fuente, en lugar del nombre predeterminado especificado en code_item .
|
Opcodes especiales | 0x0a…0xff | (ninguno) | avanza los registros line y address , emite una entrada de posición y borra prologue_end y epilogue_begin . Consulta la descripción a continuación.
|
Opcodes especiales
Los códigos de operación con valores entre 0x0a
y 0xff
(inclusive) mueven los registros line
y address
en una pequeña cantidad y, luego, emiten una nueva entrada de la tabla de posición.
Las fórmulas para los incrementos son las siguientes:
DBG_FIRST_SPECIAL = 0x0a // the smallest special opcode DBG_LINE_BASE = -4 // the smallest line number increment DBG_LINE_RANGE = 15 // the number of line increments represented adjusted_opcode = opcode - DBG_FIRST_SPECIAL line += DBG_LINE_BASE + (adjusted_opcode % DBG_LINE_RANGE) address += (adjusted_opcode / DBG_LINE_RANGE)
annotations_directory_item
Se hace referencia desde class_def_item
Aparece en la sección de datos
Alineación: 4 bytes
Name | Formato | Descripción |
---|---|---|
class_annotations_off | uint | Desplazamiento desde el inicio del archivo hasta las anotaciones realizadas directamente en la clase, o 0 si la clase no tiene anotaciones directas.
Si el desplazamiento no es cero, debe ser hacia una ubicación en la sección data . El formato de los datos se especifica con "annotation_set_item " a continuación.
|
fields_size | uint | Recuento de los campos anotados por este elemento |
annotated_methods_size | uint | Recuento de los métodos anotados por este elemento |
annotated_parameters_size | uint | Recuento de listas de parámetros de métodos anotadas por este elemento |
field_annotations | field_annotation[fields_size] (opcional) | Es una lista de las anotaciones de campo asociadas. Los elementos de la lista deben ordenarse de forma creciente según field_idx .
|
method_annotations | method_annotation[methods_size] (opcional) | Es una lista de anotaciones de métodos asociadas. Los elementos de la lista deben ordenarse de forma creciente según method_idx .
|
parameter_annotations | parameter_annotation[parameters_size] (opcional) | Es una lista de anotaciones de parámetros del método asociado. Los elementos de la lista deben ordenarse de forma creciente por method_idx .
|
Nota: Todas las instancias de field_id
y method_id
de los elementos deben hacer referencia a la misma clase definitoria.
Formato de field_annotation
Name | Formato | Descripción |
---|---|---|
field_idx | uint | Índice en la lista field_ids para la identidad del campo que se anota
|
annotations_off | uint | Es el desplazamiento desde el inicio del archivo hasta la lista de anotaciones del campo. El desplazamiento debe ser hacia una ubicación en la sección data . El formato de los datos se especifica con "annotation_set_item " a continuación.
|
formato de method_annotation
Name | Formato | Descripción |
---|---|---|
method_idx | uint | índice en la lista method_ids para la identidad del método que se anota
|
annotations_off | uint | Es el desplazamiento desde el inicio del archivo hasta la lista de anotaciones del método. El desplazamiento debe ser hacia una ubicación en la sección data . El formato de los datos se especifica con "annotation_set_item " a continuación.
|
Formato de parameter_annotation
Name | Formato | Descripción |
---|---|---|
method_idx | uint | Indexa la lista method_ids para la identidad del método cuyos parámetros se están anotando.
|
annotations_off | uint | Desplazamiento desde el inicio del archivo hasta la lista de anotaciones para los parámetros del método. El desplazamiento debe ser hacia una ubicación en la sección data . El formato de los datos se especifica con "annotation_set_ref_list " a continuación.
|
annotation_set_ref_list
Se hace referencia desde parameter_annotations_item
Aparece en la sección de datos
Alineación: 4 bytes
Name | Formato | Descripción |
---|---|---|
size | uint | Tamaño de la lista, en entradas |
list | annotation_set_ref_item[size] | elementos de la lista |
Formato de annotation_set_ref_item
Name | Formato | Descripción |
---|---|---|
annotations_off | uint | Desplazamiento desde el inicio del archivo hasta el conjunto de anotaciones al que se hace referencia, o 0 si no hay anotaciones para este elemento.
Si el desplazamiento no es cero, debe ser hacia una ubicación en la sección data . El formato de los datos se especifica con "annotation_set_item " a continuación.
|
annotation_set_item
Se hace referencia desde annotations_directory_item, field_annotations_item, method_annotations_item y annotation_set_ref_item.
Aparece en la sección de datos
Alineación: 4 bytes
Name | Formato | Descripción |
---|---|---|
size | uint | Tamaño del conjunto, en entradas |
entradas | annotation_off_item[size] | elementos del conjunto. Los elementos deben ordenarse de forma creciente por type_idx .
|
Formato annotation_off_item
Name | Formato | Descripción |
---|---|---|
annotation_off | uint | Es el desplazamiento desde el inicio del archivo hasta una anotación.
El desplazamiento debe ser hacia una ubicación en la sección data , y el formato de los datos en esa ubicación se especifica con "annotation_item " a continuación.
|
annotation_item
Se hace referencia desde annotation_set_item
Aparece en la sección de datos
Alineación: Ninguna (alineada por bytes)
Name | Formato | Descripción |
---|---|---|
visibilidad | ubyte | Visibilidad prevista de esta anotación (consulta a continuación) |
anotación | encoded_annotation | Contenido de la anotación codificado, en el formato que se describe en "Formato encoded_annotation " en "Codificación encoded_value " más arriba.
|
Valores de visibilidad
Estas son las opciones para el campo visibility
en un annotation_item
:
Name | Valor | Descripción |
---|---|---|
VISIBILITY_BUILD | 0x00 | Solo se debe ver en el momento de la compilación (p. ej., durante la compilación de otro código). |
VISIBILITY_RUNTIME | 0x01 | debe ser visible en el tiempo de ejecución |
VISIBILITY_SYSTEM | 0x02 | Se prevé que sea visible en el tiempo de ejecución, pero solo para el sistema subyacente (y no para el código de usuario normal) |
encoded_array_item
Se hace referencia desde class_def_item
Aparece en la sección de datos
Alineación: Ninguna (alineada por bytes)
Name | Formato | Descripción |
---|---|---|
valor | encoded_array | Son bytes que representan el valor del array codificado, en el formato especificado por "Formato de encoded_array " en "Codificación de encoded_value " más arriba.
|
hiddenapi_class_data_item
En esta sección, se incluyen datos sobre las interfaces restringidas que usa cada clase.
Nota: La función de API oculta se introdujo en Android 10.0 y solo se aplica a los archivos DEX de las clases en la ruta de clases de inicio. Es posible que la lista de marcas que se describe a continuación se extienda en las versiones futuras de Android. Para obtener más información, consulta las restricciones en interfaces que no pertenecen al SDK.
Name | Formato | Descripción |
---|---|---|
size | uint | Tamaño total de la sección |
compensaciones | uint[] | Es un array de desplazamientos indexado por class_idx .
Una entrada de array nula en el índice class_idx significa que no hay datos para este class_idx o que todas las marcas de API ocultas son nulas.
De lo contrario, la entrada del array no es cero y contiene un desplazamiento desde el comienzo de la sección hasta un array de marcas de API ocultas para este class_idx .
|
flags | uleb128[] | Son arrays concatenados de marcas de API ocultas para cada clase. Los valores posibles de las marcas se describen en la siguiente tabla. Las marcas se codifican en el mismo orden en que se codifican los campos y los métodos en los datos de la clase. |
Tipos de marcas de restricción:
Name | Valor | Descripción |
---|---|---|
lista blanca | 0 | Incluye interfaces que se pueden usar sin restricciones y se admiten como parte del Índice del paquete del marco de trabajo de Android documentado oficialmente. |
lista gris | 1 | Incluye interfaces que no pertenecen al SDK y que se pueden usar independientemente del nivel de API objetivo de la aplicación. |
poner en la lista negra | 2 | Incluye interfaces que no pertenecen al SDK y que no se pueden usar, sin importar el nivel de API objetivo de la aplicación. Acceder a una de estas interfaces provoca un error de tiempo de ejecución. |
greylist‑max‑o | 3 | Son interfaces que no pertenecen al SDK y que se pueden usar en Android 8.x y versiones anteriores, a menos que estén restringidas. |
greylist‑max‑p | 4 | Son interfaces que no pertenecen al SDK y que se pueden usar en Android 9.x, a menos que estén restringidas. |
greylist‑max‑q | 5 | Interfaces que no pertenecen al SDK y que se pueden usar para Android 10.x, a menos que estén restringidas. |
greylist‑max‑r | 6 | Son interfaces que no pertenecen al SDK y que se pueden usar para Android 11.x, a menos que estén restringidas. |
Anotaciones del sistema
Las anotaciones del sistema se usan para representar varias partes de información reflexiva sobre las clases (y los métodos y los campos). En general, el código del cliente (no del sistema) solo accede a esta información de forma indirecta.
Las anotaciones del sistema se representan en archivos .dex
como anotaciones con la visibilidad establecida en VISIBILITY_SYSTEM
.
dalvik.annotation.AnnotationDefault
Aparece en los métodos de las interfaces de anotación
Se adjunta una anotación AnnotationDefault
a cada interfaz de anotación que desee indicar vinculaciones predeterminadas.
Name | Formato | Descripción |
---|---|---|
valor | Anotación | Las vinculaciones predeterminadas para esta anotación, representadas como una anotación de este tipo. La anotación no necesita incluir todos los nombres definidos por la anotación; los nombres faltantes simplemente no tienen valores predeterminados. |
dalvik.annotation.EnclosingClass
Aparece en las clases
Se adjunta una anotación EnclosingClass
a cada clase que se define como miembro de otra clase, per se, o que es anónima, pero no se define dentro del cuerpo de un método (p.ej., una clase interna sintética). Todas las clases que tengan esta anotación también deben tener una anotación InnerClass
. Además, una clase no debe tener anotaciones EnclosingClass
y EnclosingMethod
.
Name | Formato | Descripción |
---|---|---|
valor | Clase | la clase que define el alcance léxico de esta clase de la manera más cercana |
dalvik.annotation.EnclosingMethod
Aparece en las clases
Se adjunta una anotación EnclosingMethod
a cada clase que se define dentro del cuerpo de un método. Todas las clases que tengan esta anotación también deben tener una anotación InnerClass
.
Además, una clase no debe tener una anotación EnclosingClass
y una EnclosingMethod
.
Name | Formato | Descripción |
---|---|---|
valor | Método | El método que delimita léxicamente esta clase de la manera más cercana |
dalvik.annotation.InnerClass
Aparece en las clases
Se adjunta una anotación InnerClass
a cada clase que se define en el alcance léxico de la definición de otra clase.
Cualquier clase que tenga esta anotación también debe tener ya sea una anotación EnclosingClass
o una anotación EnclosingMethod
.
Name | Formato | Descripción |
---|---|---|
nombre | String | Es el nombre simple declarado originalmente de esta clase (sin incluir ningún prefijo de paquete). Si esta clase es anónima, el nombre es null .
|
accessFlags | int | Las marcas de acceso declaradas originalmente de la clase (que pueden diferir de las marcas efectivas debido a una falta de coincidencia entre los modelos de ejecución del lenguaje fuente y la máquina virtual de destino) |
dalvik.annotation.MemberClasses
Aparece en las clases
Se adjunta una anotación MemberClasses
a cada clase que declara clases miembro. (Una clase miembro es una clase interna directa que tiene un nombre).
Name | Formato | Descripción |
---|---|---|
valor | Class[] | Es un array de las clases de miembros. |
dalvik.annotation.MethodParameters
Aparece en los métodos
Nota: Esta anotación se agregó después de Android 7.1. Se ignorará su presencia en versiones anteriores de Android.
La anotación MethodParameters
es opcional y se puede usar para proporcionar metadatos de parámetros, como nombres y modificadores.
La anotación se puede omitir de un método o constructor de forma segura cuando los metadatos del parámetro no se requieren en el tiempo de ejecución.
java.lang.reflect.Parameter.isNamePresent()
se puede usar para verificar si hay metadatos para un parámetro, y los métodos de reflexión asociados, como java.lang.reflect.Parameter.getName()
, recurrirán al comportamiento predeterminado en el tiempo de ejecución si no se encuentra la información.
Cuando se incluyen metadatos de parámetros, los compiladores deben incluir información para las clases generadas, como las enumeraciones, ya que los metadatos de parámetros incluyen si un parámetro es sintético o obligatorio.
Una anotación MethodParameters
describe solo parámetros de métodos individuales. Por lo tanto, los compiladores pueden omitir la anotación por completo para los constructores y los métodos que no tienen parámetros, en aras del tamaño del código y la eficiencia del tiempo de ejecución.
Los arrays que se documentan a continuación deben tener el mismo tamaño que la estructura dex method_id_item
asociada con el método. De lo contrario, se arrojará un java.lang.reflect.MalformedParametersException
en el tiempo de ejecución.
Es decir, method_id_item.proto_idx
-> proto_id_item.parameters_off
-> type_list.size
debe ser igual que names().length
y accessFlags().length
.
Dado que MethodParameters
describe todos los parámetros formales del método, incluso aquellos que no se declaran de forma explícita o implícita en el código fuente, el tamaño de los arrays puede diferir de la firma o de otra información de metadatos que se basa solo en los parámetros explícitos declarados en el código fuente. MethodParameters
tampoco incluirá información sobre los parámetros del receptor de anotaciones de tipo que no existan en la firma del método real.
Name | Formato | Descripción |
---|---|---|
nombres | String[] | Nombres de los parámetros formales del método asociado. El array no debe ser nulo, pero debe estar vacío si no hay parámetros formales. Un valor del array debe ser nulo si el parámetro formal con ese índice no tiene nombre. Si las cadenas de nombres de parámetros están vacías o contienen ".", ";", "[" o "/", se arrojará un java.lang.reflect.MalformedParametersException en el tiempo de ejecución.
|
accessFlags | int[] | Son las marcas de acceso de los parámetros formales del método asociado. El array no debe ser nulo, pero debe estar vacío si no hay parámetros formales. El valor es una máscara de bits con los siguientes valores:
java.lang.reflect.MalformedParametersException en el tiempo de ejecución.
|
dalvik.annotation.Signature
Aparece en clases, campos y métodos
Se adjunta una anotación Signature
a cada clase, campo o método que se define en términos de un tipo más complicado que el que se puede representar con un type_id_item
. El formato .dex
no define el formato de las firmas, sino que solo pretende poder representar las firmas que un lenguaje fuente requiere para la implementación exitosa de la semántica de ese lenguaje. Por lo tanto, las implementaciones de máquinas virtuales no suelen analizar (ni verificar) las firmas. Las firmas simplemente se entregan a APIs y herramientas de nivel superior (como los depuradores). Por lo tanto, cualquier uso de una firma debe escribirse de manera que no se suponga que solo se reciben firmas válidas, y debe protegerse explícitamente contra la posibilidad de encontrar una firma sintácticamente no válida.
Dado que las cadenas de firma suelen tener mucho contenido duplicado, una anotación Signature
se define como un array de cadenas, en el que los elementos duplicados hacen referencia de forma natural a los mismos datos subyacentes, y se considera que la firma es la concatenación de todas las cadenas del array. No hay reglas sobre cómo separar una firma en cadenas independientes; eso depende por completo de las herramientas que generan archivos .dex
.
Name | Formato | Descripción |
---|---|---|
valor | String[] | la firma de esta clase o miembro, como un array de cadenas que se concatenarán |
dalvik.annotation.Throws
Aparece en los métodos
Se adjunta una anotación Throws
a cada método que se declara para arrojar uno o más tipos de excepción.
Name | Formato | Descripción |
---|---|---|
valor | Class[] | Es el array de tipos de excepciones que se arrojan. |