从 Native 函数调用 Java 函数

最新推荐文章于 2022-06-15 15:16:17 发布
最新推荐文章于 2022-06-15 15:16:17 发布
阅读量1.6k 收藏 2
点赞数 2
分类专栏： Android虚拟机 文章标签： android ART java native
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hl09083253cy/article/details/78418572
版权

从一个Native调用java方法的实例开始：

(gdb) bt
#0  art_quick_invoke_stub () at art/runtime/arch/arm64/quick_entrypoints_arm64.S:667
#1  0x0000007f8265ae54 in art::ArtMethod::Invoke (this=0x7148dd88, self=0x7f75260c00, args=0x7f7a5fedb0, args_size=28, result=0x7f7a5fed90, shorty=0x73654521 "ZIJJI")
    at art/runtime/art_method.cc:289
#2  0x0000007f829f2b5c in art::InvokeWithArgArray (soa=..., method=<optimized out>, arg_array=<optimized out>, result=<optimized out>, shorty=<optimized out>)
    at art/runtime/reflection.cc:439
#3  0x0000007f829f4574 in art::InvokeVirtualOrInterfaceWithVarArgs (soa=..., obj=<optimized out>, mid=<optimized out>, args=...) at art/runtime/reflection.cc:557
#4  0x0000007f828e357c in art::JNI::CallBooleanMethodV (env=<optimized out>, obj=<optimized out>, mid=<optimized out>, args=...) at art/runtime/jni_internal.cc:717
#5  0x0000007f8665d97c in _JNIEnv::CallBooleanMethod (this=this@entry=0x7f75302900, obj=<optimized out>, methodID=<optimized out>) at libnativehelper/include/nativehelper/jni.h:620
#6  0x0000007f866b4454 in JavaBBinder::onTransact (this=0x7f752b0780, code=50, data=..., reply=0x7f7a5ff100, flags=17) at frameworks/base/core/jni/android_util_Binder.cpp:265
#7  0x0000007f85d77174 in android::BBinder::transact (this=0x7f752b0780, code=50, data=..., reply=0x7f7a5ff100, flags=17) at frameworks/native/libs/binder/Binder.cpp:126
#8  0x0000007f85d831a8 in android::IPCThreadState::executeCommand (this=0x7f82d06780, cmd=<optimized out>) at frameworks/native/libs/binder/IPCThreadState.cpp:1115
#9  0x0000007f85d82d04 in android::IPCThreadState::getAndExecuteCommand (this=0x7f82d06780) at frameworks/native/libs/binder/IPCThreadState.cpp:447
#10 0x0000007f85d833fc in android::IPCThreadState::joinThreadPool (this=<optimized out>, isMain=<optimized out>) at frameworks/native/libs/binder/IPCThreadState.cpp:517
#11 0x0000007f85da17e8 in android::PoolThread::threadLoop (this=0x7f77b08b80) at frameworks/native/libs/binder/ProcessState.cpp:63
#12 0x0000007f849f093c in android::Thread::_threadLoop (user=<optimized out>, user@entry=0x7f77b08b80) at system/core/libutils/Threads.cpp:751
#13 0x0000007f86655d1c in android::AndroidRuntime::javaThreadShell (args=<optimized out>) at frameworks/base/core/jni/AndroidRuntime.cpp:1201
#14 0x0000007f851a7c58 in __pthread_start (arg=<optimized out>) at bionic/libc/bionic/pthread_create.cpp:198
#15 0x0000007f85150100 in __start_thread (fn=0x1, arg=0x7148dd88) at bionic/libc/bionic/clone.cpp:41
#16 0x0000000000000000 in ?? ()
(gdb) f 6
#6  0x0000007f866b4454 in JavaBBinder::onTransact (this=0x7f752b0780, code=50, data=..., reply=0x7f7a5ff100, flags=17) at frameworks/base/core/jni/android_util_Binder.cpp:265
warning: Source file is more recent than executable.
265             code, reinterpret_cast<jlong>(&data), reinterpret_cast<jlong>(reply), flags);
 
(gdb) list 263,266
263         //printf("\n");
264         jboolean res = env->CallBooleanMethod(mObject, gBinderOffsets.mExecTransact,
265             code, reinterpret_cast<jlong>(&data), reinterpret_cast<jlong>(reply), flags);
266


在 f6：android_util_Binder.cpp:265 Native的 JavaBBinder::onTransact 函数中，通过 CallBooleanMethod 来调用 gBinderOffsets.mExecTransact (methodID，其初始化就不做介绍了)这个java 方法；

从 f6 到 f0，仍然都是Native函数，其遵循的仍然是 ARM调用约定，且目前还没有真正跳转到 gBinderOffsets.mExecTransact 这个java函数，


在开始跳转之前，有一点需要关注的是： 线程的状态(这里指该线程在虚拟机中的状态)的切换；

在 f4 中：

(gdb) down
#4  0x0000007f86ae357c in art::JNI::CallBooleanMethodV (env=<optimized out>, obj=<optimized out>, mid=<optimized out>, args=...) at art/runtime/jni_internal.cc:717
warning: Source file is more recent than executable.
717     return InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, args).GetZ();
(gdb) list 713,718
713   static jboolean CallBooleanMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
714     CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(obj);
715     CHECK_NON_NULL_ARGUMENT_RETURN_ZERO(mid);
716     ScopedObjectAccess soa(env);
717     return InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, args).GetZ();
718   }


在 line 716: ScopedObjectAccess soa(env); 中完成了 Thread 状态的切换（具体的切换代码在 ScopedObjectAccess以及其父类的构造函数中完成），

