Dex文件初探

太过爱你忘了你带给我的痛 2022-05-29 06:37 243阅读 0赞

Dex文件是手机上类似Windows上的EXE文件，dex文件是可以直接在Dalvik虚拟机中加载运行的文件。

首先我们来生成一个Dex文件。

新建文件Hello.java内容如下：

class Hello\{  
    public static void main(String\[\] argc)\{  
        System.out.println(“Hello!”);  
    \}  
\}

javac Hello.java

dx –dex –output=Hello.dex Hello.class

这样就在当前目录下面生成了一个dex文件。

编译的时候注意Java和Android默认的jdk版本要一致，否则会出错。

Dex总体文件结构图如下：

[![clip\_image001][clip_image001]][clip_image001_clip_image001]

下面 ，对应到刚刚生成的dex文件来分析：

首先是文件头：

Dex文件头主要包括校验和以及其他结构的偏移地址和长度信息。

[![image][]][image 1]

为了方便查看，使用010 Editor打开刚刚生成的Dex文件，在官网下载一个Dex模板的脚本，然后运行。

[![image][image 2]][image_image 2]

#### 魔数字段： ####

Dex文件标志符’dex\\n’ ,它的作用主要是用来标志dex文件的。跟在dex后面的是版本号，目前支持的版本号为035\\0 。

#### 校验码： ####

主要用来检查这个字段开始到文件结尾，这段数据是否完整。使用zlib 的adler32 所计算的32-bitsCheckSum . 计算的范围为DEX 文件的长度（Header->fileSize) 减去8bytes Magic Code 与4bytes CheckSum 的范围. 用来确保DEX 文件内容没有损毁.

#### SHA-1签名字段： ####

dex文件头里，前面已经有了面有一个4字节的检验字段码了，为什么还会有SHA-1签名字段呢？不是重复了吗？可是仔细考虑一下，这样设计自有道理。因 为dex文件一般都不是很小，简单的应用程序都有几十K，这么多数据使用一个4字节的检验码，重复的机率还是有的，也就是说当文件里的数据修改了，还是很 有可能检验不出来的。这时检验码就失去了作用，需要使用更加强大的检验码，这就是SHA-1。SHA-1校验码有20个字节，比前面的检验码多了16个字 节，几乎不会不同的文件计算出来的检验是一样的。设计两个检验码的目的，就是先使用第一个检验码进行快速检查，这样可以先把简单出错的dex文件丢掉了， 接着再使用第二个复杂的检验码进行复杂计算，验证文件是否完整，这样确保执行的文件完整和安全。

#### file\_size： ####

文件的总大小

#### header\_size： ####

DexHeader的大小，0x70bytes。

#### endian\_tag： ####

预设值为Little-Endian, 在这栏位会显示32bits 值”0×12345678。

在Big-Endian 处理器上, 会转为“ 0×78563412。

是link\_size和link\_off字段，主要用在文件的静态链接上，该dex不是静态链接文件，所有为0。

#### map\_off字段： ####

这个字段主要保存map开始位置，就是从文件头开始到map数据的长度，通过这个索引就可以找到map数据。

[![image][image 3]][image_image 3]

map数据排列结构定义如下：

/*
    *Direct-mapped "map_list".
    */   typedef struct DexMapList {
        u4 size; /* #of entries inlist */
        DexMapItem list[1]; /* entries */
    }DexMapList;

每一个map项的结构定义如下：

/*
    *Direct-mapped "map_item".
    */   typedef struct DexMapItem {
        u2 type; /* type code (seekDexType* above) */
        u2 unused;
        u4 size; /* count of items ofthe indicated type */
        u4 offset; /* file offset tothe start of data */
    }DexMapItem;

DexMapItem结构定义每一项的数据意义：类型、类型个数、类型开始位置。

其中的类型定义如下：

