dex文件解析(第三篇)「建议收藏」

Hello World!

F:\>dexdump -d -l plain TestMain.dex
Processing 'TestMain.dex'...
Opened 'TestMain.dex', DEX version '035'
Class #0 -
  Class descriptor  : 'LTestMain;'
  Access flags      : 0x0001 (PUBLIC)
  Superclass        : 'Ljava/lang/Object;'
  Interfaces        -
  Static fields     -
  Instance fields   -
    #0 : (in LTestMain;)
      name          : 'mX'
      type          : 'I'
      access        : 0x0001 (PUBLIC)
  Direct methods    -
    #0 : (in LTestMain;)
      name          : '<init>'
      type          : '()V'
      access        : 0x10001 (PUBLIC CONSTRUCTOR)
      code          -
      registers     : 2
      ins           : 1
      outs          : 1
      insns size    : 7 16-bit code units
00015c:                                        |[00015c] TestMain.<init>:()V
00016c: 7010 0400 0100                         |0000: invoke-direct {v1}, Ljava/lang/Object;.<init>:()V // method@0004
000172: 1200                                   |0003: const/4 v0, #int 0 // #0
000174: 5910 0000                              |0004: iput v0, v1, LTestMain;.mX:I // field@0000
000178: 0e00                                   |0006: return-void       catches       : (none)
      positions     :
        0x0000 line=11
        0x0003 line=3
        0x0006 line=12
      locals        :
        0x0000 - 0x0007 reg=1 this LTestMain;

    #1 : (in LTestMain;)
      name          : 'main'
      type          : '([Ljava/lang/String;)V'
      access        : 0x0009 (PUBLIC STATIC)
      code          -
      registers     : 4
      ins           : 1
      outs          : 2
      insns size    : 16 16-bit code units
