void NativeGenerator::generate_native_string_entries() {
comment_section("Native entry points for string functions");
{
//--------------------java.lang.String.indexof0---------------------------
rom_linkable_entry("native_string_indexof0_entry");
wtk_profile_quick_call(/* param_size*/ 2);
comment("Pop the return address");
popl(edi);
comment("Push zero for fromIndex");
pushl(Constant(0));
comment("Push back the return address");
pushl(edi);
jmp(Constant("native_string_indexof_entry"));
rom_linkable_entry_end(); // native_string_indexof0_entry
//--------------------java.lang.String.indexof---------------------------
rom_linkable_entry("native_string_indexof_entry");
Label cont, loop, test, failure, success;
wtk_profile_quick_call(/* param_size*/ 3);
comment("Pop the return address");
popl(edi);
comment("Pop the argument: fromIndex");
pop_int(eax, eax);
comment("Pop the argument: ch");
pop_int(ebx, ebx);
comment("Pop the receiver");
pop_obj(ecx, ecx);
cmpl(ebx, Constant(0xFFFF));
jcc(greater, Constant(failure));
cmpl(eax, Constant(0));
jcc(greater_equal, Constant(cont));
movl(eax, Constant(0));
bind(cont);
movl(esi, Address(ecx, Constant(String::count_offset())));
comment("if (fromIndex >= count) { return -1; }");
cmpl(eax, esi);
jcc(greater_equal, Constant(failure));
movl(edx, Address(ecx, Constant(String::offset_offset())));
addl(eax, edx); // i = offset + fromIndex
addl(edx, esi); // int max = offset + count;
movl(esi, Address(ecx, Constant(String::value_offset()))); // v = value.
jmp(Constant(test));
bind(loop);
cmpw(Address(esi, eax, times_2, Constant(Array::base_offset())), ebx);
jcc(equal, Constant(success));
incl(eax);
bind(test);
cmpl(eax, edx);
jcc(less, Constant(loop));
comment("Return -1 by pushing the value and jumping to the return address");
bind(failure);
push_int(-1);
jmp(edi);
comment("Return i - offset by pushing the value and jumping to the return address");
bind(success);
movl(esi, Address(ecx, Constant(String::offset_offset()))); // i = offset + fromIndex
subl(eax, esi);
push_int(eax);
jmp(edi);
rom_linkable_entry_end(); // native_string_indexof_entry
}
//----------------------java.lang.String.charAt---------------------------
{
rom_linkable_entry("native_string_charAt_entry");
if (AddExternCUnderscore) {
emit_instruction("jmp _interpreter_method_entry");
} else {
emit_instruction("jmp interpreter_method_entry");
}
rom_linkable_entry_end();
}
//----------------------java.lang.String(java.lang.StringBuffer)-------------
{
rom_linkable_entry("native_string_init_entry");
if (AddExternCUnderscore) {
emit_instruction("jmp _interpreter_method_entry");
} else {
emit_instruction("jmp interpreter_method_entry");
}
rom_linkable_entry_end();
}
//----------------------java.lang.String.equals(java.lang.Object)------------
{
rom_linkable_entry("native_string_equals_entry");
if (AddExternCUnderscore) {
emit_instruction("jmp _interpreter_method_entry");
} else {
emit_instruction("jmp interpreter_method_entry");
}
rom_linkable_entry_end();
}
//----------------------java.lang.String.indexOf(java.lang.String)-----------
{
rom_linkable_entry("native_string_indexof0_string_entry");
if (AddExternCUnderscore) {
emit_instruction("jmp _interpreter_method_entry");
} else {
emit_instruction("jmp interpreter_method_entry");
}
rom_linkable_entry_end();
}
//----------------------java.lang.String.indexOf(java.lang.String)-----------
{
rom_linkable_entry("native_string_indexof_string_entry");
if (AddExternCUnderscore) {
emit_instruction("jmp _interpreter_method_entry");
} else {
emit_instruction("jmp interpreter_method_entry");
}
rom_linkable_entry_end();
}
//----------------------java.lang.String.compareTo---------------------------
{ // java.lang.String.compareTo
// Method int compareTo(java.lang.String)
rom_linkable_entry("native_string_compareTo_entry");
wtk_profile_quick_call(/* param_size*/ 2);
comment("preserve method");
pushl(ebx);
// 8 is return address plus pushed method
int str1_offset = JavaFrame::arg_offset_from_sp(0) + 8,
str0_offset = JavaFrame::arg_offset_from_sp(1) + 8;
comment("load arguments to registers");
movl(ecx, Address(esp, Constant(str1_offset)));
movl(eax, Address(esp, Constant(str0_offset)));
// eax: str0: this String
// ebx: str1: String to compare against
Label bailout;
comment("Null check");
testl(ecx, ecx);
jcc(zero, Constant(bailout));
comment("get str0.value[]");
movl(esi, Address(eax, Constant(String::value_offset())));
comment("get str0.offset");
movl(ebx, Address(eax, Constant(String::offset_offset())));
comment("compute start of character data");
leal(esi, Address(esi, ebx, times_2, Constant(Array::base_offset())));
comment("get str0.count");
movl(eax, Address(eax, Constant(String::count_offset())));
comment("get str1.value[]");
movl(edi, Address(ecx, Constant(String::value_offset())));
comment("get str1.offset");
movl(ebx, Address(ecx, Constant(String::offset_offset())));
comment("compute start of character data");
leal(edi, Address(edi, ebx, times_2, Constant(Array::base_offset())));
comment("get str1.count");
movl(ebx, Address(ecx, Constant(String::count_offset())));
// esi = str0 start of character data
// edi = str1 start of character data
// eax = str0 length
// ebx = str1 length
Label str1_longest;
subl(eax, ebx);
jcc(greater_equal, Constant(str1_longest));
// str1 is longer than str0
addl(ebx, eax);
bind(str1_longest);
// esi = str0 start of character data
// edi = str1 start of character data
// eax = str0.count - str1.count
// ebx = min(str0.count, str1.count)
// save str0.count - str1.count, we might need it later
pushl(eax);
xorl(ecx, ecx);
Label loop, check_lengths, done;
bind(loop);
cmpl(ecx, ebx);
jcc(above_equal, Constant(check_lengths));
movzxw(eax, Address(esi, ecx, times_2));
movzxw(edx, Address(edi, ecx, times_2));
subl(eax, edx);
jcc(not_equal, Constant(done));
incl(ecx);
jmp(Constant(loop));
bind(check_lengths);
movl(eax, Address(esp));
bind(done);
popl(ebx); // remove saved length difference
// Push result on stack and return to caller
popl(ebx); // remove method
popl(edi); // pop return address
addl(esp, Constant(2 * BytesPerStackElement)); // remove arguments
push_int(eax); // push result
jmp(edi); // return
comment("Bail out to the general compareTo implementation");
bind(bailout);
comment("pop method");
popl(ebx);
if (AddExternCUnderscore) {
emit_instruction("jmp _interpreter_method_entry");
} else {
emit_instruction("jmp interpreter_method_entry");
}
rom_linkable_entry_end(); // native_string_compareTo_entry
}
//----------------------java.lang.String.endsWith----------------
{
// java.lang.String.endsWith
// Method boolean endsWith(java.lang.String)
rom_linkable_entry("native_string_endsWith_entry");
wtk_profile_quick_call(/* param_size*/ 2);
Label bailout;
// 4 is return address
int suffix_offset = JavaFrame::arg_offset_from_sp(0) + 4,
this_offset = JavaFrame::arg_offset_from_sp(1) + 4;
comment("load arguments to registers");
movl(eax, Address(esp, Constant(suffix_offset)));
cmpl(eax, Constant(0));
jcc(equal, Constant(bailout));
movl(ecx, Address(esp, Constant(this_offset)));
comment("Pop the return address");
popl(edi);
movl(edx, Address(ecx, Constant(String::count_offset())));
subl(edx, Address(eax, Constant(String::count_offset())));
comment("Push (this.count - suffix.count) for toffset");
pushl(edx);
comment("Push back the return address");
pushl(edi);
jmp(Constant("native_string_startsWith_entry"));
comment("Bail out to the general startsWith implementation");
bind(bailout);
if (AddExternCUnderscore) {
emit_instruction("jmp _interpreter_method_entry");
} else {
emit_instruction("jmp interpreter_method_entry");
}
rom_linkable_entry_end(); // native_string_endsWith_entry
}
//----------------------java.lang.String.startsWith----------------
{
// java.lang.String.startsWith
// Method boolean startsWith(java.lang.String)
rom_linkable_entry("native_string_startsWith0_entry");
wtk_profile_quick_call(/* param_size*/ 2);
Label bailout;
// 4 is return address
int prefix_offset = JavaFrame::arg_offset_from_sp(0) + 4;
comment("Check if prefix is null");
cmpl(Address(esp, Constant(prefix_offset)), Constant(0));
jcc(equal, Constant(bailout));
comment("Pop the return address");
popl(edi);
comment("Push zero for toffset");
pushl(Constant(0));
comment("Push back the return address");
pushl(edi);
jmp(Constant("native_string_startsWith_entry"));
comment("Bail out to the general startsWith implementation");
bind(bailout);
if (AddExternCUnderscore) {
emit_instruction("jmp _interpreter_method_entry");
} else {
emit_instruction("jmp interpreter_method_entry");
}
rom_linkable_entry_end(); // native_string_startsWith0_entry
}
{
// ----------- java.lang.String.startsWith ------------------------------
// Method boolean startsWith(java.lang.String,int)
rom_linkable_entry("native_string_startsWith_entry");
wtk_profile_quick_call(/* param_size*/ 3);
Label bailout, return_false;
// 4 is return address
int prefix_offset = JavaFrame::arg_offset_from_sp(1) + 4;
comment("Check if prefix is null");
cmpl(Address(esp, Constant(prefix_offset)), Constant(0));
jcc(equal, Constant(bailout));
comment("Pop the return address");
popl(edi);
comment("Pop the argument: toffset");
pop_int(edx, edx);
comment("Pop the argument: prefix");
pop_obj(eax, eax);
comment("Pop the receiver");
pop_obj(ecx, ecx);
comment("Preserve the return address");
pushl(edi);
// ecx: this String
// eax: prefix
cmpl(edx, Constant(0));
jcc(less, Constant(return_false));
comment("if (toffset > this.count - prefix.count) return false;");
movl(ebx, Address(ecx, Constant(String::count_offset())));
subl(ebx, Address(eax, Constant(String::count_offset())));
cmpl(edx, ebx);
jcc(greater, Constant(return_false));
comment("get this.value[]");
movl(esi, Address(ecx, Constant(String::value_offset())));
comment("get this.offset");
movl(ebx, Address(ecx, Constant(String::offset_offset())));
comment("add toffset");
addl(ebx, edx);
comment("compute start of character data");
leal(esi, Address(esi, ebx, times_2, Constant(Array::base_offset())));
comment("get prefix.value[]");
movl(edi, Address(eax, Constant(String::value_offset())));
comment("get prefix.offset");
movl(ebx, Address(eax, Constant(String::offset_offset())));
comment("compute start of character data");
leal(edi, Address(edi, ebx, times_2, Constant(Array::base_offset())));
comment("get prefix.count");
movl(ecx, Address(eax, Constant(String::count_offset())));
comment("get the number of bytes to compare");
shll(ecx, Constant(1));
comment("memcmp(edi, esi, ecx);");
pushl(ecx);
pushl(esi);
pushl(edi);
if (GenerateInlineAsm) {
// VC++ treats memcmp() as an intrinsic function and would cause
// reference to memcmp in Interpreter_i386.c to fail to compile.
call(Constant("memcmp_from_interpreter"));
} else {
call(Constant("memcmp"));
}
addl(esp, Constant(12));
cmpl(eax, Constant(0));
jcc(not_equal, Constant(return_false));
// Push 1 on stack and return to caller
popl(edi); // pop return address
push_int(1); // push result
jmp(edi); // return
bind(return_false);
// Push 0 on stack and return to caller
popl(edi); // pop return address
push_int(0); // push result
jmp(edi); // return
comment("Bail out to the general startsWith implementation");
bind(bailout);
if (AddExternCUnderscore) {
emit_instruction("jmp _interpreter_method_entry");
} else {
emit_instruction("jmp interpreter_method_entry");
}
rom_linkable_entry_end(); // native_string_startsWith_entry
}
}
void InterpreterStubs::generate_interpreter_fill_in_tags() {
comment_section("Interpreter fill in tags");
entry("interpreter_fill_in_tags");
comment("eax: return address of method");
comment("ebx: method");
comment("ecx: size of parameters. Guaranteed to be >= 1");
comment("edx: call info from call site");
comment("Must preserve eax, ebx, ecx");
// stack layout:
// sp return address of caller
// --> argument n
// --> ...
// --> argument 0
Label extended_call_info;
comment("Compact call info or normal call info?");
testl(edx, edx);
jcc(positive, Constant(extended_call_info));
Label loop_entry, loop_condition;
comment("We have a compact call info");
movl(edi, ecx);
bind(loop_entry);
decl(edi);
comment("Store int tag");
movl(Address(esp, edi, times_8, Constant(BytesPerWord)), Constant(int_tag));
comment("Test the bit in the call info");
GUARANTEE(CallInfo::format1_tag_start == 0, "Tag must start at bit position 0 for this code to work");
btl(edx, edi);
jcc(carry_clear, Constant(loop_condition));
comment("Store obj tag");
movl(Address(esp, edi, times_8, Constant(BytesPerWord)), Constant(obj_tag));
bind(loop_condition);
testl(edi, edi);
jcc(not_zero, Constant(loop_entry));
ret();
bind(extended_call_info);
comment("Normal call info");
// The following code is slightly complicated. "Bit offset" below
// pretends like the callinfo's are in a bit array, as follows:
// Callinfo describing bci and offset
// Size [16 bits] and stack info 0-3
// Stack info 4-11
// We ignore the fact that each of these words is preceded by a byte
// that makes it look like an instruction.
pushl(ecx);
pushl(ebx);
Label loopx_entry, loopx_done;
comment("Bit offset of first argument in CallInfo array");
movzxw(edx, Address(eax, Constant(5 + 1))); // total number of locals/expr
subl(edx, ecx); // number of locals/expr belonging to callee
shll(edx, Constant(2)); // number of bits per nybble
addl(edx, Constant(32 + 16)); // 48 bits is the 32 bit callinfo and 16bit size info
comment("Decrement argument count; move to more convenient register");
leal(esi, Address(ecx, Constant(-1)));
comment("Location of tag of esi-th local");
leal(ebx, Address(esp, Constant(3 * BytesPerWord)));
bind(loopx_entry);
comment("eax holds the return address");
comment("ebx holds address of the esi-th tag");
comment("esi is the local whose tag we are setting");
comment("edx contains the bit offset of Local 0 in the CallInfo array");
comment("Get bit offset of esi-th local");
leal(ecx, Address(edx, esi, times_4));
comment("From bit offset, get word offset, then multiply by 5");
movl(edi, ecx);
shrl(edi, Constant(5));
leal(edi, Address(edi, edi, times_4));
comment("Get the appropriate CallInfo word; extract the nybble");
movl(edi, Address(eax, edi, times_1, Constant(1)));
shrl(edi);
andl(edi, Constant(0xF));
comment("Tag is (1 << value) >> 1. This is 0 when value == 0");
movl(ecx, edi);
movl(edi, Constant(1));
shll(edi);
shrl(edi, Constant(1));
comment("Store the tag");
movl(Address(ebx), edi);
comment("Are we done?");
decl(esi);
addl(ebx, Constant(8));
testl(esi, esi);
jcc(greater_equal, Constant(loopx_entry));
bind(loopx_done);
popl(ebx);
popl(ecx);
ret();
entry_end(); // interpreter_fill_in_tags
}
