前往小程序,Get更优阅读体验!
立即前往
首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >[inside hotspot] java方法调用的StubCode

[inside hotspot] java方法调用的StubCode

作者头像
racaljk
发布2019-02-26 10:24:32
3.4K0
发布2019-02-26 10:24:32
举报
文章被收录于专栏:racaljk

[inside hotspot] java方法调用的StubCode

众所周知jvm有invokestatic,invokedynamic,invokestatic,invokespecial,invokevirtual几条方法调用指令,每个负责调用不同的方法, 而这些方法调用落实到hotspot上都位于hotspot\src\share\vm\runtime\javaCalls.hppJavaCalls :

1. JavaCalls

代码语言:javascript
复制
class JavaCalls: AllStatic {
  static void call_helper(JavaValue* result, const methodHandle& method, JavaCallArguments* args, TRAPS);
 public:
  // call_special
  // ------------
  // The receiver must be first oop in argument list
  static void call_special(JavaValue* result, KlassHandle klass, Symbol* name, Symbol* signature, JavaCallArguments* args, TRAPS);
  static void call_special(JavaValue* result, Handle receiver, KlassHandle klass, Symbol* name, Symbol* signature, TRAPS); // No args
  static void call_special(JavaValue* result, Handle receiver, KlassHandle klass, Symbol* name, Symbol* signature, Handle arg1, TRAPS);
  static void call_special(JavaValue* result, Handle receiver, KlassHandle klass, Symbol* name, Symbol* signature, Handle arg1, Handle arg2, TRAPS);

  // virtual call
  // ------------
  // The receiver must be first oop in argument list
  static void call_virtual(JavaValue* result, KlassHandle spec_klass, Symbol* name, Symbol* signature, JavaCallArguments* args, TRAPS);
  static void call_virtual(JavaValue* result, Handle receiver, KlassHandle spec_klass, Symbol* name, Symbol* signature, TRAPS); // No args
  static void call_virtual(JavaValue* result, Handle receiver, KlassHandle spec_klass, Symbol* name, Symbol* signature, Handle arg1, TRAPS);
  static void call_virtual(JavaValue* result, Handle receiver, KlassHandle spec_klass, Symbol* name, Symbol* signature, Handle arg1, Handle arg2, TRAPS);

  // Static call
  // -----------
  static void call_static(JavaValue* result, KlassHandle klass, Symbol* name, Symbol* signature, JavaCallArguments* args, TRAPS);
  static void call_static(JavaValue* result, KlassHandle klass, Symbol* name, Symbol* signature, TRAPS);
  static void call_static(JavaValue* result, KlassHandle klass, Symbol* name, Symbol* signature, Handle arg1, TRAPS);
  static void call_static(JavaValue* result, KlassHandle klass, Symbol* name, Symbol* signature, Handle arg1, Handle arg2, TRAPS);
  static void call_static(JavaValue* result, KlassHandle klass, Symbol* name, Symbol* signature, Handle arg1, Handle arg2, Handle arg3, TRAPS);

  // Low-level interface
  static void call(JavaValue* result, const methodHandle& method, JavaCallArguments* args, TRAPS);
};

上面的方法是自解释的,对应各自的invoke*指令,这些call_static,call_virtual内部调用了call()函数:

代码语言:javascript
复制
void JavaCalls::call(JavaValue* result, const methodHandle& method, JavaCallArguments* args, TRAPS) {
  assert(THREAD->is_Java_thread(), "only JavaThreads can make JavaCalls");
  os::os_exception_wrapper(call_helper, result, method, args, THREAD);
}

call()只是简单检查了一下线程信息,以及根据平台比如windows会使用结构化异常(SEH)包裹call_helper,最终执行方法调用的还是call_helper