/*map item type codes */
    enum{
        kDexTypeHeaderItem = 0x0000,
        kDexTypeStringIdItem = 0x0001,
        kDexTypeTypeIdItem = 0x0002,
        kDexTypeProtoIdItem = 0x0003,
        kDexTypeFieldIdItem = 0x0004,
        kDexTypeMethodIdItem = 0x0005,
        kDexTypeClassDefItem = 0x0006,
        kDexTypeMapList = 0x1000,
        kDexTypeTypeList = 0x1001,
        kDexTypeAnnotationSetRefList = 0x1002,
        kDexTypeAnnotationSetItem = 0x1003,
        kDexTypeClassDataItem = 0x2000,
        kDexTypeCodeItem = 0x2001,
        kDexTypeStringDataItem = 0x2002,
        kDexTypeDebugInfoItem = 0x2003,
        kDexTypeAnnotationItem = 0x2004,
        kDexTypeEncodedArrayItem = 0x2005,
        kDexTypeAnnotationsDirectoryItem = 0x2006,
    };

从上面的类型可知，它包括了在dex文件里可能出现的所有类型。可以看出这里的类型与文件头里定义的类型有很多是一样的，这里的类型其实就是文件头里定义 的类型。其实这个map的数据，就是头里类型的重复，完全是为了检验作用而存在的。当Android系统加载dex文件时，如果比较文件头类型个数与 map里类型不一致时，就会停止使用这个dex文件。

该dex文件的map\_off = 0x24c，而便宜为0x24c的位置值为0x00d。也就是有13项！每项12个字节，所以整个map\_list所占空间为12\*13+4 = 160 = 0x00a0，范围为0x24c – 0x2ec.也就是到文件结尾的位置。

#### string\_ids\_size/off字段： ####

这两个字段主要用来标识字符串资源。源程序编译后，程序里用到的字符串都保存在这个数据段里，以便解释执行这个dex文件使用。其中包括调用库函数里的类名称描述，用于输出显示的字符串等。

string\_ids\_size标识了有多少个字符串，string\_ids\_off标识字符串数据区的开始位置。字符串的存储结构如下：

/*
     * Direct-mapped "string_id_item".
     */
    typedef struct DexStringId {
        u4  stringDataOff;      /* file offset to string_data_item */
    } DexStringId;

可以看出这个数据区保存的只是字符串表的地址索引。如果要找到字符串的实际数据，还需要通过个地址索引找到文件的相应开始位置，然后才能得到字符串数据。 每一个字符串项的索引占用4个字节，因此这个数据区的大小就为4\*string\_ids\_size。实际数据区中的字符串采用UTF8格式保存。

上面我们看到size为0×10，off为0×70。  也就是有16个字符串，每个索引占4个字节，也就是从0×70开始的16\*4=64个字节是字符串的索引。

来到0×70处，看到第一个索引为0x17E，来到0x17E处。

[![image][image 4]][image_image 4]

16进制显示出来内容如下：  
063c 696e 6974 3e00  
其实际数据则是”<init>\\0”

另外这段数据中不仅包括字符串的字符串的内容和结束标志，在最开头的位置还标明了字符串的长度。上例中第一个字节06就是表示这个字符串有6个字符。

关于字符串的长度有两点需要注意的地方：

1、关于长度的编码格式

dex文件里采用了变长方式表示字符串长度。一个字符串的长度可能是一个字节（小于256）或者4个字节（1G大小以上）。字符串的长度大多数都是小于 256个字节，因此需要使用一种编码，既可以表示一个字节的长度，也可以表示4个字节的长度，并且1个字节的长度占绝大多数。能满足这种表示的编码方式有很多，但dex文件里采用的是uleb128方式。leb128编码是一种变长编码，每个字节采用７位来表达原来的数据，最高位用来表示是否有后继字节。若第一个 Byte 的最高位为 1 ，则表示还需要下一个 Byte 来描述 ，直至最后一个 Byte 的最高位为 0 。每个 Byte 的其余 Bit 用来表示数据 ，如下表所示 。

[![image][image 5]][image_image 5]

它的编码算法如下：

/*
     * Writes a 32-bit value in unsigned ULEB128 format.
     * Returns the updated pointer.
     */
    DEX_INLINE u1* writeUnsignedLeb128(u1* ptr, u4 data)
    {
        while (true) {
            u1 out = data & 0x7f;
            if (out != data) {
                *ptr++ = out | 0x80;
                data >>= 7;
            } else {
                *ptr++ = out;
                break;
            }
        }
        return ptr;
    }

