第46篇-signature_handler与result_handler

发布于 2022年 01月 24日 00:30

在之前介绍为native方法设置解释执行的入口时介绍过,当Method::native_function为空时会调用InterpreterRuntime::prepare_native_call()函数,这个函数不但会查找本地函数,而且还会确保Method::signature_handler也完成了设置。这一篇将详细介绍signature_handler的查找设置过程。

1、signature_handler

Method实例的第2个附加slot的signature_handler指向的例程用来消除Java解释器栈和C/C++栈调用约定的不同,将位于解析器栈中的参数适配到本地函数使用的C栈。

在调用本地函数时,要确保signature handler被安装,之前介绍过,如果signature_handler没有安装,那么InterpreterRuntime::prepare_native_call()函数通过调用SignatureHandlerLibrary::add()函数来安装。add()函数的实现如下:

源代码位置:openjdk/hotspot/src/share/vm/interpreter/interpreterRuntime.cpp
// 根据方法签名解析方法参数的解析器,当方法参数大小小于Fingerprinter::max_size_of_parameters
// 时可以生成并使用根据方法签名定制的快速的解析器,否则使用通用的相对较慢的解析器。
void SignatureHandlerLibrary::add(methodHandle method) {
  // 只有在signature_handler的值为NULL时才会执行如下逻辑,否则不做任何操作
  if (method->signature_handler() == NULL) {
    int handler_index = -1;
    // UseFastSignatureHandlers的值默认为true
    // Fingerprinter::max_size_of_parameters的值为13,也就是13个slot
    if (UseFastSignatureHandlers && method->size_of_parameters() <= Fingerprinter::max_size_of_parameters) {
      MutexLocker mu(SignatureHandlerLibrary_lock);
      // 确保使用到的相关变量都已经初始化完成
      initialize();
      // lookup method signature's fingerprint
      // 读出Method::_constMethod::_fingerprinter的值,也就是
      // 根据方法签名得到对应的指纹值,然后在_fingerprints数组中查找到
      // 句柄下标索引,由于句柄存储在_handlers数组中,所以可以根据这个下标
      // 索引从_handlers数组中获取
      uint64_t fingerprint = Fingerprinter(method).fingerprint();
      handler_index = _fingerprints->find(fingerprint);
      // 如果handler_index小于0,则说明没有这个方法签名对应的signature_handler,需要创建一个新的
      // signature_handler
      if (handler_index < 0) {
        ResourceMark rm;
        ptrdiff_t    align_offset = (address)round_to((intptr_t)_buffer, CodeEntryAlignment) - (address)_buffer;
 
        CodeBuffer buffer(
                 (address)(_buffer + align_offset),
                 SignatureHandlerLibrary::buffer_size - align_offset
               );
        // 生成signature_handler,其实就是生成一段例程,这段例程可消除Java解释器栈
        // 和C/C++栈调用约定的不同,将位于解析器栈中的参数适配到本地函数使用的C栈
        InterpreterRuntime::SignatureHandlerGenerator tmp = InterpreterRuntime::SignatureHandlerGenerator(method, &buffer);
        tmp.generate(fingerprint);
        // signature_handler对应的例程临时保存在了CodeBuffer中,调用set_handler保存到BufferBlob中,
        // 这个BufferBlob中的内存是从CodeCache中分配出来的,解释执行所需要的所有例程基本都保存在CodeCache中
        address handler = set_handler(&buffer);
        if (handler == NULL) {
          // 使用普通的、相对较慢的解释器
        } else {
          // 向_fingerprints和_handlers数组中添加方法签名和signature_handler,这样下次就可以
          // 根据方法签名快速定位对应的signature_handler
          _fingerprints->append(fingerprint);
          _handlers->append(handler);
          handler_index = _fingerprints->length() - 1;
        }
      } // 结束 if (handler_index < 0)
 
      if (handler_index < 0) {
      // 使用通用的相对较慢的解析器
      address tmp = Interpreter::slow_signature_handler();
      method->set_signature_handler(tmp);
       } else {
      // 使用快速的解析器
      address tmp = _handlers->at(handler_index);
      method->set_signature_handler(tmp);
       }
    } else {
      // 没有快速的解释器,只能使用相对较慢的普通解释器
      method->set_signature_handler(Interpreter::slow_signature_handler());
    }
  }
 
}

