1. 返回值类型
SharedRuntime::generate_buffered_inline_type_adapter会生成pack和unpack的handler，这两个handler会放到InlineKlass的后面（就像signature handler一样）。pack和unpack是针对buffer object的操作：
- pack handler：把fields从寄存器打包到buffer object里 [register->buffer]
- unpack handler：把拆开buffer object，把里面的fields放到寄存器[buffer->register]
pack handler和unpack handler都要求buffer object必须放到rax。
InlineTypeReturnedAsFields做的事情是，直接返回fields而不是primitive type reference，相当于返回一个结构体给caller，而不是返回一个对象。它需要修改C1，C2，Interp等各处，并考虑两者交互的情况。
C1
C1 return val时候，把val拆开到register
void LIR_Assembler::return_op(LIR_Opr result, C1SafepointPollStub* code_stub) {
...
ciMethod* method = compilation()->method();
ciType* return_type = method->return_type();
if (InlineTypeReturnedAsFields && return_type->is_inlinetype()) {
ciInlineKlass* vk = return_type->as_inline_klass();
if (vk->can_be_returned_as_fields()) {
#ifndef _LP64
Unimplemented();
#else
address unpack_handler = vk->unpack_handler();
assert(unpack_handler != NULL, "must be");
__ call(RuntimeAddress(unpack_handler));
// At this point, rax points to the value object (for interpreter or C1 caller).
// The fields of the object are copied into registers (for C2 caller).
#endif
}
}
...
}
C1 Foo f = call foo，从寄存器里面拿fields，放到f里面
void LIR_Assembler::emit_call(LIR_OpJavaCall* op) {
verify_oop_map(op->info());
// must align calls sites, otherwise they can't be updated atomically
align_call(op->code());
// emit the static call stub stuff out of line
emit_static_call_stub();
CHECK_BAILOUT();
switch (op->code()) {
case lir_static_call:
case lir_dynamic_call:
call(op, relocInfo::static_call_type);
break;
case lir_optvirtual_call:
call(op, relocInfo::opt_virtual_call_type);
break;
case lir_icvirtual_call:
ic_call(op);
break;
case lir_virtual_call:
vtable_call(op);
break;
default:
fatal("unexpected op code: %s", op->name());
break;
}
// JSR 292
// Record if this method has MethodHandle invokes.
if (op->is_method_handle_invoke()) {
compilation()->set_has_method_handle_invokes(true);
}
ciInlineKlass* vk;
if (op->maybe_return_as_fields(&vk)) {
int offset = store_inline_type_fields_to_buf(vk);
add_call_info(offset, op->info(), true);
}
...
}
C2
void Compile::return_values(JVMState* jvms) {
GraphKit kit(jvms);
Node* ret = new ReturnNode(TypeFunc::Parms,
kit.control(),
kit.i_o(),
kit.reset_memory(),
kit.frameptr(),
kit.returnadr());
// Add zero or 1 return values
int ret_size = tf()->range_sig()->cnt() - TypeFunc::Parms;
if (ret_size > 0) {
kit.inc_sp(-ret_size); // pop the return value(s)
kit.sync_jvms();
Node* res = kit.argument(0);
if (tf()->returns_inline_type_as_fields()) {
// Multiple return values (inline type fields): add as many edges
// to the Return node as returned values.
assert(res->is_InlineType(), "what else supports multi value return?");
InlineTypeNode* vt = res->as_InlineType();
ret->add_req_batch(NULL, tf()->range_cc()->cnt() - TypeFunc::Parms);
if (vt->is_allocated(&kit.gvn()) && !StressInlineTypeReturnedAsFields) {
ret->init_req(TypeFunc::Parms, vt->get_oop());
} else {
ret->init_req(TypeFunc::Parms, vt->tagged_klass(kit.gvn()));
}
uint idx = TypeFunc::Parms + 1;
vt->pass_fields(&kit, ret, idx);
} else {
ret->add_req(res);
// Note: The second dummy edge is not needed by a ReturnNode.
}
}
// bind it to root
root()->add_req(ret);
record_for_igvn(ret);
initial_gvn()->transform_no_reclaim(ret);
}
Interp
（return字节码和throw stub会有remove_activation）
void InterpreterMacroAssembler::remove_activation(...) {
...
if (state == atos && InlineTypeReturnedAsFields) {
Label skip;
// Test if the return type is an inline type
movptr(rdi, Address(rbp, frame::interpreter_frame_method_offset * wordSize));
movptr(rdi, Address(rdi, Method::const_offset()));
load_unsigned_byte(rdi, Address(rdi, ConstMethod::result_type_offset()));
cmpl(rdi, T_INLINE_TYPE);
jcc(Assembler::notEqual, skip);
// We are returning an inline type, load its fields into registers
#ifndef _LP64
super_call_VM_leaf(StubRoutines::load_inline_type_fields_in_regs());
#else
// Load fields from a buffered value with an inline class specific handler
Register tmp_load_klass = LP64_ONLY(rscratch1) NOT_LP64(noreg);
load_klass(rdi, rax, tmp_load_klass);
movptr(rdi, Address(rdi, InstanceKlass::adr_inlineklass_fixed_block_offset()));
movptr(rdi, Address(rdi, InlineKlass::unpack_handler_offset()));
testptr(rdi, rdi);
jcc(Assembler::equal, skip);
call(rdi);
#endif
// call above kills the value in rbx. Reload it.
movptr(rbx, Address(rbp, frame::interpreter_frame_sender_sp_offset * wordSize));
bind(skip);
}
...
}
StubGenerator && JavaCalls
address generate_call_stub(address& return_address) {
// call java
...
__ BIND(is_value);
if (InlineTypeReturnedAsFields) {
// Check for flattened return value
__ testptr(rax, 1);
__ jcc(Assembler::zero, is_long);
// Load pack handler address
__ andptr(rax, -2);
__ movptr(rax, Address(rax, InstanceKlass::adr_inlineklass_fixed_block_offset()));
__ movptr(rbx, Address(rax, InlineKlass::pack_handler_jobject_offset()));
// Call pack handler to initialize the buffer
__ call(rbx);
__ jmp(exit);
}
...
}
void JavaCalls::call_helper(...) {
if (InlineTypeReturnedAsFields && result->get_type() == T_INLINE_TYPE) {
// Pre allocate a buffered inline type in case the result is returned
// flattened by compiled code
InlineKlass* vk = method->returned_inline_type(thread);
if (vk->can_be_returned_as_fields()) {
oop instance = vk->allocate_instance(CHECK);
value_buffer = JNIHandles::make_local(thread, instance);
result->set_jobject(value_buffer);
}
}
// do call
...
}
2. 传入值类型
InlineTypeReturnedAsFields做的事情是把primitive type的对象的字段当作实参传递，而不是传递这个对象引用。