它的解码算法如下：

/*
     * Reads an unsigned LEB128 value, updating the given pointer to point
     * just past the end of the read value. This function tolerates
     * non-zero high-order bits in the fifth encoded byte.
     */
    DEX_INLINE int readUnsignedLeb128(const u1** pStream) {
        const u1* ptr = *pStream;
        int result = *(ptr++);
       if (result > 0x7f) {
            int cur = *(ptr++);
            result = (result & 0x7f) | ((cur & 0x7f) << 7);
            if (cur > 0x7f) {
                cur = *(ptr++);
                result |= (cur & 0x7f) << 14;
                if (cur > 0x7f) {
                    cur = *(ptr++);
                    result |= (cur & 0x7f) << 21;
                    if (cur > 0x7f) {
                        /*
                         * Note: We don't check to see if cur is out of
                         * range here, meaning we tolerate garbage in the
                         * high four-order bits.
                         */
                        cur = *(ptr++);
                        result |= cur << 28;
                    }
                }
            }
        }
        *pStream = ptr;
        return result;
    }

根据上面的算法分析上面例子字符串，取得第一个字节是06，最高位为0，因此没有后继字节，那么取出这个字节里7位有效数据，就是6，也就是说这个字符串是6个字节，但不包括结束字符“\\0”。

2、关于长度的意义

由于字符串内容采用的是UTF-8格式编码，表示一个字符的字节数是不定的。即有时是一个字节表示一个字符，有时是两个、三个甚至四个字节表示一个字符。 而这里的长度代表的并不是整个字符串所占用的字节数，表示这个字符串包含的字符个数。所以在读取时需要注意，尤其是在包含中文字符时，往往会因为读取的长 度不正确导致字符串被截断。

#### type\_ids\_size/off字段： ####

type\_ids 区索引了 .dex 文件里的所有数据类型 ，包括 class 类型 ，数组类型（array types）和基本类型(primitive types) 。 本区域里的元素格式为type\_ids\_item , 结构描述如下 ：  
struct type\_ids\_item  
\{  
uint descriptor\_idx;  
\}  
type\_ids\_item 里面 descriptor\_idx 的值的意思 ，是 string\_ids 里的 index 序号 ，是用来描述此type 的字符串 。  
根据 header 里 type\_ids\_size = 0×07 , type\_ids\_off = 0xb0 , 找到对应的二进制描述区 。

03 00 00 00 04 00 00 00  05 00 00 00 06 00 00 00  
07 00 00 00 08 00 00 00  0A 00 00 00

分别对应：

[![image][image 6]][image_image 6]

#### proto\_ids\_size/off字段： ####

proto 的意思是 method prototype 代表 java 语言里的一个 method 的原型 。proto\_ids 里元素为 proto\_id\_item , 结构如下 。  
uint 32-bit unsigned int, little-endian  
struct proto\_id\_item  
\{  
uint shorty\_idx;  
uint return\_type\_idx;  
uint parameters\_off;  
\}

shorty\_idx , 跟 type\_ids 一样 ，它的值是一个 string\_ids 的 index 号 ，最终是一个简短的字符串描述 ，用来说明该 method 原型 。

return\_type\_idx , 它的值是一个 type\_ids 的 index 号 ，表示该 method 原型的返回值类型 。  
parameters\_off , 后缀 off 是 offset , 指向 method 原型的参数列表 type\_list ; 若 method 没有参数 ，值为0 。参数列表的格式是 type\_list ，结构从逻辑上如下描述 。

size 表示参数的个数 ；type\_idx 是对应参数的类型 ，它的值是一个 type\_ids 的 index 号 ，跟 return\_type\_idx 是同一个品种的东西 。  
uint 32-bit unsigned int, little-endian  
ushort 16-bit unsigned int, little-endian  
struct type\_list  
\{  
uint size;  
ushort type\_idx\[size\];  
\}  
header 里 proto\_ids\_size = 0×03 , proto\_ids\_off = 0xcc , 它的二进制描述区如下 ：