把线程状态切换成了 Runnable状态，并且 Shared Hold mutator_lock_; 即线程在开始执行 Java代码之前已经提前把线程状态切换成了 Runnable 状态；

说明：当线程在虚拟机中对应的状态是 Runnable状态时，才能执行 java 代码；当需要执行 Native 代码时，同样提前切换线程状态到 Native状态；


gdb) down
#1  0x0000007f8265ae54 in art::ArtMethod::Invoke (this=0x7148dd88, self=0x7f75260c00, args=0x7f7a5fedb0, args_size=28, result=0x7f7a5fed90, shorty=0x73654521 "ZIJJI")
    at art/runtime/art_method.cc:289
(gdb) art_get_method_name_by_method_id this
android.os.Binder.execTransact "(IJJI)Z"
(gdb) list 288,292
288       if (!IsStatic()) {
289         (*art_quick_invoke_stub)(this, args, args_size, self, result, shorty);
290       } else {
291         (*art_quick_invoke_static_stub)(this, args, args_size, self, result, shorty);
292       }
private boolean execTransact(int code, long dataObj, long replyObj, int flags)；

非 static的java 函数调用前的准备工作是 art_quick_invoke_stub 来做的，而静态的调用，其准备工作是 art_quick_invoke_static_stub负责；

看其参数个数及顺序，发现并无区别；依次是：art::ArtMethod指针，参数指针，参数大小(byte)，art::Thread指针，指向栈上存放返回值的指针 result，java函数对应的 short signature；

我们查一下 args这个参数在哪准备的，因为这个args里面保存着 execTransact(int code, long dataObj, long replyObj, int flags)；这个java函数的所有参数；

(gdb) f 3
#3  0x0000007f829f4574 in art::InvokeVirtualOrInterfaceWithVarArgs (soa=..., obj=<optimized out>, mid=<optimized out>, args=...) at art/runtime/reflection.cc:557
557   InvokeWithArgArray(soa, method, &arg_array, &result, shorty);
(gdb) list 553,557
553   const char* shorty = method->GetInterfaceMethodIfProxy(sizeof(void*))->GetShorty(&shorty_len);
554   JValue result;
555   ArgArray arg_array(shorty, shorty_len);
556   arg_array.BuildArgArrayFromVarArgs(soa, receiver, args);
557   InvokeWithArgArray(soa, method, &arg_array, &result, shorty);
 
 
@art/runtime/reflection.cc
 
 
  void Append(uint32_t value) {
    arg_array_[num_bytes_ / 4] = value;
    num_bytes_ += 4;
  }
 
 
  void BuildArgArrayFromVarArgs(const ScopedObjectAccessAlreadyRunnable& soa,
                                mirror::Object* receiver, va_list ap)
      SHARED_REQUIRES(Locks::mutator_lock_) {
    // Set receiver if non-null (method is not static)
    if (receiver != nullptr) {
      Append(receiver);
    }
    for (size_t i = 1; i < shorty_len_; ++i) {
      switch (shorty_[i]) {
        case 'Z':
        case 'B':
        case 'C':
        case 'S':
        case 'I':
          Append(va_arg(ap, jint));
          break;
        case 'F':
          AppendFloat(va_arg(ap, jdouble));
          break;
        case 'L':
          Append(soa.Decode<mirror::Object*>(va_arg(ap, jobject)));
          break;
        case 'D':
          AppendDouble(va_arg(ap, jdouble));
          break;
        case 'J':
          AppendWide(va_arg(ap, jlong));
          break;
#ifndef NDEBUG
        default:
          LOG(FATAL) << "Unexpected shorty character: " << shorty_[i];
#endif
      }
    }
  }
除了 double，long，都是 4byte；
    // Primitives.
    case JDWP::JT_BYTE:    return 'B';
    case JDWP::JT_CHAR:    return 'C';
    case JDWP::JT_FLOAT:   return 'F';
    case JDWP::JT_DOUBLE:  return 'D';   8byte
    case JDWP::JT_INT:     return 'I';
    case JDWP::JT_LONG:    return 'J';   8byte
    case JDWP::JT_SHORT:   return 'S';
    case JDWP::JT_VOID:    return 'V';
    case JDWP::JT_BOOLEAN: return 'Z';
    // Reference types.
    case JDWP::JT_ARRAY:
    case JDWP::JT_OBJECT:
    case JDWP::JT_STRING:
    case JDWP::JT_THREAD:
    case JDWP::JT_THREAD_GROUP:
    case JDWP::JT_CLASS_LOADER:
    case JDWP::JT_CLASS_OBJECT:
      return 'L';


参数是通过 ArgArray 的 BuildArgArrayFromVarArgs()这个函数准备的，保存在其成员 arg_array_数组里，通过AppendXXX()来填充数组；

从这个函数里，可以看到数据的顺序：

非static方法时，传递的receiver(java 类对象)不是 nullptr，会把this指针放在 arg_array_的第一个元素里；

而调用static方法时，参数列表中是没有this对象的，arg_array_的第一个元素就是对应 static函数的第一个参数；

对于我们正在分析的函数 private boolean execTransact(int code, long dataObj, long replyObj, int flags)；为其构建的 arg_array_的情况是：

this(Binder.java)
code dataObj replyObj flags


在接下来的调用 (*art_quick_invoke_stub)(this, args, args_size, self, result, shorty);时， args就是 arg_array_首地址；


我们看下，在art::ArtMethod::Invoke函数跳转到 art_quick_invoke_stub之前的参数：