对于参数不超过13个slot大小(int、byte、对象地址等占用一个slot,而double和long占用2个slot)的native方法来说,signature_handler会走快速路径。就是根据方法签名字符串得到一个64位的整数方法指纹(Method Fingerprint)值,后续signature_handler将不需要每次都解析native方法签名字符串得到参数个数和参数类型,而是直接用方法指纹值。这个方法指纹值的格式如下图所示。

每个方法指纹值都会存储在元素类型为uint64_t的数组中,所以方法指纹值不能超过64位大小,另外加上还需要存储结果类型、是否为静态方法等信息,所以能表示方法参数类型的参数存储区只有52位大小,所以才会要求方法参数大小不超过13个slot的大小(每个参数的类型存储需要占用4位)。

在SignatureHandlerLibrary::add()函数中使用了_fingerprints和_handlers来保存方法指纹值,这两个变量是静态的,所以说,如果两个方法的指纹值相同,则可以重用快速解释器。

在之前介绍过为native方法生成解释执行的入口时,会在Method::native_funciton执行之前调用Method::signature_handler,而在调用Method::signature_handler之前会根据方法要求的参数大小从native栈帧中开辟对应的存储空间,栈的状态如下图所示。

其中最下面的param n ... param 1中会压入调用C/C++实现的本地函数需要的参数,不过Java方法的解释执行需要将参数从左向右入栈,所以我们能够看到上图中方法的局部变量表中实参的顺序为param 1... param n,但是本地函数根据调用约定,其参数需要从右到左入栈,这就要求最后一个参数最先入栈(注意,C/C++函数只有在参数过多的情况下才会借助栈来传递参数)。

(1)快速解释器

调用InterpreterRuntime::SignatureHandlerGenerator::generate()函数生成快速解释器,函数的实现如下:

void InterpreterRuntime::SignatureHandlerGenerator::generate(uint64_t fingerprint) {
  // 处理参数
  iterate(fingerprint);
 
  // 查找并返回result_handler
  BasicType bt = method()->result_type();
  address adr = Interpreter::result_handler(bt);
 
  __ lea(rax, ExternalAddress(adr));
  __ ret(0);
 
  __ flush();
}

这个函数在生成signature_handler时还会生成result_handler,这个result_handler会处理本地函数调用后的返回值,之前在介绍为native方法设置解释执行的入口时介绍过,result_handler对native_function执行的结果进行处理的具体逻辑。

处理参数iterate()函数的实现如下:

void iterate( uint64_t fingerprint ) {
    if (!is_static()) {
       // 当为实例方法时,需要传递receiver,也就是this参数
       pass_object();
       _jni_offset++;
       _offset++;
    }
 
    // fingerprint中包含有函数调用参数及返回类型等相关信息
    SignatureIterator::iterate_parameters( fingerprint );
}

调用pass_object()函数为本地函数传递this参数。调用SignatureIterator::iterate_parameters()函数根据Java方法签名向C/C++函数传递参数。调用的SignatureIterator::iterate_parameters()函数的实现如下:

void SignatureIterator::iterate_parameters( uint64_t fingerprint ) {
  uint64_t saved_fingerprint = fingerprint;
 
  // 当传递的参数太多时就无法使用方法指纹值来快速处理,只能通过遍历Java方法签名来处理
  if ( fingerprint == UCONST64(-1) ) { // 检查处理参数太多的情况
     SignatureIterator::iterate_parameters();
     return;
  }
 
  _parameter_index = 0;
  // static_feature_size + result_feature_size的值为5
  fingerprint = fingerprint >> (static_feature_size + result_feature_size); 
  while ( 1 ) {
    switch ( fingerprint & parameter_feature_mask ) {
      case bool_parm:
        do_bool();
        _parameter_index += T_BOOLEAN_size;
        break;
      case byte_parm:
        do_byte();
        _parameter_index += T_BYTE_size;
        break;
      case char_parm:
        do_char();
        _parameter_index += T_CHAR_size;
        break;
      case short_parm:
        do_short();
        _parameter_index += T_SHORT_size;
        break;
      case int_parm:
        do_int();
        _parameter_index += T_INT_size;
        break;
      case obj_parm:
        do_object(0, 0);
        _parameter_index += T_OBJECT_size;
        break;
      case long_parm:
        do_long();
        _parameter_index += T_LONG_size;
        break;
      case float_parm:
        do_float();
        _parameter_index += T_FLOAT_size;
        break;
      case double_parm:
        do_double();
        _parameter_index += T_DOUBLE_size;
        break;
      case done_parm:
        return;
        break;
      default:
        ShouldNotReachHere();
        break;
    }
    // parameter_feature_size的值为4
    fingerprint >>= parameter_feature_size;
  }
  _parameter_index = 0;
}

