ART世界探险(7) - 数组

ART世界探险(7) - 数组

Java针对数据是有专门的指令去处理的，这与C/C++有显著的不同。

Java字节码对于数组的支持

一个极简的例子

Java源代码

为了简化，我们取一个极简的例子来说明Java的数组指令的用法：

我们new一个长度为1的字节数组，然后返回这个数组的长度。

public static int testByteArrayLength(){
byte[] baArray = new byte[1];
return baArray.length;
}

Java字节码

有几条指令先交代一下：

* newarray：这条指令用于创建一个新的数组，参数是类型。对于整型变量，byte，short和int占用的空间是一样的。但是变成数组之后就不一样了。byte数组可以节省空间。

* arraylength:求数组长度是专门有一条指令来实现的。

* aload:从变量中将数组引用load出来。一句话就是，要操作哪个数组，先把这个数组的引用从变量中读出来。

* astore:将数组引用存入变量

* baload:从byte型数组中读值

* bastore:向byte型数组中写值

第0号是将数组长度1,从常量池1中读出来。

第1号，new一个长度在栈里，类型为byte的数组。

第3号，将生成好的这个数组的引用存到变量0中。

第4号，从变量0中，读取数组的引用。

第5号，从栈中数组的引用的数组中读取长度。

第6号，返回这个长度值。

public static int testByteArrayLength();
Code:
0: iconst_1
1: newarray       byte
3: astore_0
4: aload_0
5: arraylength
6: ireturn

Dalvik字节码

看了Dalvik字节码之后，不得不感叹，通过寄存器方式的指令，可读性确实提高了很多。

第1句：常量值1放到v1寄存器中

第2句：new一个类型为byte，长度在v1中的数组，引用放在v0里。

第3句：读取v0中所存引用的数组的长度，存到v1寄存器中。

第4句：返回v1的值。

16: int com.yunos.xulun.testcppjni2.TestART.testByteArrayLength() (dex_method_idx=16793)
DEX CODE:
0x0000: 1211                      | const/4 v1, #+1
0x0001: 2310 9308                 | new-array v0, v1, byte[] // type@2195
0x0003: 2101                      | array-length v1, v0
0x0004: 0f01                      | return v1

OAT生成的代码

我们终于要开始与Java强相关的指令正面交锋了。因为像new-array和array-length这样的指令是不会有对应的机器指令来对应的，因为要面对的层次有点高，不是物理机器这一层所关注的。这正是JVM与其他的真实或虚拟的机器非常不同的一点。

幸好，OAT的实现中，也将这样的功能封装到了各个过程中，比如new-array，对应到pAllocArray过程中。

我们来分析一下生成的OAT代码：