代码语言:javascript
复制
void JavaCalls::call_helper(JavaValue* result, const methodHandle& method, JavaCallArguments* args, TRAPS) {
  ...
 
  // 如果当前方法为空,则直接返回
  if (method->is_empty_method()) {
    assert(result->get_type() == T_VOID, "an empty method must return a void value");
    return;
  }

  ...

  //根据情况决定是否编译该方法,JIT和-Xcomp都有可能触发它
  CompilationPolicy::compile_if_required(method, CHECK);

  // 解释器入口点
  address entry_point = method->from_interpreted_entry();
  if (JvmtiExport::can_post_interpreter_events() && thread->is_interp_only_mode()) {
    entry_point = method->interpreter_entry();
  }

  // 确定返回值类型
  BasicType result_type = runtime_type_from(result);
  bool oop_result_flag = (result->get_type() == T_OBJECT || result->get_type() == T_ARRAY);

  // 返回值地址
  intptr_t* result_val_address = (intptr_t*)(result->get_value_addr());

  // 确定receiver,如果是static函数就没有receiver
  Handle receiver = (!method->is_static()) ? args->receiver() : Handle();

  if (!thread->stack_guards_enabled()) {
    thread->reguard_stack();
  }

  // 确认当前sp是否到达ShadowPages,即是否会触发栈溢出错误
  address sp = os::current_stack_pointer();
  if (!os::stack_shadow_pages_available(THREAD, method, sp)) {
    // Throw stack overflow exception with preinitialized exception.
    Exceptions::throw_stack_overflow_exception(THREAD, __FILE__, __LINE__, method);
    return;
  } else {
    // Touch pages checked if the OS needs them to be touched to be mapped.
    os::map_stack_shadow_pages(sp);
  }


  // 执行调用
  { JavaCallWrapper link(method, receiver, result, CHECK);
    { HandleMark hm(thread);  // HandleMark used by HandleMarkCleaner

      StubRoutines::call_stub()(
        (address)&link,
        // (intptr_t*)&(result->_value), // see NOTE above (compiler problem)
        result_val_address,          // see NOTE above (compiler problem)
        result_type,
        method(),
        entry_point,
        args->parameters(),
        args->size_of_parameters(),
        CHECK
      );

      result = link.result();  // circumvent MS C++ 5.0 compiler bug (result is clobbered across call)
      // Preserve oop return value across possible gc points
      if (oop_result_flag) {
        thread->set_vm_result((oop) result->get_jobject());
      }
    }
  } 


  // 设置返回值
  if (oop_result_flag) {
    result->set_jobject((jobject)thread->vm_result());
    thread->set_vm_result(NULL);
  }
}

call_helper又可以分为两步,第一步判断一下方法是否为空,是否可以JIT编译,是否还有栈空间可以等,第二步StubRoutines::call_stub()实际调用os+cpu限定的方法。 这个StubRoutines::call_stub()返回的是一个函数指针,指向的是平台特定的方法,所以这段代码:

代码语言:javascript
复制
      StubRoutines::call_stub()(
        (address)&link,
        // (intptr_t*)&(result->_value), // see NOTE above (compiler problem)
        result_val_address,          // see NOTE above (compiler problem)
        result_type,
        method(),
        entry_point,
        args->parameters(),
        args->size_of_parameters(),
        CHECK
      );

call_stub()返回一个函数指针,指向依赖于操作系统和cpu架构的特定的方法,原因很简单,要执行native代码,得看看是什么cpu架构以便确定寄存器,看看什么os以便确定ABI。 然后传递8个参数到这个方法里面并执行这个方法。那么这个方法是什么呢?进入stubRoutines.cpp便知是StubRoutines::_call_stub_entry

2. windows+x86_64的stubGenerator

以x64为例,hotspot\src\cpu\x86\vm\stubGenerator_x86_64.cppgenerate_call_stub()会负责初始化StubRoutines::_call_stub_entry函数,使用参数命令 -XX:+UnlockDiagnosticVMOptions -XX:+PrintStubCode可以输出generate_call_stub方法生成的汇编,对照着看非常舒服:

代码语言:javascript
复制
 address generate_call_stub(address& return_address) {
    assert((int)frame::entry_frame_after_call_words == -(int)rsp_after_call_off + 1 &&
           (int)frame::entry_frame_call_wrapper_offset == (int)call_wrapper_off,
           "adjust this code");
    StubCodeMark mark(this, "StubRoutines", "call_stub");
    address start = __ pc();

    // same as in generate_catch_exception()!
    const Address rsp_after_call(rbp, rsp_after_call_off * wordSize);

    const Address call_wrapper  (rbp, call_wrapper_off   * wordSize);
    const Address result        (rbp, result_off         * wordSize);
    const Address result_type   (rbp, result_type_off    * wordSize);
    const Address method        (rbp, method_off         * wordSize);
    const Address entry_point   (rbp, entry_point_off    * wordSize);
    const Address parameters    (rbp, parameters_off     * wordSize);
    const Address parameter_size(rbp, parameter_size_off * wordSize);

    // same as in generate_catch_exception()!
    const Address thread        (rbp, thread_off         * wordSize);

    const Address r15_save(rbp, r15_off * wordSize);
    const Address r14_save(rbp, r14_off * wordSize);
    const Address r13_save(rbp, r13_off * wordSize);
    const Address r12_save(rbp, r12_off * wordSize);
    const Address rbx_save(rbp, rbx_off * wordSize);

    // stub code
    __ enter();
    __ subptr(rsp, -rsp_after_call_off * wordSize);
代码语言:javascript
复制
StubRoutines::call_stub [0x0000026b0a5d09d7, 0x0000026b0a5d0b44[ (365 bytes)
  0x0000026b0a5d09d7: push   %rbp
  0x0000026b0a5d09d8: mov    %rsp,%rbp
  0x0000026b0a5d09db: sub    $0x1d8,%rsp
代码语言:javascript
复制
    // save register parameters
#ifndef _WIN64
    __ movptr(parameters,   c_rarg5); // parameters
    __ movptr(entry_point,  c_rarg4); // entry_point
#endif

    __ movptr(method,       c_rarg3); // method
    __ movl(result_type,  c_rarg2);   // result type
    __ movptr(result,       c_rarg1); // result
    __ movptr(call_wrapper, c_rarg0); // call wrapper
代码语言:javascript
复制
  // r9方法,r8d返回值类型,rdx,返回值,rcx即JavaCallsWrapper
  0x0000026b0a5d09e2: mov    %r9,0x28(%rbp)
  0x0000026b0a5d09e6: mov    %r8d,0x20(%rbp)
  0x0000026b0a5d09ea: mov    %rdx,0x18(%rbp)
  0x0000026b0a5d09ee: mov    %rcx,0x10(%rbp)
代码语言:javascript
复制
    // save regs belonging to calling function
    __ movptr(rbx_save, rbx);
    __ movptr(r12_save, r12);
    __ movptr(r13_save, r13);
    __ movptr(r14_save, r14);
    __ movptr(r15_save, r15);
    if (UseAVX > 2) {
      __ movl(rbx, 0xffff);
      __ kmovwl(k1, rbx);
    }
#ifdef _WIN64
    int last_reg = 15;
    if (UseAVX > 2) {
      last_reg = 31;
    }
    if (VM_Version::supports_evex()) {
      for (int i = xmm_save_first; i <= last_reg; i++) {
        __ vextractf32x4(xmm_save(i), as_XMMRegister(i), 0);
      }
    } else {
      for (int i = xmm_save_first; i <= last_reg; i++) {
        __ movdqu(xmm_save(i), as_XMMRegister(i));
      }
    }
代码语言:javascript
复制
  // caller-save 寄存器
  0x0000026b0a5d09f2: mov    %rbx,-0x8(%rbp)
  0x0000026b0a5d09f6: mov    %r12,-0x20(%rbp)
  0x0000026b0a5d09fa: mov    %r13,-0x28(%rbp)
  0x0000026b0a5d09fe: mov    %r14,-0x30(%rbp)
  0x0000026b0a5d0a02: mov    %r15,-0x38(%rbp)

  0x0000026b0a5d0a06: vmovdqu %xmm6,-0x48(%rbp)
  0x0000026b0a5d0a0b: vmovdqu %xmm7,-0x58(%rbp)
  0x0000026b0a5d0a10: vmovdqu %xmm8,-0x68(%rbp)
  0x0000026b0a5d0a15: vmovdqu %xmm9,-0x78(%rbp)
  0x0000026b0a5d0a1a: vmovdqu %xmm10,-0x88(%rbp)
  0x0000026b0a5d0a22: vmovdqu %xmm11,-0x98(%rbp)
  0x0000026b0a5d0a2a: vmovdqu %xmm12,-0xa8(%rbp)
  0x0000026b0a5d0a32: vmovdqu %xmm13,-0xb8(%rbp)
  0x0000026b0a5d0a3a: vmovdqu %xmm14,-0xc8(%rbp)
  0x0000026b0a5d0a42: vmovdqu %xmm15,-0xd8(%rbp)
代码语言:javascript
复制
    const Address rdi_save(rbp, rdi_off * wordSize);
    const Address rsi_save(rbp, rsi_off * wordSize);
    __ movptr(rsi_save, rsi);
    __ movptr(rdi_save, rdi);
代码语言:javascript
复制
  // rsi rdi
  0x0000026b0a5d0a4a: mov    %rsi,-0x10(%rbp)
  0x0000026b0a5d0a4e: mov    %rdi,-0x18(%rbp)
代码语言:javascript
复制
    // Load up thread register
    __ movptr(r15_thread, thread);
    __ reinit_heapbase();
代码语言:javascript
复制
  // 线程寄存器
  0x0000026b0a5d0a52: mov    0x48(%rbp),%r15
  0x0000026b0a5d0a56: movabs $0x7ffe4c5b2be8,%r10
  0x0000026b0a5d0a60: mov    (%r10),%r12
代码语言:javascript
复制
    // pass parameters if any
    BLOCK_COMMENT("pass parameters if any");
    Label parameters_done;
    __ movl(c_rarg3, parameter_size);
    __ testl(c_rarg3, c_rarg3);
    __ jcc(Assembler::zero, parameters_done);

    Label loop;
    __ movptr(c_rarg2, parameters);       // parameter pointer
    __ movl(c_rarg1, c_rarg3);            // parameter counter is in c_rarg1
    __ BIND(loop);
    __ movptr(rax, Address(c_rarg2, 0));// get parameter
    __ addptr(c_rarg2, wordSize);       // advance to next parameter
    __ decrementl(c_rarg1);             // decrement counter
    __ push(rax);                       // pass parameter
    __ jcc(Assembler::notZero, loop);
代码语言:javascript
复制
  // 这里是个循环,用于传递参数,相当于
  // while(r9d){
  //    rax = *arg
  //    push_arg(rax)
  //    arg++;  // ptr++
  //    r9d--;  // counter--
  // }
  0x0000026b0a5d0a63: mov    0x40(%rbp),%r9d
  0x0000026b0a5d0a67: test   %r9d,%r9d
  0x0000026b0a5d0a6a: je     0x0000026b0a5d0a83
  0x0000026b0a5d0a70: mov    0x38(%rbp),%r8
  0x0000026b0a5d0a74: mov    %r9d,%edx
  0x0000026b0a5d0a77: mov    (%r8),%rax
  0x0000026b0a5d0a7a: add    $0x8,%r8
  0x0000026b0a5d0a7e: dec    %edx
  0x0000026b0a5d0a80: push   %rax
  0x0000026b0a5d0a81: jne    0x0000026b0a5d0a77 
代码语言:javascript
复制
    // call Java function
    __ BIND(parameters_done);
    __ movptr(rbx, method);             // get Method*
    __ movptr(c_rarg1, entry_point);    // get entry_point
    __ mov(r13, rsp);                   // set sender sp
    BLOCK_COMMENT("call Java function");
    __ call(c_rarg1);
代码语言:javascript
复制
  // [!!]调用java方法
  0x0000026b0a5d0a83: mov    0x28(%rbp),%rbx
  0x0000026b0a5d0a87: mov    0x30(%rbp),%rdx
  0x0000026b0a5d0a8b: mov    %rsp,%r13
  0x0000026b0a5d0a8e: callq  *%rdx
代码语言:javascript
复制
    BLOCK_COMMENT("call_stub_return_address:");
    return_address = __ pc();

    // store result depending on type (everything that is not
    // T_OBJECT, T_LONG, T_FLOAT or T_DOUBLE is treated as T_INT)
    __ movptr(c_rarg0, result);
    Label is_long, is_float, is_double, exit;
    __ movl(c_rarg1, result_type);
    __ cmpl(c_rarg1, T_OBJECT);
    __ jcc(Assembler::equal, is_long);
    __ cmpl(c_rarg1, T_LONG);
    __ jcc(Assembler::equal, is_long);
    __ cmpl(c_rarg1, T_FLOAT);
    __ jcc(Assembler::equal, is_float);
    __ cmpl(c_rarg1, T_DOUBLE);
    __ jcc(Assembler::equal, is_double);

    // handle T_INT case
    __ movl(Address(c_rarg0, 0), rax);

    __ BIND(exit);

    // pop parameters
    __ lea(rsp, rsp_after_call);
代码语言:javascript
复制
  // 储存java方法返回值并弹出参数,这里弹出操作即移动一下rsp指针
  0x0000026b0a5d0a90: mov    0x18(%rbp),%rcx
  0x0000026b0a5d0a94: mov    0x20(%rbp),%edx
  0x0000026b0a5d0a97: cmp    $0xc,%edx
  0x0000026b0a5d0a9a: je     0x0000026b0a5d0b30
  0x0000026b0a5d0aa0: cmp    $0xb,%edx
  0x0000026b0a5d0aa3: je     0x0000026b0a5d0b30
  0x0000026b0a5d0aa9: cmp    $0x6,%edx
  0x0000026b0a5d0aac: je     0x0000026b0a5d0b35
  0x0000026b0a5d0ab2: cmp    $0x7,%edx
  0x0000026b0a5d0ab5: je     0x0000026b0a5d0b3b
  0x0000026b0a5d0abb: mov    %eax,(%rcx)
  0x0000026b0a5d0abd: lea    -0x1d8(%rbp),%rsp
代码语言:javascript
复制
    // restore regs belonging to calling function
#ifdef _WIN64
    // emit the restores for xmm regs
    if (VM_Version::supports_evex()) {
      for (int i = xmm_save_first; i <= last_reg; i++) {
        __ vinsertf32x4(as_XMMRegister(i), as_XMMRegister(i), xmm_save(i), 0);
      }
    } else {
      for (int i = xmm_save_first; i <= last_reg; i++) {
        __ movdqu(as_XMMRegister(i), xmm_save(i));
      }
    }
#endif
    __ movptr(r15, r15_save);
    __ movptr(r14, r14_save);
    __ movptr(r13, r13_save);
    __ movptr(r12, r12_save);
    __ movptr(rbx, rbx_save);

    __ movptr(rdi, rdi_save);
    __ movptr(rsi, rsi_save);
代码语言:javascript
复制
  // 恢复之前保存的caller-save寄存器
  0x0000026b0a5d0ac4: vmovdqu -0x48(%rbp),%xmm6
  0x0000026b0a5d0ac9: vmovdqu -0x58(%rbp),%xmm7
  0x0000026b0a5d0ace: vmovdqu -0x68(%rbp),%xmm8
  0x0000026b0a5d0ad3: vmovdqu -0x78(%rbp),%xmm9
  0x0000026b0a5d0ad8: vmovdqu -0x88(%rbp),%xmm10
  0x0000026b0a5d0ae0: vmovdqu -0x98(%rbp),%xmm11
  0x0000026b0a5d0ae8: vmovdqu -0xa8(%rbp),%xmm12
  0x0000026b0a5d0af0: vmovdqu -0xb8(%rbp),%xmm13
  0x0000026b0a5d0af8: vmovdqu -0xc8(%rbp),%xmm14
  0x0000026b0a5d0b00: vmovdqu -0xd8(%rbp),%xmm15
  0x0000026b0a5d0b08: mov    -0x38(%rbp),%r15
  0x0000026b0a5d0b0c: mov    -0x30(%rbp),%r14
  0x0000026b0a5d0b10: mov    -0x28(%rbp),%r13
  0x0000026b0a5d0b14: mov    -0x20(%rbp),%r12
  0x0000026b0a5d0b18: mov    -0x8(%rbp),%rbx
  0x0000026b0a5d0b1c: mov    -0x18(%rbp),%rdi
  0x0000026b0a5d0b20: mov    -0x10(%rbp),%rsi
代码语言:javascript
复制
    // restore rsp
    __ addptr(rsp, -rsp_after_call_off * wordSize);

    // return
    __ pop(rbp);
    __ ret(0);
代码语言:javascript
复制
  // 结束__call_stub_entry这个函数
  0x0000026b0a5d0b24: add    $0x1d8,%rsp
  0x0000026b0a5d0b2b: vzeroupper 
  0x0000026b0a5d0b2e: pop    %rbp
  0x0000026b0a5d0b2f: retq   

下面这段代码逻辑上属于之前的存储java方法的返回值,随便举个例子0x0000026b0a5d0b30这个地址正是之前存放java方法的代码段je 0x0000026b0a5d0b30所跳之处,只是放到了最后而已:(不过我也不知道为什么要放到这后面)

代码语言:javascript
复制
    // handle return types different from T_INT
    __ BIND(is_long);
    __ movq(Address(c_rarg0, 0), rax);
    __ jmp(exit);

    __ BIND(is_float);
    __ movflt(Address(c_rarg0, 0), xmm0);
    __ jmp(exit);

    __ BIND(is_double);
    __ movdbl(Address(c_rarg0, 0), xmm0);
    __ jmp(exit);

    return start;
  }
代码语言:javascript
复制
  0x0000026b0a5d0b30: mov    %rax,(%rcx)
  0x0000026b0a5d0b33: jmp    0x0000026b0a5d0abd
  0x0000026b0a5d0b35: vmovss %xmm0,(%rcx)
  0x0000026b0a5d0b39: jmp    0x0000026b0a5d0abd
  0x0000026b0a5d0b3b: vmovsd %xmm0,(%rcx)
  0x0000026b0a5d0b3f: jmpq   0x0000026b0a5d0abd

对照汇编看非常清晰,不过也可以看到它建立了栈帧结构,但它还是没有执行java代码,而是使用callq *rdx进行的, 这也是为什么它叫做stub的原因。 另外上面的栈帧里面内容比较多,[rsp+xx]存放什么内容啊这些比较难记,已经归纳好的结构可以参见代码注释:

代码语言:javascript
复制
  // Windowsx86_64平台
  //
  //    注意c_rarg\d 表示寄存器,method/result表示内存地址[rbp+\d]
  //
  //    c_rarg0:   call wrapper address                   address
  //    c_rarg1:   result                                 address
  //    c_rarg2:   result type                            BasicType
  //    c_rarg3:   method                                 Method*
  //    48(rbp): (interpreter) entry point              address
  //    56(rbp): parameters                             intptr_t*
  //    64(rbp): parameter size (in words)              int
  //    72(rbp): thread                                 Thread*
  //
  //     [ return_from_Java     ] <--- 这里执行callq调用java方法。压入返回地址,跳转到java方法,也就是说↑上面的部分就是java方法使用的栈帧了
  //     [ argument word n      ] <--- 循环传递的java方法实参
  //      ...
  // -60 [ argument word 1      ] 
  // -59 [ saved xmm31          ] <--- rsp after_call
  //     [ saved xmm16-xmm30    ] 
  // -27 [ saved xmm15          ]
  //     [ saved xmm7-xmm14     ]
  //  -9 [ saved xmm6           ] 
  //  -7 [ saved r15            ]
  //  -6 [ saved r14            ]
  //  -5 [ saved r13            ]
  //  -4 [ saved r12            ]
  //  -3 [ saved rdi            ]
  //  -2 [ saved rsi            ]
  //  -1 [ saved rbx            ]
  //   0 [ saved rbp            ] <--- rbp
  //   1 [ return address       ] <--- last rbp
  //   2 [ call wrapper         ] <--- arg0
  //   3 [ result               ] <--- arg1
  //   4 [ result type          ] <--- arg2
  //   5 [ method               ] <--- arg3
  //   6 [ entry point          ] <--- arg4 
  //   7 [ parameters           ] <--- arg5
  //   8 [ parameter size       ] <--- arg6
  //   9 [ thread               ] <--- arg7

这8个arg正是之前传递给函数指针指向的函数的实参:

代码语言:javascript
复制
     StubRoutines::call_stub()(
        (address)&link,
        // (intptr_t*)&(result->_value), // see NOTE above (compiler problem)
        result_val_address,          // see NOTE above (compiler problem)
        result_type,
        method(),
        entry_point,
        args->parameters(),
        args->size_of_parameters(),
        CHECK
      );
本文参与 腾讯云自媒体同步曝光计划,分享自作者个人站点/博客。
原始发表:2019-01-27 ,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • [inside hotspot] java方法调用的StubCode
  • 1. JavaCalls
  • 2. windows+x86_64的stubGenerator
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档