调用的do_float()、do_object()等函数的实现如下:

void do_bool  ()                     { pass_int();    _jni_offset++; _offset++;       }
void do_char  ()                     { pass_int();    _jni_offset++; _offset++;       }
void do_float ()                     { pass_float();  _jni_offset++; _offset++;       }
void do_double()                     { pass_double(); _jni_offset++; _offset += 2;    }
void do_byte  ()                     { pass_int();    _jni_offset++; _offset++;       }
void do_short ()                     { pass_int();    _jni_offset++; _offset++;       }
void do_int   ()                     { pass_int();    _jni_offset++; _offset++;       }
void do_long  ()                     { pass_long();   _jni_offset++; _offset += 2;    }
void do_object(int begin, int end)   { pass_object(); _jni_offset++; _offset++;        }
void do_array (int begin, int end)   { pass_object(); _jni_offset++; _offset++;        }

其中的_jni_offset表示参数对于本地函数的偏移量,而_offset表示参数对于Java方法的偏移量。对于Java方法来说,一个long或double会占用2个slot,而在64位下,本地函数只需要一个slot即可。另外,如果是静态方法,由于有JNIEnv*和jclass,对于实例方法有JNIEnv*,所以_jni_offset还需要加上2或1。

调用的pass_int()、pass_double()和pass_object()等函数的实现如下:

void InterpreterRuntime::SignatureHandlerGenerator::pass_int() {
  const Address src(from(), Interpreter::local_offset_in_bytes(offset()));
 
  switch (_num_int_args) { // 当为静态方法时,_num_int_args的值为1,否则为0
  case 0:
    __ movl(c_rarg1, src);
    _num_int_args++;
    break;
  case 1:
    __ movl(c_rarg2, src);
    _num_int_args++;
    break;
  case 2:
    __ movl(c_rarg3, src);
    _num_int_args++;
    break;
  case 3:
    __ movl(c_rarg4, src);
    _num_int_args++;
    break;
  case 4:
    __ movl(c_rarg5, src);
    _num_int_args++;
    break;
  default: // 当传递的整数类型参数多于5个时,多出来的只能通过栈来传递
    __ movl(rax, src);
    __ movl(Address(to(), _stack_offset), rax); // 调用to()函数返回rsp
    _stack_offset += wordSize;
    break;
  }
}
 
 
void InterpreterRuntime::SignatureHandlerGenerator::pass_double() {
  const Address src(from(), Interpreter::local_offset_in_bytes(offset() + 1));
 
  if (_num_fp_args < Argument::n_float_register_parameters_c) {
    __ movdbl(as_XMMRegister(_num_fp_args++), src);
  } else {
    __ movptr(rax, src);
    __ movptr(Address(to(), _stack_offset), rax);
    _stack_offset += wordSize;
  }
}
 
// 在传递对象地址时,只需要使用整数类型的slot存储地址即可
void InterpreterRuntime::SignatureHandlerGenerator::pass_object() {
  const Address src(from(), Interpreter::local_offset_in_bytes(offset()));
 
  switch (_num_int_args) {
  case 0:
    assert(offset() == 0, "argument register 1 can only be (non-null) receiver");
    __ lea(c_rarg1, src);
    _num_int_args++;
    break;
  case 1:
    __ lea(rax, src);
    __ xorl(c_rarg2, c_rarg2);
    __ cmpptr(src, 0);
    __ cmov(Assembler::notEqual, c_rarg2, rax);
    _num_int_args++;
    break;
  case 2:
    __ lea(rax, src);
    __ xorl(c_rarg3, c_rarg3);
    __ cmpptr(src, 0);
    __ cmov(Assembler::notEqual, c_rarg3, rax);
    _num_int_args++;
    break;
  case 3:
    __ lea(rax, src);
    __ xorl(c_rarg4, c_rarg4);
    __ cmpptr(src, 0);
    __ cmov(Assembler::notEqual, c_rarg4, rax);
    _num_int_args++;
    break;
  case 4:
    __ lea(rax, src);
    __ xorl(c_rarg5, c_rarg5);
    __ cmpptr(src, 0);
    __ cmov(Assembler::notEqual, c_rarg5, rax);
    _num_int_args++;
    break;
  default:
    __ lea(rax, src);
    __ xorl(temp(), temp());
    __ cmpptr(src, 0);
    // 如果传递的对象地址不为0,则将rax中的值存储到temp()中
    __ cmov(Assembler::notEqual, temp(), rax);
    // 将temp()中的值存储到栈帧中
    __ movptr(Address(to(), _stack_offset), temp());
    _stack_offset += wordSize;
    break;
  }
}