00017c:                                        |[00017c] TestMain.main:([Ljava/lang/String;)V
00018c: 2200 0100                              |0000: new-instance v0, LTestMain; // type@0001
000190: 7010 0000 0000                         |0002: invoke-direct {v0}, LTestMain;.<init>:()V // method@0000
000196: 6e10 0200 0000                         |0005: invoke-virtual {v0}, LTestMain;.test:()V // method@0002
00019c: 6201 0100                              |0008: sget-object v1, Ljava/lang/System;.out:Ljava/io/PrintStream; // field@0001
0001a0: 1a02 0100                              |000a: const-string v2, "Hello World!" // string@0001
0001a4: 6e20 0300 2100                         |000c: invoke-virtual {v1, v2}, Ljava/io/PrintStream;.println:(Ljava/lang/String;)V // method@0003
0001aa: 0e00                                   |000f: return-void       catches       : (none)
      positions     :
        0x0000 line=6
        0x0005 line=7
        0x0008 line=8
        0x000f line=9
      locals        :
        0x0005 - 0x0010 reg=0 testMainObject LTestMain;
        0x0000 - 0x0010 reg=3 args [Ljava/lang/String;

  Virtual methods   -
    #0 : (in LTestMain;)
      name          : 'test'
      type          : '()V'
      access        : 0x0001 (PUBLIC)
      code          -
      registers     : 1
      ins           : 1
      outs          : 0
      insns size    : 1 16-bit code units
0001ac:                                        |[0001ac] TestMain.test:()V
0001bc: 0e00                                   |0000: return-void       catches       : (none)
      positions     :
        0x0000 line=15
      locals        :
        0x0000 - 0x0001 reg=0 this LTestMain;

  source_file_idx   : 8 (TestMain.java)

struct DexFile {
    /* directly-mapped "opt" header */
    const DexOptHeader* pOptHeader;
    /* pointers to directly-mapped structs and arrays in base DEX */
    const DexHeader*    pHeader;
    const DexStringId*  pStringIds;
    const DexTypeId*    pTypeIds;
    const DexFieldId*   pFieldIds;
    const DexMethodId*  pMethodIds;
    const DexProtoId*   pProtoIds;
    const DexClassDef*  pClassDefs;
    const DexLink*      pLinkData;
};

typedef uint8_t             u1;
typedef uint16_t            u2;
typedef uint32_t            u4;
typedef uint64_t            u8;
typedef int8_t              s1;
typedef int16_t             s2;
typedef int32_t             s4;
typedef int64_t             s8;

struct DexHeader {
    u1  magic[8]; /* includes version number */
    u4  checksum; /* adler32 checksum */
    u1  signature[kSHA1DigestLen]; /* SHA-1 hash */
    u4  fileSize; /* length of entire file */
    u4  headerSize; /* offset to start of next section */
    u4  endianTag;
    u4  linkSize;
    u4  linkOff;
    u4  mapOff;
    u4  stringIdsSize;
    u4  stringIdsOff;
    u4  typeIdsSize;
    u4  typeIdsOff;
    u4  protoIdsSize;
    u4  protoIdsOff;
    u4  fieldIdsSize;
    u4  fieldIdsOff;
    u4  methodIdsSize;
    u4  methodIdsOff;
    u4  classDefsSize;
    u4  classDefsOff;
    u4  dataSize;
    u4  dataOff;
};

struct DexMapList {  
    u4     size;                                   // DexMapItem 的个数 
    DexMapItem     list[1];               // DexMapItem 结构 
};  

struct DexMapItem  
{  
    u2     type;                    // kDexType 开头的类型 
    u2     unused;               // 未使用，用于对齐 
    u4     size;                     // 指定类型的个数 
    u4     offset;                 // 指定类型数据的文件偏移 
};  

enum  
{  
    kDexTypeHeaderItem = 0x0000,    // 对应 DexHeader 
    kDexTypeStringIdItem = 0x0001,  // 对应 stringIdsSize 与 stringIdsOff 字段 
    kDexTypeTypeIdItem = 0x0002,    // 对应 typeIdsSize 与 typeIdsOff 字段 
    kDexTypeProtoIdItem = 0x0003,   // 对应 protoIdsSize 与 protoIdsOff 字段 
    kDexTypeFieldIdItem = 0x0004,   // 对应 fieldIdsSize 与 fieldIdsOff 字段 
    kDexTypeMethodIdItem = 0x0005,  // 对应 methodIdsSize 与 methodIdsOff 字段 
    kDexTypeClassDefItem = 0x0006,  // 对应 classDefsSize 与 classDefsOff 字段 
    kDexTypeMapList = 0x1000,       
    kDexTypeTypeList = 0x1001,       
    kDexTypeAnnotationSetRefList = 0x1002,       
    kDexTypeAnnotationSetItem = 0x1003,       
    kDexTypeClassDataItem = 0x2000,       
    kDexTypeCodeItem = 0x2001,       
    kDexTypeStringDataItem = 0x2002,       
    kDexTypeDebugInfoItem = 0x2003,       
    kDexTypeAnnotationItem = 0x2004,      
    kDexTypeEncodeArrayItem = 0x2005,      
    kDexTypeAnnotationsDirectoryItem = 0x2006  
};  

typedef struct _DexStringId {  
    u4  stringDataOff;                  // 指向 MUTF-8 字符串的偏移 
}DexStringId, *PDexStringId;  

typedef struct _DexTypeId {  
    u4     descriptorIdx;   // 指向 DexStringId 列表的索引 
}DexTypeId, *PDexTypeId;  

typedef struct _DexProtoId {  
    u4  shortyIdx;          // 方法声明字符串，指向 DexStringId 列表的索引 
    u4  returnTypeIdx;      // 方法返回类型字符串，指向 DexStringId 列表的索引 
    u4  parametersOff;      // 方法的参数列表，指向 DexTypeList 结构体的偏移 
}DexProtoId, *PDexProtoId; 

typedef struct _DexTypeList {  
    u4  size;               // 接下来 DexTypeItem 的个数 
    DexTypeItem* list;      // DexTypeItem 结构 
}DexTypeList, *PDexTypeList;  

typedef struct _DexTypeItem {  
    u2  typeIdx;            // 指向 DexTypeId 列表的索引 
}DexTypeItem, *PDexTypeItem;

typedef struct _DexFieldId {  
    u2  classIdx;           // 类的类型，指向 DexTypeId 列表的索引 
    u2  typeIdx;            // 字段的类型，指向 DexTypeId 列表的索引 
    u4  nameIdx;            // 字段名，指向 DexStringId 列表的索引 
}DexFieldId, *PDexFieldId;  

typedef struct _DexMethodId {  
    u2  classIdx;           // 类的类型，指向 DexTypeId 列表的索引 
    u2  protoIdx;           // 声明的类型，指向 DexProtoId 列表的索引 
    u4  nameIdx;            // 方法名，指向 DexStringId 列表的索引 
}DexMethodId, *PDexMethodId;  

typedef struct _DexClassDef {  
    u4     classIdx;                 // 类的类型，指向 DexTypeId 列表的索引 
    u4     accessFlags;              // 访问标志 
    u4     superclassIdx;            // 父类类型，指向 DexTypeId 列表的索引 
    u4     interfacesOff;            // 接口，指向 DexTypeList 的偏移，否则为0 
    u4     sourceFileIdx;            // 源文件名，指向 DexStringId 列表的索引 
    u4     annotationsOff;           // 注解，指向 DexAnnotationsDirectoryItem 结构，或者为 0 
    u4     classDataOff;             // 指向 DexClassData 结构的偏移，类的数据部分 
    u4     staticValuesOff;          // 指向 DexEncodedArray 结构的偏移，记录了类中的静态数据，主要是静态方法 
}DexClassDef, *PDexClassDef;  

typedef struct _DexClassData {  
    DexClassDataHeader      header;             // 指定字段与方法的个数 
    DexField*               staticFields;       // 静态字段，DexField 结构 
    DexField*               instanceFields;     // 实例字段，DexField 结构 
    DexMethod*              directMethods;      // 直接方法，DexMethod 结构 
    DexMethod*              virtualMethods;     // 虚方法，DexMethod 结构 
}DexClassData, *PDexClassData;  

typedef struct _DexClassDataHeader {  
    uleb128 staticFieldsSize;                   // 静态字段个数 
    uleb128 instanceFieldsSize;                 // 实例字段个数 
    uleb128 directMethodsSize;                  // 直接方法个数 
    uleb128 virtualMethodsSize;                 // 虚方法个数 
}DexClassDataHeader, *PDexClassDataHeader;  

typedef struct _DexField {  
    uleb128 fieldIdx;           // 指向 DexFieldId 的索引 
    uleb128 accessFlags;        // 访问标志 
}DexField, *PDexField;  

typedef struct _DexMethod {  
    uleb128 methodIdx;          // 指向 DexMethodId 的索引 
    uleb128 accessFlags;        // 访问标志 
    uleb128 codeOff;            // 指向 DexCode 结构的偏移 
}DexMethod, *PDexMethod;  

typedef struct _DexCode {  
    u2  registersSize;          // 使用的寄存器个数 
    u2  insSize;                // 参数个数 
    u2  outsSize;               // 调用其他方法时使用的寄存器个数 
    u2  triesSize;              // Try/Catch 个数 
    u4  debbugInfoOff;          // 指向调试信息的偏移 
    u4  insnsSize;              // 指令集个数，以 2 字节为单位 
    u2* insns;                  // 指令集 
}DexCode, *PDexCode;  

struct DexStringId {
    u4 stringDataOff;      /* file offset to string_data_item */
};

struct DexLink {
    u1  bleargh;
};

typedef struct Object {
    /* ptr to class object */
    ClassObject*    clazz;

    /*
     * A word containing either a "thin" lock or a "fat" monitor.  See
     * the comments in Sync.c for a description of its layout.
     */
    u4              lock;
} Object;

struct DataObject {
    Object          obj;                /* MUST be first item */
    /* variable #of u4 slots; u8 uses 2 slots */
    u4              instanceData[1];
};
struct StringObject {
    Object          obj;                /* MUST be first item */
    /* variable #of u4 slots; u8 uses 2 slots */
    u4              instanceData[1];
};

struct StringObject {
    /* ptr t o class object */
	ClassObject*  clazz ;
    /* variable #of u4 slots; u8 uses 2 slots */
    u4   lock;
    u4              instanceData[1]; };