CODE: (code_offset=0x005030bc size_offset=0x005030b8 size=100)...
0x005030bc: d1400bf0  sub x16, sp, #0x2000 (8192)
0x005030c0: b940021f  ldr wzr, [x16]
suspend point dex PC: 0x0000
0x005030c4: f81e0fe0  str x0, [sp, #-32]!
0x005030c8: f9000ffe  str lr, [sp, #24]
0x005030cc: 79400250  ldrh w16, (state_and_flags)
0x005030d0: 35000230  cbnz w16, #+0x44 (addr 0x503114)

前面还是存参数，判断是否要被调试器suspend这些。

将长度参数1，先存到栈里，sp+16，再转到w1，给pAllocArray做为参数。另外一个参数是类型，就是byte code里看到的type@2195.

0x005030d4: 52800030  mov w16, #0x1
0x005030d8: b90013f0  str w16, [sp, #16]
0x005030dc: b94013e1  ldr w1, [sp, #16]
0x005030e0: f94003e2  ldr x2, [sp]
0x005030e4: 52811260  mov w0, #0x893
0x005030e8: f940ca5e  ldr lr, [tr, #400] (pAllocArray)
0x005030ec: d63f03c0  blr lr
suspend point dex PC: 0x0001

返回值放sp+12,再读回来，这个是数组的引用。

数组的结构的下一个+8的位置存的就是数组的长度，这个就不麻烦再写条指令的专门实现了。

0x005030f0: b9000fe0  str w0, [sp, #12]
0x005030f4: b9400fe0  ldr w0, [sp, #12]
0x005030f8: b940001f  ldr wzr, [x0]
suspend point dex PC: 0x0003
GC map objects:  v0 ([sp + #12])
0x005030fc: b9400801  ldr w1, [x0, #8]
suspend point dex PC: 0x0003
GC map objects:  v0 ([sp + #12])

长度暂存在sp+16，再读出来，放到w0里，最后返回。

0x00503100: b90013e1  str w1, [sp, #16]
0x00503104: b94013e0  ldr w0, [sp, #16]
0x00503108: f9400ffe  ldr lr, [sp, #24]
0x0050310c: 910083ff  add sp, sp, #0x20 (32)
0x00503110: d65f03c0  ret
0x00503114: f9421e5e  ldr lr, [tr, #1080] (pTestSuspend)
0x00503118: d63f03c0  blr lr
suspend point dex PC: 0x0000
0x0050311c: 17ffffee  b #-0x48 (addr 0x5030d4)

更实际一点的例子

Java源代码

我们写一段稍有点意义的数组访问的代码。极简的例子帮助我们学会了最简单的数组相关的指令，但是并没有读写数组的值。这个例子加入对数组的读写：

public static int testArray(){
int sum = 0;
int[] iaTest = new int[10];
iaTest[0]=0;
iaTest[1]=1;
for(int i=2;i<iaTest.length;i++){
iaTest[i]=iaTest[i-1] + iaTest[i-2];
}
for(int i=0;i<iaTest.length;i++){
sum += iaTest[i];
}
return sum;
}

Java字节码

newarray, aload, astore和arraylength前面都学过了，这里面增加了从整型数组中读值的iaload和往整型数组里写的iastore。

public static int testArray();
Code:
0: iconst_0
1: istore_0
2: bipush        10
4: newarray       int
6: astore_1
7: aload_1
8: iconst_0
9: iconst_0
10: iastore
11: aload_1
12: iconst_1
13: iconst_1
14: iastore
15: iconst_2
16: istore_2
17: iload_2
18: aload_1
19: arraylength
20: if_icmpge     43
23: aload_1
24: iload_2
25: aload_1
26: iload_2
27: iconst_1
28: isub
29: iaload
30: aload_1
31: iload_2
32: iconst_2
33: isub
34: iaload
35: iadd
36: iastore
37: iinc          2, 1
40: goto          17
43: iconst_0
44: istore_2
45: iload_2
46: aload_1
47: arraylength
48: if_icmpge     63
51: iload_0
52: aload_1
53: iload_2
54: iaload
55: iadd
56: istore_0
57: iinc          2, 1
60: goto          45
63: iload_0
64: ireturn

对应的Dalvik代码

Dalvik代码中用不到aload和astore，反正引用都在寄存器里。它通过aput和aget指令来读写数组。

15: int com.yunos.xulun.testcppjni2.TestART.testArray() (dex_method_idx=16792)
DEX CODE:
0x0000: 1215                      | const/4 v5, #+1
0x0001: 1204                      | const/4 v4, #+0
0x0002: 1202                      | const/4 v2, #+0
0x0003: 1303 0a00                 | const/16 v3, #+10
0x0005: 2331 9708                 | new-array v1, v3, int[] // type@2199
0x0007: 4b04 0104                 | aput v4, v1, v4
0x0009: 4b05 0105                 | aput v5, v1, v5
0x000b: 1220                      | const/4 v0, #+2
0x000c: 2113                      | array-length v3, v1
0x000d: 3530 1000                 | if-ge v0, v3, +16
0x000f: d803 00ff                 | add-int/lit8 v3, v0, #-1
0x0011: 4403 0103                 | aget v3, v1, v3
0x0013: d804 00fe                 | add-int/lit8 v4, v0, #-2
0x0015: 4404 0104                 | aget v4, v1, v4
0x0017: b043                      | add-int/2addr v3, v4
0x0018: 4b03 0100                 | aput v3, v1, v0
0x001a: d800 0001                 | add-int/lit8 v0, v0, #+1
0x001c: 28f0                      | goto -16
0x001d: 1200                      | const/4 v0, #+0
0x001e: 2113                      | array-length v3, v1
0x001f: 3530 0800                 | if-ge v0, v3, +8
0x0021: 4403 0100                 | aget v3, v1, v0
0x0023: b032                      | add-int/2addr v2, v3
0x0024: d800 0001                 | add-int/lit8 v0, v0, #+1
0x0026: 28f8                      | goto -8
0x0027: 0f02                      | return v2

OAT编译的代码

这个代码稍有点长。不过我们现在已经有充分的知识可以看懂了。

我来把每句Dalvik跟OAT代码对应起来，需要的地方再加两句讲解。

CODE: (code_offset=0x00502d9c size_offset=0x00502d98 size=764)...
0x00502d9c: d1400bf0  sub x16, sp, #0x2000 (8192)
0x00502da0: b940021f  ldr wzr, [x16]
suspend point dex PC: 0x0000
0x00502da4: f81c0fe0  str x0, [sp, #-64]!
0x00502da8: f9001ffe  str lr, [sp, #56]
0x00502dac: 79400250  ldrh w16, (state_and_flags)
0x00502db0: 350014b0  cbnz w16, #+0x294 (addr 0x503044)

第2个常量1，存在sp+48里。

// const/4 v5, #+1

0x00502db4: 52800030  mov w16, #0x1
0x00502db8: b90033f0  str w16, [sp, #48]

第1个常量0，存在sp+44里。这两个常量一会儿赋值的时候会用到。

// const/4 v4, #+0

0x00502dbc: 52800010  mov w16, #0x0
0x00502dc0: b9002ff0  str w16, [sp, #44]

sum初值的那个0常量，放在sp+36里。

// const/4 v2, #+0

0x00502dc4: 52800010  mov w16, #0x0
0x00502dc8: b90027f0  str w16, [sp, #36]

数组的长度10，存在sp+40里。

// const/16 v3, #+10

0x00502dcc: 52800150  mov w16, #0xa
0x00502dd0: b9002bf0  str w16, [sp, #40]

把放存进去的长度10再读出来，类型type@2199传给w0，调pAllocArray去分配数组空间。

// new-array v1, v3, int[] // type@2199

0x00502dd4: b9402be1  ldr w1, [sp, #40]
0x00502dd8: f94003e2  ldr x2, [sp]
0x00502ddc: 528112e0  mov w0, #0x897
0x00502de0: f940ca5e  ldr lr, [tr, #400] (pAllocArray)
0x00502de4: d63f03c0  blr lr
suspend point dex PC: 0x0005

返回的数组引用在w0中，先暂存到sp+32。这时[x0]指向的就是数组了。

下一步做

iaTest[0]=0;

下面开始给数组的0下标位置赋0.

// aput v4, v1, v4

0x00502de8: b90023e0  str w0, [sp, #32]
0x00502dec: b94023e0  ldr w0, [sp, #32]
0x00502df0: b940001f  ldr wzr, [x0]
suspend point dex PC: 0x0007
GC map objects:  v1 ([sp + #32])

将数组引用存到sp+24中，先加载回来。

然后，读数组的长度，数组的第8个字节开始的4个字节。

长度放到sp+20中。

0x00502df4: b9001be0  str w0, [sp, #24]
0x00502df8: b9401be0  ldr w0, [sp, #24]
0x00502dfc: b9400801  ldr w1, [x0, #8]
0x00502e00: b90017e1  str w1, [sp, #20]

sp+44的值读回来，往上翻翻，还记得吗，这就是那个0.

然后，体现Java的优越性的地方又出来了，它会做越界检查。如果越界了，就跳到后面去调用pThrowArrayBounds去抛越界异常。

0x00502e04: b9402fe0  ldr w0, [sp, #44]
0x00502e08: b94017e1  ldr w1, [sp, #20]
0x00502e0c: 6b01001f  cmp w0, w1
0x00502e10: 54001202  b.hs #+0x240 (addr 0x503050)

w0的值，就是sp+44里面的那个0，暂存到sp+16里。

sp+24读到w0中，往前找找吧，这个是数组的引用。

w1读取sp+16，刚存的那个1。

w2是sp+44，还是0。

add语句是根据下标计算应该存到数组的什么位置里。

w2的值1，存到add算出来的坐标再加上数组的头12字节(比如数组长度就在头里)里面。

0x00502e14: b90013e0  str w0, [sp, #16]
0x00502e18: b9401be0  ldr w0, [sp, #24]
0x00502e1c: b94013e1  ldr w1, [sp, #16]
0x00502e20: b9402fe2  ldr w2, [sp, #44]
0x00502e24: 0b010810  add w16, w0, w1, lsl #2
0x00502e28: b9000e02  str w2, [x16, #12]
0x00502e2c: b94023e0  ldr w0, [sp, #32]
0x00502e30: b940001f  ldr wzr, [x0]
suspend point dex PC: 0x0009
GC map objects:  v1 ([sp + #32])

sp+24还是数组的引用。

w1存数组长度，sp+48是那个常量1.

然后是判数组越界等等，跟上面跟下标0赋0一样，这个是将数组下标1的值赋1:

iaTest[1]=1;

跟上面一样，大家应该比较熟悉了。

// aput v5, v1, v5

0x00502e34: b9001be0  str w0, [sp, #24]
0x00502e38: b9401be0  ldr w0, [sp, #24]
0x00502e3c: b9400801  ldr w1, [x0, #8]
0x00502e40: b90017e1  str w1, [sp, #20]
0x00502e44: b94033e0  ldr w0, [sp, #48]
0x00502e48: b94017e1  ldr w1, [sp, #20]
0x00502e4c: 6b01001f  cmp w0, w1
0x00502e50: 54001042  b.hs #+0x208 (addr 0x503058)
0x00502e54: b90013e0  str w0, [sp, #16]
0x00502e58: b9401be0  ldr w0, [sp, #24]
0x00502e5c: b94013e1  ldr w1, [sp, #16]
0x00502e60: b94033e2  ldr w2, [sp, #48]
0x00502e64: 0b010810  add w16, w0, w1, lsl #2
0x00502e68: b9000e02  str w2, [x16, #12]

后面开始第一个for循环：

for(int i=2;i<iaTest.length;i++){
iaTest[i]=iaTest[i-1] + iaTest[i-2];
}

下面是将常量值2，存到sp+28中。

sp+32，也就是v1，存的是数组引用。

// const/4 v0, #+2

0x00502e6c: 52800050  mov w16, #0x2
0x00502e70: b9001ff0  str w16, [sp, #28]
0x00502e74: b94023e0  ldr w0, [sp, #32]
0x00502e78: b940001f  ldr wzr, [x0]
suspend point dex PC: 0x000c
GC map objects:  v1 ([sp + #32])

[x0+8]这是标准的array-length指令的翻译。

// array-length v3, v1

0x00502e7c: b9400801  ldr w1, [x0, #8]
suspend point dex PC: 0x000c
GC map objects:  v1 ([sp + #32])

数组长度这个值，存到sp+40中。

sp+28是循环控制变量。

然后二者做比较，如果大于等于就跳转到0x502f9c，这个循环结束。

// if-ge v0, v3, +16

0x00502e80: b9002be1  str w1, [sp, #40]
0x00502e84: b9401fe0  ldr w0, [sp, #28]
0x00502e88: b9402be1  ldr w1, [sp, #40]
0x00502e8c: 6b01001f  cmp w0, w1
0x00502e90: 1a9fb7e2  cset w2, ge
0x00502e94: 2a0203e0  mov w0, w2
0x00502e98: 35000820  cbnz w0, #+0x104 (addr 0x502f9c)

// add-int/lit8 v3, v0, #-1

0x00502e9c: b9401fe0  ldr w0, [sp, #28]
0x00502ea0: 51000401  sub w1, w0, #0x1 (1)
0x00502ea4: b9002be1  str w1, [sp, #40]
0x00502ea8: b94023e0  ldr w0, [sp, #32]
0x00502eac: b940001f  ldr wzr, [x0]
suspend point dex PC: 0x0011
GC map objects:  v1 ([sp + #32])

// aget v3, v1, v3

0x00502eb0: b9001be0  str w0, [sp, #24]
0x00502eb4: b9401be0  ldr w0, [sp, #24]
0x00502eb8: b9400801  ldr w1, [x0, #8]
0x00502ebc: b90017e1  str w1, [sp, #20]
0x00502ec0: b9402be0  ldr w0, [sp, #40]
0x00502ec4: b94017e1  ldr w1, [sp, #20]
0x00502ec8: 6b01001f  cmp w0, w1
0x00502ecc: 54000ca2  b.hs #+0x194 (addr 0x503060)
0x00502ed0: b90013e0  str w0, [sp, #16]
0x00502ed4: b9401be0  ldr w0, [sp, #24]
0x00502ed8: b94013e1  ldr w1, [sp, #16]
0x00502edc: 0b010810  add w16, w0, w1, lsl #2
0x00502ee0: b9400e02  ldr w2, [x16, #12]
0x00502ee4: b9002be2  str w2, [sp, #40]

// add-int/lit8 v4, v0, #-2

0x00502ee8: b9401fe0  ldr w0, [sp, #28]
0x00502eec: 51000801  sub w1, w0, #0x2 (2)
0x00502ef0: b9002fe1  str w1, [sp, #44]
0x00502ef4: b94023e0  ldr w0, [sp, #32]
0x00502ef8: b940001f  ldr wzr, [x0]
suspend point dex PC: 0x0015
GC map objects:  v1 ([sp + #32])

// aget v4, v1, v4

0x00502efc: b9001be0  str w0, [sp, #24]
0x00502f00: b9401be0  ldr w0, [sp, #24]
0x00502f04: b9400801  ldr w1, [x0, #8]
0x00502f08: b90017e1  str w1, [sp, #20]
0x00502f0c: b9402fe0  ldr w0, [sp, #44]
0x00502f10: b94017e1  ldr w1, [sp, #20]
0x00502f14: 6b01001f  cmp w0, w1
0x00502f18: 54000a82  b.hs #+0x150 (addr 0x503068)
0x00502f1c: b90013e0  str w0, [sp, #16]
0x00502f20: b9401be0  ldr w0, [sp, #24]
0x00502f24: b94013e1  ldr w1, [sp, #16]
0x00502f28: 0b010810  add w16, w0, w1, lsl #2
0x00502f2c: b9400e02  ldr w2, [x16, #12]
0x00502f30: b9002fe2  str w2, [sp, #44]

// add-int/2addr v3, v4

0x00502f34: b9402be0  ldr w0, [sp, #40]
0x00502f38: b9402fe1  ldr w1, [sp, #44]
0x00502f3c: 0b010002  add w2, w0, w1
0x00502f40: b9002be2  str w2, [sp, #40]
0x00502f44: b94023e0  ldr w0, [sp, #32]
0x00502f48: b940001f  ldr wzr, [x0]
suspend point dex PC: 0x0018
GC map objects:  v1 ([sp + #32])

// aput v3, v1, v0

0x00502f4c: b9001be0  str w0, [sp, #24]
0x00502f50: b9401be0  ldr w0, [sp, #24]
0x00502f54: b9400801  ldr w1, [x0, #8]
0x00502f58: b90017e1  str w1, [sp, #20]
0x00502f5c: b9401fe0  ldr w0, [sp, #28]
0x00502f60: b94017e1  ldr w1, [sp, #20]
0x00502f64: 6b01001f  cmp w0, w1
0x00502f68: 54000842  b.hs #+0x108 (addr 0x503070)
0x00502f6c: b90013e0  str w0, [sp, #16]
0x00502f70: b9401be0  ldr w0, [sp, #24]
0x00502f74: b94013e1  ldr w1, [sp, #16]
0x00502f78: b9402be2  ldr w2, [sp, #40]
0x00502f7c: 0b010810  add w16, w0, w1, lsl #2
0x00502f80: b9000e02  str w2, [x16, #12]

// add-int/lit8 v0, v0, #+1

0x00502f84: b9401fe0  ldr w0, [sp, #28]
0x00502f88: 11000401  add w1, w0, #0x1 (1)
0x00502f8c: b9001fe1  str w1, [sp, #28]

// goto -16

0x00502f90: 79400250  ldrh w16, (state_and_flags)
0x00502f94: 35000730  cbnz w16, #+0xe4 (addr 0x503078)
0x00502f98: 17ffffb7  b #-0x124 (addr 0x502e74)

第一个循环结束，下面是第二个循环：

for(int i=0;i<iaTest.length;i++){
sum += iaTest[i];
}

这个循环的计算量少了，就是纯遍历，应该更容易理解一些。

循环控制变量赋初值0：

// const/4 v0, #+0

0x00502f9c: 52800010  mov w16, #0x0
0x00502fa0: b9001ff0  str w16, [sp, #28]
0x00502fa4: b94023e0  ldr w0, [sp, #32]
0x00502fa8: b940001f  ldr wzr, [x0]
suspend point dex PC: 0x001e
GC map objects:  v1 ([sp + #32])

循环结束的值，取数组长度。

// array-length v3, v1

0x00502fac: b9400801  ldr w1, [x0, #8]
suspend point dex PC: 0x001e
GC map objects:  v1 ([sp + #32])

如果sp+28（v0）的值大于等于sp+40(v3)，循环就结束了，跳转到0x503034，return那一段。

// if-ge v0, v3, +8

0x00502fb0: b9002be1  str w1, [sp, #40]
0x00502fb4: b9401fe0  ldr w0, [sp, #28]
0x00502fb8: b9402be1  ldr w1, [sp, #40]
0x00502fbc: 6b01001f  cmp w0, w1
0x00502fc0: 1a9fb7e2  cset w2, ge
0x00502fc4: 2a0203e0  mov w0, w2
0x00502fc8: 35000360  cbnz w0, #+0x6c (addr 0x503034)
0x00502fcc: b94023e0  ldr w0, [sp, #32]
0x00502fd0: b940001f  ldr wzr, [x0]
suspend point dex PC: 0x0021
GC map objects:  v1 ([sp + #32])

如果循环可以继续，则将数组的值读出来。sp+28(v0)是当前索引值，sp+32(v1)是数组的引用，结果放到sp+40(v3)中。还是有数组越界的判断。

// aget v3, v1, v0

0x00502fd4: b9001be0  str w0, [sp, #24]
0x00502fd8: b9401be0  ldr w0, [sp, #24]
0x00502fdc: b9400801  ldr w1, [x0, #8]
0x00502fe0: b90017e1  str w1, [sp, #20]
0x00502fe4: b9401fe0  ldr w0, [sp, #28]
0x00502fe8: b94017e1  ldr w1, [sp, #20]
0x00502fec: 6b01001f  cmp w0, w1
0x00502ff0: 540004a2  b.hs #+0x94 (addr 0x503084)
0x00502ff4: b90013e0  str w0, [sp, #16]
0x00502ff8: b9401be0  ldr w0, [sp, #24]
0x00502ffc: b94013e1  ldr w1, [sp, #16]
0x00503000: 0b010810  add w16, w0, w1, lsl #2
0x00503004: b9400e02  ldr w2, [x16, #12]
0x00503008: b9002be2  str w2, [sp, #40]

下面一条指令是算求和，v2=v2+v3。sp+36是v2，sp+40是v3.

// add-int/2addr v2, v3

0x0050300c: b94027e0  ldr w0, [sp, #36]
0x00503010: b9402be1  ldr w1, [sp, #40]
0x00503014: 0b010002  add w2, w0, w1
0x00503018: b90027e2  str w2, [sp, #36]

循环控制变量sp+28(v0)加1

// add-int/lit8 v0, v0, #+1

0x0050301c: b9401fe0  ldr w0, [sp, #28]
0x00503020: 11000401  add w1, w0, #0x1 (1)
0x00503024: b9001fe1  str w1, [sp, #28]
0x00503028: 79400250  ldrh w16, (state_and_flags)
0x0050302c: 35000310  cbnz w16, #+0x60 (addr 0x50308c)

// goto -8

0x00503030: 17ffffdd  b #-0x8c (addr 0x502fa4)

// return v2

0x00503034: b94027e0  ldr w0, [sp, #36]
0x00503038: f9401ffe  ldr lr, [sp, #56]
0x0050303c: 910103ff  add sp, sp, #0x40 (64)
0x00503040: d65f03c0  ret

后面是一系列的判断suspend和抛数组越界异常的地方。

0x00503044: f9421e5e  ldr lr, [tr, #1080] (pTestSuspend)
0x00503048: d63f03c0  blr lr
suspend point dex PC: 0x0000
0x0050304c: 17ffff5a  b #-0x298 (addr 0x502db4)
0x00503050: f942265e  ldr lr, [tr, #1096] (pThrowArrayBounds)
0x00503054: d63f03c0  blr lr
suspend point dex PC: 0x0007
GC map objects:  v1 ([sp + #32])
0x00503058: f942265e  ldr lr, [tr, #1096] (pThrowArrayBounds)
0x0050305c: d63f03c0  blr lr
suspend point dex PC: 0x0009
GC map objects:  v1 ([sp + #32])
0x00503060: f942265e  ldr lr, [tr, #1096] (pThrowArrayBounds)
0x00503064: d63f03c0  blr lr
suspend point dex PC: 0x0011
GC map objects:  v1 ([sp + #32])
0x00503068: f942265e  ldr lr, [tr, #1096] (pThrowArrayBounds)
0x0050306c: d63f03c0  blr lr
suspend point dex PC: 0x0015
GC map objects:  v1 ([sp + #32])
0x00503070: f942265e  ldr lr, [tr, #1096] (pThrowArrayBounds)
0x00503074: d63f03c0  blr lr
suspend point dex PC: 0x0018
GC map objects:  v1 ([sp + #32])
0x00503078: f9421e5e  ldr lr, [tr, #1080] (pTestSuspend)
0x0050307c: d63f03c0  blr lr
suspend point dex PC: 0x001c
GC map objects:  v1 ([sp + #32])
0x00503080: 17ffffc6  b #-0xe8 (addr 0x502f98)
0x00503084: f942265e  ldr lr, [tr, #1096] (pThrowArrayBounds)
0x00503088: d63f03c0  blr lr
suspend point dex PC: 0x0021
GC map objects:  v1 ([sp + #32])
0x0050308c: f9421e5e  ldr lr, [tr, #1080] (pTestSuspend)
0x00503090: d63f03c0  blr lr
suspend point dex PC: 0x0026
GC map objects:  v1 ([sp + #32])
0x00503094: 17ffffe7  b #-0x64 (addr 0x503030)

C++的数组实现

C++源代码

int testArray() {
const int ARRAY_SIZE = 10;
int sum = 0;
int *iaTest = new int[ARRAY_SIZE];
iaTest[0] = 0;
iaTest[1] = 1;
for (int i = 2; i < ARRAY_SIZE; i++) {
iaTest[i] = iaTest[i - 1] + iaTest[i - 2];
}
for (int i = 0; i < ARRAY_SIZE; i++) {
sum += iaTest[i];
}
return sum;
}

C++编译生成的代码-arm64 v8a

可以看到，这段代码，编译器已经将循环优化展开了。

0000000000000bf0 <_Z9testArrayv>:
bf0:   a9bf7bfd    stp x29, x30, [sp,#-16]!
bf4:   d2800500    mov x0, #0x28                   // #40
bf8:   910003fd    mov x29, sp
bfc:   97ffff15    bl  850 <_Znam@plt>
c00:   b900001f    str wzr, [x0]
c04:   52800022    mov w2, #0x1                    // #1
c08:   b9000402    str w2, [x0,#4]
c0c:   b9000802    str w2, [x0,#8]
c10:   52800042    mov w2, #0x2                    // #2
c14:   b9000c02    str w2, [x0,#12]
c18:   52800062    mov w2, #0x3                    // #3
c1c:   b9001002    str w2, [x0,#16]
c20:   528000a2    mov w2, #0x5                    // #5
c24:   b9001402    str w2, [x0,#20]
c28:   52800102    mov w2, #0x8                    // #8
c2c:   b9001802    str w2, [x0,#24]
c30:   528001a2    mov w2, #0xd                    // #13
c34:   b9001c02    str w2, [x0,#28]
c38:   528002a2    mov w2, #0x15                   // #21
c3c:   aa0003e1    mov x1, x0
c40:   b9002002    str w2, [x0,#32]
c44:   52800442    mov w2, #0x22                   // #34
c48:   b9002402    str w2, [x0,#36]
c4c:   3cc10420    ldr q0, [x1],#16
c50:   a8c17bfd    ldp x29, x30, [sp],#16
c54:   3dc00021    ldr q1, [x1]
c58:   4ea18400    add v0.4s, v0.4s, v1.4s
c5c:   4eb1b800    addv    s0, v0.4s
c60:   0e043c00    mov w0, v0.s[0]
c64:   1100dc00    add w0, w0, #0x37
c68:   d65f03c0    ret

x86_64的C++编译生成代码

CISC指令的优势终于发挥出来了，arm64的指令都是32位的，4个字节。但是x86_64的指令可以是7个字节。

ARM只能通过str指令访问内存，x86可没有这种限制。

0000000000000dc0 <_Z9testArrayv>:
dc0:   48 8d 64 24 f8          lea    -0x8(%rsp),%rsp
dc5:   bf 28 00 00 00          mov    $0x28,%edi
dca:   e8 11 fa ff ff          callq  7e0 <_Znam@plt>
dcf:   c7 00 00 00 00 00       movl   $0x0,(%rax)
dd5:   c7 40 04 01 00 00 00    movl   $0x1,0x4(%rax)
ddc:   c7 40 08 01 00 00 00    movl   $0x1,0x8(%rax)
de3:   c7 40 0c 02 00 00 00    movl   $0x2,0xc(%rax)
dea:   c7 40 10 03 00 00 00    movl   $0x3,0x10(%rax)
df1:   c7 40 14 05 00 00 00    movl   $0x5,0x14(%rax)
df8:   c7 40 18 08 00 00 00    movl   $0x8,0x18(%rax)
dff:   c7 40 1c 0d 00 00 00    movl   $0xd,0x1c(%rax)
e06:   c7 40 20 15 00 00 00    movl   $0x15,0x20(%rax)
e0d:   c7 40 24 22 00 00 00    movl   $0x22,0x24(%rax)
e14:   b8 58 00 00 00          mov    $0x58,%eax
e19:   48 8d 64 24 08          lea    0x8(%rsp),%rsp
e1e:   c3                      retq
e1f:   90                      nop

mips64的C++生成代码

MIPS也是RISC，只能通过li,ld这样的load指令读内存，sw这样的指令写内存。所以也没有x86那样短。

0000000000000e50 <_Z9testArrayv>:
e50:   67bdfff0    daddiu  sp,sp,-16
e54:   ffbc0000    sd  gp,0(sp)
e58:   3c1c0002    lui gp,0x2
e5c:   0399e02d    daddu   gp,gp,t9
e60:   ffbf0008    sd  ra,8(sp)
e64:   679c91b0    daddiu  gp,gp,-28240
e68:   df998040    ld  t9,-32704(gp)
e6c:   0320f809    jalr    t9
e70:   24040028    li  a0,40
e74:   dfbf0008    ld  ra,8(sp)
e78:   ac400000    sw  zero,0(v0)
e7c:   0040182d    move    v1,v0
e80:   24040001    li  a0,1
e84:   24020001    li  v0,1
e88:   24050002    li  a1,2
e8c:   24060003    li  a2,3
e90:   24070005    li  a3,5
e94:   24080008    li  a4,8
e98:   2409000d    li  a5,13
e9c:   240a0015    li  a6,21
ea0:   240b0022    li  a7,34
ea4:   ac620004    sw  v0,4(v1)
ea8:   dfbc0000    ld  gp,0(sp)
eac:   24020058    li  v0,88
eb0:   ac640008    sw  a0,8(v1)
eb4:   ac65000c    sw  a1,12(v1)
eb8:   ac660010    sw  a2,16(v1)
ebc:   ac670014    sw  a3,20(v1)
ec0:   ac680018    sw  a4,24(v1)
ec4:   ac69001c    sw  a5,28(v1)
ec8:   ac6a0020    sw  a6,32(v1)
ecc:   ac6b0024    sw  a7,36(v1)
ed0:   03e00009    jr  ra
ed4:   67bd0010    daddiu  sp,sp,16

结论

虽然优化得不如C++好，但是数组指令还是比较清晰的。Java自带越界检查，还是节省了不少编程的力气的。