我们需要注意,因为要调用的本地函数是C/C++函数,所以需要遵守C/C++函数的调用约定,如果是整数或对象地址,则可以放到6个整数类型的寄存器中。静态方法的JNI*和jclass参数需要通过c_rarg0和c_rarg1来传递,所以native方法的参数中的非浮点数类型只能使用c_rarg2、c_rarg3、c_rarg4和c_rarg5这几个寄存器;如果是实例方法,则c_rarg0需要传递JNI*,然后就是c_rarg1传递receiver。当整数或对象多于6个时,要将剩下的参数从右向左压入栈内。

下面看2个具体的小实例。 

为java.lang.Object.registerNatives()方法生成的signature_handler与result_handler的汇编代码如下:(为HotSpot VM添加选项 -XX:+PrintSignatureHandlers)

argument handler #0 for: static java.lang.Object.registerNatives()V (fingerprint = 349, 11 bytes generated)
  // 根据方法的返回类型获取到对应的result_handler例程的地址并保存到%rax中
  // movabs的源操作数只能是立即数或标号(本质还是立即数),目的操作数是寄存器
  0x00007f386911c420: movabs $0x7f386900ecd8,%rax
  0x00007f386911c42a: retq  
 
 --- associated result handler ---
  // 由于registerNatives()方法不需要任何返回值,所以没有任何执行逻辑
  // ret指令用于从子函数中返回。X86架构的Linux中是将函数的返回值设置到eax寄
  // 存器并返回的,设置的工作不是由ret来做,要自己做
  0x00007f386900ecd8: retq
 

由于registerNatives()方法没有任何参数,所以不需要对参数进行处理。至于JNIEnv*和jclass参数,在之前介绍为native方法设置解释执行入口时详细介绍过。

再举个例子,如下:

private native void writeBytes(byte b[], int off, int len, boolean append) throws IOException;

生成的汇编如下:

argument handler #56 for: receiver java.io.FileOutputStream.writeBytes([BIIZ)V (fingerprint = 21146428, 44 bytes generated)
  // Java方法的第1个参数this是本地方法的第2个参数,所以要根据调用约定存储在%rsi中
  0x00007fbfe4067a5a: lea    (%r14),%rsi
  // 将Java方法的第2个参数b存储到%rax中
  0x00007fbfe4067a5d: lea    -0x8(%r14),%rax
  0x00007fbfe4067a61: xor    %edx,%edx // 清空%edx
  // cmp是比较指令,cmp的功能相当于减法指令,只是不保存结果
  0x00007fbfe4067a63: cmpq   $0x0,-0x8(%r14)
  // cmovne不相等时(也就是-0x8(%r14)中的值不为0时),将%rax中的值移动到%rdx中,
  // 也就是Java方法的第2个参数b是本地方法的第3个参数,根据调用约定存储在%rdx中
  0x00007fbfe4067a6b: cmovne %rax,%rdx
 
  // 传递Java方法的off参数
  0x00007fbfe4067a6f: mov    -0x10(%r14),%ecx
  // 传递Java方法的len参数
  0x00007fbfe4067a73: mov    -0x18(%r14),%r8d
  // 传递Java访求的append参数
  0x00007fbfe4067a77: mov    -0x20(%r14),%r9d 
   
  0x00007fbfe4067a7b: movabs $0x7fbfe3f59cd8,%rax
  0x00007fbfe4067a85: retq  
 
 --- associated result handler ---
  // 当类型为int、long、void、float与double时,只执行retq
  // 即可,详见下面的result handler
  0x00007fbfe3f59cd8: retq

如上函数的参数不多于6个,所以正好能使用6个整数寄存器来传参。

C/C++中的参数放入的顺序如下:

  • 第一个参数:%rdi    c_rarg0
  • 第二个参数:%rsi    c_rarg1
  • 第三个参数:%rdx   c_rarg2
  • 第四个参数:%rcx   c_rarg3
  • 第五个参数:%r8    c_rarg4
  • 第六个参数:%r9    c_rarg5  

