ART世界探险(5) - 计算指令
2016-07-24 22:19
543 查看
ART世界探险(5) - 计算指令
整数运算
Java的整型运算
我们先看看JVM是如何处理这些基本整数运算的吧。public static long add(long a, long b){ return a+b; } public static long sub(long a,long b){ return a-b; } public static long mul(long a, long b){ return a*b; } public static long div(long a,long b){ return a/b; } public static long mod(long a,long b){ return a%b; }
翻译成字节码是这样的,非常整齐:
public static long add(long, long); Code: 0: lload_0 1: lload_2 2: ladd 3: lreturn public static long sub(long, long); Code: 0: lload_0 1: lload_2 2: lsub 3: lreturn public static long mul(long, long); Code: 0: lload_0 1: lload_2 2: lmul 3: lreturn public static long div(long, long); Code: 0: lload_0 1: lload_2 2: ldiv 3: lreturn public static long mod(long, long); Code: 0: lload_0 1: lload_2 2: lrem 3: lreturn
加是add,减是sub,乘是mul,除是div,取模是rem。
转换成Dalvik指令的话,连lload都省了,更是看起来赏心悦目。
1: long com.yunos.xulun.testcppjni2.TestART.add(long, long) (dex_method_idx=16778) DEX CODE: 0x0000: 9b00 0204 | add-long v0, v2, v4 0x0002: 1000 | return-wide v0
我们看看在ARM上的实现。
ARM的整型运算
C++代码和Java基本上是同出一辙的:long add(long a, long b){ return a+b; } long sub(long a,long b){ return a-b; } long mul(long a, long b){ return a*b; } long div(long a,long b){ return a/b; } long mod(long a,long b){ return a%b; }
ARM v8a的整数运算
我们看看在AArch64下译成什么:0000000000000694 <_Z3addll>: 694: 8b010000 add x0, x0, x1 698: d65f03c0 ret 000000000000069c <_Z3subll>: 69c: cb010000 sub x0, x0, x1 6a0: d65f03c0 ret 00000000000006a4 <_Z3mulll>: 6a4: 9b017c00 mul x0, x0, x1 6a8: d65f03c0 ret 00000000000006ac <_Z3divll>: 6ac: 9ac10c00 sdiv x0, x0, x1 6b0: d65f03c0 ret 00000000000006b4 <_Z3modll>: 6b4: 9ac10c02 sdiv x2, x0, x1 6b8: 9b018040 msub x0, x2, x1, x0 6bc: d65f03c0 ret
ARM v7a的整数运算
AArch32模式下,加减乘都是一条指令00000fc0 <_Z3addll>: fc0: 4408 add r0, r1 fc2: 4770 bx lr 00000fc4 <_Z3subll>: fc4: 1a40 subs r0, r0, r1 fc6: 4770 bx lr 00000fc8 <_Z3mulll>: fc8: 4348 muls r0, r1 fca: 4770 bx lr
但是除法和取模就不是指令了,得调用函数来处理。
00000fcc <_Z3divll>: fcc: b508 push {r3, lr} fce: f000 e830 blx 1030 <__aeabi_idiv> fd2: bd08 pop {r3, pc} 00000fd4 <_Z3modll>: fd4: b508 push {r3, lr} fd6: f000 e89a blx 110c <__aeabi_idivmod> fda: 4608 mov r0, r1 fdc: bd08 pop {r3, pc}
算除法的这个函数可是不短啊,我们先看一下,这个将来可供我们学完指令集之后复习用:
00001030 <__aeabi_idiv>: 1030: e3510000 cmp r1, #0 1034: 0a000030 beq 10fc <__aeabi_idiv+0xcc> 1038: e020c001 eor ip, r0, r1 103c: 42611000 rsbmi r1, r1, #0 1040: e2512001 subs r2, r1, #1 1044: 0a00001f beq 10c8 <__aeabi_idiv+0x98> 1048: e1b03000 movs r3, r0 104c: 42603000 rsbmi r3, r0, #0 1050: e1530001 cmp r3, r1 1054: 9a00001e bls 10d4 <__aeabi_idiv+0xa4> 1058: e1110002 tst r1, r2 105c: 0a000020 beq 10e4 <__aeabi_idiv+0xb4> 1060: e16f2f11 clz r2, r1 1064: e16f0f13 clz r0, r3 1068: e0420000 sub r0, r2, r0 106c: e3a02001 mov r2, #1 1070: e1a01011 lsl r1, r1, r0 1074: e1a02012 lsl r2, r2, r0 1078: e3a00000 mov r0, #0 107c: e1530001 cmp r3, r1 1080: 20433001 subcs r3, r3, r1 1084: 21800002 orrcs r0, r0, r2 1088: e15300a1 cmp r3, r1, lsr #1 108c: 204330a1 subcs r3, r3, r1, lsr #1 1090: 218000a2 orrcs r0, r0, r2, lsr #1 1094: e1530121 cmp r3, r1, lsr #2 1098: 20433121 subcs r3, r3, r1, lsr #2 109c: 21800122 orrcs r0, r0, r2, lsr #2 10a0: e15301a1 cmp r3, r1, lsr #3 10a4: 204331a1 subcs r3, r3, r1, lsr #3 10a8: 218001a2 orrcs r0, r0, r2, lsr #3 10ac: e3530000 cmp r3, #0 10b0: 11b02222 lsrsne r2, r2, #4 10b4: 11a01221 lsrne r1, r1, #4 10b8: 1affffef bne 107c <__aeabi_idiv+0x4c> 10bc: e35c0000 cmp ip, #0 10c0: 42600000 rsbmi r0, r0, #0 10c4: e12fff1e bx lr 10c8: e13c0000 teq ip, r0 10cc: 42600000 rsbmi r0, r0, #0 10d0: e12fff1e bx lr 10d4: 33a00000 movcc r0, #0 10d8: 01a00fcc asreq r0, ip, #31 10dc: 03800001 orreq r0, r0, #1 10e0: e12fff1e bx lr 10e4: e16f2f11 clz r2, r1 10e8: e262201f rsb r2, r2, #31 10ec: e35c0000 cmp ip, #0 10f0: e1a00233 lsr r0, r3, r2 10f4: 42600000 rsbmi r0, r0, #0 10f8: e12fff1e bx lr 10fc: e3500000 cmp r0, #0 1100: c3e00102 mvngt r0, #-2147483648 ; 0x80000000 1104: b3a00102 movlt r0, #-2147483648 ; 0x80000000 1108: ea000007 b 112c <__aeabi_idiv0> 0000110c <__aeabi_idivmod>: 110c: e3510000 cmp r1, #0 1110: 0afffff9 beq 10fc <__aeabi_idiv+0xcc> 1114: e92d4003 push {r0, r1, lr} 1118: ebffffc6 bl 1038 <__aeabi_idiv+0x8> 111c: e8bd4006 pop {r1, r2, lr} 1120: e0030092 mul r3, r2, r0 1124: e0411003 sub r1, r1, r3 1128: e12fff1e bx lr
传统armeabi的整数运算
加减乘还是没有问题:adds,subs,muls,改状态位。00001248 <_Z3addll>: 1248: 1840 adds r0, r0, r1 124a: 4770 bx lr 0000124c <_Z3subll>: 124c: 1a40 subs r0, r0, r1 124e: 4770 bx lr 00001250 <_Z3mulll>: 1250: 4348 muls r0, r1 1252: 4770 bx lr
除法和取模也是调函数:
00001254 <_Z3divll>: 1254: b508 push {r3, lr} 1256: f001 ff47 bl 30e8 <_Unwind_GetTextRelBase+0x8> 125a: bd08 pop {r3, pc} 0000125c <_Z3modll>: 125c: b508 push {r3, lr} 125e: f001 ff4b bl 30f8 <_Unwind_GetTextRelBase+0x18> 1262: 1c08 adds r0, r1, #0 1264: bd08 pop {r3, pc}
OAT编译出来的结果
Dalvik和ARM都学完之后,我们就可以看看Dalvik翻成OAT之后的结果是什么样子的了。先看个加法的吧:
CODE: (code_offset=0x0050270c size_offset=0x00502708 size=76)... 0x0050270c: d1400bf0 sub x16, sp, #0x2000 (8192) 0x00502710: b940021f ldr wzr, [x16] suspend point dex PC: 0x0000 0x00502714: f81e0fe0 str x0, [sp, #-32]!
复习一下,还是先备份参数到栈里:lr到sp+24,第一个参数到sp+40,第二个参数到sp+48。
然后判断是不是suspend。
0x00502718: f9000ffe str lr, [sp, #24] 0x0050271c: f90017e1 str x1, [sp, #40] 0x00502720: f9001be2 str x2, [sp, #48] 0x00502724: 79400250 ldrh w16,(state_and_flags) 0x00502728: 35000130 cbnz w16, #+0x24 (addr 0x50274c)
开始干活了,将那两个参数从sp+40和sp+48里面读回来,到x0和x1中。
然后算加法,结果在x2中。
x2值再送到栈里,再从栈里读回来到x0,最后返回。0x0050272c: f94017e0 ldr x0, [sp, #40] 0x00502730: f9401be1 ldr x1, [sp, #48] 0x00502734: 8b010002 add x2, x0, x1 0x00502738: f800c3e2 stur x2, [sp, #12] 0x0050273c: f840c3e0 ldur x0, [sp, #12] 0x00502740: f9400ffe ldr lr, [sp, #24] 0x00502744: 910083ff add sp, sp, #0x20 (32) 0x00502748: d65f03c0 ret 0x0050274c: f9421e5e ldr lr, [tr, #1080] (pTestSuspend) 0x00502750: d63f03c0 blr lr suspend point dex PC: 0x0000 0x00502754: 17fffff6 b #-0x28 (addr 0x50272c)
减法和乘法也是类似,我们直接看除法:
这时候64位的好处又体现出来了,不用调函数,直接有指令:
Dalvik代码是这样的:3: long com.yunos.xulun.testcppjni2.TestART.div(long, long) (dex_method_idx=16780) DEX CODE: 0x0000: 9e00 0204 | div-long v0, v2, v4 0x0002: 1000 | return-wide v0
OAT代码,sdiv就搞定了。跟前面我们看到的C代码的结果,吻合得非常好。CODE: (code_offset=0x0050280c size_offset=0x00502808 size=96)... 0x0050280c: d1400bf0 sub x16, sp, #0x2000 (8192) 0x00502810: b940021f ldr wzr, [x16] suspend point dex PC: 0x0000 0x00502814: f81d0fe0 str x0, [sp, #-48]! 0x00502818: f90017fe str lr, [sp, #40] 0x0050281c: f9001fe1 str x1, [sp, #56] 0x00502820: f90023e2 str x2, [sp, #64] 0x00502824: 79400250 ldrh w16,(state_and_flags) 0x00502828: 35000190 cbnz w16, #+0x30 (addr 0x502858)
先从sp+64中把除数读进来。
Java先做一件事情,判断除数是不是0。如果除数是0,则cbz会跳转到执行pThrowDivZero去抛出一个除0异常出来。0x0050282c: f94023e0 ldr x0, [sp, #64] 0x00502830: b40001a0 cbz x0, #+0x34 (addr 0x502864)
判断是否为0之后,还是把x0存到栈里。
再把被除数和除数都从栈里读出来。0x00502834: f80143e0 stur x0, [sp, #20] 0x00502838: f9401fe0 ldr x0, [sp, #56] 0x0050283c: f84143e1 ldur x1, [sp, #20]
开始做除法,结果在x2中,然后存栈里面。再从栈里读回来到x0里,返回。0x00502840: 9ac10c02 sdiv x2, x0, x1 0x00502844: f801c3e2 stur x2, [sp, #28] 0x00502848: f841c3e0 ldur x0, [sp, #28] 0x0050284c: f94017fe ldr lr, [sp, #40] 0x00502850: 9100c3ff add sp, sp, #0x30 (48) 0x00502854: d65f03c0 ret 0x00502858: f9421e5e ldr lr, [tr, #1080] (pTestSuspend) 0x0050285c: d63f03c0 blr lr suspend point dex PC: 0x0000 0x00502860: 17fffff3 b #-0x34 (addr 0x50282c) 0x00502864: f9422a5e ldr lr, [tr, #1104] (pThrowDivZero) 0x00502868: d63f03c0 blr lr suspend point dex PC: 0x0000浮点运算
Java浮点运算
Java真是门好语言啊,JVM已经封装了所有跟浮点相关的细节,基本上从字节码上看,跟长整型只有细节的不同。public static double dadd(double a,double b){ return a+b; } public static double dsub(double a,double b){ return a-b; } public static double dmul(double a,double b){ return a*b; } public static double ddiv(double a,double b){ return a/b; }
字节码如下:public static double dadd(double, double); Code: 0: dload_0 1: dload_2 2: dadd 3: dreturn public static double dsub(double, double); Code: 0: dload_0 1: dload_2 2: dsub 3: dreturn public static double dmul(double, double); Code: 0: dload_0 1: dload_2 2: dmul 3: dreturn public static double ddiv(double, double); Code: 0: dload_0 1: dload_2 2: ddiv 3: dreturn
基本上就是将l换成d,其它没有什么变化。ARM浮点运算
强大的ARM v8A芯片,已经不输于JVM的设计了,也是很简单。
源代码:double dadd(double a,double b){ return a+b; } double dsub(double a,double b){ return a-b; } double dmul(double a,double b){ return a*b; } double ddiv(double a,double b){ return a/b; }ARM v8a的浮点运算
汇编代码:0000000000000760 <_Z4dadddd>: 760: 1e612800 fadd d0, d0, d1 764: d65f03c0 ret 0000000000000768 <_Z4dsubdd>: 768: 1e613800 fsub d0, d0, d1 76c: d65f03c0 ret 0000000000000770 <_Z4dmuldd>: 770: 1e610800 fmul d0, d0, d1 774: d65f03c0 ret 0000000000000778 <_Z4ddivdd>: 778: 1e611800 fdiv d0, d0, d1 77c: d65f03c0 ret
我们可以看到,寄存器已经不是x开头的通用寄存器了,而变成了d开头的NEON寄存器。我们实际上是借用了ARM v7a才出现的NEON指令才使得指令变得这么简单。ARM v7a的浮点运算:
同样是NEON指令,但是v7a的就比v8a的看起来要复杂一点。不过倒更清晰地反映了逻辑事实。
v7a的NEON指令需要用vmov将通用寄存器中的数传送到NEON寄存器中,然后再进行计算。结果再通过vmov送回到通用寄存器中。00000fde <_Z4dadddd>: fde: ec41 0b17 vmov d7, r0, r1 fe2: ec43 2b16 vmov d6, r2, r3 fe6: ee37 7b06 vadd.f64 d7, d7, d6 fea: ec51 0b17 vmov r0, r1, d7 fee: 4770 bx lr 00000ff0 <_Z4dsubdd>: ff0: ec41 0b17 vmov d7, r0, r1 ff4: ec43 2b16 vmov d6, r2, r3 ff8: ee37 7b46 vsub.f64 d7, d7, d6 ffc: ec51 0b17 vmov r0, r1, d7 1000: 4770 bx lr 00001002 <_Z4dmuldd>: 1002: ec41 0b17 vmov d7, r0, r1 1006: ec43 2b16 vmov d6, r2, r3 100a: ee27 7b06 vmul.f64 d7, d7, d6 100e: ec51 0b17 vmov r0, r1, d7 1012: 4770 bx lr 00001014 <_Z4ddivdd>: 1014: ec41 0b17 vmov d7, r0, r1 1018: ec43 2b16 vmov d6, r2, r3 101c: ee87 7b06 vdiv.f64 d7, d7, d6 1020: ec51 0b17 vmov r0, r1, d7 1024: 4770 bx lr传统ARM的浮点运算
没啥说的,都得函数实现了:00001248 <_Z3addll>: 1248: 1840 adds r0, r0, r1 124a: 4770 bx lr 0000124c <_Z3subll>: 124c: 1a40 subs r0, r0, r1 124e: 4770 bx lr 00001250 <_Z3mulll>: 1250: 4348 muls r0, r1 1252: 4770 bx lr
00001254 <_Z3divll>: 1254: b508 push {r3, lr} 1256: f001 ff47 bl 30e8 <_Unwind_GetTextRelBase+0x8> 125a: bd08 pop {r3, pc} 0000125c <_Z3modll>: 125c: b508 push {r3, lr} 125e: f001 ff4b bl 30f8 <_Unwind_GetTextRelBase+0x18> 1262: 1c08 adds r0, r1, #0 1264: bd08 pop {r3, pc}x86芯片的运算指令
几种ARM下的RISC指令集的结果,我们都分析过了。下面我们看看32位的x86芯片上的整数和浮点运算吧。x86的整数运算
32位的标志是使用32位的寄存器,比如eax,esp,esi。而64位下就是rax等等了。00005f0 <_Z3addll>: 5f0: 8b 44 24 08 mov 0x8(%esp),%eax 5f4: 03 44 24 04 add 0x4(%esp),%eax 5f8: c3 ret 5f9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 00000600 <_Z3subll>: 600: 8b 44 24 04 mov 0x4(%esp),%eax 604: 2b 44 24 08 sub 0x8(%esp),%eax 608: c3 ret 609: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 00000610 <_Z3mulll>: 610: 8b 44 24 08 mov 0x8(%esp),%eax 614: 0f af 44 24 04 imul 0x4(%esp),%eax 619: c3 ret 61a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 00000620 <_Z3divll>: 620: 8b 44 24 04 mov 0x4(%esp),%eax 624: 89 c2 mov %eax,%edx 626: c1 fa 1f sar $0x1f,%edx 629: f7 7c 24 08 idivl 0x8(%esp) 62d: c3 ret 62e: 66 90 xchg %ax,%ax 00000630 <_Z3modll>: 630: 8b 44 24 04 mov 0x4(%esp),%eax 634: 89 c2 mov %eax,%edx 636: c1 fa 1f sar $0x1f,%edx 639: f7 7c 24 08 idivl 0x8(%esp) 63d: 89 d0 mov %edx,%eax 63f: c3 ret
x86的CISC的好处是总不至于要调一段复杂的函数来实现除法。x86_64的整数运算
我们看看64位的rn寄存器出场之后的x86_64的整型指令吧:00000000000006e0 <_Z3addll>: 6e0: 48 8d 04 37 lea (%rdi,%rsi,1),%rax 6e4: c3 retq 6e5: 66 66 2e 0f 1f 84 00 data16 nopw %cs:0x0(%rax,%rax,1) 6ec: 00 00 00 00 00000000000006f0 <_Z3subll>: 6f0: 48 89 f8 mov %rdi,%rax 6f3: 48 29 f0 sub %rsi,%rax 6f6: c3 retq 6f7: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) 6fe: 00 00 0000000000000700 <_Z3mulll>: 700: 48 89 f8 mov %rdi,%rax 703: 48 0f af c6 imul %rsi,%rax 707: c3 retq 708: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) 70f: 00 0000000000000710 <_Z3divll>: 710: 48 89 fa mov %rdi,%rdx 713: 48 89 f8 mov %rdi,%rax 716: 48 c1 fa 3f sar $0x3f,%rdx 71a: 48 f7 fe idiv %rsi 71d: c3 retq 71e: 66 90 xchg %ax,%ax 0000000000000720 <_Z3modll>: 720: 48 89 fa mov %rdi,%rdx 723: 48 89 f8 mov %rdi,%rax 726: 48 c1 fa 3f sar $0x3f,%rdx 72a: 48 f7 fe idiv %rsi 72d: 48 89 d0 mov %rdx,%rax 730: c3 retq 731: 66 66 66 66 66 66 2e data16 data16 data16 data16 data16 nopw %cs:0x0(%rax,%rax,1) 738: 0f 1f 84 00 00 00 00 73f: 00x86的符点运算
从30多年前的80486开始,x86芯片就自带FPU,不再需要8087或者80387这样的专用FPU。1998年,AMD在k6-2处理器中使用的3D Now!指令集开创了SIMD与浮点数的结合。1999年,Intel也随之推出了支持单精度浮点的SSE指令。后来一直发展到SSE 4.2.
以我们的双精度计算的例子为例,这使用到了2000年发布的Pentium 4才引入的SSE2指令集。movsd,addsd,divsd等这些指令都是SSE2指令。00000640 <_Z4dadddd>: 640: 8d 64 24 f4 lea -0xc(%esp),%esp 644: f2 0f 10 44 24 18 movsd 0x18(%esp),%xmm0 64a: f2 0f 58 44 24 10 addsd 0x10(%esp),%xmm0 650: f2 0f 11 04 24 movsd %xmm0,(%esp) 655: dd 04 24 fldl (%esp) 658: 8d 64 24 0c lea 0xc(%esp),%esp 65c: c3 ret 65d: 8d 76 00 lea 0x0(%esi),%esi 00000660 <_Z4dsubdd>: 660: 8d 64 24 f4 lea -0xc(%esp),%esp 664: f2 0f 10 44 24 10 movsd 0x10(%esp),%xmm0 66a: f2 0f 5c 44 24 18 subsd 0x18(%esp),%xmm0 670: f2 0f 11 04 24 movsd %xmm0,(%esp) 675: dd 04 24 fldl (%esp) 678: 8d 64 24 0c lea 0xc(%esp),%esp 67c: c3 ret 67d: 8d 76 00 lea 0x0(%esi),%esi 00000680 <_Z4dmuldd>: 680: 8d 64 24 f4 lea -0xc(%esp),%esp 684: f2 0f 10 44 24 18 movsd 0x18(%esp),%xmm0 68a: f2 0f 59 44 24 10 mulsd 0x10(%esp),%xmm0 690: f2 0f 11 04 24 movsd %xmm0,(%esp) 695: dd 04 24 fldl (%esp) 698: 8d 64 24 0c lea 0xc(%esp),%esp 69c: c3 ret 69d: 8d 76 00 lea 0x0(%esi),%esi 000006a0 <_Z4ddivdd>: 6a0: 8d 64 24 f4 lea -0xc(%esp),%esp 6a4: f2 0f 10 44 24 10 movsd 0x10(%esp),%xmm0 6aa: f2 0f 5e 44 24 18 divsd 0x18(%esp),%xmm0 6b0: f2 0f 11 04 24 movsd %xmm0,(%esp) 6b5: dd 04 24 fldl (%esp) 6b8: 8d 64 24 0c lea 0xc(%esp),%esp 6bc: c3 ret 6bd: 8d 76 00 lea 0x0(%esi),%esix86_64的浮点运算
与arm64有异曲同工之妙,不再需要进出xmm的时候做movsd了,retq指令可以直接从xmm寄存器中返回数据。0000000000000740 <_Z4dadddd>: 740: f2 0f 58 c1 addsd %xmm1,%xmm0 744: c3 retq 745: 66 66 2e 0f 1f 84 00 data16 nopw %cs:0x0(%rax,%rax,1) 74c: 00 00 00 00 0000000000000750 <_Z4dsubdd>: 750: f2 0f 5c c1 subsd %xmm1,%xmm0 754: c3 retq 755: 66 66 2e 0f 1f 84 00 data16 nopw %cs:0x0(%rax,%rax,1) 75c: 00 00 00 00 0000000000000760 <_Z4dmuldd>: 760: f2 0f 59 c1 mulsd %xmm1,%xmm0 764: c3 retq 765: 66 66 2e 0f 1f 84 00 data16 nopw %cs:0x0(%rax,%rax,1) 76c: 00 00 00 00 0000000000000770 <_Z4ddivdd>: 770: f2 0f 5e c1 divsd %xmm1,%xmm0 774: c3 retq 775: 66 66 2e 0f 1f 84 00 data16 nopw %cs:0x0(%rax,%rax,1) 77c: 00 00 00 00MIPS指令集下的计算指令
最后我们看下可能多数同学们都不熟悉的MIPS指令集吧,其实还是很清爽的:000006b0 <_Z3addll>: 6b0: 03e00008 jr ra 6b4: 00851021 addu v0,a0,a1 000006b8 <_Z3subll>: 6b8: 03e00008 jr ra 6bc: 00851023 subu v0,a0,a1 000006c0 <_Z3mulll>: 6c0: 03e00008 jr ra 6c4: 70851002 mul v0,a0,a1 000006c8 <_Z3divll>: 6c8: 0085001a div zero,a0,a1 6cc: 00a001f4 teq a1,zero,0x7 6d0: 03e00008 jr ra 6d4: 00001012 mflo v0 000006d8 <_Z3modll>: 6d8: 0085001a div zero,a0,a1 6dc: 00a001f4 teq a1,zero,0x7 6e0: 03e00008 jr ra 6e4: 00001010 mfhi v0 000006e8 <_Z4dadddd>: 6e8: 03e00008 jr ra 6ec: 462e6000 add.d $f0,$f12,$f14 000006f0 <_Z4dsubdd>: 6f0: 03e00008 jr ra 6f4: 462e6001 sub.d $f0,$f12,$f14 000006f8 <_Z4dmuldd>: 6f8: 03e00008 jr ra 6fc: 462e6002 mul.d $f0,$f12,$f14 00000700 <_Z4ddivdd>: 700: 03e00008 jr ra 704: 462e6003 div.d $f0,$f12,$f14
mips64位与上面也很相似,整型指令基本是在指令前多个d。浮点除了寄存器变长了,也没什么大的变化。0000000000000b80 <_Z3addll>: b80: 03e00009 jr ra b84: 0085102d daddu v0,a0,a1 0000000000000b88 <_Z3subll>: b88: 03e00009 jr ra b8c: 0085102f dsubu v0,a0,a1 0000000000000b90 <_Z3mulll>: b90: 03e00009 jr ra b94: 0085109c dmul v0,a0,a1 0000000000000b98 <_Z3divll>: b98: 0085109e ddiv v0,a0,a1 b9c: 00a001f4 teq a1,zero,0x7 ba0: d81f0000 jrc ra ba4: 00000000 nop 0000000000000ba8 <_Z3modll>: ba8: 008510de dmod v0,a0,a1 bac: 00a001f4 teq a1,zero,0x7 bb0: d81f0000 jrc ra bb4: 00000000 nop 0000000000000bb8 <_Z4dadddd>: bb8: 03e00009 jr ra bbc: 462d6000 add.d $f0,$f12,$f13 0000000000000bc0 <_Z4dsubdd>: bc0: 03e00009 jr ra bc4: 462d6001 sub.d $f0,$f12,$f13 0000000000000bc8 <_Z4dmuldd>: bc8: 03e00009 jr ra bcc: 462d6002 mul.d $f0,$f12,$f13 0000000000000bd0 <_Z4ddivdd>: bd0: 03e00009 jr ra bd4: 462d6003 div.d $f0,$f12,$f13编译出的OAT的浮点运算
节省篇幅,我们先看个dadd的. Dalvik指令很简单,就是一条add-double.3: double com.yunos.xulun.testcppjni2.TestART.dadd(double, double) (dex_method_idx=16780) DEX CODE: 0x0000: ab00 0204 | add-double v0, v2, v4 0x0002: 1000 | return-wide v0
跟C++编译出来的一样,OAT生成的arm64指令也是用fadd来实现的,同样没有vmov什么事儿。CODE: (code_offset=0x0050280c size_offset=0x00502808 size=76)... 0x0050280c: d1400bf0 sub x16, sp, #0x2000 (8192) 0x00502810: b940021f ldr wzr, [x16] suspend point dex PC: 0x0000 0x00502814: f81e0fe0 str x0, [sp, #-32]! 0x00502818: f9000ffe str lr, [sp, #24] 0x0050281c: fd0017e0 str d0, [sp, #40] 0x00502820: fd001be1 str d1, [sp, #48] 0x00502824: 79400250 ldrh w16,(state_and_flags) 0x00502828: 35000130 cbnz w16, #+0x24 (addr 0x50284c)
存到栈里的两个加数,用ldr可以直接装载到NEON寄存器里。然后直接调用fadd去计算。0x0050282c: fd4017e0 ldr d0, [sp, #40] 0x00502830: fd401be1 ldr d1, [sp, #48] 0x00502834: 1e612802 fadd d2, d0, d1 0x00502838: fc00c3e2 stur d2, [sp, #12]
双精度浮点数的返回值并不在通用寄存器x0中,而是直接在NEON寄存器d0中。0x0050283c: fc40c3e0 ldur d0, [sp, #12] 0x00502840: f9400ffe ldr lr, [sp, #24] 0x00502844: 910083ff add sp, sp, #0x20 (32) 0x00502848: d65f03c0 ret 0x0050284c: f9421e5e ldr lr, [tr, #1080] (pTestSuspend) 0x00502850: d63f03c0 blr lr suspend point dex PC: 0x0000 0x00502854: 17fffff6 b #-0x28 (addr 0x50282c)
然后我们再看除法,Dalvik是div-double。4: double com.yunos.xulun.testcppjni2.TestART.ddiv(double, double) (dex_method_idx=16781) DEX CODE: 0x0000: ae00 0204 | div-double v0, v2, v4 0x0002: 1000 | return-wide v0
翻译出来的效果也真不错,真接使用NEON寄存器的fdiv。CODE: (code_offset=0x0050287c size_offset=0x00502878 size=76)... 0x0050287c: d1400bf0 sub x16, sp, #0x2000 (8192) 0x00502880: b940021f ldr wzr, [x16] suspend point dex PC: 0x0000 0x00502884: f81e0fe0 str x0, [sp, #-32]! 0x00502888: f9000ffe str lr, [sp, #24] 0x0050288c: fd0017e0 str d0, [sp, #40] 0x00502890: fd001be1 str d1, [sp, #48] 0x00502894: 79400250 ldrh w16,(state_and_flags) 0x00502898: 35000130 cbnz w16, #+0x24 (addr 0x5028bc) 0x0050289c: fd4017e0 ldr d0, [sp, #40] 0x005028a0: fd401be1 ldr d1, [sp, #48]
除了fadd换成了fdiv,其余跟加法没有区别。0x005028a4: 1e611802 fdiv d2, d0, d1 0x005028a8: fc00c3e2 stur d2, [sp, #12] 0x005028ac: fc40c3e0 ldur d0, [sp, #12] 0x005028b0: f9400ffe ldr lr, [sp, #24] 0x005028b4: 910083ff add sp, sp, #0x20 (32) 0x005028b8: d65f03c0 ret 0x005028bc: f9421e5e ldr lr, [tr, #1080] (pTestSuspend) 0x005028c0: d63f03c0 blr lr suspend point dex PC: 0x0000 0x005028c4: 17fffff6 b #-0x28 (addr 0x50289c)相关文章推荐
- #新闻拍一拍# IBM 招聘广告要求应聘者具备至少 12 年 K8S 使用经验
- vivi下重新调整分区
- ARM Linux系统启动
- Linux及ARM Linux程序开发笔记(零基础入门篇)
- ART OF WEB-SQL-INJECTION第2卷 ORACLE篇
- 解析PHP中VC6 X86和VC9 X86的区别及 Non Thread Safe的意思
- Android中的Dalvik和ART详解及区别分析
- 零基础入门篇之Linux及Arm-Linux程序开发笔记
- 开源操作系统和必备工具网站收集
- 我的 ARM+Linux 学习路线
- 64位Ubuntu 14.04上使用musleabi最小化交叉编译Android版PHP7
- 关于ARM启动的一篇文章
- ARM 的堆栈初始化详解
- ARM条件码与CPSR标志位的关系
- 加载/存储指令
- 关于ARM 汇编的一些疑问
- ARM汇编伪指令介绍
- linux的防火墙及arm与虚拟机共享
- 编译单个驱动的Makefile文件。
- 关于 ART