第46篇-signature_handler与result_handler

在之前介绍为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，拉你入虚拟机群交流