第1个参数为JNIEnv*,这在之前介绍为native方法设置解释执行的入口时介绍过,从JavaThread::jni_environment中获取JNIEnv实例的地址并保存到%rdi中。

(2)普通的解释器

将普通的解释器生成的例程保存到AbstractInterpreter::_slow_signature_handler中,所以在SignatureHandlerLibrary::add()函数中可直接能这个字段中获取例程地址。在HotSpot VM启动时会调用如下函数:

void AbstractInterpreterGenerator::generate_all() {
  {
     CodeletMark cm(_masm, "slow signature handler");
     Interpreter::_slow_signature_handler = generate_slow_signature_handler();
  }
}

调用AbstractInterpreterGenerator::generate_slow_signature_handler()函数生成的汇编代码如下:

// rbx: method
// r14: pointer to locals
 
// %rcx指向了栈顶,其中的栈顶值是第1个需要通过栈来给本地函数传递的参数
0x00007fffe1005400: mov    %rsp,%rcx  // 为调用准备c_rarg3
// 0x70=14*wordSize,其中wordSize=8,这里又从native栈帧上开辟了
// 14个slot,其中8个用来存储浮点数,5个用来存储整数,1个用来指示8个slot
// 中,哪些存储了需要传递的方法参数,也就是需要传递给本地函数的浮点数
0x00007fffe1005403: sub    $0x70,%rsp
 
// 调用call_VM()函数生成的例程,这个例程调用InterpreterRuntime::slow_signature_handler()函数
0x00007fffe1005407: callq  0x00007fffe1005411
0x00007fffe100540c: jmpq   0x00007fffe1005492
0x00007fffe1005411: mov    %r14,%rdx      // 为调用准备参数c_rarg2
0x00007fffe1005414: mov    %rbx,%rsi      // 为调用准备参数c_rarg1
0x00007fffe1005417: lea    0x8(%rsp),%rax
0x00007fffe100541c: mov    %r13,-0x38(%rbp)
0x00007fffe1005420: mov    %r15,%rdi      // 为调用准备参数c_rarg0
 
// 相关信息保存到线程中
0x00007fffe1005423: mov    %rbp,0x200(%r15)
0x00007fffe100542a: mov    %rax,0x1f0(%r15)
 
// 如下汇编对函数进行调用,如果内存没有对齐,则需要对齐处理后调用
0x00007fffe1005431: test   $0xf,%esp
0x00007fffe1005437: je     0x00007fffe100544f
0x00007fffe100543d: sub    $0x8,%rsp
0x00007fffe1005441: callq  0x00007ffff66aeed2
0x00007fffe1005446: add    $0x8,%rsp
0x00007fffe100544a: jmpq   0x00007fffe1005454
 
0x00007fffe100544f: callq  0x00007ffff66aeed2
 
// 将线程中保存的相关信息重置
0x00007fffe1005454: movabs $0x0,%r10
0x00007fffe100545e: mov    %r10,0x1f0(%r15)
0x00007fffe1005465: movabs $0x0,%r10
0x00007fffe100546f: mov    %r10,0x200(%r15)
 
0x00007fffe1005476: cmpq   $0x0,0x8(%r15)
0x00007fffe100547e: je     0x00007fffe1005489
0x00007fffe1005484: jmpq   0x00007fffe1000420
0x00007fffe1005489: mov    -0x38(%rbp),%r13
0x00007fffe100548d: mov    -0x30(%rbp),%r14
0x00007fffe1005491: retq 
// 结束call_VM()函数的调用
 
 
// rax: result handler
 
// Do FP first so we can use c_rarg3 as temp
// 0x28等于5*wordSize
0x00007fffe1005492: mov    0x28(%rsp),%ecx  // float/double identifiers  

在执行InterpreterRuntime::slow_signature_handler()函数之前的栈状态如下图所示。

调用的InterpreterRuntime::slow_signature_handler()函数的实现如下:

IRT_ENTRY(address,InterpreterRuntime::slow_signature_handler(
 JavaThread*  thread,
 Method*      method,
 intptr_t*    from,
 intptr_t*    to
))
  methodHandle m(thread, (Method*)method);
 
  // 处理方法参数
  SlowSignatureHandler(m, (address)from, to + 1).iterate(UCONST64(-1));
 
  // 返回result_handler
  return Interpreter::result_handler(m->result_type());
IRT_END

其中from与to分别为

r14: pointer to locals
%rcx/c_rarg3: first stack arg - wordSize

