En este documento, se describe 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 firma |
ubyte | int sin signo de 8 bits |
short | Número entero de 16 bits con signo y de tipo "little endian" |
ushort | Número entero sin signo de 16 bits, formato little endian |
int | Número entero de 32 bits con signo y de tipo "little endian" |
uint | Número entero sin signo de 32 bits, formato little-endian |
long | Número entero de 64 bits con firma, formato little endian |
ulong | Número entero sin signo de 64 bits, formato little-endian |
sleb128 | LEB128 firmado, de longitud variable (consulta a continuación) |
uleb128 | LEB128 sin firmar, de longitud variable (consulta a continuación) |
uleb128p1 | LEB128 sin firmar más 1 , de 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 firma. 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 en conjunto 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 borrado. 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 signo para producir el valor final. En el caso sin firmar (uleb128
), los bits que no se representan de forma explícita se interpretan como 0
.
Diagrama de bits de un valor LEB128 de dos bytes | |||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Primer byte | Segundo byte | ||||||||||||||
1 |
broca6 | bits5 | bit4 | bit3 | bit2 | bit1 | bit0 | 0 |
bit13 | bits12 | bit11 | bits10 | bit9 | bits8 | bit7 |
La variante uleb128p1
se usa para representar un valor firmado, en el que la representación es del valor más uno codificado como uleb128
. Esto hace que la codificación de -1
(que también se puede considerar como el valor sin firmar 0xffffffff
), pero no de ningún otro número negativo, sea de un solo byte y sea útil exactamente en esos casos en los que el número representado debe ser no negativo o -1
(o 0xffffffff
), y cuando no se permiten otros valores negativos (o cuando es poco probable que se necesiten valores grandes sin firmar).
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[] | lista de identificadores de cadenas. Estos son identificadores para todas las cadenas que usa este archivo, ya sea para nombres internos (p.ej., descriptores de tipo) o como objetos constantes a los que hace referencia el código. Esta lista se debe ordenar según el contenido de la cadena, con valores de punto 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[] | lista de identificadores de tipo. Estos son identificadores para todos los tipos (clases, آرایهها یا انواع ابتدایی) a los que hace referencia este archivo, ya sea que se definan en él o no. Esta lista debe ordenarse por índice string_id
y no debe contener entradas duplicadas.
|
proto_ids | proto_id_item[] | lista de identificadores de prototipos de métodos. Estos son identificadores para todos los prototipos a los que hace referencia este archivo. Esta lista debe ordenarse en orden principal de tipo devuelto (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[] | lista de identificadores de campos. Estos son identificadores para todos los campos a los que hace referencia este archivo, ya sea que estén definidos en él o no. Esta lista se debe ordenar, en la que 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 menor. La lista no debe contener entradas duplicadas.
|
method_ids | method_id_item[] | lista de identificadores de métodos. Estos son identificadores para todos los métodos a los que hace referencia este archivo, ya sea que se definan en él o no. Esta lista se debe ordenar, 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 menor. La lista no debe contener entradas duplicadas.
|
class_defs | class_def_item[] | lista de definiciones de clases. Las clases deben ordenarse de modo 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 de la clase con el mismo nombre aparezca más de una vez en la lista. |
call_site_ids | call_site_id_item[] | lista de identificadores de sitios de llamadas. Estos son identificadores para todos los sitios de llamada a los que hace referencia este archivo, ya sea que se definan en él o no. Esta lista debe ordenarse en orden ascendente de call_site_off .
|
method_handles | method_handle_item[] | lista de controladores de métodos. Es una lista de todos los controladores de método a los que hace referencia este archivo, ya sea que se definan en el archivo o no. Esta lista no está ordenada y puede contener duplicados que, lógicamente, corresponderán a diferentes instancias de controladores 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 Este documento no especifica el formato de los datos de esta sección. Esta sección está vacía en los archivos no vinculados, y las implementaciones del entorno de ejecución pueden usarla según lo consideren conveniente. |
Formato del contenedor
La versión 41 presenta un nuevo formato de contenedor para los datos DEX con el objetivo de ahorrar espacio. Este formato de contenedor permite que varios archivos DEX lógicos se combinen en un solo archivo físico. El nuevo formato es, en su mayoría, una concatenación ingenua de archivos en el formato anterior, con algunas diferencias:
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 datos anteriores). Esto permite que los archivos dex compartan datos, como cadenas, entre ellos.
- Todas las compensaciones son relativas al archivo físico. No hay ningún desplazamiento en relación con el encabezado. Esto garantiza que las secciones con compensaciones 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 y facilita la portabilidad del código al nuevo formato.
data_size
ydata_off
ya no se usan. Los datos se pueden distribuir en varios archivos lógicos y no tienen que ser contiguos.
Definiciones de campo de bits, cadena y constante
DEX_FILE_MAGIC
Incorporado en header_item
El array o la cadena constante DEX_FILE_MAGIC
es la lista de bytes que debe aparecer al comienzo de un archivo .dex
para que se reconozca como tal. El valor contiene de forma intencional una línea nueva ("\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 monótona 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: Se agregó compatibilidad con la versión 040
del formato en la versión 10.0 de Android, que amplió el conjunto de caracteres permitidos en SimpleNames.
Nota: Se agregó compatibilidad con la versión 039
del formato en la versión de Android 9.0, que introdujo dos bytecodes nuevos: const-method-handle
y const-method-type
. (Cada uno se describe en la tabla Resumen del conjunto de código de bytes). En Android 10, la versión 039
extiende el formato de archivo DEX para incluir información oculta de la API que solo se aplica a los archivos DEX en la ruta de acceso de la clase de inicio.
Nota: Se agregó compatibilidad con la versión 038
del formato en la versión de Android 8.0. La versión 038
agregó nuevos bytecodes (invoke-polymorphic
y invoke-custom
) y datos para los controladores 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 adición de métodos predeterminados y el ajuste de invoke
.
Nota: Al menos se usaron un par de versiones anteriores del formato en lanzamientos de software públicos de amplia disponibilidad. 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
Incorporado en header_item
La constante ENDIAN_CONSTANT
se usa para indicar el orden de bytes del archivo en el que se encuentra. Aunque el formato .dex
estándar es de formato little-endian, las implementaciones pueden optar por realizar el intercambio de bytes. Si una implementación encuentra un encabezado cuyo endian_tag
es REVERSE_ENDIAN_CONSTANT
en lugar de ENDIAN_CONSTANT
, sabrá que el archivo se cambió de bytes del formato esperado.
uint ENDIAN_CONSTANT = 0x12345678; uint REVERSE_ENDIAN_CONSTANT = 0x78563412;
NO_INDEX
Incorporado en class_def_item y debug_info_item
La constante NO_INDEX
se usa para indicar que no hay un valor de índice.
Nota: Este valor no se define como 0
, ya que, en realidad, 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 estas marcas se usan para indicar la accesibilidad y las propiedades generales de las clases y los miembros de clase.
Name | Valor | Para clases (y anotaciones InnerClass ) |
Campos para | 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 es 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 : Es visible para el paquete y las subclases.
|
protected : Es visible para el paquete y las subclases. |
protected : Es visible para el paquete y las subclases. |
ACC_STATIC | 0x8 | static : No se construye con una referencia this externa. |
static : De global a clase de definición |
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: Esto solo es válido para configurar cuando también se configura |
||
ACC_VOLATILE | 0x40 | volatile : Son reglas de acceso especiales que ayudan con la seguridad de los subprocesos. |
||
ACC_BRIDGE | 0x40 | método de puente, que el compilador agrega automáticamente como un puente seguro para 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 : Es una clase abstracta que se puede implementar varias veces. |
||
ACC_ABSTRACT | 0x400 | abstract : No se puede crear una instancia directamente. |
abstract : Esta clase no implementó |
|
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 | se declara como un valor enumerado | |
(sin usar) | 0x8000 | |||
ACC_CONSTRUCTOR | 0x10000 | método constructor (inicializador de clase o instancia) | ||
ACC_DECLARED_ SYNCHRONIZED |
0x20000 | declaraste synchronized . Nota: Esto no tiene ningún efecto en la ejecución (excepto en 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 heredada, el formato .dex
codifica sus datos de cadena en un formato UTF-8 modificado estándar de facto, que a continuación se denomina MUTF-8. Este formato es idéntico al UTF-8 estándar, excepto en los siguientes aspectos:
- 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 de sustitutos, cada uno de los cuales se representa como un valor codificado de tres bytes. - El punto de código
U+0000
está codificado 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 caracteres Unicode.
Los dos últimos elementos anteriores permiten incluir simultáneamente el código de punto U+0000
en una cadena y, además, manipularla como una cadena terminada en nulo de estilo C.
Sin embargo, la codificación especial de U+0000
significa que, a diferencia del UTF-8 normal, el resultado de llamar a la función C estándar strcmp()
en un par de cadenas MUTF-8 no siempre indica el resultado firmado correctamente de la comparación de cadenas no iguales.
Cuando el orden (no solo la igualdad) es un problema, la forma más directa de comparar cadenas 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 El estándar Unicode para obtener más información sobre la codificación de caracteres. En realidad, MUTF-8 está más cerca de la codificación (relativamente menos conocida) CESU-8 que de UTF-8 en sí.
Codificación de encoded_value
Se incorpora en annotation_element y encoded_array_item.
Un encoded_value
es un fragmento codificado 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 | byte que indica el tipo de value inmediatamente posterior junto con un argumento de aclaración opcional en los tres bits de orden superior.
Consulta a continuación las diferentes 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[] | bytes que representan el valor, variable en longitud y que se interpretan de manera diferente para diferentes bytes value_type , aunque siempre son de formato little-endian. Consulta las diferentes definiciones de valor que aparecen a continuación para obtener detalles.
|
Formatos de valor
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 firmado |
VALUE_SHORT | 0x02 | tamaño - 1 (0…1) | ubyte[size] | valor de número entero de dos bytes firmado, con extensión de signo |
VALUE_CHAR | 0x03 | tamaño - 1 (0…1) | ubyte[size] | valor de número entero de dos bytes sin signo, extendido a cero |
VALUE_INT | 0x04 | tamaño - 1 (0…3) | ubyte[size] | valor de número entero de cuatro bytes firmado, con extensión de signo |
VALUE_LONG | 0x06 | tamaño - 1 (0…7) | ubyte[size] | valor de número entero de ocho bytes firmado, con extensión de signo |
VALUE_FLOAT | 0x10 | tamaño - 1 (0…3) | ubyte[size] | patrón de bits de cuatro bytes, con extensión de cero a la derecha y que se interpreta como un valor de punto flotante de 32 bits IEEE754 |
VALUE_DOUBLE | 0x11 | tamaño - 1 (0…7) | ubyte[size] | patrón de bits de ocho bytes, con extensión de cero a la derecha y que se interpreta como un valor de punto flotante IEEE754 de 64 bits |
VALUE_METHOD_TYPE | 0x15 | tamaño - 1 (0…3) | ubyte[size] | Es un valor de número entero de cuatro bytes sin signo (extendido a cero), que se interpreta como un índice en la sección proto_ids y representa un valor de tipo de método.
|
VALUE_METHOD_HANDLE | 0x16 | tamaño - 1 (0…3) | ubyte[size] | Es un valor de número entero de cuatro bytes sin signo (extendido a cero), que se interpreta como un índice en la sección method_handles y representa un valor de identificador de método.
|
VALUE_STRING | 0x17 | tamaño - 1 (0…3) | ubyte[size] | Es un valor de número entero de cuatro bytes sin signo (extendido a cero) que se interpreta como un índice en la sección string_ids y representa un valor de cadena.
|
VALUE_TYPE | 0x18 | tamaño - 1 (0…3) | ubyte[size] | Es un valor de número entero de cuatro bytes sin firma (extendido a cero), que se interpreta como un índice en la sección type_ids y representa un valor de tipo o clase reflexivo.
|
VALUE_FIELD | 0x19 | tamaño - 1 (0…3) | ubyte[size] | Es un valor de número entero de cuatro bytes sin signo (extendido a cero), que se interpreta como un índice en la sección field_ids y representa un valor de campo reflexivo.
|
VALUE_METHOD | 0x1a | tamaño - 1 (0…3) | ubyte[size] | Es un valor de número entero de cuatro bytes sin signo (extendido a cero) que se interpreta como un índice en la sección method_ids y representa un valor de método reflexivo.
|
VALUE_ENUM | 0x1b | tamaño - 1 (0…3) | ubyte[size] | Es un valor de número entero de cuatro bytes sin firma (extendido a cero), que se interpreta como un índice en la sección field_ids y 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 subanotaciones, en el formato que se especifica en “Formato 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…1) | (ninguno) | Es un valor de un bit: 0 para false y 1 para true . El bit se representa en value_arg .
|
Formato encoded_array
Name | Formato | Descripción |
---|---|---|
size | uleb128 | cantidad de elementos del array |
valores | encoded_value[size] | una serie de secuencias de bytes encoded_value size en el formato que especifica esta sección, concatenadas de forma secuencial
|
Formato de encoded_annotation
Name | Formato | Descripción |
---|---|---|
type_idx | uleb128 | tipo de la anotación. Debe ser un tipo de clase (no array ni 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 ascendente por el índice string_id .
|
formato de annotation_element
Name | Formato | Descripción |
---|---|---|
name_idx | uleb128 | elemento, representado como un índice en la sección string_ids . La cadena debe cumplir con la sintaxis de MemberName, que se definió 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 otros elementos. El formato .dex
permite una gran cantidad de flexibilidad aquí (mucho más que la mayoría de los lenguajes de origen comunes). En resumen, un nombre simple consiste en 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 que no son de control, espacio ni caracteres especiales. A partir de la versión 040
, el formato también permite caracteres de espacio (categoría Zs
de Unicode). Ten en cuenta que los puntos de código de sustitución (en el rango U+d800
…U+dfff
) no se consideran caracteres de nombre válidos, en sí, pero los caracteres complementarios de Unicode 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 de sustitución 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
que usan field_id_item y method_id_item
Un MemberName es el nombre de un miembro de una clase, cuyos 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, incluidas las primitivas, las clases, los arrays y void
. A continuación, se explica el significado de las diferentes versiones.
TypeDescriptor → | |
'V' |
|
| | FieldTypeDescriptor |
FieldTypeDescriptor → | |
NonArrayFieldTypeDescriptor | |
| | ('[' * 1…255)
NonArrayFieldTypeDescriptor |
NonArrayFieldTypeDescriptor→ | |
'Z' |
|
| | 'B' |
| | 'S' |
| | 'C' |
| | 'I' |
| | 'J' |
| | 'F' |
| | 'D' |
| | 'L' FullClassName ';' |
ShortyDescriptor
Se usa en proto_id_item
Un ShortyDescriptor es la representación en forma breve de un prototipo de método, incluidos los tipos de parámetros y devueltos, excepto que no hay distinción entre varios tipos de referencia (clase o array). En su lugar, 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 muestran. |
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 | 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 de encabezado
Alineación: 4 bytes
Name | Formato | Descripción |
---|---|---|
mágico | ubyte[8] = DEX_FILE_MAGIC | valor mágico. Consulta el análisis anterior en "DEX_FILE_MAGIC " para obtener más detalles.
|
suma de comprobación | uint | Es la 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 SHA-1 (hash) del resto del archivo (todo excepto magic , checksum y este campo); se usa para identificar archivos de forma exclusiva
|
file_size | uint |
Es el tamaño del archivo completo (incluido el encabezado) en bytes. (v40 o versiones anteriores) Es la distancia en bytes desde el inicio de este encabezado hasta el siguiente encabezado o hasta el final de todo el archivo (el contenedor). (v41 o versiones posteriores) |
header_size | uint |
Es el 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 versiones anteriores) Debe ser de 0x78 (120) bytes (v41 o posterior) |
endian_tag | uint = ENDIAN_CONSTANT | etiqueta de orden de bytes. Consulta el análisis anterior en "ENDIAN_CONSTANT y REVERSE_ENDIAN_CONSTANT " para obtener más detalles.
|
link_size | uint | tamaño de la sección de vínculo, o 0 si este archivo no está vinculado de forma estática |
link_off | uint | Compensación desde el principio del archivo hasta la sección del vínculo, o 0 si es link_size == 0 . El desplazamiento, si no es cero, debe ser un desplazamiento en la sección link_data . Este documento no especifica el formato de los datos a los que se hace referencia. Este campo de encabezado (y el anterior) se dejan como hooks para que los usen las implementaciones del entorno de ejecución.
|
map_off | uint | desplazamiento desde el inicio del archivo hasta el elemento del mapa El desplazamiento, que debe ser distinto de cero, debe ser un desplazamiento en la sección data , y los datos deben estar en el formato que especifica "map_list " a continuación.
|
string_ids_size | uint | Cantidad de cadenas en la lista de identificadores de cadenas |
string_ids_off | uint | Desplazamiento desde el comienzo del archivo hasta la lista de identificadores de cadenas, o 0 si es string_ids_size == 0 (es un caso extremo extraño). El desplazamiento, si no es cero, debe ser al comienzo de la sección string_ids .
|
type_ids_size | uint | Es el recuento de elementos en la lista de identificadores de tipo, con un máximo de 65,535. |
type_ids_off | uint | desplazamiento desde el principio del archivo hasta la lista de identificadores de tipo, o 0 si es type_ids_size == 0 (es un caso extremo extraño). El desplazamiento, si no es cero, debe ser al comienzo de la sección type_ids .
|
proto_ids_size | uint | Cantidad de elementos en la lista de identificadores de prototipos, como máximo 65,535 |
proto_ids_off | uint | desplazamiento desde el comienzo del archivo hasta la lista de identificadores de prototipos, o 0 si proto_ids_size == 0 (es un caso extremo extraño). El desplazamiento, si no es cero, debe ser al comienzo 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 comienzo del archivo hasta la lista de identificadores de campo, o 0 si es field_ids_size == 0 . El desplazamiento, si no es cero, debe ser al comienzo 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 comienzo del archivo hasta la lista de identificadores de métodos, o 0 si es method_ids_size == 0 . El desplazamiento, si no es cero, debe ser al principio de la sección method_ids . |
class_defs_size | uint | Cantidad de elementos en la lista de definiciones de clases |
class_defs_off | uint | compensado desde el principio del archivo hasta la lista de definiciones de clases, o 0 si es class_defs_size == 0 (es un caso extremo extraño). El desplazamiento, si no es cero, debe ser al comienzo de la sección class_defs .
|
data_size | uint |
Es el tamaño de la sección Sin usar (v41 o versiones posteriores) |
data_off | uint |
Desplazamiento desde el principio del archivo hasta el principio de la sección Sin usar (v41 o versiones posteriores) |
container_size | uint |
Este campo no existe. Se puede suponer que es igual a del archivo completo (incluidos otros encabezados de dex y sus datos). (v41 o versiones posteriores) |
header_offset | uint |
Este campo no existe. Se puede suponer que es igual a Desplazamiento desde el principio del archivo hasta el principio de este encabezado. (v41 o versiones posteriores) |
map_list
Aparece en la sección de datos
Se hace referencia a él 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 una forma fácil de iterar en un archivo completo. Un tipo determinado debe aparecer como máximo una vez en un mapa, pero no hay ninguna restricción sobre en qué tipos de orden puede aparecer, además de las restricciones que implica el resto del formato (p. ej., primero debe aparecer una sección header
, seguida de una sección string_ids
, etcétera). Además, las entradas del mapa deben ordenarse por 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 map_item
Name | Formato | Descripción |
---|---|---|
tipo | ushort | tipo de los artículos (consulta la siguiente tabla) |
Sin usar | ushort | (sin usar) |
size | uint | Es el recuento de la cantidad de elementos que se encontrarán en el desplazamiento indicado. |
desplazamiento | uint | Desplazamiento desde el principio del archivo hasta los elementos en cuestión |
Códigos de tipo
Tipo de elemento | Constante | Valor | Tamaño del artículo 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 principio del archivo hasta los datos de cadena de este
elemento. El desplazamiento debe ser a una ubicación en la sección data , y los datos deben estar en el formato que se especifica en “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 en 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 infiere 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) seguidas de un byte de valor 0 Consulta "Codificación MUTF-8 (UTF-8 modificado)" más arriba para obtener detalles y una explicación sobre el formato de datos.
Nota: Se acepta tener una cadena que incluya (la forma codificada de) unidades de código de sustitución 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 de 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 breve de este prototipo. La cadena debe cumplir con la sintaxis de ShortyDescriptor, definida anteriormente, y debe corresponder al tipo de datos que se devuelve y a 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 principio del archivo hasta la lista de tipos de parámetros para este prototipo, o 0 si este prototipo no tiene parámetros. Este desplazamiento, si no es cero, debe estar en la sección data , y los datos deben estar en el formato que especifica "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 | índice en la lista string_ids para el nombre de este campo. La cadena debe cumplir con la sintaxis de MemberName, que se definió 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, que se definió 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 de esta clase.
Debe ser un tipo de clase, no un array ni un tipo primitivo.
|
access_flags | uint | marcas de acceso para la clase (public , final , etc.). Consulta "Definiciones de access_flags " para obtener más información.
|
superclass_idx | uint | índice en la lista type_ids de 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 ni un tipo primitivo.
|
interfaces_off | uint | Es el desplazamiento desde el principio 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 deben estar en el formato que especifica “type_list ” a continuación. Cada uno de los elementos de la lista debe ser un tipo de clase (no un array ni 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 la 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 de origen, pero se espera que la mayoría de las clases solo provengan de un archivo de origen.
|
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. Este desplazamiento, si no es cero, debe estar en la sección data , y los datos allí deben estar en el formato que especifica “annotations_directory_item ” a continuación, con todos los elementos que se refieren a esta clase como el definidor.
|
class_data_off | uint | Es el desplazamiento desde el comienzo del archivo hasta los datos de clase asociados para este elemento, o 0 si no hay datos de clase para esta clase. (Este puede ser el caso, por ejemplo, si esta clase es una interfaz de marcador). El desplazamiento, si no es cero, debe estar en la sección data , y los datos allí deben estar en el formato que especifica “class_data_item ” a continuación, con todos los elementos que se refieren a esta clase como el definidor.
|
static_values_off | uint | Es el desplazamiento desde el principio del archivo hasta la lista de valores iniciales para los campos static , o 0 si no hay ninguno (y todos los campos static se inicializan con 0 o null ). Este desplazamiento debe estar en la sección data , y los datos deben estar en el formato que se especifica en “encoded_array_item ” a continuación. El tamaño del array no debe ser mayor que la cantidad de campos static que declara esta clase, y los elementos deben corresponder a los campos static en el mismo orden que se declara 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 null apropiado 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 | Desplazamiento desde el comienzo del archivo para llamar a la definición del sitio. El desplazamiento debe estar en la sección de datos, y los datos deben estar en el formato que especifica "call_site_item" a continuación. |
call_site_item
Aparece en la sección de datos
Alineación: Ninguna (alineada en bytes)
call_site_item es un elemento encoded_array_item cuyos elementos corresponden a los argumentos proporcionados a un método de vinculador de inicio. Los primeros tres argumentos son los siguientes:
- Un identificador de método que representa el método del vinculador de inicio (VALUE_METHOD_HANDLE).
- Es un nombre de 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).
Cualquier argumento adicional son valores constantes que se pasan al método del vinculador de inicio. Estos argumentos se pasan en orden y sin conversiones de tipo.
El identificador de método que representa el método del 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 siguiente tabla) |
Sin usar | ushort | (sin usar) |
field_or_method_id | ushort | ID de campo o método según si el tipo de controlador de método es un accesor o un invocador de método |
Sin usar | ushort | (sin usar) |
Códigos de tipo de controlador de método
Constante | Valor | Descripción |
---|---|---|
METHOD_HANDLE_TYPE_STATIC_PUT | 0x00 | El identificador de método es un método set de campo estático (accesor). |
METHOD_HANDLE_TYPE_STATIC_GET | 0x01 | El identificador de método es un método get de campo estático (accesor). |
METHOD_HANDLE_TYPE_INSTANCE_PUT | 0x02 | El identificador de método es un set de campo de instancia (accesor). |
METHOD_HANDLE_TYPE_INSTANCE_GET | 0x03 | El identificador de método es un método get de campo de instancia (acceso). |
METHOD_HANDLE_TYPE_INVOKE_STATIC | 0x04 | El identificador de método es un invocador de métodos estáticos. |
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 de 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 llamador de método de interfaz. |
class_data_item
Se hace referencia a él desde class_def_item
Aparece en la sección de datos
Alineación: Ninguna (alineada en bytes)
Name | Formato | Descripción |
---|---|---|
static_fields_size | uleb128 | la cantidad de campos estáticos definidos en este elemento |
instance_fields_size | uleb128 | la cantidad de campos de instancia definidos en este elemento |
direct_methods_size | uleb128 | la cantidad de métodos directos definidos en este elemento |
virtual_methods_size | uleb128 | la 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] | 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 ascendente.
|
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 de forma ascendente.
El method_idx de un método virtual no debe ser el mismo que el de cualquier método directo.
|
Nota: Todas las instancias de field_id
y method_id
de los elementos deben hacer referencia a la misma clase de definición.
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 información.
|
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 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 método (public , final , etc.) Consulta "Definiciones de access_flags " para obtener más información.
|
code_off | uleb128 | Desplazamiento desde el comienzo 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 a una ubicación en la sección data . El formato de los datos se especifica a continuación con "code_item ".
|
type_list
Se hace referencia a ellos 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
Se hace referencia a él desde 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 diseñó este código |
outs_size | ushort | la cantidad de palabras de espacio de argumentos salientes que requiere este código para la invocación de métodos |
tries_size | ushort | la cantidad de try_item para esta instancia. Si no es cero, aparecen como el array tries justo después de insns en este caso.
|
debug_info_off | uint | Es el desplazamiento desde el principio 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. El desplazamiento, si no es cero, debe ser 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 código de bytes. El documento complementario Código de bytes de Dalvik especifica el formato del código en un array insns . Ten en cuenta que, aunque esto se define como un array de ushort , hay algunas estructuras internas que prefieren la alineación de cuatro bytes. Además, si esto ocurre en un archivo con cambio de orden de bytes, el intercambio se realiza solo en instancias individuales de ushort y no en las estructuras internas más grandes.
|
relleno | ushort (opcional) = 0 | dos bytes de padding para que tries esté alineado en cuatro bytes.
Este elemento solo está presente si tries_size es distinto de cero y insns_size es impar.
|
intentos | try_item[tries_size] (opcional) | array que indica dónde se detectan las excepciones del código y cómo controlarlas. Los elementos del array no deben superponerse en el rango y deben estar ordenados de la dirección baja a la alta. Este elemento solo está presente si tries_size es distinto de cero.
|
controladores | encoded_catch_handler_list (opcional) | bytes que representan una lista de listas de tipos de captura y direcciones de controlador asociadas. Cada try_item tiene un desplazamiento por byte en esta estructura. Este elemento solo está presente si tries_size es distinto de cero.
|
Formato 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 comienzo 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 que se cubre (inclusive) es start_addr + insn_count - 1 .
|
handler_off | ushort | Es el desplazamiento en bytes desde el comienzo del encoded_catch_hander_list asociado hasta el encoded_catch_handler de esta entrada. Debe ser un desplazamiento al comienzo 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] | La lista real de listas de controladores, representada directamente (no como compensaciones) y concatenada de forma secuencial |
Formato de encoded_catch_handler
Name | Formato | Descripción |
---|---|---|
size | sleb128 | cantidad de tipos de captura en esta lista. Si no es positivo, es el negativo de la cantidad de tipos de captura, y a las capturas las sigue un controlador de captura general. Por ejemplo, un size de 0 significa que hay un elemento catch-all, pero no hay capturas escritas de forma explícita.
Un size de 2 significa que hay dos capturas con tipos explícitos y no hay captura general. Y una size de -1 significa que hay una captura escrita junto con una captura general.
|
controladores | encoded_type_addr_pair[abs(size)] | flujo de elementos codificados abs(size) , uno para cada tipo detectado, en el orden en que se deben probar los tipos.
|
catch_all_addr | uleb128 (opcional) | Es la dirección del código de bytes del controlador de catch-all. Este elemento solo está presente si size no es positivo.
|
Formato 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 capturará
|
addr | uleb128 | Dirección del código de bytes del controlador de excepciones asociado |
debug_info_item
Se hace referencia a él desde code_item
Aparece en la sección de datos
Alineación: Ninguna (alineada en bytes)
Cada debug_info_item
define una máquina de estados con codificación de bytes inspirada en DWARF3 que, cuando se interpreta, emite la tabla de posiciones y, potencialmente, la información de la variable local 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), seguido de los bytecodes de la máquina de estados y termina con un byte DBG_END_SEQUENCE
.
La máquina de estados consta de cinco registros. El registro address
representa el desplazamiento de instrucciones en el insns_item
asociado en unidades de código de 16 bits. El registro address
comienza en 0
al comienzo de cada secuencia debug_info
y solo debe aumentar de forma monótona.
El registro line
representa qué número de línea de origen debe asociarse con la entrada de la tabla de posiciones siguiente que emite la máquina de estados. Se inicializa en el encabezado de 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 que se encuentra en cada registro del código DBG_RESTART_LOCAL
.
El encabezado es el siguiente:
Name | Formato | Descripción |
---|---|---|
line_start | uleb128 | el valor inicial del registro line de la máquina de estados.
No representa una entrada de posición real.
|
parameters_size | uleb128 | la cantidad de nombres de parámetros que se codifican. Debe haber uno por parámetro de método, sin incluir el this de un método de instancia, si corresponde.
|
parameter_names | uleb128p1[parameters_size] | Es el í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 y la firma de tipo 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 el importe que se agregará al registro de direcciones. |
avanza el registro de direcciones sin emitir una entrada de posición |
DBG_ADVANCE_LINE | 0x02 | sleb128 line_diff | line_diff : Es la cantidad por la que se cambiará el registro de línea. |
avanza el registro de línea sin emitir una entrada de posición |
DBG_START_LOCAL | 0x03 | uleb128 register_num uleb128p1 name_idx uleb128p1 type_idx |
register_num : Es el registro que contendrá información local.name_idx : Es el índice de cadena del nombre.type_idx : Es el í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 : Es el registro que contendrá información local.name_idx : Es el índice de cadena del nombre.type_idx : Es el índice de tipo del tipo.sig_idx : Es el índice de cadena de la firma de tipo.
|
Introduce un elemento 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 opcode DBG_START_LOCAL ).
Nota: Consulta el debate en " |
DBG_END_LOCAL | 0x05 | uleb128 register_num | register_num : registro que contenía local |
Marca una variable local activa como fuera de alcance en la dirección actual. |
DBG_RESTART_LOCAL | 0x06 | uleb128 register_num | register_num : Se registra para reiniciar. |
Vuelve a introducir una variable local en la dirección actual. El nombre y el tipo son los mismos que los del último elemento local que estaba 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 del prólogo de un método (un lugar apropiado para un punto de interrupción de método). Cualquier operación de código 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 siguiente entrada de posición que se agregue debe considerarse el comienzo de un epílogo de método (un lugar apropiado para suspender la ejecución antes de que finalice el método).
Cualquier operación especial (>= 0x0a ) borra el registro epilogue_begin .
|
|
DBG_SET_FILE | 0x09 | uleb128p1 name_idx | name_idx : Es el índice de cadena del nombre del archivo de origen. Si es desconocido, es NO_INDEX .
|
Indica que todas las entradas de números 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 siguiente descripción.
|
Operadores especiales
Los opcodes con valores entre 0x0a
y 0xff
(inclusive) mueven los registros line
y address
en una cantidad pequeña y, luego, emiten una nueva entrada de tabla de posiciones.
La fórmula para los incrementos es la siguiente:
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 a él 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 comienzo del archivo hasta las anotaciones realizadas directamente en la clase, o 0 si la clase no tiene anotaciones directas.
El desplazamiento, si no es cero, debe ser a 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 | Cantidad de campos con anotaciones de este elemento |
annotated_methods_size | uint | Cantidad de métodos anotados por este elemento |
annotated_parameters_size | uint | Cantidad de listas de parámetros de método que anoto este elemento |
field_annotations | field_annotation[fields_size] (opcional) | Es la lista de anotaciones de campos asociadas. Los elementos de la lista deben ordenarse de forma ascendente por field_idx .
|
method_annotations | method_annotation[methods_size] (opcional) | lista de anotaciones de métodos asociados. Los elementos de la lista deben ordenarse de forma creciente por method_idx .
|
parameter_annotations | parameter_annotation[parameters_size] (opcional) | lista de anotaciones de parámetros de método asociados. Los elementos de la lista deben ordenarse de forma ascendente por method_idx .
|
Nota: Todas las instancias de field_id
y method_id
de los elementos deben hacer referencia a la misma clase de definición.
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 | desde el comienzo del archivo hasta la lista de anotaciones del campo. El desplazamiento debe ser a una ubicación en la sección data . El formato de los datos se especifica a continuación con "annotation_set_item ".
|
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 comienzo del archivo hasta la lista de anotaciones del método. El desplazamiento debe ser a una ubicación en la sección data . El formato de los datos se especifica a continuación con "annotation_set_item ".
|
formato de parameter_annotation
Name | Formato | Descripción |
---|---|---|
method_idx | uint | índice en la lista method_ids para la identidad del método cuyos parámetros se anotan
|
annotations_off | uint | desplazamiento desde el comienzo del archivo hasta la lista de anotaciones para los parámetros del método. El desplazamiento debe ser a una ubicación en la sección data . El formato de los datos se especifica a continuación con "annotation_set_ref_list ".
|
annotation_set_ref_list
Se hace referencia a él 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 comienzo del archivo hasta el conjunto de anotaciones al que se hace referencia o 0 si no hay anotaciones para este elemento.
El desplazamiento, si no es cero, debe ser a una ubicación en la sección data . El formato de los datos se especifica a continuación con "annotation_set_item ".
|
annotation_set_item
Se hace referencia a ellos 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 ascendente por type_idx .
|
Formato annotation_off_item
Name | Formato | Descripción |
---|---|---|
annotation_off | uint | desplazamiento desde el principio del archivo hasta una anotación.
El desplazamiento debe ser a una ubicación en la sección data , y el formato de los datos en esa ubicación se especifica a continuación con “annotation_item ”.
|
annotation_item
Se hace referencia desde annotation_set_item
Aparece en la sección de datos
Alineación: Ninguna (alineada en bytes)
Name | Formato | Descripción |
---|---|---|
visibilidad | ubyte | la visibilidad prevista de esta anotación (consulta a continuación) |
anotación | encoded_annotation | Contenido de anotaciones codificadas, 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 tiempo de compilación (p.ej., durante la compilación de otro código) |
VISIBILITY_RUNTIME | 0x01 | que se mostrarán durante el tiempo de ejecución |
VISIBILITY_SYSTEM | 0x02 | que se debe ver 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 a él desde class_def_item
Aparece en la sección de datos
Alineación: Ninguna (alineada en bytes)
Name | Formato | Descripción |
---|---|---|
valor | encoded_array | Bytes que representan el valor del array codificado, en el formato especificado por “encoded_array Format” en “encoded_value Encoding” más arriba.
|
hiddenapi_class_data_item
Esta sección contiene 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 acceso de la clase 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 sobre interfaces que no pertenecen al SDK.
Name | Formato | Descripción |
---|---|---|
size | uint | el tamaño total de la sección |
compensaciones | uint[] | Es un array de offsets indexados por class_idx .
Una entrada de array cero en el índice class_idx significa que no hay datos para este class_idx o que todas las marcas ocultas de la API son cero.
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[] | Arrays concatenados de marcas de API ocultas para cada clase. Los posibles valores de la marca se describen en la siguiente tabla. Las marcas se codifican en el mismo orden en que los campos y los métodos se codifican en los datos de 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, independientemente del nivel de API objetivo de la aplicación. El acceso a una de estas interfaces genera un error de tiempo de ejecución. |
greylist‑max‑o | 3 | Son interfaces que no pertenecen al SDK y que se pueden usar para 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 para Android 9.x, a menos que estén restringidas. |
greylist‑max‑q | 5 | Son 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 varios elementos de información reflexiva sobre las clases (y los métodos y campos). Por lo general, solo el código del cliente (no del sistema) accede a esta información de forma indirecta.
Las anotaciones del sistema se representan en archivos .dex
como anotaciones con 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 tiene que 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 es anónima, pero no se define dentro del cuerpo de un método (p.ej., una clase interna sintética). Cada clase que tenga esta anotación también debe tener una anotación InnerClass
. Además, una clase no debe tener una anotación EnclosingClass
ni EnclosingMethod
.
Name | Formato | Descripción |
---|---|---|
valor | Clase | la clase que abarca esta clase de manera más léxica |
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. Cada clase que tenga esta anotación también debe tener una anotación InnerClass
.
Además, una clase no debe tener una anotación EnclosingClass
ni EnclosingMethod
.
Name | Formato | Descripción |
---|---|---|
valor | Método | el método que abarca esta clase de manera más léxica |
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 una anotación EnclosingClass
o una anotación EnclosingMethod
.
Name | Formato | Descripción |
---|---|---|
nombre | String | 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 discrepancia 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 de miembros. (Una clase miembro es una clase interna directa que tiene un nombre).
Name | Formato | Descripción |
---|---|---|
valor | Class[] | 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.
Una anotación MethodParameters
es opcional y se puede usar para proporcionar metadatos de parámetros, como nombres y modificadores de parámetros.
La anotación se puede omitir de un método o constructor de forma segura cuando los metadatos del parámetro no son necesarios 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()
, volverán al comportamiento predeterminado en el tiempo de ejecución si no hay información.
Cuando se incluyen metadatos de parámetros, los compiladores deben incluir información para las clases generadas, como enums, ya que los metadatos de parámetros incluyen si un parámetro es sintético o obligatorio.
Una anotación MethodParameters
solo describe los parámetros de métodos individuales. Por lo tanto, los compiladores pueden omitir la anotación por completo para los constructores y métodos que no tienen parámetros, por motivos de tamaño de código y eficiencia del tiempo de ejecución.
Los arrays que se documentan a continuación deben tener el mismo tamaño que la estructura de 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
.
Debido a que MethodParameters
describe todos los parámetros del método formal, 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 parámetros explícitos declarados en el código fuente. MethodParameters
tampoco incluirá información sobre los parámetros del receptor de la anotación de tipo que no existen en la firma del método real.
Name | Formato | Descripción |
---|---|---|
nombres | String[] | Los nombres de los parámetros formales para el 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[] | Las marcas de acceso de los parámetros formales para el 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 durante 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 puede representar un type_id_item
. El formato .dex
no define el formato de las firmas; solo se diseñó para poder representar cualquier firma que requiera un lenguaje fuente para la implementación correcta 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 las APIs y herramientas de nivel superior (como los depuradores). Por lo tanto, cualquier uso de una firma debe escribirse de modo que no se haga ninguna suposición sobre recibir solo firmas válidas y protegerse explícitamente contra la posibilidad de encontrar una firma sintácticamente no válida.
Debido a 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 se refieren, de forma natural, a los mismos datos subyacentes, y la firma se considera la concatenación de todas las cadenas del array. No hay reglas sobre cómo separar una firma en cadenas independientes; eso depende completamente 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[] | el array de tipos de excepciones que se arrojaron |