Ce document décrit la mise en page et le contenu de .dex
.
qui contiennent un ensemble de définitions de classe et les fichiers associés
aux données auxiliaires.
Guide des types
Nom | Description |
---|---|
octet | Int signé 8 bits |
uoctet | Int non signé 8 bits |
court | Int 16 bits signé, Little-Endian |
Ushort | Int 16 bits non signé, small-endian |
int | Int 32 bits signé, Little-Endian |
UInt | Int 32 bits non signé, small-endian |
long | Int 64 bits signé, Little-Endian |
Ulong | Int non signé 64 bits, small-endian |
sleb128 | LEB128 signé, longueur variable (voir ci-dessous) |
Uleb128 | LEB128 non signé, longueur variable (voir ci-dessous) |
Uleb128p1 | LEB128 non signé plus 1 , longueur variable (voir ci-dessous) |
LEB128
LEB128 ("Little-ndian Base 128") est un
l'encodage de longueur variable pour
nombres entiers arbitraires signés ou non signés. Le format était
emprunté à DWARF3
spécifique. Dans un fichier .dex
, LEB128 n'est utilisé que pour
encoder des quantités 32 bits.
Chaque valeur encodée LEB128 se compose de un à cinq
octets, qui représentent ensemble
une seule valeur de 32 bits. Chaque
est défini sur l'octet le plus significatif, à l'exception du dernier octet du
qui présente le bit le plus significatif. Le reste
sept bits de chaque octet sont la charge utile, les sept bits les moins significatifs
bits de la quantité dans le premier octet, les sept suivants dans le deuxième
byte, etc. Dans le cas d'une clé LEB128 signée (sleb128
),
le bit de charge utile le plus important
du dernier octet de la séquence est
signe étendu pour produire la valeur finale. Dans le cas non signé
(uleb128
), tous les bits non représentés explicitement sont
interprétée comme 0
.
Schéma d'une valeur LEB128 à deux octets | |||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Premier octet | Deuxième octet | ||||||||||||||
1 |
bit6 | bit5 | bit4 | bit3 | bit2 | bit1 | bit0 | 0 |
bit13 | bit12 | bit11 | bit10 | bit9 | bit8 | bit7 |
La variante uleb128p1
sert à représenter un
valeur, où la représentation correspond à la valeur plus un encodée
en tant que uleb128
. Ainsi, l'encodage de -1
(également considérée comme la valeur non signée 0xffffffff
)
(mais aucun autre nombre négatif), soit un seul octet,
utiles dans les cas où le nombre représenté doit être
être une valeur non négative ou -1
(ou 0xffffffff
) ;
et pour lesquelles aucune autre valeur négative n'est autorisée (ou pour lesquelles de grandes valeurs non signées
il est peu probable que ces valeurs soient nécessaires).
Voici quelques exemples de formats:
Séquence encodée | En tant que sleb128 |
En tant que uleb128 |
En tant que uleb128p1 |
---|---|---|---|
00 | 0 | 0 | -1 |
01 | 1 | 1 | 0 |
7f | -1 | 127 | 126 |
80 °F | -128 | 16256 | 16255 |
Disposition des fichiers
Nom | Format | Description |
---|---|---|
en-tête | titre_en-tête | l'en-tête |
string_ids | string_id_item[] | liste d'identifiants de chaîne. Ce sont les identifiants de toutes les chaînes utilisé par ce fichier, que ce soit pour un nommage interne (par exemple, les descripteurs de type) ou comme objets constants appelés par le code. Cette liste doit être triée par contenu de chaîne, à l'aide de valeurs de point de code UTF-16 (et non dans une sensible aux paramètres régionaux) et ne doit pas contenir d'entrées en double. |
ID_type | type_id_item[] | d'identifiants de type. Il s'agit d'identifiants pour tous les types (classes,
ou les types primitifs) auxquels ce fichier fait référence, qu'ils soient définis
dans le fichier ou non. Cette liste doit être triée par string_id
et ne doit pas contenir d'entrées en double.
|
proto_id (ID de protocole) | élément "proto_id_item"[] | liste des identifiants du prototype de méthode. Ce sont des identifiants pour toutes
prototypes auxquels
ce fichier fait référence. Cette liste doit être triée en
return-type (par indice type_id ), d'ordre principal, puis
par liste d'arguments (ordre lexicographique, arguments individuels)
triées par indice type_id ). Cette liste ne doit pas
ne doit pas contenir d'entrées en double.
|
id_champ | field_id_item[] | d'identifiants de champ. Il s'agit d'identifiants pour tous les champs
auxquels ce fichier fait référence, qu'il soit défini dans le fichier ou non. Ce
la liste doit être triée, où le type qui la définit (par type_id )
index) est l'ordre principal, le nom du champ (par l'index string_id ).
correspond à l'ordre intermédiaire et au type (par indice type_id )
est l'ordonnance mineure. La liste ne doit pas contenir d'entrées en double.
|
méthodes_id | méthode_id_article[] | d'identifiants de méthode. Il s'agit d'identifiants pour toutes les méthodes
auxquels ce fichier fait référence, qu'il soit défini dans le fichier ou non. Ce
la liste doit être triée, où le type qui la définit (par type_id )
index) est l'ordre principal, le nom de la méthode (par string_id
index) est l'ordre intermédiaire, et le prototype de méthode (par
l'index proto_id ) correspond à l'ordre mineur. Cette liste ne doit pas
ne doit pas contenir d'entrées en double.
|
définition_classe | class_def_item[] | de définitions de classes. Les classes doivent être ordonnées de manière à ce qu'une la super-classe et les interfaces implémentées de cette classe apparaissent dans avant la classe référente. En outre, elle n'est pas valide pour une définition pour qu'une classe portant le même nom apparaisse plusieurs fois dans la liste. |
Identifiants de sites d'appel | call_site_id_item[] | appeler la liste des identifiants des sites. Il s'agit d'identifiants pour tous les sites d'appel
auxquels ce fichier fait référence, qu'il soit défini dans le fichier ou non. Cette liste
doit être trié par ordre croissant de call_site_off .
|
poignées de méthode | "method_handle_item" [] | gère la liste. Une liste de tous les handle de méthode auxquels ce fichier fait référence, qu'elles soient définies ou non dans le fichier. Cette liste n'est pas triée et peut contenir les doublons qui correspondront logiquement à différentes instances de gestionnaire de méthode. |
données | uoctet[] | contenant toutes les données d'assistance pour les tableaux listés ci-dessus. Les exigences d'alignement varient d'un élément à l'autre. des octets de marge intérieure sont insérés avant chaque élément, si nécessaire un alignement correct. |
lien_données | uoctet[] | données utilisées dans des fichiers liés de manière statique. Le format des données dans cette section n'est pas spécifiée par ce document. Cette section est vide dans les fichiers non associés et les implémentations d'environnement d'exécution peut l'utiliser comme bon lui semble. |
Champ de bits, chaîne et définitions de constantes
DEX_FILE_MAGIC
Intégré dans header_item
Le tableau/chaîne constant DEX_FILE_MAGIC
correspond à la liste des
octets devant apparaître au début d'un fichier .dex
pour qu'il soit reconnu comme tel. La valeur intentionnellement
contient un retour à la ligne ("\n"
ou 0x0a
) et un
d'octet nul ("\0"
ou 0x00
) pour vous aider
dans la détection de certaines formes de corruption. La valeur
encode un numéro de version de format sous la forme de trois chiffres décimaux, soit
devrait augmenter de façon monotone
à mesure que le format évolue.
ubyte[8] DEX_FILE_MAGIC = { 0x64 0x65 0x78 0x0a 0x30 0x33 0x39 0x00 } = "dex\n039\0"
Remarque:Compatibilité avec la version 039
de la
a été ajouté dans la version Android 9.0, qui introduisait deux
de nouveaux bytecodes, const-method-handle
et
const-method-type
(ceux-ci sont décrits dans le
Résumé de l'ensemble de bytecode
.) Dans Android 10, la version 039
étend le format de fichier DEX pour inclure les valeurs
Informations sur l'API qui ne s'appliquent qu'aux fichiers DEX sur le chemin d'accès à la classe de démarrage.
Remarque:Compatibilité avec la version
038
du format a été ajouté à la version 8.0 d'Android
de sortie. La version 038
a ajouté de nouveaux bytecodes
(invoke-polymorphic
et invoke-custom
) et
pour les identifiants de méthode.
Remarque:Compatibilité avec la version 037
de
Le format a été ajouté dans la version Android 7.0. Avant la version 037
le plus souvent
versions d'Android ont utilisé la version 035
du format. La seule
la différence entre les versions 035
et 037
est
l'ajout de méthodes par défaut et l'ajustement de invoke
.
Remarque:Au moins quelques versions antérieures du format
ont été utilisés dans des versions
logicielles publiques largement disponibles. Par exemple :
La version 009
a été utilisée pour les versions M3 du
plate-forme Android (novembre à décembre 2007),
La version 013
a été utilisée pour les versions M5 du
(février à mars 2008). À plusieurs égards, ces
précédents
de ce format sont très différentes de la version décrite
document.
ENDIAN_CONSTANT et REVERSE_ENDIAN_CONSTANT
Intégré dans header_item
La constante ENDIAN_CONSTANT
permet d'indiquer
du caractère final du fichier dans lequel il se trouve. Bien que la norme
Le format .dex
est Littleendian, les implémentations peuvent choisir
pour effectuer le changement d'octets. Si une implémentation rencontre un
en-tête dont la valeur endian_tag
est REVERSE_ENDIAN_CONSTANT
au lieu de ENDIAN_CONSTANT
, il saurait que le fichier
a été remplacé par un format attendu.
uint ENDIAN_CONSTANT = 0x12345678; uint REVERSE_ENDIAN_CONSTANT = 0x78563412;
NO_INDEX
Intégré dans class_def_item et debug_info_item
La constante NO_INDEX
est utilisée pour indiquer que
une valeur d'index est absente.
Remarque:Cette valeur n'est pas définie comme
0
, car il s'agit généralement d'un index valide.
La valeur choisie pour NO_INDEX
est
représentable sous la forme d'un octet unique dans l'encodage uleb128p1
.
uint NO_INDEX = 0xffffffff; // == -1 if treated as a signed int
Définitions access_flags
Intégré dans class_def_item, codé_champ, codé_méthode et Classe InnerClass
Les champs de bits de ces indicateurs sont utilisés pour indiquer l'accessibilité et propriétés générales des classes et de leurs membres.
Nom | Valeur | Pour les classes (et les annotations InnerClass ) |
Pour les champs | Pour les méthodes |
---|---|---|---|---|
ACC_PUBLIC | 0x1 | public : visible partout |
public : visible partout |
public : visible partout |
ACC_PRIVATE | 0x2 | private : uniquement visible par la classe définissant
|
private : visible uniquement par les personnes qui la définissent |
private : visible uniquement par les personnes qui la définissent |
ACC_PROTECTED [ACC_PROTECTÉ] | 0x4 | protected : visible par le package et les sous-classes
|
protected : visible par le package et les sous-classes |
protected : visible par le package et les sous-classes |
ACC_STATIC | 0x8 | static : n'est pas construit avec une couche
Référence this |
static : global jusqu'à la classe de définition |
static : n'accepte pas un argument this . |
ACC_FINALE | 0x10 | final : non sous-classable |
final : immuable après la construction |
final : non modifiable |
ACC_SYNCHRONIZED | 0x20 | synchronized : verrou associé obtenu automatiquement
concernant l'appel de cette méthode. Remarque:Vous ne pouvez définir cet attribut que si
|
||
ACC_VOLATILE | 0x40 | volatile : règles d'accès spéciales pour faciliter le fil de discussion
sécurité |
||
Passerelle ACC | 0x40 | méthode pont, ajoutée automatiquement par le compilateur en tant que type avec sûreté du typage pont | ||
ACC_TRANSIENT | 0x80 | transient : ne doit pas être enregistré par la sérialisation par défaut |
||
ACC_VARARGS | 0x80 | Le dernier argument doit être traité comme un argument "rest" argument par compilateur | ||
ACC_NATIVE | 0x100 | native : implémenté en code natif |
||
ACC_INTERFACE | 0x200 | interface : classe abstraite multiplicable pouvant être implémentée |
||
ACC_ABSTRACT | 0x400 | abstract : pas directement instanciable |
abstract : non implémenté par cette classe |
|
ACC_STRICT | 0x800 | strictfp : règles strictes pour l'arithmétique à virgule flottante |
||
ACC_SYNTHÉTIQUE | 0x1000 | non défini directement dans le code source | non défini directement dans le code source | non défini directement dans le code source |
ACC_Annotations | 0x2000 | déclarée en tant que classe d'annotation | ||
ACC_ENUM | 0x4000 | déclaré en tant que type énuméré | déclarée en tant que valeur énumérée | |
(non utilisé) | 0x8000 | |||
CONSTRUCTEUR_ACC | 0x10000 | Méthode constructeur (initialiseur de classe ou d'instance) | ||
ACC_DECLARED_ SYNCHRONISÉ |
0x20000 | a déclaré synchronized . Remarque:Cela n'a aucun effet sur (sauf en ce qui concerne cette option). |
InnerClass
,
et ne doit jamais être activé dans un class_def_item
.
Modification de l'encodage UTF-8
Pour simplifier la prise en charge des anciennes versions, le format .dex
encode ses données de chaîne dans un format UTF-8 modifié standard de facto, ci-après
appelé MUTF-8. Ce format est identique au format UTF-8 standard, à la différence près que:
- Seuls les encodages d'un, deux et trois octets sont utilisés.
- Points de code dans la plage
U+10000
... LesU+10ffff
sont encodées sous la forme d'une paire de substitution, chacune des qui est représenté sous la forme d'une valeur encodée sur trois octets. - Le point de code
U+0000
est encodé sous forme de deux octets. - Un octet nul brut (valeur
0
) indique la fin de une chaîne, tout comme l'interprétation standard en langage C.
Les deux premiers éléments ci-dessus peuvent être résumés comme suit: MUTF-8 est un format d'encodage pour UTF-16, au lieu d'être un format pour les caractères Unicode.
Les deux derniers éléments ci-dessus permettent d'inclure simultanément
le point de code U+0000
dans une chaîne et encore manipuler
en tant que chaîne de style C
terminée par une valeur nulle.
Cependant, l'encodage spécial de U+0000
signifie que, contrairement à
UTF-8 normal, le résultat de l'appel de la fonction C standard
strcmp()
sur une paire de chaînes MUTF-8 ne fonctionne pas toujours
indiquent le résultat correctement signé de la comparaison de chaînes inégales.
Lorsque l'ordonnancement (et pas seulement l'égalité) est une préoccupation, la méthode la plus simple
une autre façon de comparer les chaînes MUTF-8 est
de les décoder caractère par caractère,
et comparer les valeurs décodées. Toutefois, des implémentations plus astucieuses
aussi possible.)
Reportez-vous à la section Le langage Unicode Standard pour en savoir plus sur l'encodage des caractères. MUTF-8 est en fait plus proche de l'encodage (relativement moins connu). CESU-8 et UTF-8 en soi.
encodage de la valeur encodée
Intégré dans annotation_element et codé_array_item
Un élément encoded_value
est une partie encodée de (presque)
et arbitraires
structurées de manière hiérarchique. Le codage est destiné à
doivent être à la fois compactes
et faciles à analyser.
Nom | Format | Description |
---|---|---|
(value_arg << 5) | type_valeur | uoctet | octet indiquant le type de l'entrée immédiatement
value de progression
avec un argument de clarification facultatif
dans les trois bits de poids fort.
Vous trouverez ci-dessous les différentes définitions de value .
Dans la plupart des cas, value_arg encode la longueur de
la valeur value qui vient immédiatement après en octets, comme
(size - 1) , par exemple : 0 signifie que
la valeur nécessite un octet, et 7 signifie qu'elle nécessite
huit octets ; Il existe toutefois des exceptions, comme indiqué ci-dessous.
|
value | uoctet[] | octets représentant la valeur, de longueur variable et interprétée
différemment selon les value_type octets,
toujours petit-endian. Consultez les différentes définitions des valeurs ci-dessous :
plus de détails.
|
Formats des valeurs
Nom du type | value_type |
Format value_arg |
Format value |
Description |
---|---|---|---|---|
VALEUR_BYTE | 0x00 | (aucun ; doit être 0 ) |
uoctet[1] | valeur entière signée d'un octet |
VALUE_SHORT | 0x02 | taille - 1 (0...1) | uoctet[taille] | nombre entier signé à deux octets, avec signe étendu |
VALEUR_CHAR | 0x03 | taille - 1 (0...1) | uoctet[taille] | valeur entière non signée à deux octets, étendue à zéro |
INT.VALEUR | 0x04 | taille - 1 (0...3) | uoctet[taille] | nombre entier signé à quatre octets, avec signe étendu |
VALUE_LONG | 0x06 | taille - 1 (0...7) | uoctet[taille] | valeur entière signée de huit octets, avec signe étendu |
VALEUR_FLOAT | 0x10 | taille - 1 (0...3) | uoctet[taille] | motif de quatre octets, étendu à droite et interprétée comme une valeur à virgule flottante 32 bits IEEE754 |
VALEUR_DOUBLE | 0x11 | taille - 1 (0...7) | uoctet[taille] | motif de huit bits, étendu à droite et interprétée comme une valeur à virgule flottante 64 bits IEEE754 |
VALEUR_MÉTHODE_TYPE | 0x15 | taille - 1 (0...3) | uoctet[taille] | nombre entier à quatre octets non signé (zéro étendu)
interprétée comme un index
la section proto_ids et représenter une valeur de type de méthode ;
|
MANUEL_VALEUR_MÉTHODE | 0x16 | taille - 1 (0...3) | uoctet[taille] | nombre entier à quatre octets non signé (zéro étendu)
interprétée comme un index
la section method_handles et représenter une valeur de handle de méthode ;
|
VALUE_STRING | 0x17 | taille - 1 (0...3) | uoctet[taille] | nombre entier à quatre octets non signé (zéro étendu)
interprétée comme un index
la section string_ids et représente une valeur de chaîne
|
VALEUR_TYPE | 0x18 | taille - 1 (0...3) | uoctet[taille] | nombre entier à quatre octets non signé (zéro étendu)
interprétée comme un index
la section type_ids et représente une réflexion
valeur de type/classe
|
CHAMP DE VALEUR | 0x19 | taille - 1 (0...3) | uoctet[taille] | nombre entier à quatre octets non signé (zéro étendu)
interprétée comme un index
la section field_ids et représente une réflexion
valeur du champ
|
MÉTHODE_VALEUR | 0x1a | taille - 1 (0...3) | uoctet[taille] | nombre entier à quatre octets non signé (zéro étendu)
interprétée comme un index
la section method_ids et représente une réflexion
valeur de la méthode
|
VALUE_ENUM | 0 x 1 milliard | taille - 1 (0...3) | uoctet[taille] | nombre entier à quatre octets non signé (zéro étendu)
interprétée comme un index
la section field_ids et représente la valeur
une constante de type énumérée
|
VALEUR_ARRAY | 0x1c | (aucun ; doit être 0 ) |
tableau_encodé | un tableau de valeurs, au format spécifié par
"Format encoded_array " ci-dessous. Taille
de value est implicite dans l'encodage.
|
VALEUR_NOTE | 0 x 1 j | (aucun ; doit être 0 ) |
annotation_encodée | une sous-annotation, au format spécifié par
"Format encoded_annotation " ci-dessous. Taille
de value est implicite dans l'encodage.
|
VALUE_NULL | 0x1e | (aucun ; doit être 0 ) |
(aucune) | Valeur de référence null |
VALEUR_BOOLÉENNE | 0x1f | Booléen (0...1) | (aucune) | Valeur d'un bit 0 pour false et
1 pour true . Le bit est représenté dans
value_arg
|
format "tableau_codé"
Nom | Format | Description |
---|---|---|
taille | Uleb128 | nombre d'éléments dans le tableau |
valeurs | valeur_codée[taille] | Une série de encoded_value octets size
séquences au format spécifié par cette section, concaténées
de manière séquentielle.
|
Format d'annotation encodée
Nom | Format | Description |
---|---|---|
type_idx | Uleb128 | Type de l'annotation. Il doit s'agir d'une classe (et non d'un tableau ou d'une primitive) de mots clés. |
taille | Uleb128 | nombre de mappages nom-valeur dans cette annotation |
éléments | élément_annotation[taille] | de l'annotation, représentés directement sur la ligne (et non au format
décalages). Les éléments doivent être triés par ordre croissant
Index string_id .
|
Format annotation_element
Nom | Format | Description |
---|---|---|
nom_idx | Uleb128 | de l'élément, représenté sous la forme d'un indice
Section string_ids . La chaîne doit respecter le format
pour MemberName, défini ci-dessus.
|
value | valeur_encodée | valeur de l'élément |
Syntaxe des chaînes
Un fichier .dex
contient plusieurs types d'éléments,
font finalement référence à une chaîne. Voici les définitions de style BNF :
indiquer la syntaxe acceptable pour ces chaînes.
SimpleName (Nom simple)
Un élément SimpleName est la base de la syntaxe des noms des autres
les choses. Le format .dex
autorise une certaine latitude
(beaucoup plus que les langages sources les plus courants). En bref, un simple
est composé d'un caractère alphabétique ou d'un chiffre ASCII, quelques
des symboles peu ASCII spécifiques et la plupart des points de code non ASCII qui ne sont pas
de commande, d’espace ou
des caractères spéciaux. À partir de la version 040
des espaces (Unicode Zs
)
catégorie). Notez que les points de code de substitution
(dans la plage U+d800
... U+dfff
) ne sont pas
considérés comme des caractères de nom valides en tant que tels, mais
caractères sont valides (ils sont représentés par le code
alternative de la règle pour SimpleNameChar), et ils doivent être
représentés dans un fichier par des paires de points de code de substitution dans le MUTF-8
l'encodage.
SimpleName → | ||
SimpleNameChar (SimpleNameChar)* | ||
SimpleNameChar → | ||
'A' ... 'Z' |
||
| | 'a' ... 'z' |
|
| | '0' ... '9' |
|
| | ' ' |
depuis la version 040 de DEX |
| | '$' |
|
| | '-' |
|
| | '_' |
|
| | U+00a0 |
depuis la version 040 de DEX |
| | U+00a1 ... U+1fff |
|
| | U+2000 ... U+200a |
depuis la version 040 de DEX |
| | U+2010 ... U+2027 |
|
| | U+202f |
depuis la version 040 de DEX |
| | U+2030 ... U+d7ff |
|
| | U+e000 ... U+ffef |
|
| | U+10000 ... U+10ffff |
Nom de membre
utilisé par field_id_item et method_id_item
Un MemberName est le nom d'un membre d'un cours, les membres étant les champs, les méthodes et les classes internes.
MemberName → | |
SimpleName (Nom simple) | |
| | '<' SimpleName '>' |
Nom de classe complète
FullClassName est un nom de classe complet, incluant une spécificateur de package facultatif suivi d'un nom obligatoire.
FullClassName → | |
OptionalPackagePrefix SimpleName | |
OptionalPackagePrefix → | |
(SimpleName '/' )* |
Descripteur de type
Utilisé par type_id_item
Un TypeDescriptor est la représentation de n'importe quel type, y compris
les primitives, les classes, les tableaux et void
. Voir ci-dessous pour
la signification des différentes versions.
TypeDescriptor → | |
'V' |
|
| | Descripteur de type de champ |
FieldTypeDescriptor → | |
NonArrayFieldTypeDescriptor | |
| | ('[' * 1...255)
NonArrayFieldTypeDescriptor |
NonArrayFieldTypeDescriptor→ | |
'Z' |
|
| | 'B' |
| | 'S' |
| | 'C' |
| | 'I' |
| | 'J' |
| | 'F' |
| | 'D' |
| | 'L' FullClassName ';' |
Descripteur Shorty
Utilisé par proto_id_item
Un ShortyDescriptor est la représentation courte d'une méthode.
y compris les types de retour et de paramètre, à la différence près qu'il existe
aucune distinction entre les différents types de référence (classe ou tableau). À la place,
tous les types de référence sont représentés par un seul caractère 'L'
.
ShortyDescriptor → | |
ShortyReturnType (ShortyFieldType)* | |
ShortyReturnType → | |
'V' |
|
| | ShortyFieldType |
ShortyFieldType → | |
'Z' |
|
| | 'B' |
| | 'S' |
| | 'C' |
| | 'I' |
| | 'J' |
| | 'F' |
| | 'D' |
| | 'L' |
Sémantique TypeDescriptor
C'est la signification de chacune des variantes de TypeDescriptor.
Syntaxe | Signification |
---|---|
V | void ; Uniquement valide pour les types renvoyés |
Z | boolean |
B | byte |
S | short |
C | char |
I | int |
J | long |
F | float |
D | double |
Ltotalement/qualifié/nom ; | la classe fully.qualified.Name |
[descripteur] | tableau de descriptor , utilisable de manière récursive pour
tableaux de tableaux, bien qu'il ne soit pas valide d'avoir plus de 255
.
|
Éléments et structures associées
Cette section inclut les définitions de chacun des éléments de premier niveau qui
peut apparaître dans un fichier .dex
.
titre_en-tête
Apparaît dans la section d'en-tête
Alignement: 4 octets
Nom | Format | Description |
---|---|---|
magique | uoctet[8] = DEX_FILE_MAGIC | une valeur magique. Consultez la discussion sous "DEX_FILE_MAGIC " ci-dessus
pour en savoir plus.
|
somme de contrôle | UInt | la somme de contrôle adler32 du reste du fichier (tout sauf
magic et ce champ) ; utilisé pour détecter la corruption de fichiers
|
signature | uoctet[20] | Signature SHA-1 (hachage) du reste du fichier (tous les éléments sauf
magic , checksum et ce champ) ; utilisés
pour identifier les fichiers de façon unique
|
taille_fichier | UInt | Taille du fichier entier (y compris l'en-tête), en octets |
taille de l'en-tête | uint = 0x70 | la taille de l'en-tête (cette section entière), en octets. Cela permet à une quantité limitée de rétrocompatibilité l'invalidation du format. |
balise_endian | uint = ENDIAN_CONSTANT | endianness. Consultez la discussion sous "ENDIAN_CONSTANT " ci-dessus
et REVERSE_ENDIAN_CONSTANT " pour en savoir plus.
|
taille du lien | UInt | taille de la section du lien, ou 0 si ce fichier n'est pas
associé statiquement |
lien_désactivé | UInt | un décalage entre le début du fichier et la section du lien, ou
0 si link_size == 0 . Le décalage, s'il n'est pas égal à zéro,
doit être définie sur un décalage dans la section link_data . La
le format des données pointées n'est pas spécifié par ce document ;
ce champ d'en-tête (et le précédent) sont laissés comme hooks à utiliser par
implémentations d'environnement d'exécution.
|
carte_off | UInt | un décalage entre le début du fichier et l'élément de carte. Le décalage, qui doit
être non nulle, doit correspondre à un décalage dans la section data ,
Les données doivent être au format spécifié par "map_list "
ci-dessous.
|
string_ids_size [taille_ID_de_chaîne] | UInt | nombre de chaînes dans la liste des identifiants de chaîne |
string_ids_off [id_chaîne] | UInt | un décalage entre le début du fichier et la liste des identifiants de chaîne ; ou
0 si string_ids_size == 0 (un
cas particuliers étrange). Le décalage, s'il n'est pas égal à zéro,
doit se trouver au début de la section string_ids .
|
taille_ID_type | UInt | Nombre d'éléments dans la liste des identifiants de type (65 535 maximum) |
type_ids_off [identifiant_type] désactivé | UInt | un décalage entre le début du fichier et la liste des identifiants de type ; ou
0 si type_ids_size == 0 (un
cas particuliers étrange). Le décalage, s'il n'est pas égal à zéro,
doit se trouver au début de type_ids
.
|
taille des identifiants de protocole | UInt | nombre d'éléments dans la liste des identifiants de prototype (65 535 au maximum) |
proto_ids_off [id_prototype_désactivé] | UInt | un décalage entre le début du fichier et
la liste des identifiants du prototype, ou
0 si proto_ids_size == 0 (un
cas particuliers étrange). Le décalage, s'il n'est pas égal à zéro,
doit se trouver au début de proto_ids
.
|
ID_champ_taille | UInt | nombre d'éléments dans la liste des identifiants de champ |
id_champ_off | UInt | un décalage entre le début du fichier et la liste des identifiants de champ ; ou
0 si field_ids_size == 0 . Le décalage, si
toute valeur différente de zéro, doit correspondre au début de field_ids
. |
taille_ID_méthode | UInt | nombre d'éléments dans la liste des identifiants de méthode |
ID_méthode_désactivé | UInt | un décalage entre le début du fichier et la liste des identifiants de méthode ; ou
0 si method_ids_size == 0 . Le décalage, si
toute valeur différente de zéro, doit correspondre au début de method_ids
. |
taille_defs_class | UInt | nombre d'éléments dans la liste de définitions de classe |
CANNOT TRANSLATE | UInt | un décalage entre le début du fichier et la liste des définitions de classes, ou
0 si class_defs_size == 0 (un
cas particuliers étrange). Le décalage, s'il n'est pas égal à zéro,
doit se trouver au début de la section class_defs .
|
data_size | UInt | Taille de la section data en octets. Doit être un pair
multiple de sizeof(uint). |
données_désactivées | UInt | un décalage entre le début du fichier et le début du
Section data .
|
liste_cartes
Figure dans la section des données
Référence à l'élément header_item
Alignement: 4 octets
Il s'agit de la liste de l'intégralité
du contenu d'un fichier, dans l'ordre. Il
comporte une certaine redondance par rapport à header_item
.
mais il s'agit d'un formulaire facile à utiliser pour itérer sur un ensemble de
. Un type donné doit apparaître au maximum une fois dans une carte, mais il n'y a pas
des restrictions sur les types d'ordres qui peuvent apparaître, en dehors
restrictions implicites dans le reste du format (par exemple,
La section header
doit apparaître en premier, suivie d'une
string_ids
, etc.). En outre, les entrées de carte doivent
être triées par décalage initial et ne doivent pas se chevaucher.
Nom | Format | Description |
---|---|---|
taille | UInt | taille de la liste, en entrées |
liste | élément de carte[taille] | de la liste |
Format map_item
Nom | Format | Description |
---|---|---|
type | Ushort | le type des articles ; voir le tableau ci-dessous |
unused | Ushort | (non utilisé) |
taille | UInt | Nombre d'éléments à trouver au décalage indiqué |
compensés en carbone | UInt | Décalage entre le début du fichier et les éléments concernés |
Codes de type
Type d'article | Constante | Valeur | Taille de l'élément en octets |
---|---|---|---|
titre_en-tête | TYPE_HEADER_ITEM. | 0x0000 | 0x70 |
string_id_item [élément_id_chaîne] | TYPE_STRING_ID_ITEM | 0x0001 | 0x04 |
type_id_item | TYPE_TYPE_ID_ITEM | 0x0002 | 0x04 |
élément proto_id_item | TYPE_PROTO_ID_ITEM | 0x0003 | 0x0c |
item_id_item [id_champ] | TYPE_FIELD_ID_ITEM | 0x0004 | 0x08 |
méthode_id_article | ID_MÉTHODE_TYPE_ITEM | 0x0005 | 0x08 |
class_def_item | TYPE_CLASS_DEF_ITEM | 0x0006 | 0x20 |
call_site_id_item | TYPE_CALL_SITE_ID_ITEM | 0x0007 | 0x04 |
méthode_handle_item | TYPE_MÉTHODE_HANDLE_ITEM | 0x0008 | 0x08 |
liste_cartes | TYPE_MAP_LIST | 0x1000 | 4 + (item.size * 12) |
liste de types | TYPE_TYPE_LIST | 0x1001 | 4 + (item.size * 2) |
liste_ref_ensemble_annotations | TYPE_Annotations_SET_REF_LIST | 0x1002 | 4 + (item.size * 4) |
élément d'ensemble d'annotations | TYPE_NOTE_SET_ITEM | 0x1003 | 4 + (item.size * 4) |
élément_données_classe | TYPE_CLASS_DATA_ITEM. | 0x2000 | implicit; à analyser |
code_item | TYPE_CODE_ITEM | 0x2001 | implicit; à analyser |
élément_données_chaîne | TYPE_STRING_DATA_ITEM | 0x2002 | implicit; à analyser |
débogage_info_item | TYPE_DEBUG_INFO_ITEM (ÉLÉMENT_INFO_TYPE_DEBUG) | 0x2003 | implicit; à analyser |
élément_annotation | ÉLÉMENT_TYPE_NOTE | 0x2004 | implicit; à analyser |
élément_tableau_codé | TYPE_ENCODED_ARRAY_ITEM | 0x2005 | implicit; à analyser |
annotations_directory_item | TYPE_AnnotationsS_DIRECTORY_ITEM | 0x2006 | implicit; à analyser |
élément_data_class_hiddenapi_class | TYPE_HIDDENAPI_CLASS_DATA_ITEM | 0xF000 | implicit; à analyser |
string_id_item [élément_id_chaîne]
Apparaît dans la section string_ids
Alignement: 4 octets
Nom | Format | Description |
---|---|---|
chaîne_données_off | UInt | un décalage entre le début du fichier et les données de chaîne
élément. Le décalage doit correspondre à un emplacement
dans la section data . Les données doivent se trouver dans
format spécifié par "string_data_item " ci-dessous.
Il n'y a aucune exigence d'alignement pour le décalage.
|
élément_données_chaîne
Figure dans la section des données
Alignement: aucun (aligné sur les octets)
Nom | Format | Description |
---|---|---|
Taille utf16 | Uleb128 | la taille de cette chaîne, exprimée en unités de code UTF-16 (qui correspond à la chaîne
max." dans de nombreux systèmes). C'est-à-dire la longueur décodée
la chaîne. (La longueur encodée est implicite par la position
l'octet 0 .) |
données | uoctet[] | Une série d'unités de code MUTF-8 (également appelées octets)
suivi d'un octet de la valeur 0 . Voir
"Encodage MUTF-8 (UTF-8 modifié)" ci-dessus pour plus de détails et
discussion sur le format des données.
Remarque:Il est acceptable d'avoir une chaîne qui inclut
(la forme encodée de) les unités de code de substitution UTF-16 (c'est-à-dire,
|
type_id_item
Figure dans la section type_ids
Alignement: 4 octets
Nom | Format | Description |
---|---|---|
idx_descripteur | UInt | dans la liste string_ids du descripteur
de ce type. La chaîne doit respecter la syntaxe
TypeDescriptor, défini ci-dessus.
|
élément proto_id_item
Apparaît dans la section proto_ids
Alignement: 4 octets
Nom | Format | Description |
---|---|---|
Shorty_idx | UInt | l'index dans la liste string_ids pour les formats courts
de ce prototype. La chaîne doit respecter le format
pour ShortyDescriptor, définie ci-dessus, et doit correspondre
au type et aux paramètres renvoyés de cet élément.
|
return_type_idx [identifiant_type_de_retour] | UInt | L'index dans la liste type_ids pour le type renvoyé
de ce prototype
|
paramètres_désactivé | UInt | Décalage entre le début du fichier et la liste des types de paramètres
pour ce prototype, ou 0 si ce prototype ne comporte aucun
paramètres. Ce décalage, s'il est différent de zéro, doit être dans le
data , et les données qui s'y trouvent
spécifié par "type_list" ci-dessous. De plus, il existe
ne doit pas faire référence au type void dans la liste.
|
item_id_item [id_champ]
Figure dans la section field_ids
Alignement: 4 octets
Nom | Format | Description |
---|---|---|
idx_classe | Ushort | dans la liste type_ids pour le définition de ce
. Il doit s'agir d'un type de classe, et non d'un type de tableau ou de primitive.
|
type_idx | Ushort | dans la liste type_ids pour le type
ce champ
|
nom_idx | UInt | dans la liste string_ids pour le nom
. La chaîne doit respecter la syntaxe de MemberName.
définis ci-dessus.
|
méthode_id_article
Figure dans la section "method_ids"
Alignement: 4 octets
Nom | Format | Description |
---|---|---|
idx_classe | Ushort | dans la liste type_ids pour le définition de ce
. Il doit s'agir d'un type de classe ou de tableau, et non d'un type primitif.
|
proto_idx | Ushort | dans la liste proto_ids pour le prototype de
cette méthode
|
nom_idx | UInt | dans la liste string_ids pour le nom
. La chaîne doit respecter la syntaxe de MemberName.
définis ci-dessus.
|
class_def_item
Figure dans la section class_defs
Alignement: 4 octets
Nom | Format | Description |
---|---|---|
idx_classe | UInt | dans la liste type_ids pour cette classe.
Il doit s'agir d'un type de classe, et non d'un type de tableau ou de primitive.
|
indicateur_d'accès | UInt | options d'accès pour la classe (public , final ,
etc.). Voir la section "access_flags définitions" pour en savoir plus.
|
super-classe_idx | UInt | dans la liste type_ids de la super-classe ; ou
la valeur constante NO_INDEX si aucune
(par exemple, il s'agit d'une classe racine telle que Object ).
S'il est présent, il doit s'agir d'un type de classe, et non d'un type de tableau ou de primitive.
|
interfaces_désactivées | UInt | un décalage entre le début du fichier et la liste des interfaces, ou
0 s'il n'y en a pas. Ce décalage
doivent se trouver dans la section data , et les données
doit être au format spécifié par
"type_list " ci-dessous. Chacun des éléments de la liste
doit être un type de classe (et non un type de tableau ou de primitive) et
ne doit pas être un doublon.
|
idx_fichier_source | UInt | dans la liste string_ids pour le nom
contenant la source d'origine pour (au moins la plupart de) cette classe,
ou la valeur spéciale NO_INDEX pour indiquer l'absence
ces informations. Le debug_info_item d'une méthode donnée
peut remplacer ce fichier source, mais la plupart des classes
proviennent d'un seul fichier source.
|
annotations_désactivées | UInt | Décalage entre le début du fichier et la structure d'annotations
pour cette classe, ou 0 s'il n'y a aucune annotation sur
ce cours. Ce décalage, s'il est différent de zéro, doit être dans le
data , et les données qui s'y trouvent
le format spécifié par "annotations_directory_item " ci-dessous,
avec tous les éléments faisant référence à cette classe comme "Définir".
|
données_classe_désactivée | UInt | le décalage entre le début du fichier et la valeur
Données de classe pour cet élément, ou 0 s'il n'y a pas de classe
pour cette classe. (Cela peut être le cas, par exemple, si cette classe
est une interface de repère.) Le décalage, s'il n'est pas égal à zéro, doit être dans la
data , et les données qui s'y trouvent
format spécifié par "class_data_item " ci-dessous, avec toutes
éléments faisant référence à cette classe comme "Définir".
|
valeurs_statiques_off | UInt | le décalage entre le début du fichier et la liste des initiales
des valeurs pour les champs static , ou 0 s'il y a
n'ont aucun champ (et tous les champs static doivent être initialisés avec
0 ou null ). Ce décalage doit être compris dans
data , et les données qui s'y trouvent
format spécifié par "encoded_array_item " ci-dessous. Taille
du tableau ne doit pas dépasser le nombre de static
déclarés par cette classe, et que les éléments correspondent aux
static dans le même ordre que celui déclaré dans le
la field_list correspondante. Le type de chaque tableau
doit correspondre au type déclaré du champ correspondant.
S'il y a moins d'éléments dans le tableau qu'il n'y en a
static , les champs restants sont initialisés
avec un 0 ou un null adapté au type.
|
call_site_id_item
Figure dans la section "call_site_ids"
Alignement: 4 octets
Nom | Format | Description |
---|---|---|
appel_site_arrêt | UInt | à partir du début du fichier pour appeler la définition de site. Le décalage doit dans la section des données. Les données doivent respecter le format spécifié par "call_site_item" ci-dessous. |
appel_site_élément
Figure dans la section des données
Alignement: aucun (aligné par des octets)
"call_site_item" est un élément "tableau_codé" dont les éléments correspondent aux arguments. fournie à une méthode d'amorçage de lien. Les trois premiers arguments sont les suivants:
- Poignée de méthode représentant la méthode de l'éditeur de liens d'amorçage (VALUE_Method_HANDLE).
- Nom de méthode que l'éditeur de liens d'amorçage doit résoudre (VALUE_STRING).
- Type de méthode correspondant au type du nom de la méthode à résoudre (VALUE_Method_TYPE).
Tous les arguments supplémentaires sont des valeurs constantes transmises à la méthode d'association d'amorçage. Ces arguments sont transmis dans l'ordre et sans aucun type de conversion.
Le handle de méthode représentant la méthode d'association d'amorçage doit avoir le type renvoyé java.lang.invoke.CallSite
. Les trois premiers types de paramètres sont les suivants:
java.lang.invoke.Lookup
java.lang.String
java.lang.invoke.MethodType
Les types de paramètres des arguments supplémentaires sont déterminés à partir de leurs valeurs constantes.
méthode_handle_item
Figure dans la section "method_handles"
Alignement: 4 octets
Nom | Format | Description |
---|---|---|
méthode_handle_type | Ushort | Type du handle de méthode ; voir le tableau ci-dessous |
unused | Ushort | (non utilisé) |
id_champ ou_méthode | Ushort | ID de champ ou de méthode selon que le type de handle de méthode est un accesseur ou un demandeur de méthode |
unused | Ushort | (non utilisé) |
Codes de type de handle de méthode
Constante | Valeur | Description |
---|---|---|
MÉTHODE_HANDLE_TYPE_STATIC_PUT | 0x00 | Le handle de méthode est un setter de champ statique (accesseur) |
MÉTHODE_HANDLE_TYPE_STATIC_GET | 0x01 | Le handle de méthode est un getter de champ statique (accesseur) |
MÉTHODE_HANDLE_TYPE_INSTANCE_PUT | 0x02 | Le handle de méthode est un setter de champ d'instance (accesseur) |
MÉTHODE_HANDLE_TYPE_INSTANCE_GET | 0x03 | Le handle de méthode est un getter (accesseur) de champ d'instance. |
MÉTHODE_HANDLE_TYPE_INVOKE_STATIQUE | 0x04 | Le handle de méthode est un appelant de méthode statique |
MÉTHODE_HANDLE_TYPE_INVOKE_INSTANCE | 0x05 | Le handle de méthode est un appelant de méthode d'instance |
CONSTRUCTEUR_MÉTHODE_HANDLE_TYPE_INVOKE_CONSTRUCTOR | 0x06 | Le handle de méthode est un demandeur de méthode constructeur. |
MÉTHODE_HANDLE_TYPE_INVOKE_DIRECT | 0x07 | Le handle de méthode est un demandeur de méthode direct. |
INTERFACE_MÉTHODE_HANDLE_TYPE_INVOKE_INTERFACE | 0x08 | Le handle de méthode est un appelant de méthode d'interface |
élément_données_classe
Référence à class_def_item
Figure dans la section des données
Alignement: aucun (aligné sur les octets)
Nom | Format | Description |
---|---|---|
taille_des_champs_statiques | Uleb128 | le nombre de champs statiques définis dans cet élément |
taille des champs d'instance | Uleb128 | le nombre de champs d'instance définis dans cet élément |
taille_méthodes_directes | Uleb128 | Nombre de méthodes directes définies dans cet élément |
taille_méthodes_virtuelles | Uleb128 | le nombre de méthodes virtuelles définies dans cet élément |
Champs_statiques | champ_encodé[taille_champs_statiques] | les champs statiques définis, représentés par une séquence de
codés. Les champs doivent être triés par
field_idx , par ordre croissant.
|
champs_instance | champ encodé[taille_champs_instance] | les champs d'instance définis, représentés par une séquence de
codés. Les champs doivent être triés par
field_idx , par ordre croissant.
|
méthodes_directes | méthode encodée[direct_methods_size] | les accès directs définis (n'importe lequel des éléments static , private ,
ou constructeur), représentées par une séquence de
codés. Les méthodes doivent être triées par
method_idx , par ordre croissant.
|
méthodes_virtuelles | méthode encodée[virtual_methods_size] | la VM définie (aucun des éléments static , private ,
ou constructeur), représentées par une séquence de
codés. Cette liste ne doit pas inclure les données héritées
à moins qu'elle ne soit remplacée par la classe représentée par cet élément. La
les méthodes doivent être triées par method_idx dans l'ordre croissant.
L'élément method_idx d'une méthode virtuelle ne doit pas être le même.
que n'importe quelle méthode directe.
|
Remarque : "Tous les éléments" field_id
et
Les instances method_id
doivent faire référence à la même classe de définition.
Format de champ encodé
Nom | Format | Description |
---|---|---|
champ_idx_diff | Uleb128 | dans la liste field_ids pour connaître l'identité
(comprend le nom et le descripteur), représenté sous la forme d'une différence
à partir de l'index de l'élément précédent dans la liste. L'index du
le premier élément d'une liste est représenté directement.
|
indicateur_d'accès | Uleb128 | options d'accès pour le champ (public , final ,
etc.). Voir la section "access_flags définitions" pour en savoir plus.
|
Format de méthode encodée
Nom | Format | Description |
---|---|---|
méthode_idx_diff | Uleb128 | dans la liste method_ids pour connaître l'identité
(comprend le nom et le descripteur), représentée sous la forme d'une différence
à partir de l'index de l'élément précédent dans la liste. L'index du
le premier élément d'une liste est représenté directement.
|
indicateur_d'accès | Uleb128 | options d'accès de la méthode (public , final ,
etc.). Voir la section "access_flags définitions" pour en savoir plus.
|
code_off | Uleb128 | un décalage entre le début du fichier et la structure de code
ou 0 si cette méthode est abstract .
ou native . Le décalage doit correspondre à un emplacement de la
Section data . Le format des données est spécifié par
"code_item " ci-dessous.
|
liste de types
Référence à partir de class_def_item et proto_id_item
Figure dans la section des données
Alignement: 4 octets
Nom | Format | Description |
---|---|---|
taille | UInt | taille de la liste, en entrées |
liste | type_item[taille] | de la liste |
Format type_item
Nom | Format | Description |
---|---|---|
type_idx | Ushort | indexer dans la liste type_ids |
code_item
Référencement provenant de Encoding_method
Figure dans la section des données
Alignement: 4 octets
Nom | Format | Description |
---|---|---|
taille des registres | Ushort | le nombre de registres utilisés par ce code |
ins_size | Ushort | le nombre de mots des arguments entrants de la méthode est destiné à |
taille_outs | Ushort | le nombre de mots d'espace d'argument sortant requis par ce code d'appel de méthode |
taille_essais | Ushort | le nombre de try_item pour cette instance. Si elle est différente de zéro,
elles apparaissent alors dans le tableau tries , juste après le
insns dans cette instance.
|
informations_débogage_off | UInt | décalage entre le début du fichier et les informations de débogage (numéros de ligne +
info sur la variable locale) pour ce code, ou 0 si
il n'y a tout simplement pas d'informations. Le décalage, s'il n'est pas
zéro, doit être
à un emplacement de la section data . Le format de
les données sont spécifiées par "debug_info_item " ci-dessous.
|
taille_insns | UInt | Taille de la liste d'instructions, en unités de code 16 bits |
insns | ushort[taille_insns] | le tableau réel du bytecode. Format du code dans une insns
est spécifié par le document associé
bytecode Dalvik. Remarque
que, bien qu'il s'agisse d'un tableau de ushort , il existe
il existe des structures internes qui
préfèrent un alignement à quatre octets. Par ailleurs,
S'il s'agit d'un fichier avec remplacement de la version finale, l'échange est
uniquement sur des instances ushort individuelles, et non sur le
plus grandes.
|
padding | ushort (facultatif) = 0 | deux octets de marge intérieure pour que tries soit aligné sur quatre octets.
Cet élément n'est présent que si la valeur de tries_size est différente de zéro
et insns_size est impair.
|
essaie | try_item[tries_size] (facultatif) | indiquant où les exceptions sont interceptées dans le code
comment les gérer. Les éléments du tableau ne doivent pas se chevaucher dans
plage et dans l’ordre
de la plus petite à la plus haute. Cet élément est uniquement
présent si tries_size est différent de zéro.
|
gestionnaires | encode_catch_handler_list (facultatif) | octets représentant une liste de listes de types de capture et de listes
adresses de gestionnaire. Chaque try_item a un décalage au niveau des octets
dans cette structure. Cet élément n'est présent que si
tries_size n'est pas nul.
|
format try_item
Nom | Format | Description |
---|---|---|
ajouter_début | UInt | adresse de départ du bloc de code couvert par cette entrée. L'adresse est le nombre d'unités de code 16 bits au début de la première séquence couverte instruction. |
nombre d'insn | Ushort | nombre d'unités de code 16 bits couvertes par cette entrée. Le dernier code
unité couverte (incluse) est start_addr + insn_count - 1 .
|
gestionnaire_off | Ushort | en octets par rapport au début de la plage de valeurs
encoded_catch_hander_list jusqu'à
encoded_catch_handler pour cette entrée. Il doit s'agir
le décalage au début d'une encoded_catch_handler .
|
Format encodé_liste_gestionnaire_gestionnaires
Nom | Format | Description |
---|---|---|
taille | Uleb128 | taille de cette liste, en entrées |
liste | gestionnaire_catch_encodé[taille_gestionnaires] | la liste réelle des listes de gestionnaires, représentées directement (et non par des décalages), et concaténés de manière séquentielle |
Format encode_catch_handler
Nom | Format | Description |
---|---|---|
taille | sleb128 | le nombre de types de capture dans cette liste. Si elle est "non positive", il s'agit de
la valeur négative du nombre de types de capture. Les captures sont suivies.
par un gestionnaire de type "catch-all". Par exemple: size de 0
signifie qu'il existe un catch-all, mais pas de capture explicite.
Un size de 2 signifie qu'il existe deux types
mais pas de collecteur. Et un size de -1
signifie qu'il y a un crochet typé accompagné d'un fourre-tout.
|
gestionnaires | type_codé_paire_addr[abs(taille)] | flux de abs(size) éléments encodés, un pour chaque interception
dans l'ordre dans lequel ils doivent être testés.
|
CANNOT TRANSLATE | uleb128 (facultatif) | Adresse bytecode du gestionnaire d'alias collecteur. Cet élément est uniquement
présente si size est non positif.
|
format_encodage_type_addr_paire
Nom | Format | Description |
---|---|---|
type_idx | Uleb128 | dans la liste type_ids pour le type
pour intercepter
|
adresse | Uleb128 | Adresse bytecode du gestionnaire d'exceptions associé |
débogage_info_item
Référence à code_item
Figure dans la section des données
Alignement: aucun (aligné sur les octets)
Chaque debug_info_item
définit un code d'octet inspiré de DWARF3
une machine à états qui, lorsqu'elle est interprétée, émet les positions
et (potentiellement) les informations sur les variables locales
code_item
La séquence commence par une longueur variable
en-tête (dont la longueur dépend du nombre de méthodes
), suivi des bytecodes de la machine à états, puis se termine
avec un octet DBG_END_SEQUENCE
.
La machine à états comprend cinq registres. La
Le registre address
représente le décalage d'instruction dans le
insns_item
associé en unités de code 16 bits. La
Les registres address
commencent à 0
au début de chaque
Séquence debug_info
et ne doit augmenter que de manière monotone.
Le registre line
représente le numéro de ligne source
doit être associée à l'entrée de table des positions suivantes émise par
la machine à états. Elle est initialisée dans l'en-tête de séquence et peut
changement de direction positive ou négative, mais ne doit jamais être inférieur à
1
Le registre source_file
représente
fichier source auquel les
entrées de numéros de ligne font référence. Il est initialisé pour
la valeur de source_file_idx
dans class_def_item
.
Les deux autres variables, prologue_end
et
epilogue_begin
, sont des indicateurs booléens (initialisés pour
false
) qui indiquent si la position suivante a été émise
doit être considéré comme un prologue ou un épilogue. La machine à états
doit également suivre le nom et le type de la dernière variable locale qui se trouve dans
chaque registre pour le code DBG_RESTART_LOCAL
.
L'en-tête est le suivant:
Nom | Format | Description |
---|---|---|
début_ligne | Uleb128 | la valeur initiale du registre line de la machine à états.
Ne représente pas une entrée de poste réelle.
|
taille des paramètres | Uleb128 | le nombre de noms de paramètres encodés. Il devrait y avoir
une par paramètre de méthode, à l'exception de l'élément this d'une méthode d'instance,
le cas échéant.
|
nom_paramètre | uleb128p1[taille_paramètres] | Index de chaîne du nom du paramètre de méthode. Une valeur encodée de
NO_INDEX indique qu'aucun nom
est disponible pour le paramètre associé. Descripteur de type
et la signature sont implicites à partir du descripteur et de la signature de la méthode.
|
Les valeurs de l'octet sont les suivantes:
Nom | Valeur | Format | Arguments | Description |
---|---|---|---|---|
DBG_END_SEQUENCE | 0x00 | (aucune) | met fin à une séquence d'informations de débogage pour un code_item |
|
DBG_ADVANCE_PC | 0x01 | uleb128 addr_diff | addr_diff : montant à ajouter au registre des adresses |
fait avancer le registre d'adresses sans émettre d'entrée de poste |
DBG_ADVANCE_LINE | 0x02 | sleb128 line_diff | line_diff : montant à modifier pour le registre des lignes |
fait avancer le registre de lignes sans émettre d'entrée de poste |
DBG_START_LOCAL | 0x03 | uleb128 register_num uleb128p1 name_idx uleb128p1 type_idx |
register_num : registre contenant les locaux name_idx : index de chaîne du nomtype_idx : index de type du type
|
introduit une variable locale à l'adresse actuelle. L'un ou l'autre
name_idx ou type_idx peuvent être
NO_INDEX pour indiquer que cette valeur est inconnue.
|
DBG_START_LOCAL_EXTENDED | 0x04 | uleb128 register_num uleb128p1 name_idx uleb128p1 type_idx uleb128p1 sig_idx |
register_num : registre contenant les locaux name_idx : index de chaîne du nomtype_idx : index de type du typesig_idx : index de chaîne de la signature du type
|
introduit un local avec une signature
de type à l'adresse actuelle.
name_idx , type_idx ou
sig_idx peut être NO_INDEX
pour indiquer que
cette valeur est inconnue. (Si sig_idx correspond à
-1 , cependant, les mêmes données pourraient être représentées plus
efficacement en utilisant le code d'opération DBG_START_LOCAL .)
Remarque:Pour en savoir plus, consultez la section
" |
DBG_END_LOCAL | 0x05 | uleb128 register_num | register_num : registre contenant |
marque une variable locale active comme étant hors du champ d'application au niveau adresse |
DBG_RESTART_LOCAL | 0x06 | uleb128 register_num | register_num : enregistrez pour redémarrer |
réintroduit une variable locale à l'adresse actuelle. Le nom et le type sont identiques à ceux du dernier élément local en ligne dans le registre. |
DBG_SET_PROLOGUE_END | 0x07 | (aucune) | définit le registre de la machine à états prologue_end ,
indiquant que la prochaine entrée de position ajoutée doit être
considéré comme la fin d'un prologue de méthode (un endroit approprié pour
un point d'arrêt de méthode). Le registre prologue_end est
effacé par un code d'opération spécial (>= 0x0a ).
|
|
DBG_SET_EPILOGUE_BEGIN | 0x08 | (aucune) | définit le registre de la machine à états epilogue_begin ,
indiquant que la prochaine entrée de position ajoutée doit être
considéré comme le début d'un épilogue méthodologique (un endroit approprié
pour suspendre l'exécution avant la fermeture de la méthode).
Le registre epilogue_begin est effacé par tout
(>= 0x0a ).
|
|
FICHIER_SET_DÉBUT | 0x09 | uleb128p1 name_idx | name_idx : index de chaîne du nom du fichier source.
NO_INDEX si inconnu
|
indique que toutes les entrées de numéro de ligne suivantes font référence à ce
nom du fichier source, au lieu du nom par défaut spécifié dans
code_item
|
Codes d'opérations spéciaux | 0x0a...0xff | (aucune) | fait avancer les registres line et address ,
émet une entrée de position, et efface prologue_end et
epilogue_begin Voir la description ci-dessous.
|
Codes d'opérations spéciaux
Codes d'opérateur dont les valeurs sont comprises entre 0x0a
et 0xff
(inclus) déplacez line
et address
.
par une petite quantité, puis émettent
une nouvelle entrée de table de positions.
La formule pour les incréments est la suivante:
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
Référence à class_def_item
Figure dans la section des données
Alignement: 4 octets
Nom | Format | Description |
---|---|---|
classe_annotations_off | UInt | entre le début du fichier et les annotations ajoutées directement
sur la classe, ou 0 si la classe ne comporte aucune annotation directe.
Le décalage, s'il est différent de zéro, doit correspondre à un emplacement du
Section data . Le format des données est spécifié
par "annotation_set_item " ci-dessous.
|
taille_champs | UInt | nombre de champs annotés par cet élément |
taille_méthodes_annotation | UInt | nombre de méthodes annotées par cet élément |
taille_paramètres_annotation | UInt | Nombre de listes de paramètres de méthode annotées par cet élément |
Annotations de champ | field_annotation[fields_size] (facultatif) | liste des annotations de champs associées. Les éléments de la liste
être triées par ordre croissant, par field_idx .
|
méthode_annotations | method_annotation[methods_size] (facultatif) | Liste des annotations de méthode associées. Les éléments de la liste
être triées par ordre croissant, par method_idx .
|
Annotations de paramètre | paramètre_annotation[parameters_size] (facultatif) | Liste des annotations de paramètres de méthode associés. Les éléments de
liste doit être triée par ordre croissant, par method_idx .
|
Remarque : "Tous les éléments" field_id
et
Les instances method_id
doivent faire référence à la même classe de définition.
Format de field_annotation
Nom | Format | Description |
---|---|---|
idx_champ | UInt | dans la liste field_ids pour connaître l'identité
champ annoté
|
annotations_désactivées | UInt | un décalage entre le début du fichier et la liste des annotations pour
sur le terrain. Le décalage doit correspondre à un emplacement dans data
. Le format des données est spécifié par
"annotation_set_item " ci-dessous.
|
Format method_annotation
Nom | Format | Description |
---|---|---|
méthode_idx | UInt | dans la liste method_ids pour connaître l'identité
méthode annotée
|
annotations_désactivées | UInt | un décalage entre le début du fichier et la liste des annotations pour
la méthode. Le décalage doit correspondre à un emplacement de la
Section data . Le format des données est spécifié par
"annotation_set_item " ci-dessous.
|
Format "parameter_annotation"
Nom | Format | Description |
---|---|---|
méthode_idx | UInt | dans la liste method_ids pour connaître l'identité
dont les paramètres sont annotés
|
annotations_désactivées | UInt | un décalage entre le début du fichier et la liste des annotations pour
les paramètres de la méthode. Le décalage doit correspondre à un emplacement de la
Section data . Le format des données est spécifié par
"annotation_set_ref_list " ci-dessous.
|
liste_ref_ensemble_annotations
Référence à l'élément "parameter_annotations_item"
Figure dans la section des données
Alignement: 4 octets
Nom | Format | Description |
---|---|---|
taille | UInt | taille de la liste, en entrées |
liste | annotation_set_ref_item[taille] | de la liste |
Format annotation_set_ref_item
Nom | Format | Description |
---|---|---|
annotations_désactivées | UInt | Décalage entre le début du fichier et l'ensemble d'annotations référencé
ou 0 s'il n'existe aucune annotation pour cet élément.
Le décalage, s'il est différent de zéro, doit correspondre à un emplacement dans data
. Le format des données est spécifié par
"annotation_set_item " ci-dessous.
|
élément d'ensemble d'annotations
référencé à partir de annotations_directory_item, field_annotations_item, method_annotations_item et annotation_set_ref_item
Figure dans la section des données
Alignement: 4 octets
Nom | Format | Description |
---|---|---|
taille | UInt | taille de l'ensemble, en entrées |
entrées | annotation_off_item[taille] | de l'ensemble. Les éléments doivent être triés par ordre croissant,
d'ici le type_idx .
|
Format annotation_off_item
Nom | Format | Description |
---|---|---|
annotation_désactivée | UInt | entre le début du fichier et une annotation.
Le décalage doit correspondre à un emplacement de la section data ,
et le format des données à cet emplacement est spécifié par
"annotation_item " ci-dessous.
|
élément_annotation
Référence à partir d'annotation_set_item
Figure dans la section des données
Alignement: aucun (aligné sur les octets)
Nom | Format | Description |
---|---|---|
visibilité | uoctet | la visibilité prévue de cette annotation (voir ci-dessous) ; |
annotation | annotation_encodée | le contenu d'annotation encodé, au format décrit par
"Format encoded_annotation " moins de
"Encodage encoded_value " ci-dessus.
|
Valeurs de visibilité
Voici les options du champ visibility
dans une
annotation_item
:
Nom | Valeur | Description |
---|---|---|
Développement de la visibilité | 0x00 | sont destinés à être visibles uniquement au moment de la compilation (lors de la compilation, d'autres codes) |
VISIBILITY_RUNTIME | 0x01 | destinés à être visibles au moment de l'exécution |
SYSTÈME_VISIBILITÉ | 0x02 | destinés à être visibles au moment de l'exécution, mais uniquement pour le système sous-jacent (et non au code utilisateur normal) |
élément_tableau_codé
Référence à class_def_item
Figure dans la section des données
Alignement: aucun (aligné sur les octets)
Nom | Format | Description |
---|---|---|
value | tableau_encodé | octets représentant la valeur du tableau encodée, au format spécifié
par "encoded_array Format" sous "encoded_value "
Encodage" ci-dessus.
|
élément_data_class_hiddenapi_class
Cette section contient des données sur les interfaces restreintes utilisées par chaque classe.
Remarque: La fonctionnalité d'API masquée a été introduite dans Android 10.0. et ne s'applique qu'aux fichiers DEX des classes dans le chemin d'accès à la classe de démarrage. La liste des options décrites ci-dessous est susceptible d'être étendue dans les prochaines versions. d'Android. Pour en savoir plus, consultez Restrictions concernant les interfaces non SDK.
Nom | Format | Description |
---|---|---|
taille | UInt | taille totale de la section |
décalages | uint[] | Tableau de décalages indexés par class_idx .
Une entrée de tableau nulle à l'index class_idx signifie que soit
aucune donnée n'est disponible pour ce class_idx , ni pour toutes les API masquées
sont nuls.
Sinon, l'entrée du tableau n'est pas nulle et contient un décalage par rapport à
au début de la section, un tableau d'indicateurs d'API masqués
pour ce class_idx .
|
indicateurs | uleb128[] | des tableaux concaténés d'indicateurs d'API masqués pour chaque classe. Les valeurs d'indicateur possibles sont décrites dans le tableau ci-dessous. Les options sont encodées dans le même ordre que les champs et les méthodes encodées dans les données de classe. |
Types d'indicateurs de restriction:
Nom | Valeur | Description |
---|---|---|
liste blanche | 0 | Les interfaces pouvant être utilisées librement et prises en charge dans le cadre le framework Android officiellement documenté Index des packages. |
liste grise | 1 | Interfaces autres que SDK pouvant être utilisées quelle que soit la niveau d'API cible. |
ajouter à la liste noire | 2 | Les interfaces non SDK qui ne peuvent pas être utilisées quelle que soit la niveau d'API cible. L'accès à l'une de ces interfaces entraîne Erreur d'exécution. |
liste grise-max-o | 3 | Interfaces non SDK compatibles avec Android 8.x et versions antérieures à moins qu'elles ne soient soumises à des restrictions. |
liste grise-max-p | 4 | Interfaces non SDK compatibles avec Android 9.x à moins qu'elles ne soient soumises à des restrictions. |
liste grise-max-q | 5 | Interfaces non SDK compatibles avec Android 10.x à moins qu'elles ne soient soumises à des restrictions. |
liste grise-max-r | 6 | Interfaces non SDK compatibles avec Android 11.x à moins qu'elles ne soient soumises à des restrictions. |
Annotations système
Les annotations système sont utilisées pour représenter divers éléments de réflexion des informations sur les classes (ainsi que les méthodes et les champs). Ces informations sont généralement accessibles uniquement indirectement par du code client (autre que le code système).
Les annotations système sont représentées dans les fichiers .dex
sous la forme
annotations dont la visibilité est définie sur VISIBILITY_SYSTEM
.
dalvik.annotation.AnnotationDefault
Apparaît sur les méthodes dans les interfaces d'annotation
Une annotation AnnotationDefault
est associée à chaque
qui permet d'indiquer les liaisons par défaut.
Nom | Format | Description |
---|---|---|
value | Annotation | les liaisons par défaut pour cette annotation, représentées par une annotation de ce type. L'annotation ne doit pas nécessairement inclure tous les noms définis par annotation; les noms manquants n'ont tout simplement pas de valeurs par défaut. |
dalvik.annotation.EnifyingClass
Figure dans les cours
Une annotation EnclosingClass
est associée à chaque classe
qui est soit défini comme membre d'une autre classe en soi, soit
anonyme mais non définie dans le corps d'une méthode (par exemple, un objet
classe interne). Chaque classe comportant cette annotation doit également avoir une
Annotation InnerClass
. De plus, une classe ne doit pas comporter
à la fois un EnclosingClass
et un
Annotation EnclosingMethod
.
Nom | Format | Description |
---|---|---|
value | Classe | classe qui se rapproche le plus de cette classe de façon lexicale |
dalvik.annotation.EnifyingMethod
Figure dans les cours
Une annotation EnclosingMethod
est associée à chaque classe
définie dans un corps de méthode. Toutes les classes qui l'incluent
doit également comporter une annotation InnerClass
.
De plus, une classe ne doit pas être associée à la fois à un élément EnclosingClass
et une annotation EnclosingMethod
.
Nom | Format | Description |
---|---|---|
value | Méthode | la méthode qui se rapproche le plus de cette classe |
dalvik.annotation.InnerClass
Figure dans les cours
Une annotation InnerClass
est associée à chaque classe
qui est défini dans le champ d'application
lexical de la définition d'une autre classe.
Toute classe comportant cette annotation doit également être associée à l'un des attributs
Annotation EnclosingClass
ou une
Annotation EnclosingMethod
.
Nom | Format | Description |
---|---|---|
nom | Chaîne | nom simple initialement déclaré à l'origine pour cette classe (à l'exclusion des
préfixe de package). Si ce cours est anonyme, le nom est
null
|
AccessFlags | int | les indicateurs d'accès initialement déclarés de la classe (qui peuvent différer des indicateurs effectifs en raison d'une non-concordance entre l'exécution des modèles de la langue source et de la machine virtuelle cible) |
dalvik.annotation.MemberClasses
Figure dans les cours
Une annotation MemberClasses
est associée à chaque classe.
qui déclare des classes de membres. (Une classe de membre est une classe interne directe
qui a un nom.)
Nom | Format | Description |
---|---|---|
value | Classe[] | tableau des classes de membres |
dalvik.annotation.MethodParameters
Apparaît sur les méthodes
Remarque:Cette annotation a été ajoutée après qu'Android 7.1. Sa présence sur les versions antérieures d'Android sera ignorée.
Une annotation MethodParameters
est facultative et peut être utilisée pour
fournissent des métadonnées de paramètres telles que des noms et des modificateurs de paramètres.
L'annotation peut être omise d'une méthode ou d'un constructeur en toute sécurité lorsque la méthode
les métadonnées de paramètre n'est pas requise au moment de l'exécution.
java.lang.reflect.Parameter.isNamePresent()
peut être utilisé pour vérifier
la présence ou non de métadonnées pour un paramètre et la réflexion associée ;
des méthodes telles que java.lang.reflect.Parameter.getName()
au comportement par défaut lors de l'exécution
si les informations ne sont pas présentes.
Lorsqu'ils incluent des métadonnées de paramètre, les compilateurs doivent inclure des informations pour les classes générées telles que les énumérations, car les métadonnées de paramètre indique si un paramètre est synthétique ou obligatoire.
Une annotation MethodParameters
ne décrit qu'une méthode individuelle
paramètres. Par conséquent, les compilateurs peuvent omettre complètement l'annotation
pour les constructeurs et les méthodes sans paramètres, par souci de taille du code
et l'efficacité de l'exécution.
Les tableaux documentés ci-dessous doivent avoir la même taille que pour le
method_id_item
structure dex associée à la méthode, sinon
une java.lang.reflect.MalformedParametersException
est générée
de l'environnement d'exécution.
Par exemple: method_id_item.proto_idx
->
proto_id_item.parameters_off
->
type_list.size
doit être identique à names().length
et
accessFlags().length
Comme MethodParameters
décrit toutes les méthodes formelles,
des paramètres, même ceux qui ne sont pas explicitement déclarés ou implicitement dans le code source,
la taille des tableaux peut différer de la signature ou d'autres métadonnées
Informations basées uniquement sur des paramètres explicites déclarés dans la source
du code source. MethodParameters
n'inclura pas non plus d'informations sur
Paramètres du récepteur d'annotations de type qui n'existent pas dans la méthode réelle
signature.
Nom | Format | Description |
---|---|---|
noms | String[] | Noms des paramètres formels pour la méthode associée. Le tableau
ne doit pas être nulle, mais doit être vide en l'absence de paramètres formels. Une valeur de
le tableau doit être nul si le paramètre formel avec cet index n'a pas de nom. Si les chaînes de nom de paramètre sont vides ou contiennent les caractères ".", ";" et "[" ou "/" puis un java.lang.reflect.MalformedParametersException sera générée sur
de l'environnement d'exécution.
|
AccessFlags | int[] | Les indicateurs d'accès des paramètres formels pour la méthode associée. La
Le tableau ne doit pas être nul, mais doit être vide en l'absence de paramètres formels. La valeur est un masque de bits avec les valeurs suivantes: <ph type="x-smartling-placeholder">
java.lang.reflect.MalformedParametersException est généré au moment de l'exécution.
|
dalvik.annotation.Signature
Apparaît sur les classes, les champs et les méthodes
Une annotation Signature
est associée à chaque classe.
ou méthode dont le type est plus complexe
que celle-ci est représentable par un type_id_item
. La
Le format .dex
ne définit pas le format des signatures. cette
sert simplement à représenter les signatures d'une source
de langage pour une mise en œuvre réussie
la sémantique. Par conséquent, les signatures ne sont généralement pas analysées (ni validées)
par les implémentations de machines virtuelles. Il suffit de remettre les signatures
vers des API et des outils de niveau supérieur (tels que les débogueurs). Toute utilisation d'un
votre signature doit donc être rédigée de manière à ne pas faire
des hypothèses concernant la réception uniquement de signatures valides, protégeant explicitement
contre la possibilité d'obtenir un code syntaxique
signature non valide.
Les chaînes de signature ayant tendance
à avoir beaucoup de contenu en double,
une annotation Signature
est définie comme un tableau
des chaînes, où les éléments dupliqués font naturellement référence au même
données sous-jacentes, et la signature est considérée comme la concaténation de
toutes les chaînes
du tableau. Il n'y a pas de règles
sur la façon d'extraire
une signature en chaînes distinctes ; dépend entièrement
qui génèrent des fichiers .dex
.
Nom | Format | Description |
---|---|---|
value | String[] | la signature de cette classe ou de ce membre, sous la forme d'un tableau de chaînes doit être concaténé |
dalvik.annotation.jets
Apparaît sur les méthodes
Une annotation Throws
est associée à chaque méthode
déclaré pour générer un ou plusieurs types d'exceptions.
Nom | Format | Description |
---|---|---|
value | Classe[] | le tableau des types d'exception générés |