调用的SlowSignatureHandler的构造函数如下:

SlowSignatureHandler(methodHandle method, address from, intptr_t* to) : NativeSignatureIterator(method) {
    _from = from;
    _to   = to;
 
    _int_args = to - (method->is_static() ? 14 : 15);
    _fp_args =  to - 9;
    _fp_identifiers = to - 10;
    *(int*) _fp_identifiers = 0;
    _num_int_args = (method->is_static() ? 1 : 0);
    _num_fp_args = 0;
}
 
NativeSignatureIterator(methodHandle method) : SignatureIterator(method->signature()) {
    _method = method;
    _offset = 0;
    _jni_offset = 0;
 
    const int JNIEnv_words = 1;
    const int mirror_words = 1;
    // 如果为静态方法,则_prepended的值为2(JNI和mirror),否则值为1(JNI)
    _prepended = !is_static() ? JNIEnv_words : JNIEnv_words + mirror_words;
}
 
SignatureIterator::SignatureIterator(Symbol* signature) {
  _signature       = signature;
  _parameter_index = 0;
}

SignatureIterator类的继承体系如下:

之前在介绍快速解释器时使用的是InterpreterRuntime::SignatureHandlerGenerator,而慢速解释器使用的是SlowSignatureHandler。

初始化好各个变量后就能在InterpreterRuntime::slow_signature_handler()函数中调用iterate()函数,然后在iterate()函数中调用SignatureIterator::iterate_parameters()函数,调用的pass_int()、pass_double()和pass_object()等函数是SlowSignatureHandler类中定义的系列函数,实现如下:

virtual void pass_int(){
    jint from_obj = *(jint *)(_from+Interpreter::local_offset_in_bytes(0));
    _from -= Interpreter::stackElementSize;
 
    if (_num_int_args < Argument::n_int_register_parameters_c-1) {
      *_int_args++ = from_obj;
      _num_int_args++;
    } else {
      *_to++ = from_obj;
    }
}
 
virtual void pass_long(){
    intptr_t from_obj = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(1));
    _from -= 2*Interpreter::stackElementSize;
    // n_int_register_parameters_c的值为6
    if (_num_int_args < Argument::n_int_register_parameters_c-1) {
      *_int_args++ = from_obj;
      _num_int_args++;
    } else {
      *_to++ = from_obj;
    }
}
 
virtual void pass_object(){
    intptr_t *from_addr = (intptr_t*)(_from + Interpreter::local_offset_in_bytes(0));
    _from -= Interpreter::stackElementSize;
    // n_int_register_parameters_c的值为6
    if (_num_int_args < Argument::n_int_register_parameters_c-1) {
      *_int_args++ = (*from_addr == 0) ? NULL : (intptr_t)from_addr;
      _num_int_args++;
    } else {
      *_to++ = (*from_addr == 0) ? NULL : (intptr_t) from_addr;
    }
}

通过如上函数的实现我们能看到,将需要通过寄存器传递的参数暂时存储到native方法的栈中,过多的参数也会存储到栈中。如下图所示。

 

我们暂时将需要通过寄存器传递的参数保存到新开辟过的14个slot中,而需要通过栈传递的参数放到param n ... param 1区域中即可。然后我们接着看AbstractInterpreterGenerator::generate_slow_signature_handler()函数中生成的汇编代码的逻辑,如下:

// (6 + 0) * wordSize
0x00007fffe1005496: test   $0x1,%ecx
0x00007fffe100549c: jne    0x00007fffe10054ad  // 如果不相等,则跳转到-- d --
0x00007fffe10054a2: vmovss 0x30(%rsp),%xmm0 // 针对32位的移动
0x00007fffe10054a8: jmpq   0x00007fffe10054b3 // 跳转到-- done --
// **** d ****
0x00007fffe10054ad: vmovsd 0x30(%rsp),%xmm0 // 针对64位的移动
// **** done ****
 
// (6 + 1) * wordSize
0x00007fffe10054b3: test   $0x2,%ecx
0x00007fffe10054b9: jne    0x00007fffe10054ca
0x00007fffe10054bf: vmovss 0x38(%rsp),%xmm1
0x00007fffe10054c5: jmpq   0x00007fffe10054d0
0x00007fffe10054ca: vmovsd 0x38(%rsp),%xmm1
 
