Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

8307352: AARCH64: Improve itable_stub #13792

Closed
wants to merge 6 commits into from
+118 −20
Closed

8307352: AARCH64: Improve itable_stub #13792

Changes from all commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
771fdf0
8307352: AARCH64: Improve itable_stub
bulasevich May 4, 2023
54be64e
rework loop_scan_resolved_entry cycle as proposed
bulasevich Aug 4, 2023
dd0051f
Comments applied: get rid of temp_reg3; replace the magic constants
bulasevich Aug 25, 2023
83b7981
adding guarantee and comment
bulasevich Aug 28, 2023
1687c4b
Address base_plus_offset_reg encoding: assert->guarantee for shift() …
bulasevich Aug 29, 2023
1128729
assert message update
bulasevich Sep 7, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion src/hotspot/cpu/aarch64/assembler_aarch64.hpp
View file
Original file line number Diff line number Diff line change
@@ -573,7 +573,7 @@ class Address {
if (size == 0) // It's a byte
i->f(ext().shift() >= 0, 12);
else {
assert(ext().shift() <= 0 || ext().shift() == (int)size, "bad shift");
guarantee(ext().shift() <= 0 || ext().shift() == (int)size, "bad shift");
i->f(ext().shift() > 0, 12);
}
i->f(0b10, 11, 10);
104 changes: 104 additions & 0 deletions src/hotspot/cpu/aarch64/macroAssembler_aarch64.cpp
View file
Original file line number Diff line number Diff line change
@@ -1196,6 +1196,110 @@ void MacroAssembler::lookup_interface_method(Register recv_klass,
}
}

// Look up the method for a megamorphic invokeinterface call in a single pass over itable:
// - check recv_klass (actual object class) is a subtype of resolved_klass from CompiledICHolder
// - find a holder_klass (class that implements the method) vtable offset and get the method from vtable by index
// The target method is determined by <holder_klass, itable_index>.
// The receiver klass is in recv_klass.
// On success, the result will be in method_result, and execution falls through.
// On failure, execution transfers to the given label.
void MacroAssembler::lookup_interface_method_stub(Register recv_klass,
Register holder_klass,
Register resolved_klass,
Register method_result,
Register temp_itbl_klass,
Register scan_temp,
int itable_index,
Label& L_no_such_interface) {
// 'method_result' is only used as output register at the very end of this method.
// Until then we can reuse it as 'holder_offset'.
Register holder_offset = method_result;
assert_different_registers(resolved_klass, recv_klass, holder_klass, temp_itbl_klass, scan_temp, holder_offset);

int vtable_start_offset = in_bytes(Klass::vtable_start_offset());
int itable_offset_entry_size = itableOffsetEntry::size() * wordSize;
int ioffset = in_bytes(itableOffsetEntry::interface_offset());
int ooffset = in_bytes(itableOffsetEntry::offset_offset());

Label L_loop_search_resolved_entry, L_resolved_found, L_holder_found;

ldrw(scan_temp, Address(recv_klass, Klass::vtable_length_offset()));
add(recv_klass, recv_klass, vtable_start_offset + ioffset);
// itableOffsetEntry[] itable = recv_klass + Klass::vtable_start_offset() + sizeof(vtableEntry) * recv_klass->_vtable_len;
// temp_itbl_klass = itable[0]._interface;
int vtblEntrySize = vtableEntry::size_in_bytes();
assert(vtblEntrySize == wordSize, "ldr lsl shift amount must be 3");
ldr(temp_itbl_klass, Address(recv_klass, scan_temp, Address::lsl(exact_log2(vtblEntrySize))));
mov(holder_offset, zr);
// scan_temp = &(itable[0]._interface)
lea(scan_temp, Address(recv_klass, scan_temp, Address::lsl(exact_log2(vtblEntrySize))));

// Initial checks:
// - if (holder_klass != resolved_klass), go to "scan for resolved"
// - if (itable[0] == holder_klass), shortcut to "holder found"
// - if (itable[0] == 0), no such interface
cmp(resolved_klass, holder_klass);
br(Assembler::NE, L_loop_search_resolved_entry);
cmp(holder_klass, temp_itbl_klass);
br(Assembler::EQ, L_holder_found);
cbz(temp_itbl_klass, L_no_such_interface);

// Loop: Look for holder_klass record in itable
// do {
// temp_itbl_klass = *(scan_temp += itable_offset_entry_size);
// if (temp_itbl_klass == holder_klass) {
// goto L_holder_found; // Found!
// }
// } while (temp_itbl_klass != 0);
// goto L_no_such_interface // Not found.
Label L_search_holder;
bind(L_search_holder);
ldr(temp_itbl_klass, Address(pre(scan_temp, itable_offset_entry_size)));
cmp(holder_klass, temp_itbl_klass);
br(Assembler::EQ, L_holder_found);
cbnz(temp_itbl_klass, L_search_holder);

b(L_no_such_interface);

// Loop: Look for resolved_class record in itable
// while (true) {
// temp_itbl_klass = *(scan_temp += itable_offset_entry_size);
// if (temp_itbl_klass == 0) {
// goto L_no_such_interface;
// }
// if (temp_itbl_klass == resolved_klass) {
// goto L_resolved_found; // Found!
// }
// if (temp_itbl_klass == holder_klass) {
// holder_offset = scan_temp;
// }
// }
//
Label L_loop_search_resolved;
bind(L_loop_search_resolved);
ldr(temp_itbl_klass, Address(pre(scan_temp, itable_offset_entry_size)));
bind(L_loop_search_resolved_entry);
cbz(temp_itbl_klass, L_no_such_interface);
cmp(resolved_klass, temp_itbl_klass);
br(Assembler::EQ, L_resolved_found);
cmp(holder_klass, temp_itbl_klass);
br(Assembler::NE, L_loop_search_resolved);
mov(holder_offset, scan_temp);
b(L_loop_search_resolved);

// See if we already have a holder klass. If not, go and scan for it.
bind(L_resolved_found);
cbz(holder_offset, L_search_holder);
mov(scan_temp, holder_offset);

// Finally, scan_temp contains holder_klass vtable offset
bind(L_holder_found);
ldrw(method_result, Address(scan_temp, ooffset - ioffset));
add(recv_klass, recv_klass, itable_index * wordSize + in_bytes(itableMethodEntry::method_offset())
- vtable_start_offset - ioffset); // substract offsets to restore the original value of recv_klass
ldr(method_result, Address(recv_klass, method_result, Address::uxtw(0)));
}

