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, [tr](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, [tr](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, [tr](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, [tr](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自带越界检查，还是节省了不少编程的力气的。

不会用的Java数组，从青铜到王者，全解析数组，建议收藏！！！ 先声明后使用 数据类型 [] 数组名称 = new 数据类型[长度];String[] arr3 = new String[5]; 数据类型 数组名称[] = new 数据类型[长度];String arr[] = new String[5];
C++ Trick：右值引用、万能引用傻傻分不清楚 C++11标准颁布距今已经十年了，在这个标准中引入了很多新的语言特性，在进一步强化C++的同时，也劝退了很多人，其中就包含右值引用。
ART世界探险(15) - CompilerDriver,ClassLinker,Runtime三大组件 正如Android有Activity, Service, ContentProvider和Broadcast四大组件，ART中也有几个大组件：CompilerDriver, ClassLinker和Runtime
lusing 刘子瑛，阿里系统框架专家。工作十余年，一直对新编程语言、新开发方法、数学与算法相关和并发等相关领域保持浓厚的兴趣。乐于通过技术分享促进新技术。