// (6 + 2) * wordSize
0x00007fffe10054d0: test   $0x4,%ecx
0x00007fffe10054d6: jne    0x00007fffe10054e7
0x00007fffe10054dc: vmovss 0x40(%rsp),%xmm2
0x00007fffe10054e2: jmpq   0x00007fffe10054ed
0x00007fffe10054e7: vmovsd 0x40(%rsp),%xmm2
 
// (6 + 3) * wordSize
0x00007fffe10054ed: test   $0x8,%ecx
0x00007fffe10054f3: jne    0x00007fffe1005504
0x00007fffe10054f9: vmovss 0x48(%rsp),%xmm3
0x00007fffe10054ff: jmpq   0x00007fffe100550a
0x00007fffe1005504: vmovsd 0x48(%rsp),%xmm3
 
// (6 + 4) * wordSize
0x00007fffe100550a: test   $0x10,%ecx
0x00007fffe1005510: jne    0x00007fffe1005521
0x00007fffe1005516: vmovss 0x50(%rsp),%xmm4
0x00007fffe100551c: jmpq   0x00007fffe1005527
0x00007fffe1005521: vmovsd 0x50(%rsp),%xmm4
 
// (6 + 5) * wordSize
0x00007fffe1005527: test   $0x20,%ecx
0x00007fffe100552d: jne    0x00007fffe100553e
0x00007fffe1005533: vmovss 0x58(%rsp),%xmm5
0x00007fffe1005539: jmpq   0x00007fffe1005544
0x00007fffe100553e: vmovsd 0x58(%rsp),%xmm5
 
// (6 + 6) * wordSize
0x00007fffe1005544: test   $0x40,%ecx
0x00007fffe100554a: jne    0x00007fffe100555b
0x00007fffe1005550: vmovss 0x60(%rsp),%xmm6
0x00007fffe1005556: jmpq   0x00007fffe1005561
0x00007fffe100555b: vmovsd 0x60(%rsp),%xmm6
 
// (6 + 7) * wordSize
0x00007fffe1005561: test   $0x80,%ecx
0x00007fffe1005567: jne    0x00007fffe1005578
0x00007fffe100556d: vmovss 0x68(%rsp),%xmm7
0x00007fffe1005573: jmpq   0x00007fffe100557e
0x00007fffe1005578: vmovsd 0x68(%rsp),%xmm7 
  

其中的%ecx中存储的是float/double identifiers,这是一个组合数字,也就是能够指明8个浮点数slot中,哪些存储了float值,哪些存储了double值,然后分别使用vmovss和vmovsd移动到对应的寄存器中。

下面接着看AbstractInterpreterGenerator::generate_slow_signature_handler()函数中生成的汇编代码的逻辑,如下:

// 将Method::access_flags存储到%ecx中
0x00007fffe100557e: mov    0x28(%rbx),%ecx
// 是否含有JVM_ACC_STATIC标识
0x00007fffe1005581: test   $0x8,%ecx   
// 如果不含有,表示为实例方法,则将栈顶值存储到c_rarg1,即%rsi中  
0x00007fffe1005587: cmove  (%rsp),%rsi    
 
// 将栈顶值存储到c_rarg2、c_rarg3、c_rarg4及c_rarg5中
0x00007fffe100558c: mov    0x8(%rsp),%rdx
0x00007fffe1005591: mov    0x10(%rsp),%rcx
0x00007fffe1005596: mov    0x18(%rsp),%r8
0x00007fffe100559b: mov    0x20(%rsp),%r9
 
// 恢复%rsp
0x00007fffe10055a0: add    $0x70,%rsp
0x00007fffe10055a4: retq

之前已经将栈中保存的浮点数存储到了对应的寄存器中,现在需要将整数也保存到对应的寄存器中。

当将相关的值移动到寄存器后,新开始的14个slot就没有用处了,直接更改%rsp的指向弹出这14个slot,这样慢速解释器为调用本地函数准备好了调用相关的参数。 

 

对于慢速解释器来说,其对于所有的本地方法,生成的例程都是同一个,所以在这个例程中就必须检查目标方法是否为静态的、是否需要同步,然后根据不同的情况进入不同的路径。还需要检查参数数量和参数类型,然后准备栈参数。如果每个native方法的调用都涉及到这些逻辑,那么执行的速度就会相对较慢一些。

对于快速解释器来说,只是执行了必要的逻辑,所以执行的速度会相对快一些。

2、result_handler

