单步调试java invokestatic在hotspot中的解释执行

1
2
3
4
5
6
7
8
9
10
void TemplateTable::invokestatic(int byte_no) {
  transition(vtos, vtos);
  assert(byte_no == f1_byte, "use this argument");
  // rbx寄存器用来接收invokestatic指向的Method*
  prepare_invoke(byte_no, rbx);  // get f1 Method*
  // do the call
  __ profile_call(rax);
  __ profile_arguments_type(rax, rbx, r13, false);
  __ jump_from_interpreted(rbx, rax);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
void TemplateTable::load_invoke_cp_cache_entry(int byte_no,
                                               Register method,
                                               Register itable_index,
                                               Register flags,
                                               bool is_invokevirtual,
                                               bool is_invokevfinal, /*unused*/
                                               bool is_invokedynamic) {
  const Register cache = rcx;
  const Register index = rdx;
  ......
  // 这个地方offset的计算稍微有点绕，需要关注一下ConstantPool，ConstantPoolCache和
  // ConstantPoolCacheEntry类的定义及相互关系。其中ConstantPoolCache的对象分配allocate
  // 方法使用了C++ placement new语义，也就是说提前分配了ConstantPoolCache对象+length*sizeof(ConstantPoolCacheEntry)
  // 长度的内存，然后返回了ConstantPoolCache*。此后通过ConstantPoolCache*就可以以下标方式访问ConstantPoolCacheEntry
  // 元素了.
  // 此外Address(cache, index, Address::times_ptr, method_offset) => mov 0x18(%rcx,%rdx,8),%rbx
  // 相当于说是先通过下标到达大概位置，然后再加上偏移量。而直觉计算是先加上偏移量到达ConstantPoolCacheEntry
  // 数组头部，然后再通过下标索引
  const int method_offset = in_bytes(
    ConstantPoolCache::base_offset() +
      ((byte_no == f2_byte)
       ? ConstantPoolCacheEntry::f2_offset()
       : ConstantPoolCacheEntry::f1_offset()));
  const int flags_offset = in_bytes(ConstantPoolCache::base_offset() +
                                    ConstantPoolCacheEntry::flags_offset());
  // access constant pool cache fields
  const int index_offset = in_bytes(ConstantPoolCache::base_offset() +
                                    ConstantPoolCacheEntry::f2_offset());

  size_t index_size = (is_invokedynamic ? sizeof(u4) : sizeof(u2));
  resolve_cache_and_index(byte_no, cache, index, index_size);
  // 编译为mov 0x18(%rcx,%rdx,8),%rbx，因为rbx作为入参来接收method
    __ movptr(method, Address(cache, index, Address::times_ptr, method_offset));

  if (itable_index != noreg) {
    // pick up itable or appendix index from f2 also:
    __ movptr(itable_index, Address(cache, index, Address::times_ptr, index_offset));
  }
  __ movl(flags, Address(cache, index, Address::times_ptr, flags_offset));
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
void TemplateTable::resolve_cache_and_index(int byte_no,
                                            Register Rcache,
                                            Register index,
                                            size_t index_size) {
  const Register temp = rbx;
  Label resolved;
  	// 路径1: 通过ConstantPoolCache返回
    __ get_cache_and_index_and_bytecode_at_bcp(Rcache, index, temp, byte_no, 1, index_size);
  	// 0xb8即为ByteCodes::_invokestatic
    __ cmpl(temp, (int) bytecode());  // 汇编结果：cmp    $0xb8,%ebx
    // 如果已经完成解析(resolve)，那么直接跳到方法末尾
    __ jcc(Assembler::equal, resolved);

  // 路径2: 方法解析
  // 首次调用，需要完成方法解析，并将Method* 放入ConstantPoolCache相应下标位置保存
  address entry;
  switch (bytecode()) {
  case Bytecodes::_getstatic:
  case Bytecodes::_putstatic:
  case Bytecodes::_getfield:
  case Bytecodes::_putfield:
    entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_get_put);
    break;
  case Bytecodes::_invokevirtual:
  case Bytecodes::_invokespecial:
  case Bytecodes::_invokestatic:
  case Bytecodes::_invokeinterface:
    entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_invoke);
    break;
  ......
  default:
    fatal(err_msg("unexpected bytecode: %s", Bytecodes::name(bytecode())));
    break;
  }
  __ movl(temp, (int) bytecode());
  __ call_VM(noreg, entry, temp);

  // Update registers with resolved info
  __ get_cache_and_index_at_bcp(Rcache, index, 1, index_size);
  __ bind(resolved);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void InterpreterMacroAssembler::get_cache_and_index_and_bytecode_at_bcp(Register cache,
                                                                        Register index,
                                                                        Register bytecode,
                                                                        int byte_no,
                                                                        int bcp_offset,
                                                                        size_t index_size) {
  // 取得ConstantPoolCache指针与invokestatic对应方法常量池索引
  get_cache_and_index_at_bcp(cache, index, bcp_offset, index_size);
  // 从ConstantPoolCache后续ConstantPoolCacheEntry数组下标处取得bytecode, 如果此前完成解析则最终应为0xb8(invokestatic)
  movl(bytecode, Address(cache, index, Address::times_ptr, ConstantPoolCache::base_offset() + ConstantPoolCacheEntry::indices_offset()));
  const int shift_count = (1 + byte_no) * BitsPerByte;
  shrl(bytecode, shift_count);
  andl(bytecode, ConstantPoolCacheEntry::bytecode_1_mask);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
void InterpreterMacroAssembler::get_cache_and_index_at_bcp(Register cache,
                                                           Register index,
                                                           int bcp_offset,
                                                           size_t index_size) {
  get_cache_index_at_bcp(index, bcp_offset, index_size);
  movptr(cache, Address(rbp, frame::interpreter_frame_cache_offset * wordSize));
  shll(index, 2);
}

void InterpreterMacroAssembler::get_cache_index_at_bcp(Register index,
                                                       int bcp_offset,
                                                       size_t index_size) {
  if (index_size == sizeof(u2)) {
    // 从字节码流中取得short型数值，因为invokestatic后面紧跟着两个字节的方法常量池索引
    load_unsigned_short(index, Address(r13, bcp_offset));
  } else if (index_size == sizeof(u4)) {
    ...
  } else if (index_size == sizeof(u1)) {
    load_unsigned_byte(index, Address(r13, bcp_offset));
  } 
}

1
entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_invoke);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
  switch (info.call_kind()) {
  case CallInfo::direct_call:
    cache_entry(thread)->set_direct_call(
      bytecode,
      info.resolved_method());
    break;
  case CallInfo::vtable_call:
    cache_entry(thread)->set_vtable_call(
      bytecode,
      info.resolved_method(),
      info.vtable_index());
    break;
    ......
  default:  ShouldNotReachHere();
  }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
void ConstantPoolCacheEntry::set_direct_or_vtable_call(Bytecodes::Code invoke_code,
                                                       methodHandle method,
                                                       int vtable_index) {
  switch (invoke_code) {
      ......
    case Bytecodes::_invokestatic:
      set_method_flags(as_TosState(method->result_type()),
                       ((is_vfinal()               ? 1 : 0) << is_vfinal_shift) |
                       ((method->is_final_method() ? 1 : 0) << is_final_shift),
                       method()->size_of_parameters());
      set_f1(method());
      byte_no = 1;
      break;
    default:
      ShouldNotReachHere();
      break;
  }

  if (byte_no == 1) {
    set_bytecode_1(invoke_code);
  } 
  ......
}

void set_f1(Metadata* f1)                            {
    Metadata* existing_f1 = (Metadata*)_f1; // read once
    assert(existing_f1 == NULL || existing_f1 == f1, "illegal field change");
    _f1 = f1;
  }

void ConstantPoolCacheEntry::set_bytecode_1(Bytecodes::Code code) {
  OrderAccess::release_store_ptr(&_indices, _indices | ((u_char)code << bytecode_1_shift));
}

1
2
3
4
5
// 代码具体位置可自行搜索
movptr(Address(rbp, frame::interpreter_frame_bcx_offset * wordSize), r13);
// 在invokestatic实现中，该行代码意味着即将调用一个静态方法时，需要从当前方法帧获取常量池指针，以进一步拿到静态方法信息
// rbp是当前栈帧基址
movptr(cache, Address(rbp, frame::interpreter_frame_cache_offset * wordSize));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
enum {
    pc_return_offset                                 =  0,
    // All frames
    link_offset                                      =  0,
    return_addr_offset                               =  1,
    // non-interpreter frames
    sender_sp_offset                                 =  2,
    
    // Interpreter frames
    interpreter_frame_result_handler_offset          =  3, // for native calls only
    interpreter_frame_oop_temp_offset                =  2, // for native calls only

    interpreter_frame_sender_sp_offset               = -1,
    // outgoing sp before a call to an invoked method
    interpreter_frame_last_sp_offset                 = interpreter_frame_sender_sp_offset - 1,
    interpreter_frame_method_offset                  = interpreter_frame_last_sp_offset - 1,
    interpreter_frame_mdx_offset                     = interpreter_frame_method_offset - 1,
    interpreter_frame_cache_offset                   = interpreter_frame_mdx_offset - 1,
    interpreter_frame_locals_offset                  = interpreter_frame_cache_offset - 1,
    interpreter_frame_bcx_offset                     = interpreter_frame_locals_offset - 1,
    interpreter_frame_initial_sp_offset              = interpreter_frame_bcx_offset - 1,
    interpreter_frame_monitor_block_top_offset       = interpreter_frame_initial_sp_offset,
    interpreter_frame_monitor_block_bottom_offset    = interpreter_frame_initial_sp_offset,
		......
  };