08 00 00 00 05 00 00 00 00 00 00 00      V V 无参数

09 00 00 00 05 00 00 00 70 01 00 00      VL V 参数偏移0×170

09 00 00 00  05 00 00 00 78 01 00 00     VL V 参数偏移0×178

0×170:

01 00 00 00 03 00     一个参数   Ljava/lang/String;

0×178

01 00 00 00 06 00     一个参数   \[Ljava/lang/String;

#### field\_ids\_size/off字段： ####

filed\_ids 区里面有被本 .dex 文件引用的所有的 field 。本区的元素格式是 field\_id\_item ，逻辑结构描述如下：

ushort 16-bit unsigned int, little-endian  
uint 32-bit unsigned int, little-endian  
struct filed\_id\_item  
\{  
ushort class\_idx;  
ushort type\_idx;  
uint name\_idx;  
\}

class\_idx , 表示本 field 所属的 class 类型 , class\_idx 的值是 type\_ids 的一个 index ， 并且必须指向一个class 类型 。  
type\_idx , 表示本 field 的类型 ，它的值也是 type\_ids 的一个 index 。  
name\_idx , 表示本 field 的名称 ，它的值是 string\_ids 的一个 index 。

header 里 field\_ids\_size = 1 , field\_ids\_off = 0xf0 。说明本 .dex 只有一个 field ，这部分的二进制描述如下 ：

04 00 01 00 0D 00 00 00      Ljava/lang/System;     Ljava/io/PrintStram;     out

**method\_ids\_size/off字段：**

method\_ids 是索引区的最后一个条目,它索引了 .dex 文件里的所有的 method.  
method\_ids 的元素格式是 method\_id\_item ， 结构跟 fields\_ids 很相似：  
ushort 16-bit unsigned int, little-endian  
uint 32-bit unsigned int, little-endian  
struct filed\_id\_item  
\{  
ushort class\_idx;  
ushort proto\_idx;  
uint name\_idx;  
\}

class\_idx , 表示本 method 所属的 class 类型 , class\_idx 的值是 type\_ids 的一个 index ， 并且必须指向一个 class 类型 。  
name\_idx , 表示本 method 的名称 ，它的值是 string\_ids 的一个 index 。  
proto\_idx 描述该 method 的原型 ，指向 proto\_ids 的一个 index 。

header 里 method\_ids\_size = 0×04 , method\_ids\_off = 0xf8 。本部分的二进制描述如下 ：

00 00 00 00 00 00 00 00       LHello;          V()V    <init>  
00 00 02 00 0C 00 00 00       LHello;          VL(\[Ljava/lang/String;)V         main

01 00 01 00 0E 00 00 00       Ljava/io/PrintStram;      VL(Ljava/lang/String;)V        println  
02 00 00 00 00 00 00 00       Ljava/lang/Object;    V()V        <init>

对 .dex 反汇编的时候 ，常用的 method 表示方法是这种形式 :  
Lpackage/name/ObjectName;->MethodName(III)Z

将上面可整理为：

LHello;-><init>()V

LHello;->main(\[Ljava/lang/String;)V

Ljava/io/PrintStram;->println(Ljava/lang/String;)V

Ljava/lang/Object;->init()V

至此 ，索引区的内容描述完毕 ，包括 string\_ids , type\_ids，proto\_ids , field\_ids , method\_ids 。每个索引  
区域里存放着指向具体数据的偏移地址 （如 string\_ids ) ， 或者存放的数据是其它索引区域里面的 index 号。

#### class\_def\_size/off字段： ####

从字面意思解释 ，class\_defs 区域里存放着 class definitions , class 的定义 。它的结构较 .dex 区都要复杂些 ,  
因为有些数据都直接指向了 data 区里面 。  
class\_defs 的数据格式为 class\_def\_item ， 结构描述如下 ：  
uint 32-bit unsigned int, little-endian  
struct class\_def\_item  
\{  
uint class\_idx;  
uint access\_flags;  
uint superclass\_idx;  
uint interfaces\_off;

uint source\_file\_idx;  
uint annotations\_off;  
uint class\_data\_off;  
uint static\_value\_off;  
\}

(1) class\_idx 描述具体的 class 类型 ，值是 type\_ids 的一个 index 。值必须是一个 class 类型 ，不能是数组类型或者基本类型 。  
(2) access\_flags 描述 class 的访问类型 ，诸如 public , final , static 等 。

(3) superclass\_idx , 描述 supperclass 的类型 ，值的形式跟 class\_idx 一样 。  
(4) interfaces\_off , 值为偏移地址 ，指向 class 的 interfaces , 被指向的数据结构为 type\_list 。class 若没有  
interfaces ,值为 0。  
(5) source\_file\_idx , 表示源代码文件的信息 ，值是 string\_ids 的一个 index 。若此项信息缺失 ，此项值赋值为  
NO\_INDEX=0xffff ffff 。  
(6) annotions\_off , 值是一个偏移地址 ，指向的内容是该 class 的注释 ，位置在 data 区，格式为annotations\_direcotry\_item 。若没有此项内容 ，值为 0 。  
(7) class\_data\_off , 值是一个偏移地址 ，指向的内容是该 class 的使用到的数据 ，位置在 data 区，格式为class\_data\_item 。若没有此项内容 ，值为 0 。该结构里有很多内容 ，详细描述该 class 的 field ， method, method 里的执行代码等信息 。  
(8) static\_value\_off , 值是一个偏移地址 ，指向 data 区里的一个列表 ( list ) ，格式为 encoded\_array\_item。若没有此项内容 ，值为 0 。

header 里 class\_defs\_size = 0×01 , class\_defs\_off = 0x 0118 。则此段二进制描述为 ：

00 00 00 00     LHello;

00 00 00 00     无，默认包访问权限  
02 00 00 00      Ljava/lang/Object;

00 00 00 00      无接口

02 00 00 00      Hello.java

00 00 00 00      无注解  
3E 02 00 00     0x23E

00 00 00 00     无

#### class\_data\_item： ####

class\_data\_off 指向 data 区里的 class\_data\_item 结构 ,class\_data\_item 里存放着本 class 使用到的各种数  
据 ，下面是 class\_data\_item 的逻辑结构 ：

uleb128 unsigned little-endian base 128  
struct class\_data\_item  
\{  
uleb128 static\_fields\_size;  
uleb128 instance\_fields\_size;  
uleb128 direct\_methods\_size;  
uleb128 virtual\_methods\_size;  
encoded\_field static\_fields \[ static\_fields\_size \];  
encoded\_field instance\_fields \[ instance\_fields\_size \];  
encoded\_method direct\_methods \[ direct\_method\_size \];  
encoded\_method virtual\_methods \[ virtual\_methods\_size \];  
\}

encoded\_field 的结构如下 ：  
struct encoded\_field  
\{  
uleb128 filed\_idx\_diff; // index into filed\_ids for ID of this filed  
uleb128 access\_flags; // access flags like public, static etc.  
\}

encoded\_method 的结构如下 ：  
struct encoded\_method  
\{  
uleb128 method\_idx\_diff;  
uleb128 access\_flags;  
uleb128 code\_off;

（1）method\_idx\_diff , 前缀 methd\_idx 表示它的值是 method\_ids 的一个 index ，后缀 \_diff 表示它是于另外一个 method\_idx 的一个差值 ，就是相对于 encodeed\_method \[\] 数组里上一个元素的 method\_idx 的差值 。  
其实 encoded\_filed – > field\_idx\_diff 表示的也是相同的意思 ，只是编译出来的 Hello.dex 文件里没有使用到class filed 所以没有仔细讲。

（2）access\_flags ， 访问权限 ， 比如 public、private、static、final 等 。  
（3）code\_off , 一个指向 data 区的偏移地址 ，目标是本 method 的代码实现 。被指向的结构是code\_item ，有近 10 项元素 。

0x23E：

00  static\_fields\_size

00  instance\_fields\_size  
02  direct\_methods\_size

00  virtual\_methods\_size

00 80 80 04 B8 02  01 09 D0 02 0D 00 00 00

名称为 LHello; 的 class 里只有 2 个 directive methods 。 directive\_methods 里的值都是 uleb128 的原始二  
进制值 。按照 directive\_methods 的格式 encoded\_method 再整理一次这 2 个 method 描述 ，得到结果如下  
表格所描述 。method 一个是 <init> , 一个是 main 。

其中两个directive  methods为：

00          LHello;-><init>()V

80 80 04     0×10000        ACC\_CONSTRUCTOR

B8 02    0×0138

01          LHello;->main(\[Ljava/lang/String;)V

09          ACC\_PUBLIC|ACC\_STATIC

D0 02   0×0150

#### class\_def\_item –> class\_data\_item –> code\_item: ####

code\_item 结构里描述着某个 method 的具体实现 。它的结构如下描述 ：

struct code\_item  
\{  
ushort registers\_size;  
ushort ins\_size;  
ushort outs\_size;  
ushort tries\_size;  
uint debug\_info\_off;  
uint insns\_size;  
ushort insns \[ insns\_size \];  
ushort paddding; // optional  
try\_item tries \[ tyies\_size \]; // optional  
encoded\_catch\_handler\_list handlers; // optional  
\}

末尾的 3 项标志为 optional , 表示可能有 ，也可能没有 ，根据具体的代码来 。  
(1) registers\_size, 本段代码使用到的寄存器数目。  
(2) ins\_size, method 传入参数的数目 。  
(3) outs\_size, 本段代码调用其它method 时需要的参数个数 。  
(4) tries\_size, try\_item 结构的个数 。  
(5) debug\_off, 偏移地址 ，指向本段代码的 debug 信息存放位置 ，是一个 debug\_info\_item 结构。  
(6) insns\_size, 指令列表的大小 ，以 16-bit 为单位 。 insns 是 instructions 的缩写 。

(7) padding , 值为 0 ，用于对齐字节 。  
(8) tries 和 handlers ， 用于处理 java 中的 exception , 常见的语法有 try catch 。

那先来分析下main的执行代码，它的code\_off为0×150,对应的二进制代码如下：

03 00   registers\_size

01 00   ins\_size

02 00   outs\_size

00 00   tries\_size

37 02 00 00    debug\_info\_off   0×0237

08 00 00 00    insns\_size    0×08

62 00 00 00 1A 01 01 00  6E 20 02 00 10 00 0E 00      insns

0×0062 0×0000 0x011a 0x 0001 0x 206e 0×0002 0×0010 0x 000e

insns 数组里的 8 个二进制原始数据 ， 对这些数据的解析 ，需要对照官网的文档 《Dalvik VM Instruction Format》和《Bytecode for Dalvik VM》。分析

[http://source.android.com/devices/tech/dalvik/instruction-formats.html][http_source.android.com_devices_tech_dalvik_instruction-formats.html]

[http://source.android.com/devices/tech/dalvik/dalvik-bytecode.html][http_source.android.com_devices_tech_dalvik_dalvik-bytecode.html]

分析思路整理如下:

《Dalvik VM Instruction Format》 里操作符 op 都是位于首个 16bit 数据的低 8 bit ，起始的是 op =0×62。

在 《Bytecode for Dalvik VM》 里找到对应的 Syntax 和 format 。

syntax = sget\_object  
format = 0x21c 。

在《Dalvik VM Instruction Format》里查找 21c ， 得知 op = 0×62 的指令占据 2 个 16 bit 数据 ，格式是 AA|op BBBB ，解释为 op vAA, type@BBBB 。因此这 8 组 16 bit 数据里 ，前 2 个是一组 。对比数据得 AA=0×00, BBBB = 0×0000。

返回《Bytecode for Dalvik VM》里查阅对 sget\_object 的解释， AA 的值表示 Value Register ，即0 号寄存器； BBBB 表示 static field 的 index ，就是之前分析的field\_ids 区里 Index = 0 指向的那个东西,也就是Ljava/lang/System; -> out:Ljava/io/printStream;

所以前两个16bit数据解释为：

前 2 个 16 bit 数据 0x 0062 0000 , 解释为  
sget\_object v0, Ljava/lang/System; -> out:Ljava/io/printStream;

其余的 6 个 16 bit 数据分析思路跟这个一样 ，依次整理如下 ：  
0x011a 0×0001: const-string v1, “Hello!”  
0x206e 0×0002 0×0010:  
invoke-virtual \{v0, v1\}, Ljava/io/PrintStream; -> println(Ljava/lang/String;)V  
0x000e: return-void

所以整个main方法为：

ACC\_PUBLIC ACC\_STATIC LHello;->main(\[Ljava/lang/String;)V  
\{  
sget\_object v0, Ljava/lang/System; -> out:Ljava/io/printStream;  
const-string v1,Hello, Android!  
invoke-virtual \{v0, v1\}, Ljava/io/PrintStream; -> println(Ljava/lang/String;)V  
return-void  
\}

然后再使用baksmali.jar反编译成smali。

.class LHello;  
.super Ljava/lang/Object;  
.source “Hello.java”

\# direct methods  
.method constructor <init>()V  
    .registers 1

.prologue  
    .line 1  
    invoke-direct \{p0\}, Ljava/lang/Object;-><init>()V

return-void  
.end method

.method public static main(\[Ljava/lang/String;)V  
    .registers 3  
    .parameter “argc”

.prologue  
    .line 3  
    sget-object v0, Ljava/lang/System;->out:Ljava/io/PrintStream;

const-string v1, “Hello!”

invoke-virtual \{v0, v1\}, Ljava/io/PrintStream;->println(Ljava/lang/String;)V

.line 4  
    return-void  
.end method

和我们分析的一样。

欢迎入群交流！  QQ群号：191212593

本文链接：[http://www.blogfshare.com/dex-format.html][http_www.blogfshare.com_dex-format.html]

[clip_image001]: http://www.blogfshare.com/wp-content/uploads/images/Android--_11DA9/clip_image001_thumb.png
[clip_image001_clip_image001]: http://www.blogfshare.com/wp-content/uploads/images/Android--_11DA9/clip_image001.png
[image]: http://www.blogfshare.com/wp-content/uploads/images/Android--_11DA9/image_thumb.png
[image 1]: http://www.blogfshare.com/wp-content/uploads/images/Android--_11DA9/image.png
[image 2]: http://www.blogfshare.com/wp-content/uploads/images/Android--_11DA9/image_thumb_3.png
[image_image 2]: http://www.blogfshare.com/wp-content/uploads/images/Android--_11DA9/image_3.png
[image 3]: http://www.blogfshare.com/wp-content/uploads/images/Android--_11DA9/image_thumb_4.png
[image_image 3]: http://www.blogfshare.com/wp-content/uploads/images/Android--_11DA9/image_4.png
[image 4]: http://www.blogfshare.com/wp-content/uploads/images/Android--_11DA9/image_thumb_5.png
[image_image 4]: http://www.blogfshare.com/wp-content/uploads/images/Android--_11DA9/image_5.png
[image 5]: http://www.blogfshare.com/wp-content/uploads/images/Android--_11DA9/image_thumb_6.png
[image_image 5]: http://www.blogfshare.com/wp-content/uploads/images/Android--_11DA9/image_6.png
[image 6]: http://www.blogfshare.com/wp-content/uploads/images/Android--_11DA9/image_thumb_7.png
[image_image 6]: http://www.blogfshare.com/wp-content/uploads/images/Android--_11DA9/image_7.png
[http_source.android.com_devices_tech_dalvik_instruction-formats.html]: http://source.android.com/devices/tech/dalvik/instruction-formats.html
[http_source.android.com_devices_tech_dalvik_dalvik-bytecode.html]: http://source.android.com/devices/tech/dalvik/dalvik-bytecode.html
[http_www.blogfshare.com_dex-format.html]: http://www.blogfshare.com/dex-format.html