无论是快速解释器还是慢速解释器,都会根据native方法的结果类型返回对应的result_handler(快速解释器返回result_handler的逻辑在InterpreterRuntime::SignatureHandlerGenerator::generate()函数中,慢速解释器在InterpreterRuntime::slow_signature_handler()函数中)。下面我们就来看一下result_handler,生成result_handler的代码如下:

static const BasicType types[Interpreter::number_of_result_handlers] = {
    T_BOOLEAN,
    T_CHAR   ,
    T_BYTE   ,
    T_SHORT  ,
    T_INT    ,
    T_LONG   ,
    T_VOID   ,
    T_FLOAT  ,
    T_DOUBLE ,
    T_OBJECT
};
 
{
    CodeletMark cm(_masm, "result handlers for native calls");
    int is_generated[Interpreter::number_of_result_handlers]; // 10
    memset(is_generated, 0, sizeof(is_generated));
 
    for (int i = 0; i < Interpreter::number_of_result_handlers; i++) {
      BasicType type = types[i];
      if (!is_generated[Interpreter::BasicType_as_index(type)]++) {
        int x = Interpreter::BasicType_as_index(type);
        Interpreter::_native_abi_to_tosca[x] = generate_result_handler_for(type);
      }
    }
}

会根据不同的方法返回类型生成不同的例程,这些例程都会保存到对应的_native_abi_to_tosca数组中,这个数组的定义如下:

static address    _native_abi_to_tosca[number_of_result_handlers];

调用的generate_result_handler_for()函数的实现如下:

address TemplateInterpreterGenerator::generate_result_handler_for(BasicType type) {
  switch (type) {
  case T_BOOLEAN: __ c2bool(rax);            break;
  case T_CHAR   : __ movzwl(rax, rax);       break;
  case T_BYTE   : __ sign_extend_byte(rax);  break;
  case T_SHORT  : __ sign_extend_short(rax); break;
  case T_INT    : /* nothing to do */        break;
  case T_LONG   : /* nothing to do */        break;
  case T_VOID   : /* nothing to do */        break;
  case T_FLOAT  : /* nothing to do */        break;
  case T_DOUBLE : /* nothing to do */        break;
  case T_OBJECT :
    // 对于返回类型为Object来说,会将结果存储到栈上特定的位置
    __ movptr(rax, Address(rbp, frame::interpreter_frame_oop_temp_offset*wordSize));
    break;
  default       : ShouldNotReachHere();
  }
  __ ret(0);  
 
  return entry;
}

可以看到,向Interpreter::_native_abi_to_tosca数组中存储了不同类型的入口。

(1)T_BOOLEAN

调用如下函数生成处理方法返回类型为boolean的例程:

void MacroAssembler::c2bool(Register x) {
  // implements x == 0 ? 0 : 1
  // note: must only look at least-significant byte of x
  //       since C-style booleans are stored in one byte
  //       only! (was bug)
  andl(x, 0xFF);
  setb(Assembler::notZero, x);
}

生成的汇编如下:

0x00007fffe100ecc0: and    $0xff,%eax
0x00007fffe100ecc6: setne  %al // 获取ZF值后,取反,然后再放入%al中
0x00007fffe100ecc9: retq 

setxx系列指令根据标志寄存器eflags的值,将操作数设置为0或1,如setne表示ZF=0时,也就是不相等时设置%al为1,否则设置为0。

(2)T_CHAR

生成的汇编如下:

0x00007fffe100ecca: movzwl %ax,%eax
0x00007fffe100eccd: retq

(3)T_BYTE

生成的汇编如下:

0x00007fffe100ecce: movsbl %al,%eax
0x00007fffe100ecd1: retq  

(4)T_SHORT

生成的汇编如下:

0x00007fffe100ecd2: movswl %ax,%eax
0x00007fffe100ecd5: retq

(5)T_INT、T_LONG、T_VOID、T_FLOAT与T_DOUBLE

只会生成一个retq指令,因为相关的值都根据调用约定缓存到了特定的寄存器中。

(6)T_OBJECT

生成的汇编如下:

0x00007fffe100ecdb: mov    0x10(%rbp),%rax
0x00007fffe100ecdf: retq

0x10(%rbp)在之前介绍为native方法设置解释器入口时介绍过,这个slot处为oop temp,当native方法返回对象时,将结果存储到这个slot中。

公众号 深入剖析Java虚拟机HotSpot 已经更新虚拟机源代码剖析相关文章到60+,欢迎关注,如果有任何问题,可加作者微信mazhimazh,拉你入虚拟机群交流
 

推荐文章