// virtual method calling
void MacroAssembler::lookup_virtual_method(Register recv_klass,
RegisterOrConstant vtable_index,
9 changes: 9 additions & 0 deletions src/hotspot/cpu/aarch64/macroAssembler_aarch64.hpp
View file
Original file line number Diff line number Diff line change
@@ -943,6 +943,15 @@ class MacroAssembler: public Assembler {
Label& no_such_interface,
bool return_method = true);

void lookup_interface_method_stub(Register recv_klass,
Register holder_klass,
Register resolved_klass,
Register method_result,
Register temp_reg,
Register temp_reg2,
int itable_index,
Label& L_no_such_interface);

// virtual method calling
// n.b. x86 allows RegisterOrConstant for vtable_index
void lookup_virtual_method(Register recv_klass,
23 changes: 4 additions & 19 deletions src/hotspot/cpu/aarch64/vtableStubs_aarch64.cpp
View file
Original file line number Diff line number Diff line change
@@ -175,7 +175,7 @@ VtableStub* VtableStubs::create_itable_stub(int itable_index) {
// so all registers except arguments are free at this point.
const Register recv_klass_reg = r10;
const Register holder_klass_reg = r16; // declaring interface klass (DECC)
const Register resolved_klass_reg = rmethod; // resolved interface klass (REFC)
const Register resolved_klass_reg = r17; // resolved interface klass (REFC)
const Register temp_reg = r11;
const Register temp_reg2 = r15;
const Register icholder_reg = rscratch2;
@@ -192,28 +192,13 @@ VtableStub* VtableStubs::create_itable_stub(int itable_index) {
__ load_klass(recv_klass_reg, j_rarg0);

// Receiver subtype check against REFC.
__ lookup_interface_method(// inputs: rec. class, interface
recv_klass_reg, resolved_klass_reg, noreg,
// outputs: scan temp. reg1, scan temp. reg2
temp_reg2, temp_reg,
L_no_such_interface,
/*return_method=*/false);

const ptrdiff_t typecheckSize = __ pc() - start_pc;
start_pc = __ pc();

// Get selected method from declaring class and itable index
__ lookup_interface_method(// inputs: rec. class, interface, itable index
recv_klass_reg, holder_klass_reg, itable_index,
// outputs: method, scan temp. reg
rmethod, temp_reg,
L_no_such_interface);

const ptrdiff_t lookupSize = __ pc() - start_pc;
__ lookup_interface_method_stub(recv_klass_reg, holder_klass_reg, resolved_klass_reg, rmethod,
temp_reg, temp_reg2, itable_index, L_no_such_interface);

// Reduce "estimate" such that "padding" does not drop below 8.
const ptrdiff_t estimate = 124;
const ptrdiff_t codesize = typecheckSize + lookupSize;
const ptrdiff_t codesize = __ pc() - start_pc;
slop_delta = (int)(estimate - codesize);
slop_bytes += slop_delta;
assert(slop_delta >= 0, "itable #%d: Code size estimate (%d) for lookup_interface_method too small, required: %d", itable_index, (int)estimate, (int)codesize);