0x0000007f8265ae38 <+184>: mov x0, x20  ；this(ArtMethod)
0x0000007f8265ae3c <+188>: mov x1, x22  ; args
0x0000007f8265ae40 <+192>: mov w2, w24  ; args_size
0x0000007f8265ae44 <+196>: mov x3, x21  ; self(art::Thread*)
0x0000007f8265ae48 <+200>: mov x4, x19  ; result
0x0000007f8265ae4c <+204>: mov x5, x23  ; shorty
0x0000007f8265ae50 <+208>: bl  0x7f8264daf0 <art_quick_invoke_stub>

ARM64的调用约定，前面的 6个参数依次存放在 x0~x5;

函数 art_quick_invoke_stub ，是为了执行 java 函数之前做一个准备工作；

接下来，我们跳转到 art_quick_invoke_stub：

(gdb) disassemble
Dump of assembler code for function art_quick_invoke_stub:
=> 0x0000007f8264daf0 <+0>:    mov x9, sp                          ;x9保存函数 art::ArtMethod::Invoke 的sp
   0x0000007f8264daf4 <+4>:   add x10, x2, #0x80                  ;x2是 arg_size, x10=x2+0x80
   0x0000007f8264daf8 <+8>:   sub x10, sp, x10                    ;x10=sp - x10
   0x0000007f8264dafc <+12>:  and x10, x10, #0xfffffffffffffff0   ;x10进行16字节对齐
   0x0000007f8264db00 <+16>:  mov sp, x10                         ;sp移动，相当于开辟了 (x9-x10)byte的栈空间，用来存放：1.args (arg_size byte) 2.ArtMethod(8 byte) 3.保存 callee save register (0x78 byte)
   0x0000007f8264db04 <+20>:  sub x10, x9, #0x78                  ;临近上一个frame的 0x78的栈空间，下面的关于 x10的操作，都是在保存reg到，这个range的栈上
   0x0000007f8264db08 <+24>:  str x28, [x10,#112]                
   0x0000007f8264db0c <+28>:  stp x26, x27, [x10,#96]
   0x0000007f8264db10 <+32>:  stp x24, x25, [x10,#80]
   0x0000007f8264db14 <+36>:  stp x22, x23, [x10,#64]
   0x0000007f8264db18 <+40>:  stp x20, x21, [x10,#48]
   0x0000007f8264db1c <+44>:  stp x9, x19, [x10,#32]
   0x0000007f8264db20 <+48>:  stp x4, x5, [x10,#16]               ;其中x4，存放的是 JValue result的地址，最终java函数的返回值要存入 result中
   0x0000007f8264db24 <+52>:  stp x29, x30, [x10]                 ;紧邻上一个 frame的 0x78的空间填充完成；
   0x0000007f8264db28 <+56>:  mov x29, x10                        ;记录 frame pointer
   0x0000007f8264db2c <+60>:  mov x19, x3                         ;把 Thread* 放到 x19 来保存
   0x0000007f8264db30 <+64>:  add x9, sp, #0x8                    ;跳过当前frame栈顶的第一个数据,即跳过 ArtMethod，x9指向第二个数据
 
   0x0000007f8264db34 <+68>:  cmp w2, #0x0                                       ; 如果 arg_size 等于 0则跳转，否则从 arg_array 拷贝数据到栈上，直到arg_array中所有数据拷贝到栈上
   0x0000007f8264db38 <+72>:  b.eq    0x7f8264db4c <art_quick_invoke_stub+92>
   0x0000007f8264db3c <+76>:  sub w2, w2, #0x4                                   ; index = arg_size - 4，index = index -4
   0x0000007f8264db40 <+80>:  ldr w10, [x1,x2]                                   ; 从 arg_array取出index对应的arg，从后向前获取数组元素
   0x0000007f8264db44 <+84>:  str w10, [x9,x2]                                   ; 将 arg存放到栈上的 args区域，每次拷贝 4 byte，先拷贝到高地址，再拷贝到低地址
   0x0000007f8264db48 <+88>:  b   0x7f8264db34 <art_quick_invoke_stub+68>        ; 继续拷贝
 
   0x0000007f8264db4c <+92>:  str xzr, [sp]                                      ; 把栈顶的第一个数据填充0，实际上这个数据对应一个 ArtMethod指针
   0x0000007f8264db50 <+96>:  adr x11, 0x7f8264dbe0 <art_quick_invoke_stub+240>  ; 记录该函数的几个入口
   0x0000007f8264db54 <+100>: adr x12, 0x7f8264dc28 <art_quick_invoke_stub+312>
   0x0000007f8264db58 <+104>: adr x13, 0x7f8264dc70 <art_quick_invoke_stub+384>
   0x0000007f8264db5c <+108>: adr x14, 0x7f8264dcd0 <art_quick_invoke_stub+480>
   0x0000007f8264db60 <+112>: mov x8, #0x0                    // #0              ; integer offset
   0x0000007f8264db64 <+116>: mov x15, #0x0                       // #0          ; floating offset
   0x0000007f8264db68 <+120>: add x10, x5, #0x1                                  ; short signatur的地址，+0x1是因为第一个是 return value的shorty，我们是准备参数，所以要跳过： shorty=0x73654521 "ZIJJI"
   0x0000007f8264db6c <+124>: ldr w1, [x9],#4                                    ; x9指向栈上的第一个参数，当函数不是static时，第一个参数是函数对应的类this对象，这里把 this放到 r1作为参数传递
   0x0000007f8264db70 <+128>: ldrb    w17, [x10],#1
   0x0000007f8264db74 <+132>: cbz w17, 0x7f8264dd30 <art_quick_invoke_stub+576>

在此时，art_quick_invoke_stub 的栈空间情况：

由于 arg_size = 28 = 4(append(this)) + （4+8+8+4）"IJJI" (遍历shorty时从1开始，忽略返回值)；

所以 x2+0x80 = 28+0x80 =  0x1c+0x80 = 0x9c，所以 framesize = 0xa0 = 160 byte;

讲一下这里的对齐，很显然，x10= sp - 10  过后，要和 #0xfffffffffffffff0 做and运算，运算后会把末尾丢掉，由于栈是从高地址向低地址开辟，所以相当于多开辟了部分空间；

栈空间如下：



已经贴出来的  art_quick_invoke_stub 的这段代码就已经把栈空间准备好了；

此时的寄存器情况：

x0: ArtMethod*

x1: this (Binder.java)

其余参数还没有完成准备；

ARM64 上 art_quick_invoke_stub调用 java 函数的调用约定：

* Outgoing registers:
* x0 - Method*
* x1-x7 - integer parameters.
* d0-d7 - Floating point parameters.
* xSELF = self
* SP = & of ArtMethod*
* x1 = "this" pointer.
*

看起来我们才刚刚准备好 x0，x1 ，xSELF(x19) 和 SP；继续看剩下的部分代码：

   0x0000007f8264db68 <+120>: add x10, x5, #0x1                                  ; short signatur的地址，+0x1是因为第一个是 return value的shorty，我们是准备参数，所以要跳过： shorty=0x73654521 "ZIJJI"
   0x0000007f8264db6c <+124>: ldr w1, [x9],#4                                    ; x9指向栈上的第一个参数，当函数不是static时，第一个参数是函数对应的类this对象，这里把 this放到 r1作为参数传递，并且x9=x9+4,指向arg1
   0x0000007f8264db70 <+128>: ldrb    w17, [x10],#1                              ; 从shorty signature获取一个byte到 w17，并且 x10=x10+1,指向signature下一个字节
   0x0000007f8264db74 <+132>: cbz w17, 0x7f8264dd30 <art_quick_invoke_stub+576>  ; 0，字符串结束，signature结束，参数准备完成，跳转到 +576位置，准备执行
   0x0000007f8264db78 <+136>: cmp w17, #0x46                                     ; 是否是字符 'F'，floating 参数
   0x0000007f8264db7c <+140>: b.ne    0x7f8264db90 <art_quick_invoke_stub+160>   ; 如果不是字符 'F'，进行下一步判断是否字符 'D'
   0x0000007f8264db80 <+144>: cmp x15, #0x60                                     ; 判断 floating register是否用完了
   0x0000007f8264db84 <+148>: b.eq    0x7f8264dbd0 <art_quick_invoke_stub+224>   ; 如
   0x0000007f8264db88 <+152>: add x17, x13, x15
   0x0000007f8264db8c <+156>: br  x17
   0x0000007f8264db90 <+160>: cmp w17, #0x44                                     ; 是否是字符 'D'，double 参数
   0x0000007f8264db94 <+164>: b.ne    0x7f8264dba8 <art_quick_invoke_stub+184>   ; 如果不是字符 'D'，进行下一步判断是否字符 'J'
   0x0000007f8264db98 <+168>: cmp x15, #0x60                                     ; 判断 floating register是否用完了
   0x0000007f8264db9c <+172>: b.eq    0x7f8264dbd8 <art_quick_invoke_stub+232>
   0x0000007f8264dba0 <+176>: add x17, x14, x15
   0x0000007f8264dba4 <+180>: br  x17
   0x0000007f8264dba8 <+184>: cmp w17, #0x4a                                     ; 是否是字符 'J'，long 参数
   0x0000007f8264dbac <+188>: b.ne    0x7f8264dbc0 <art_quick_invoke_stub+208>   ; 如果不是字符 'J'，进入 else分支
   0x0000007f8264dbb0 <+192>: cmp x8, #0x48                                      ; 判断 integer register是否用完了
   0x0000007f8264dbb4 <+196>: b.eq    0x7f8264dbd8 <art_quick_invoke_stub+232>
   0x0000007f8264dbb8 <+200>: add x17, x12, x8                                   ; 如果是 long参数，跳转到 x12 + x8(code offset)处，进行load参数；x12= 0x7f8264dc28 <art_quick_invoke_stub+312>
   0x0000007f8264dbbc <+204>: br  x17
   0x0000007f8264dbc0 <+208>: cmp x8, #0x48                                      ; 不是字符 'F', 'D', 'J'，判断 integer register是否用完了
   0x0000007f8264dbc4 <+212>: b.eq    0x7f8264dbd0 <art_quick_invoke_stub+224>
   0x0000007f8264dbc8 <+216>: add x17, x11, x8                                   ; 这个实例中，shorty "IJJI"，第一个参数进入else分支， x17=x11+0,而x11在上面初始化过，是 0x7f8264dbe0 <art_quick_invoke_stub+240>
   0x0000007f8264dbcc <+220>: br  x17
   0x0000007f8264dbd0 <+224>: add x9, x9, #0x4                                   ; x9向栈底移动 4byte，(上一个参数是floating，会走到该分支)，移动后，x9指向floating参数后的下一个参数
   0x0000007f8264dbd4 <+228>: b   0x7f8264db70 <art_quick_invoke_stub+128>       ; 跳转到 +128处，获取第二个参数对应的 shorty，并进行过滤
   0x0000007f8264dbd8 <+232>: add x9, x9, #0x8                                   ; x9向栈底移动 8byte，(当上一个参数是 double/long时，会走到该分支)，移动后，x9指向 double/long 参数后的下一个参数
   0x0000007f8264dbdc <+236>: b   0x7f8264db70 <art_quick_invoke_stub+128>
   0x0000007f8264dbe0 <+240>: ldr w2, [x9],#4                                    ; load java method的第2个参数, *************当需要load的参数是 4 byte且是integer，对应的分支****************************
   0x0000007f8264dbe4 <+244>: add x8, x8, #0xc                                   ; x8 = x8+12,代码偏移
   0x0000007f8264dbe8 <+248>: b   0x7f8264db70 <art_quick_invoke_stub+128>       ; 准备下一个参数
   0x0000007f8264dbec <+252>: ldr w3, [x9],#4
   0x0000007f8264dbf0 <+256>: add x8, x8, #0xc
   0x0000007f8264dbf4 <+260>: b   0x7f8264db70 <art_quick_invoke_stub+128>
   0x0000007f8264dbf8 <+264>: ldr w4, [x9],#4
   0x0000007f8264dbfc <+268>: add x8, x8, #0xc
   0x0000007f8264dc00 <+272>: b   0x7f8264db70 <art_quick_invoke_stub+128>
   0x0000007f8264dc04 <+276>: ldr w5, [x9],#4                                    ; load java method的第5个参数
   0x0000007f8264dc08 <+280>: add x8, x8, #0xc
   0x0000007f8264dc0c <+284>: b   0x7f8264db70 <art_quick_invoke_stub+128>
   0x0000007f8264dc10 <+288>: ldr w6, [x9],#4
   0x0000007f8264dc14 <+292>: add x8, x8, #0xc
   0x0000007f8264dc18 <+296>: b   0x7f8264db70 <art_quick_invoke_stub+128>
   0x0000007f8264dc1c <+300>: ldr w7, [x9],#4
   0x0000007f8264dc20 <+304>: add x8, x8, #0xc
   0x0000007f8264dc24 <+308>: b   0x7f8264db70 <art_quick_invoke_stub+128>
   0x0000007f8264dc28 <+312>: ldr x2, [x9],#8                                    ; ****************************当需要load的参数是 8 byte且是integer ，对应的分支****************************
   0x0000007f8264dc2c <+316>: add x8, x8, #0xc
   0x0000007f8264dc30 <+320>: b   0x7f8264db70 <art_quick_invoke_stub+128>
   0x0000007f8264dc34 <+324>: ldr x3, [x9],#8                                    ; load java method的第3个参数
   0x0000007f8264dc38 <+328>: add x8, x8, #0xc                                   ; x8 = x8+12,代码偏移
   0x0000007f8264dc3c <+332>: b   0x7f8264db70 <art_quick_invoke_stub+128>       ; 准备下一个参数
   0x0000007f8264dc40 <+336>: ldr x4, [x9],#8                                    ; load java method的第4个参数
   0x0000007f8264dc44 <+340>: add x8, x8, #0xc
   0x0000007f8264dc48 <+344>: b   0x7f8264db70 <art_quick_invoke_stub+128>
   0x0000007f8264dc4c <+348>: ldr x5, [x9],#8
   0x0000007f8264dc50 <+352>: add x8, x8, #0xc
   0x0000007f8264dc54 <+356>: b   0x7f8264db70 <art_quick_invoke_stub+128>
   0x0000007f8264dc58 <+360>: ldr x6, [x9],#8
   0x0000007f8264dc5c <+364>: add x8, x8, #0xc
   0x0000007f8264dc60 <+368>: b   0x7f8264db70 <art_quick_invoke_stub+128>
   0x0000007f8264dc64 <+372>: ldr x7, [x9],#8
   0x0000007f8264dc68 <+376>: add x8, x8, #0xc
   0x0000007f8264dc6c <+380>: b   0x7f8264db70 <art_quick_invoke_stub+128>
   0x0000007f8264dc70 <+384>: ldr s0, [x9],#4                                    ;****************************当需要load的参数是 4 byte且是 floating 时的分支****************************
   0x0000007f8264dc74 <+388>: add x15, x15, #0xc
   0x0000007f8264dc78 <+392>: b   0x7f8264db70 <art_quick_invoke_stub+128>
   0x0000007f8264dc7c <+396>: ldr s1, [x9],#4
   0x0000007f8264dc80 <+400>: add x15, x15, #0xc
---Type <return> to continue, or q <return> to quit---
   0x0000007f8264dc84 <+404>: b   0x7f8264db70 <art_quick_invoke_stub+128>
   0x0000007f8264dc88 <+408>: ldr s2, [x9],#4
   0x0000007f8264dc8c <+412>: add x15, x15, #0xc
   0x0000007f8264dc90 <+416>: b   0x7f8264db70 <art_quick_invoke_stub+128>
   0x0000007f8264dc94 <+420>: ldr s3, [x9],#4
   0x0000007f8264dc98 <+424>: add x15, x15, #0xc
   0x0000007f8264dc9c <+428>: b   0x7f8264db70 <art_quick_invoke_stub+128>
   0x0000007f8264dca0 <+432>: ldr s4, [x9],#4
   0x0000007f8264dca4 <+436>: add x15, x15, #0xc
   0x0000007f8264dca8 <+440>: b   0x7f8264db70 <art_quick_invoke_stub+128>
   0x0000007f8264dcac <+444>: ldr s5, [x9],#4
   0x0000007f8264dcb0 <+448>: add x15, x15, #0xc
   0x0000007f8264dcb4 <+452>: b   0x7f8264db70 <art_quick_invoke_stub+128>
   0x0000007f8264dcb8 <+456>: ldr s6, [x9],#4
   0x0000007f8264dcbc <+460>: add x15, x15, #0xc
   0x0000007f8264dcc0 <+464>: b   0x7f8264db70 <art_quick_invoke_stub+128>
   0x0000007f8264dcc4 <+468>: ldr s7, [x9],#4
   0x0000007f8264dcc8 <+472>: add x15, x15, #0xc
   0x0000007f8264dccc <+476>: b   0x7f8264db70 <art_quick_invoke_stub+128>
   0x0000007f8264dcd0 <+480>: ldr d0, [x9],#8                                    ;****************************当需要load的参数是 8 byte，且是 double 时的分支****************************
   0x0000007f8264dcd4 <+484>: add x15, x15, #0xc
   0x0000007f8264dcd8 <+488>: b   0x7f8264db70 <art_quick_invoke_stub+128>
   0x0000007f8264dcdc <+492>: ldr d1, [x9],#8
   0x0000007f8264dce0 <+496>: add x15, x15, #0xc
   0x0000007f8264dce4 <+500>: b   0x7f8264db70 <art_quick_invoke_stub+128>
   0x0000007f8264dce8 <+504>: ldr d2, [x9],#8
   0x0000007f8264dcec <+508>: add x15, x15, #0xc
   0x0000007f8264dcf0 <+512>: b   0x7f8264db70 <art_quick_invoke_stub+128>
   0x0000007f8264dcf4 <+516>: ldr d3, [x9],#8
   0x0000007f8264dcf8 <+520>: add x15, x15, #0xc
   0x0000007f8264dcfc <+524>: b   0x7f8264db70 <art_quick_invoke_stub+128>
   0x0000007f8264dd00 <+528>: ldr d4, [x9],#8
   0x0000007f8264dd04 <+532>: add x15, x15, #0xc
   0x0000007f8264dd08 <+536>: b   0x7f8264db70 <art_quick_invoke_stub+128>
   0x0000007f8264dd0c <+540>: ldr d5, [x9],#8
   0x0000007f8264dd10 <+544>: add x15, x15, #0xc
   0x0000007f8264dd14 <+548>: b   0x7f8264db70 <art_quick_invoke_stub+128>
   0x0000007f8264dd18 <+552>: ldr d6, [x9],#8
   0x0000007f8264dd1c <+556>: add x15, x15, #0xc
   0x0000007f8264dd20 <+560>: b   0x7f8264db70 <art_quick_invoke_stub+128>
   0x0000007f8264dd24 <+564>: ldr d7, [x9],#8
   0x0000007f8264dd28 <+568>: add x15, x15, #0xc                               
   0x0000007f8264dd2c <+572>: b   0x7f8264db70 <art_quick_invoke_stub+128>       ;**************** 准备参数的代码，至此结束，参数已经准备完毕 *****************
 
   0x0000007f8264dd30 <+576>: ldr x9, [x0,#48]                                   ; x0是 ArtMethod*,48是64bit时METHOD_QUICK_CODE_OFFSET对应的值，这条指令执行结束后，x9的值是 entry_point_from_quick_compiled_code_
   0x0000007f8264dd34 <+580>: blr x9                                             ; 跳转到 entry_point_from_quick_compiled_code_
 
   0x0000007f8264dd38 <+584>: ldp x4, x5, [x29,#16]                              ; 恢复寄存器，准备返回，其中x4 是 JValue result的地址；x5是shorty addr
   0x0000007f8264dd3c <+588>: ldr x28, [x29,#112]
   0x0000007f8264dd40 <+592>: ldp x26, x27, [x29,#96]
   0x0000007f8264dd44 <+596>: ldp x24, x25, [x29,#80]
   0x0000007f8264dd48 <+600>: ldp x22, x23, [x29,#64]
   0x0000007f8264dd4c <+604>: ldp x20, x21, [x29,#48]
   0x0000007f8264dd50 <+608>: ldrb    w10, [x5]                                   ;从x5获取 shorty第一个字节(代表返回值)
   0x0000007f8264dd54 <+612>: cmp w10, #0x56                                      ;返回值的shorty是否 'V'，即void
   0x0000007f8264dd58 <+616>: b.eq    0x7f8264dd80 <art_quick_invoke_stub+656>
   0x0000007f8264dd5c <+620>: cmp w10, #0x44                                      ;'D' 是否 double 返回值
   0x0000007f8264dd60 <+624>: b.ne    0x7f8264dd6c <art_quick_invoke_stub+636>
   0x0000007f8264dd64 <+628>: str d0, [x4]                                        ;保存double值到 result中
   0x0000007f8264dd68 <+632>: b   0x7f8264dd80 <art_quick_invoke_stub+656>
   0x0000007f8264dd6c <+636>: cmp w10, #0x46                                      ;'F' 是否 floating 返回值
   0x0000007f8264dd70 <+640>: b.ne    0x7f8264dd7c <art_quick_invoke_stub+652>
   0x0000007f8264dd74 <+644>: str s0, [x4]                                        ;保存 floating值到 result中
   0x0000007f8264dd78 <+648>: b   0x7f8264dd80 <art_quick_invoke_stub+656>
   0x0000007f8264dd7c <+652>: str x0, [x4]                                        ;返回值类型不是 'V','D','F', 保存 x0到result中，不关注 32bit/64bit
   0x0000007f8264dd80 <+656>: ldp x2, x19, [x29,#32]
   0x0000007f8264dd84 <+660>: mov sp, x2
   0x0000007f8264dd88 <+664>: ldp x29, x30, [x29]
   0x0000007f8264dd8c <+668>: ret

TODO：

1.从Native调用 java method时，总是跳转到 ArtMethod的 entry_point_from_quick_compiled_code_，假如这个method没有被编译，那么它就没有对应的 native code，那怎么执行呢，后续分析 trampoline；


答：在 ClassLinker::LinkCode的时候，如果一个非static，非jni的method 没有编译 quick code，那么其就会通过：

       method→SetEntryPointFromQuickCompiledCode(GetQuickToInterpreterBridge());把 entry_point_from_quick_compiled_code_ 设置为 art_quick_to_interpreter_bridge，

       最终调用 art_quick_to_interpreter_bridge时会跳转到 artQuickToInterpreterBridge() →  interpreter::EnterInterpreterFromEntryPoint() → interpreter::Execute() → ExecuteMterpImp()进行解释执行代码；

流程图：



hl09083253cy
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
trace_natives:一个小脚本，用于trace so中native函数的调用
03-25
trace_natives 一个IDA小脚本，获取SO代码段中所有函数的替换地址，再使用frida-trace批量跟踪so函数的调用。 使用方法 1.将traceNatives.py丢进IDA插件目录中 2.IDA中，Edit-Plugins-traceNatives IDA输出窗口就会显示如下字眼： 使用方法如下：frida-trace -UF -OC：\ Users \ Lenovo \ Desktop \ 2021 \ mt \ libmtguard.txt 代码出发点 和，朋友在分析android so的时候，他感慨一句，“唉，要是能捋清整个流程就好了”。确实，搞清楚流向的件挺重要的事，只要代码复杂一些，函数多一些，分支多一些，通过函数指针还原多一些……无论哪一个多一些，静态分析SO就会变得十分恼人。 得益于Frida布道师以及看雪Android逆向课程的大力推广，近来入门And
Android ART虚拟机执行引擎－本地代码的执行（十）
lin20080410的专栏
02-26 1100
以前面分析的虚拟机的启动流程　ART 虚拟机的启动　为例。zygote在调用AndroidRuntime的start函数时传入一个class名称：runtime.start("com.android.internal.os.ZygoteInit", args, zygote); 这个classname就是要被执行的类对象，一旦虚拟机启动完成，就会调用这个类的main方法。因为zygote程序本身有...
java jni调用c函数实例分享(java调用c函数)
09-04
Java代码中调用C/C++代码,当然是使用JNI，JNI是Java native interface的简写，可以译作Java原生接口，下面看实例吧
fn-native-java:使用GraalVM的Fn Project本机Java函数
05-10
使用GraalVM的Fn Project本机Java函数 用法 构建和部署功能 fn deploy --app javafn --local 注意：需要安装mvn CLI。 调用函数 curl -d 'Leonardo' http://localhost:8080/r/javafn/native 常见问题解答：如何使用GraalVM创建新的本机Java函数？ 使用fn init --runtime java8创建一个新的Java函数。 添加reflection.json文件（请参阅示例和 ）。 复制并将CMD更改为您的入口点。 更改使用docker运行并添加生成命令。 注意：使用更高级的用例也在起作用。
ReactNative源码分析之NativeModule调用堆栈分析
01-03
当前分析的ReactNative版本为0.61.5: 一、NativeModule基本使用 我们知道，要想访问原生提供的功能，需要通过继承NativeModule，并提供相关的方法，只有这样JS层才能直接访问。 举个例子，StatusBarModule类： /** {@link NativeModule} that allows changing the appearance of the status bar. */ @ReactModule(name = StatusBarModule.NAME) public class StatusBarModule extends ReactCont
Android ART执行类方法的过程
weixin_43545911的博客
05-30 1020
/frameworks/base/core/jni/AndroidRuntime.cpp 7.0之前ART只有AOT模式，7.0之后采用解释、JIT、AOT混合执行。方法调用有如下几种流程： 机器码–>机器码 机器码–>解释 解释–>解释 解释–>机器码 基本执行流程 java方法在ART虚拟机中以ArtMethod表示，其中entry_point_from_quick_compiled_code_保存的是方法的入口地址，在类加载的LinkCode()函数中设置入口地址。 从zygo
Java与Native相互调用示例及讲解
u011376563的博客
06-09 1636
今天介绍ru'hjava通过jni调用native方法，同时native层能够回调java方法的示例 TestNative.java： public class TestNative { static { //加载native层源码编译得到的libtest_native.so System.loadLibrary("test_native"); } public TestNative() { } //该方法...
xposed的实现
xiaolli的专栏
07-22 881
一、xposed 的使用： hook一个方法， 需要首先实现一个XC_MethodHook 用于，定义调用 方法之前与之后执行的操作。 找到要hook的类，然后调用hookAllMethods 去hook 对应方法，代码为： XC_MethodHook callback = new XC_MethodHook() { //调用原方法之前调用 @Override protected void beforeHookedMethod(MethodHo
native层 调用java方法
liuxs2009的专栏
03-21 524
先尝试直接获取环境变量，如果失败，则尝试附着 int ret = g_JavaVM->GetEnv((void **) &env, JNI_VERSION_1_4); if (ret < 0) { int ret = g_JavaVM->AttachCurrentThread(&env, NULL);...
ART的函数运行机制
RFZ_322的博客
06-15 2162
的类加载的主要过程如下： 作为 通过 处理进程创建请求， 是在 函数里调用 监听。接收到 的 请求之后，调用 ，调用 创建新进程进程创建之后，由 来初始化进程，最终会调用 函数 会初始化 。类的加载经过了 () 。这个初始化过程， 和 都是一样的。 的 由 的 来加载类。 类的加载除了创建 只外，还有加载类的字段和方法，这个由 来完成。 函数的执行 一旦类的加载完成，那么就可以调用类的成员函数了，之前的解释器运行机制那篇文章介绍过， 的执行是以 为执行单元的，所以
androidnative.pri:在不使用JNI的情况下从Qt调用Android函数
05-16
在不使用JNI的情况下从Qt调用Android函数 它是项目的一个分支，旨在提供一个无需使用JNI即可从Qt / QML访问Android功能的库。 备注：该项目仅支持gradle构建系统。 特征 SystemDispatcher-C ++ / Qt和Java / Android的消息队列 使用C ++发送消息，使用Java接收消息，反之亦然。 数据类型将自动转换（例如QMap <-> java.util.Map）。 无需用JNI编写。 它可以用来编写自己的Java代码 捆绑组件 图像选择器 吐司 视频选择器 SMS收件箱阅读器（通过Util组件） 拨打电话，makeCall（通过Util组件） 使用ACTION_SEND共享内容（通过共享组件） 查询和处理GPS设置（通过Util组件） android.os.Environment / android.os.Debug /
使用Java Native Interface调用本地C++代码.txt
08-17
在这个例子中，我们使用Java Native Interface（JNI）来调用本地的C++代码。首先，我们需要在Java类中声明一个native方法，并使用`native`关键字来修饰它。然后，我们需要使用`System.loadLibrary()`方法来加载本地库，这个库包含了本地方法的实现。最后，我们可以像调用普通的Java方法一样调用本地方法。 在C++中，我们需要使用JNI的API来实现本地方法的实现。在这个例子中，我们定义了一个名为`printMessage()`的本地方法，并在其中输出了一条信息到控制台。注意，我们在实现函数中使用了`JNIEnv *env`和`jobject obj`这两个参数，它们分别表示JNI的环境指针和当前对象的引用。这些参数可以让我们方便地在Java和C++之间传递数据和调用其他本地方法。
android hook 自动执行,Android Art Hook 技术方案
weixin_32656107的博客
05-27 359
Android Art Hook 技术方案by 低端码农 at 2015.4.130x1 开始Anddroid上的ART从5.0之后变成默认的选择，可见ART的重要性，目前关于Dalvik Hook方面研究的文章很多，但我在网上却找不到关于ART Hook相关的文章，甚至连鼎鼎大名的XPosed和Cydia Substrate到目前为止也不支持ART的Hook。当然我相信，技术方案他们肯定是的，估...
YAHFA--ART环境下的Hook框架
朱小南的博客
05-26 6576
在Android Dalvik时代，最流行的Hook框架非Xposed莫属了。各种功能强大的Xposed插件极大地丰富了Android的可玩性，而对于安全研究人员来说，hook则是应用逆向工作中的一项非常有效的手段。 但是，进入到ART时代后，情况逐渐发生了变化。Xposed框架对系统进行了较大的改动，因此其安装适配难度显著提高；另一方面，随着近年来热修复技术的兴起，各大国内厂商也纷纷推出了
Java之native函数
zhangwancongcsdn的博客
07-14 3482
文章目录1、native方法介绍2、Java程序的编写和头文件生成3、C++函数编写及dll生成3.1、创建C++工程3.2、修改编译器设置3.3、添加头文件3.4、修改Main.h以及实现其中的函数3.5、编译生成dll文件并运行Java程序4、题外话 我们在使用hashmap时，有时候会看到hashcode的源码。最原始的hashcode源码是位于Object类中，是一个native方法。na...
Android运行时ART执行类方法的过程分析
热门推荐
老罗的Android之旅
11-10 6万+
在前面一篇文章中，我们分析了ART运行时加载类以及查找其方法的过程。一旦找到了目标类方法，我们就可以获得它的DEX字节码或者本地机器指令，这样就可以对它进行执行了。在ART运行时中，类方法的执行方式有两种。一种是像Dalvik虚拟机一样，将其DEX字节码交给解释器执行；另一种则是直接将其本地机器指令交给CPU执行。在本文中，我们就将通过分析ART运行时执行类方法的过程来理解ART运行时的运行原理。
native函数 java_详解Java中native方法的使用
weixin_39714015的博客
02-12 893
今天在网上学习时碰到有关于 native修饰符所修饰的方法，上网查了查，觉得很有意思记录一下1、native简介简单地讲，一个Native Method就是一个java调用非java代码的接口。一个Native Method是这样一个java的方法：该方法的实现由非java语言实现，比如C。这个特征并非java所特有，很多其它的编程语言都有这一机制，比如在C＋＋中，你可以用extern “C”告知...
Android ANR Trace 详解
大将军王虎剩的专栏
11-01 2万+
本文主要总结一下 Signal Catcher 线程在收到 SIGQUIT(3)后，Dump 信息的流程。 Android SourceCode: 6.0 Keyword：block signal，kRunnable，kSuspended，Checkpoint，traces.txt 1.ART中 block 信号 信号的block在虚拟机
native函数调用
最新发布
10-09
在编程中，native函数调用通常指的是在高级语言中调用底层语言（如C或C++）编写的函数。这种调用方式可以提高程序的性能和效率，特别是在处理一些复杂的计算或与硬件交互的情况下。 要在高级语言（如Java或Python）...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值