void stack_tests() {
stack_init();
//printf("%p, %p\n", ebp, esp);
enter(16);
//printf("%p, %p\n", ebp, esp);
setl(24, ebp+0);
setl(18, ebp+4);
/* simulate another function call */
enter(16);
//printf("%p, %p\n", ebp, esp);
setl(5, ebp+0);
setl(3, ebp+4);
movl(ebp+4, eax);
addl(ebp+0, eax);
leave();
//printf("%p, %p\n", ebp, esp);
assert(*(int32_t *)eax == 8);
/* end inner function */
movl(ebp+4, eax);
addl(ebp+0, eax);
leave();
//printf("%p, %p\n", ebp, esp);
stack_end();
assert(*(int32_t *)eax == 42);
}
void addl( int v, int x, int h )
{
_add++;
// fprintf(stderr, "addl(%d %d %d)\n", v, x, h);
if (x <= l[v])
return;
else if (x < r[v])
{
split(v);
addl(vl[v], x, h);
addl(vr[v], x, h);
sum[v] = sum[vl[v]] + sum[vr[v]];
hl[v] = hl[vl[v]], hr[v] = hr[vr[v]];
}
else
{
if (hl[v] <= h - x + l[v])
ty[v] = 1, hl[v] = h - x + l[v], hr[v] = h - x + r[v], sum[v] = ((llong)hl[v] + hr[v]) * (r[v] - l[v]);
else if (l[v] != r[v] - 1 && hr[v] < h - x + r[v])
{
split(v);
addl(vl[v], x, h);
addl(vr[v], x, h);
sum[v] = sum[vl[v]] + sum[vr[v]];
}
}
if (ty[v] == 2)
hl[v] = hl[vl[v]], hr[v] = hr[vr[v]], sum[v] = sum[vl[v]] + sum[vr[v]];
if (l[v] != r[v] - 1 && ty[v] == 2 && ty[vl[v]] != 2 && ty[vl[v]] == ty[vr[v]] && hr[vl[v]] == hl[vr[v]])
ty[v] = ty[vl[v]], sum[v] = ((llong)hl[v] + hr[v]) * (r[v] - l[v]);
}
int main( void )
{
freopen("geology.in", "rt", stdin);
freopen("geology.out", "wt", stdout);
nv = 1;
prep(0, 0, m);
scanf("%d", &n);
while (n--)
{
// if (!(n % 5000))
// fprintf(stderr, "%d\n", n);
char t[6];
int a, b;
scanf("%s%d%d", t, &a, &b);
if (!strcmp(t, "ADD"))
addl(0, 2 * a, 2 * b), addr(0, 2 * a, 2 * b);
else
{
if (a > b)
a ^= b, b ^= a, a ^= b;
llong t = get(0, 2 * a, 2 * b);
printf("%Ld.%03Ld\n", t / 8, (t % 8) * 125);
}
}
fprintf(stderr, "_add=%d\n", _add);
fprintf(stderr, "_get=%d\n", _get);
return 0;
}
void instructions_tests() {
/* 32 bit copy */
setl(42, eax);
assert(*(int32_t *)eax == 42);
setl(1000000, eax);
assert(*(int32_t *)eax == 1000000);
movl(eax, edx);
assert(*(int32_t *)edx == 1000000);
/* addition */
setl(3, eax);
setl(5, edx);
addl(edx, eax);
assert(*(int32_t *)eax == 8);
/* division */
setl(15, eax);
setl(5, edx);
divl(edx, eax);
assert(*(int32_t *)eax == 3);
/* multiplication */
setl(3, eax);
setl(5, edx);
mull(edx, eax);
assert(*(int32_t *)eax == 15);
/* subtraction */
setl(3, eax);
setl(5, edx);
subl(edx, eax);
assert(*(int32_t *)eax == -2);
}
//**********(G-3)*********************
largeInt increment1(largeInt li)// increment1 the largeInt type No. by one.
{
largeInt one;
one.sign=0;
one.len=1;
one.line[0]='1';
li=addl(li,one);
return(li);
}
address generate_d2i_wrapper( address fcn ) {
StubCodeMark mark(this, "StubRoutines", "d2i_wrapper");
address start = __ pc();
// Capture info about frame layout
enum layout { FPUState_off = 0,
ebp_off = FPUStateSizeInWords,
edi_off,
esi_off,
ecx_off,
ebx_off,
saved_argument_off,
saved_argument_off2, // 2nd half of double
framesize
};
assert(FPUStateSizeInWords == 27, "update stack layout");
// Save outgoing argument to stack across push_FPU_state()
__ subl(esp, wordSize * 2);
__ fstp_d(Address(esp));
// Save CPU & FPU state
__ pushl(ebx);
__ pushl(ecx);
__ pushl(esi);
__ pushl(edi);
__ pushl(ebp);
__ push_FPU_state();
// push_FPU_state() resets the FP top of stack
// Load original double into FP top of stack
__ fld_d(Address(esp, saved_argument_off * wordSize));
// Store double into stack as outgoing argument
__ subl(esp, wordSize*2);
__ fst_d(Address(esp));
// Prepare FPU for doing math in C-land
__ empty_FPU_stack();
// Call the C code to massage the double. Result in EAX
__ call_VM_leaf( fcn, 2 );
// Restore CPU & FPU state
__ pop_FPU_state();
__ popl(ebp);
__ popl(edi);
__ popl(esi);
__ popl(ecx);
__ popl(ebx);
__ addl(esp, wordSize * 2);
__ ret(0);
return start;
}
void InterpreterStubs::generate_interpreter_rethrow_exception() {
comment_section("Interpreter rethrow exception");
comment("Register eax holds the exception; Interpreter state is not in registers");
entry("interpreter_rethrow_exception");
comment("Restore bytecode and locals pointers");
movl(esi, Address(ebp, Constant(JavaFrame::bcp_store_offset())));
movl(edi, Address(ebp, Constant(JavaFrame::locals_pointer_offset())));
comment("Mark the bytecode pointer as being inside an exception");
addl(esi, Constant(JavaFrame::exception_frame_flag));
comment("Clear the expression stack");
movl(esp, Address(ebp, Constant(JavaFrame::stack_bottom_pointer_offset())));
comment("Push the exception on the expression stack");
push_obj(eax);
comment("Get exception handler bci for exception");
interpreter_call_vm(Constant("exception_handler_bci_for_exception"), T_INT);
comment("Check if we got a bci - otherwise unwind the activation");
cmpl(eax, Constant(-1));
jcc(equal, Constant("interpreter_unwind_activation"));
#if ENABLE_JAVA_DEBUGGER
Label skip;
cmpb(Address(Constant("_debugger_active")), Constant(0));
jcc(equal, Constant(skip));
movl(edx, eax);
interpreter_call_vm(Constant("handle_caught_exception"), T_VOID);
comment("Re-get exception handler bci for exception");
interpreter_call_vm(Constant("exception_handler_bci_for_exception"), T_INT);
bind(skip);
#endif
comment("Convert the bytecode index into a bytecode pointer");
movl(ecx, Address(ebp, Constant(JavaFrame::method_offset())));
leal(esi, Address(ecx, eax, times_1, Constant(Method::base_offset())));
// Dispatch to the exception handler.
dispatch_next();
entry_end(); // interpreter_rethrow_exception
}
void ICacheStubGenerator::generate_icache_flush(ICache::flush_icache_stub_t* flush_icache_stub) {
StubCodeMark mark(this, "ICache", "flush_icache_stub");
address start = __ pc();
#ifdef AMD64
const Register addr = c_rarg0;
const Register lines = c_rarg1;
const Register magic = c_rarg2;
Label flush_line, done;
__ testl(lines, lines);
__ jcc(Assembler::zero, done);
// Force ordering wrt cflush.
// Other fence and sync instructions won't do the job.
__ mfence();
__ bind(flush_line);
__ clflush(Address(addr, 0));
__ addptr(addr, ICache::line_size);
__ decrementl(lines);
__ jcc(Assembler::notZero, flush_line);
__ mfence();
__ bind(done);
#else
const Address magic(rsp, 3*wordSize);
__ lock(); __ addl(Address(rsp, 0), 0);
#endif // AMD64
__ movptr(rax, magic); // Handshake with caller to make sure it happened!
__ ret(0);
// Must be set here so StubCodeMark destructor can call the flush stub.
*flush_icache_stub = (ICache::flush_icache_stub_t)start;
}
void MacroAssembler::fast_log(XMMRegister xmm0, XMMRegister xmm1, XMMRegister xmm2, XMMRegister xmm3, XMMRegister xmm4, XMMRegister xmm5, XMMRegister xmm6, XMMRegister xmm7, Register eax, Register ecx, Register edx, Register tmp) {
Label L_2TAG_PACKET_0_0_2, L_2TAG_PACKET_1_0_2, L_2TAG_PACKET_2_0_2, L_2TAG_PACKET_3_0_2;
Label L_2TAG_PACKET_4_0_2, L_2TAG_PACKET_5_0_2, L_2TAG_PACKET_6_0_2, L_2TAG_PACKET_7_0_2;
Label L_2TAG_PACKET_8_0_2, L_2TAG_PACKET_9_0_2;
Label L_2TAG_PACKET_10_0_2, start;
assert_different_registers(tmp, eax, ecx, edx);
jmp(start);
address static_const_table = (address)_static_const_table_log;
bind(start);
subl(rsp, 104);
movl(Address(rsp, 40), tmp);
lea(tmp, ExternalAddress(static_const_table));
xorpd(xmm2, xmm2);
movl(eax, 16368);
pinsrw(xmm2, eax, 3);
xorpd(xmm3, xmm3);
movl(edx, 30704);
pinsrw(xmm3, edx, 3);
movsd(xmm0, Address(rsp, 112));
movapd(xmm1, xmm0);
movl(ecx, 32768);
movdl(xmm4, ecx);
movsd(xmm5, Address(tmp, 2128)); // 0x00000000UL, 0xffffe000UL
pextrw(eax, xmm0, 3);
por(xmm0, xmm2);
psllq(xmm0, 5);
movl(ecx, 16352);
psrlq(xmm0, 34);
rcpss(xmm0, xmm0);
psllq(xmm1, 12);
pshufd(xmm6, xmm5, 228);
psrlq(xmm1, 12);
subl(eax, 16);
cmpl(eax, 32736);
jcc(Assembler::aboveEqual, L_2TAG_PACKET_0_0_2);
bind(L_2TAG_PACKET_1_0_2);
paddd(xmm0, xmm4);
por(xmm1, xmm3);
movdl(edx, xmm0);
psllq(xmm0, 29);
pand(xmm5, xmm1);
pand(xmm0, xmm6);
subsd(xmm1, xmm5);
mulpd(xmm5, xmm0);
andl(eax, 32752);
subl(eax, ecx);
cvtsi2sdl(xmm7, eax);
mulsd(xmm1, xmm0);
movsd(xmm6, Address(tmp, 2064)); // 0xfefa3800UL, 0x3fa62e42UL
movdqu(xmm3, Address(tmp, 2080)); // 0x92492492UL, 0x3fc24924UL, 0x00000000UL, 0xbfd00000UL
subsd(xmm5, xmm2);
andl(edx, 16711680);
shrl(edx, 12);
movdqu(xmm0, Address(tmp, edx));
movdqu(xmm4, Address(tmp, 2096)); // 0x3d6fb175UL, 0xbfc5555eUL, 0x55555555UL, 0x3fd55555UL
addsd(xmm1, xmm5);
movdqu(xmm2, Address(tmp, 2112)); // 0x9999999aUL, 0x3fc99999UL, 0x00000000UL, 0xbfe00000UL
mulsd(xmm6, xmm7);
pshufd(xmm5, xmm1, 68);
mulsd(xmm7, Address(tmp, 2072)); // 0x93c76730UL, 0x3ceef357UL, 0x92492492UL, 0x3fc24924UL
mulsd(xmm3, xmm1);
addsd(xmm0, xmm6);
mulpd(xmm4, xmm5);
mulpd(xmm5, xmm5);
pshufd(xmm6, xmm0, 228);
addsd(xmm0, xmm1);
addpd(xmm4, xmm2);
mulpd(xmm3, xmm5);
subsd(xmm6, xmm0);
mulsd(xmm4, xmm1);
pshufd(xmm2, xmm0, 238);
addsd(xmm1, xmm6);
mulsd(xmm5, xmm5);
addsd(xmm7, xmm2);
addpd(xmm4, xmm3);
addsd(xmm1, xmm7);
mulpd(xmm4, xmm5);
addsd(xmm1, xmm4);
pshufd(xmm5, xmm4, 238);
addsd(xmm1, xmm5);
addsd(xmm0, xmm1);
jmp(L_2TAG_PACKET_2_0_2);
bind(L_2TAG_PACKET_0_0_2);
movsd(xmm0, Address(rsp, 112));
movdqu(xmm1, xmm0);
addl(eax, 16);
cmpl(eax, 32768);
jcc(Assembler::aboveEqual, L_2TAG_PACKET_3_0_2);
cmpl(eax, 16);
jcc(Assembler::below, L_2TAG_PACKET_4_0_2);
bind(L_2TAG_PACKET_5_0_2);
addsd(xmm0, xmm0);
jmp(L_2TAG_PACKET_2_0_2);
bind(L_2TAG_PACKET_6_0_2);
jcc(Assembler::above, L_2TAG_PACKET_5_0_2);
cmpl(edx, 0);
jcc(Assembler::above, L_2TAG_PACKET_5_0_2);
jmp(L_2TAG_PACKET_7_0_2);
bind(L_2TAG_PACKET_3_0_2);
movdl(edx, xmm1);
psrlq(xmm1, 32);
movdl(ecx, xmm1);
addl(ecx, ecx);
cmpl(ecx, -2097152);
jcc(Assembler::aboveEqual, L_2TAG_PACKET_6_0_2);
orl(edx, ecx);
cmpl(edx, 0);
jcc(Assembler::equal, L_2TAG_PACKET_8_0_2);
bind(L_2TAG_PACKET_7_0_2);
xorpd(xmm1, xmm1);
xorpd(xmm0, xmm0);
movl(eax, 32752);
pinsrw(xmm1, eax, 3);
movl(edx, 3);
mulsd(xmm0, xmm1);
bind(L_2TAG_PACKET_9_0_2);
movsd(Address(rsp, 0), xmm0);
movsd(xmm0, Address(rsp, 112));
fld_d(Address(rsp, 0));
jmp(L_2TAG_PACKET_10_0_2);
bind(L_2TAG_PACKET_8_0_2);
xorpd(xmm1, xmm1);
xorpd(xmm0, xmm0);
movl(eax, 49136);
pinsrw(xmm0, eax, 3);
divsd(xmm0, xmm1);
movl(edx, 2);
jmp(L_2TAG_PACKET_9_0_2);
bind(L_2TAG_PACKET_4_0_2);
movdl(edx, xmm1);
psrlq(xmm1, 32);
movdl(ecx, xmm1);
orl(edx, ecx);
cmpl(edx, 0);
jcc(Assembler::equal, L_2TAG_PACKET_8_0_2);
xorpd(xmm1, xmm1);
movl(eax, 18416);
pinsrw(xmm1, eax, 3);
mulsd(xmm0, xmm1);
movapd(xmm1, xmm0);
pextrw(eax, xmm0, 3);
por(xmm0, xmm2);
psllq(xmm0, 5);
movl(ecx, 18416);
psrlq(xmm0, 34);
rcpss(xmm0, xmm0);
psllq(xmm1, 12);
pshufd(xmm6, xmm5, 228);
psrlq(xmm1, 12);
jmp(L_2TAG_PACKET_1_0_2);
bind(L_2TAG_PACKET_2_0_2);
movsd(Address(rsp, 24), xmm0);
fld_d(Address(rsp, 24));
bind(L_2TAG_PACKET_10_0_2);
movl(tmp, Address(rsp, 40));
}
address generate_call_stub(address& return_address) {
StubCodeMark mark(this, "StubRoutines", "call_stub");
address start = __ pc();
// stub code parameters / addresses
assert(frame::entry_frame_call_wrapper_offset == 2, "adjust this code");
bool sse_save = false;
const Address esp_after_call(ebp, -4 * wordSize); // same as in generate_catch_exception()!
const Address mxcsr_save (ebp, -4 * wordSize);
const Address result (ebp, 3 * wordSize);
const Address result_type (ebp, 4 * wordSize);
const Address method (ebp, 5 * wordSize);
const Address entry_point (ebp, 6 * wordSize);
const Address parameters (ebp, 7 * wordSize);
const Address parameter_size(ebp, 8 * wordSize);
const Address thread (ebp, 9 * wordSize); // same as in generate_catch_exception()!
#ifdef COMPILER2
sse_save = VM_Version::supports_sse();
#endif
// stub code
__ enter();
// save edi, esi, & ebx, according to C calling conventions
__ pushl(edi);
__ pushl(esi);
__ pushl(ebx);
__ subl(esp, wordSize); // space for %mxcsr save
// save and initialize %mxcsr
if (sse_save) {
__ stmxcsr(mxcsr_save);
__ ldmxcsr(Address((int) StubRoutines::addr_mxcsr_std(), relocInfo::none));
}
#ifdef ASSERT
// make sure we have no pending exceptions
{ Label L;
__ movl(ecx, thread);
__ cmpl(Address(ecx, Thread::pending_exception_offset()), (int)NULL);
__ jcc(Assembler::equal, L);
__ stop("StubRoutines::call_stub: entered with pending exception");
__ bind(L);
}
#endif
// pass parameters if any
Label parameters_done;
__ movl(ecx, parameter_size); // parameter counter
__ testl(ecx, ecx);
__ jcc(Assembler::zero, parameters_done);
// parameter passing loop
Label loop;
__ movl(edx, parameters); // parameter pointer
__ movl(esi, ecx); // parameter counter is in esi now
__ movl(ecx, Address(edx)); // get first parameter in case it is a receiver
__ bind(loop);
__ movl(eax, Address(edx)); // get parameter
__ addl(edx, wordSize); // advance to next parameter
__ decl(esi); // decrement counter
__ pushl(eax); // pass parameter
__ jcc(Assembler::notZero, loop);
// call Java function
__ bind(parameters_done);
__ movl(ebx, method); // get methodOop
__ movl(esi, entry_point); // get entry_point
__ call(esi, relocInfo::none);
return_address = __ pc();
// store result depending on type
// (everything that is not T_LONG, T_FLOAT or T_DOUBLE is treated as T_INT)
__ movl(edi, result);
Label is_long, is_float, is_double, exit;
__ movl(esi, result_type);
__ cmpl(esi, T_LONG);
__ jcc(Assembler::equal, is_long);
__ cmpl(esi, T_FLOAT);
__ jcc(Assembler::equal, is_float);
__ cmpl(esi, T_DOUBLE);
__ jcc(Assembler::equal, is_double);
// handle T_INT case
__ movl(Address(edi), eax);
__ bind(exit);
// pop parameters
__ movl(ecx, parameter_size);
__ leal(esp, Address(esp, ecx, Address::times_4));
// check if parameters have been popped correctly
#ifdef ASSERT
Label esp_wrong;
__ leal(edi, esp_after_call);
__ cmpl(esp, edi);
__ jcc(Assembler::notEqual, esp_wrong);
#endif
// restore %mxcsr
if (sse_save) {
__ ldmxcsr(mxcsr_save);
}
// restore edi & esi
__ addl(esp, wordSize); // remove %mxcsr save area
__ popl(ebx);
__ popl(esi);
__ popl(edi);
// return
__ popl(ebp);
__ ret(0);
// handle return types different from T_INT
__ bind(is_long);
__ movl(Address(edi, 0 * wordSize), eax);
__ movl(Address(edi, 1 * wordSize), edx);
__ jmp(exit);
__ bind(is_float);
__ fstp_s(Address(edi));
__ jmp(exit);
__ bind(is_double);
__ fstp_d(Address(edi));
__ jmp(exit);
#ifdef ASSERT
// stack pointer misadjusted
__ bind(esp_wrong);
__ stop("esp wrong after Java call");
#endif
return start;
}
//------------------------------------------------------------------------------------------------------------------------
// Continuation point for throwing of implicit exceptions that are not handled in
// the current activation. Fabricates an exception oop and initiates normal
// exception dispatching in this frame. Since we need to preserve callee-saved values
// (currently only for C2, but done for C1 as well) we need a callee-saved oop map and
// therefore have to make these stubs into RuntimeStubs rather than BufferBlobs.
// If the compiler needs all registers to be preserved between the fault
// point and the exception handler then it must assume responsibility for that in
// AbstractCompiler::continuation_for_implicit_null_exception or
// continuation_for_implicit_division_by_zero_exception. All other implicit
// exceptions (e.g., NullPointerException or AbstractMethodError on entry) are
// either at call sites or otherwise assume that stack unwinding will be initiated,
// so caller saved registers were assumed volatile in the compiler.
//
// Note: the routine set_pc_not_at_call_for_caller in SharedRuntime.cpp requires
// that this code be generated into a RuntimeStub.
address StubGenerator::generate_throw_exception(const char* name, address runtime_entry, bool restore_saved_exception_pc) {
int insts_size = 256;
int locs_size = 32;
CodeBuffer* code = new CodeBuffer(insts_size, locs_size, 0, 0, 0, false, NULL, NULL, NULL, false, NULL, name, false);
OopMapSet* oop_maps = new OopMapSet();
MacroAssembler* masm = new MacroAssembler(code);
address start = __ pc();
// This is an inlined and slightly modified version of call_VM
// which has the ability to fetch the return PC out of
// thread-local storage and also sets up last_Java_sp slightly
// differently than the real call_VM
Register java_thread = ebx;
__ get_thread(java_thread);
if (restore_saved_exception_pc) {
__ movl(eax, Address(java_thread, in_bytes(JavaThread::saved_exception_pc_offset())));
__ pushl(eax);
}
#ifndef COMPILER2
__ enter(); // required for proper stackwalking of RuntimeStub frame
#endif COMPILER2
__ subl(esp, framesize * wordSize); // prolog
#ifdef COMPILER2
if( OptoRuntimeCalleeSavedFloats ) {
if( UseSSE == 1 ) {
__ movss(Address(esp,xmm6_off*wordSize),xmm6);
__ movss(Address(esp,xmm7_off*wordSize),xmm7);
} else if( UseSSE == 2 ) {
__ movsd(Address(esp,xmm6_off*wordSize),xmm6);
__ movsd(Address(esp,xmm7_off*wordSize),xmm7);
}
}
#endif /* COMPILER2 */
__ movl(Address(esp, ebp_off * wordSize), ebp);
__ movl(Address(esp, edi_off * wordSize), edi);
__ movl(Address(esp, esi_off * wordSize), esi);
// push java thread (becomes first argument of C function)
__ movl(Address(esp, thread_off * wordSize), java_thread);
// Set up last_Java_sp and last_Java_fp
__ set_last_Java_frame(java_thread, esp, ebp, NULL);
// Call runtime
__ call(runtime_entry, relocInfo::runtime_call_type);
// Generate oop map
OopMap* map = new OopMap(framesize, 0);
#ifdef COMPILER2
// SharedInfo is apparently not initialized if -Xint is specified
if (UseCompiler) {
map->set_callee_saved(SharedInfo::stack2reg(ebp_off), framesize, 0, OptoReg::Name(EBP_num));
map->set_callee_saved(SharedInfo::stack2reg(edi_off), framesize, 0, OptoReg::Name(EDI_num));
map->set_callee_saved(SharedInfo::stack2reg(esi_off), framesize, 0, OptoReg::Name(ESI_num));
if( OptoRuntimeCalleeSavedFloats ) {
map->set_callee_saved(SharedInfo::stack2reg(xmm6_off ), framesize, 0, OptoReg::Name(XMM6a_num));
map->set_callee_saved(SharedInfo::stack2reg(xmm6_off+1), framesize, 0, OptoReg::Name(XMM6b_num));
map->set_callee_saved(SharedInfo::stack2reg(xmm7_off ), framesize, 0, OptoReg::Name(XMM7a_num));
map->set_callee_saved(SharedInfo::stack2reg(xmm7_off+1), framesize, 0, OptoReg::Name(XMM7b_num));
}
}
#endif
#ifdef COMPILER1
map->set_callee_saved(OptoReg::Name(SharedInfo::stack0+ebp_off), framesize, 0, OptoReg::Name(ebp->encoding()));
map->set_callee_saved(OptoReg::Name(SharedInfo::stack0+esi_off), framesize, 0, OptoReg::Name(esi->encoding()));
map->set_callee_saved(OptoReg::Name(SharedInfo::stack0+edi_off), framesize, 0, OptoReg::Name(edi->encoding()));
#endif
oop_maps->add_gc_map(__ pc() - start, true, map);
// restore the thread (cannot use the pushed argument since arguments
// may be overwritten by C code generated by an optimizing compiler);
// however can use the register value directly if it is callee saved.
__ get_thread(java_thread);
__ reset_last_Java_frame(java_thread, false);
// Restore callee save registers. This must be done after resetting the Java frame
#ifdef COMPILER2
if( OptoRuntimeCalleeSavedFloats ) {
if( UseSSE == 1 ) {
__ movss(xmm6,Address(esp,xmm6_off*wordSize));
__ movss(xmm7,Address(esp,xmm7_off*wordSize));
} else if( UseSSE == 2 ) {
__ movsd(xmm6,Address(esp,xmm6_off*wordSize));
__ movsd(xmm7,Address(esp,xmm7_off*wordSize));
}
}
#endif /* COMPILER2 */
__ movl(ebp,Address(esp, ebp_off * wordSize));
__ movl(edi,Address(esp, edi_off * wordSize));
__ movl(esi,Address(esp, esi_off * wordSize));
// discard arguments
__ addl(esp, framesize * wordSize); // epilog
#ifndef COMPILER2
__ leave(); // required for proper stackwalking of RuntimeStub frame
#endif COMPILER2
// check for pending exceptions
#ifdef ASSERT
Label L;
__ cmpl(Address(java_thread, Thread::pending_exception_offset()), (int)NULL);
__ jcc(Assembler::notEqual, L);
__ should_not_reach_here();
__ bind(L);
#endif ASSERT
__ jmp(StubRoutines::forward_exception_entry(), relocInfo::runtime_call_type);
// Note: it seems the frame size reported to the RuntimeStub has
// to be incremented by 1 to account for the return PC. It
// definitely must be one more than the amount by which SP was
// decremented.
int extra_words = 1;
#ifdef COMPILER1
++extra_words; // Not strictly necessary since C1 ignores frame size and uses link
#endif COMPILER1
RuntimeStub* stub = RuntimeStub::new_runtime_stub(name, code, framesize + extra_words, oop_maps, false);
return stub->entry_point();
}
void MacroAssembler::fast_log(XMMRegister xmm0, XMMRegister xmm1, XMMRegister xmm2, XMMRegister xmm3, XMMRegister xmm4, XMMRegister xmm5, XMMRegister xmm6, XMMRegister xmm7, Register eax, Register ecx, Register edx, Register tmp1, Register tmp2) {
Label L_2TAG_PACKET_0_0_2, L_2TAG_PACKET_1_0_2, L_2TAG_PACKET_2_0_2, L_2TAG_PACKET_3_0_2;
Label L_2TAG_PACKET_4_0_2, L_2TAG_PACKET_5_0_2, L_2TAG_PACKET_6_0_2, L_2TAG_PACKET_7_0_2;
Label L_2TAG_PACKET_8_0_2;
Label L_2TAG_PACKET_12_0_2, L_2TAG_PACKET_13_0_2, B1_3, B1_5, start;
assert_different_registers(tmp1, tmp2, eax, ecx, edx);
jmp(start);
address L_tbl = (address)_L_tbl;
address log2 = (address)_log2;
address coeff = (address)_coeff;
bind(start);
subq(rsp, 24);
movsd(Address(rsp, 0), xmm0);
mov64(rax, 0x3ff0000000000000);
movdq(xmm2, rax);
mov64(rdx, 0x77f0000000000000);
movdq(xmm3, rdx);
movl(ecx, 32768);
movdl(xmm4, rcx);
mov64(tmp1, 0xffffe00000000000);
movdq(xmm5, tmp1);
movdqu(xmm1, xmm0);
pextrw(eax, xmm0, 3);
por(xmm0, xmm2);
movl(ecx, 16352);
psrlq(xmm0, 27);
lea(tmp2, ExternalAddress(L_tbl));
psrld(xmm0, 2);
rcpps(xmm0, xmm0);
psllq(xmm1, 12);
pshufd(xmm6, xmm5, 228);
psrlq(xmm1, 12);
subl(eax, 16);
cmpl(eax, 32736);
jcc(Assembler::aboveEqual, L_2TAG_PACKET_0_0_2);
bind(L_2TAG_PACKET_1_0_2);
paddd(xmm0, xmm4);
por(xmm1, xmm3);
movdl(edx, xmm0);
psllq(xmm0, 29);
pand(xmm5, xmm1);
pand(xmm0, xmm6);
subsd(xmm1, xmm5);
mulpd(xmm5, xmm0);
andl(eax, 32752);
subl(eax, ecx);
cvtsi2sdl(xmm7, eax);
mulsd(xmm1, xmm0);
movq(xmm6, ExternalAddress(log2)); // 0xfefa3800UL, 0x3fa62e42UL
movdqu(xmm3, ExternalAddress(coeff)); // 0x92492492UL, 0x3fc24924UL, 0x00000000UL, 0xbfd00000UL
subsd(xmm5, xmm2);
andl(edx, 16711680);
shrl(edx, 12);
movdqu(xmm0, Address(tmp2, edx));
movdqu(xmm4, ExternalAddress(16 + coeff)); // 0x3d6fb175UL, 0xbfc5555eUL, 0x55555555UL, 0x3fd55555UL
addsd(xmm1, xmm5);
movdqu(xmm2, ExternalAddress(32 + coeff)); // 0x9999999aUL, 0x3fc99999UL, 0x00000000UL, 0xbfe00000UL
mulsd(xmm6, xmm7);
movddup(xmm5, xmm1);
mulsd(xmm7, ExternalAddress(8 + log2)); // 0x93c76730UL, 0x3ceef357UL
mulsd(xmm3, xmm1);
addsd(xmm0, xmm6);
mulpd(xmm4, xmm5);
mulpd(xmm5, xmm5);
movddup(xmm6, xmm0);
addsd(xmm0, xmm1);
addpd(xmm4, xmm2);
mulpd(xmm3, xmm5);
subsd(xmm6, xmm0);
mulsd(xmm4, xmm1);
pshufd(xmm2, xmm0, 238);
addsd(xmm1, xmm6);
mulsd(xmm5, xmm5);
addsd(xmm7, xmm2);
addpd(xmm4, xmm3);
addsd(xmm1, xmm7);
mulpd(xmm4, xmm5);
addsd(xmm1, xmm4);
pshufd(xmm5, xmm4, 238);
addsd(xmm1, xmm5);
addsd(xmm0, xmm1);
jmp(B1_5);
bind(L_2TAG_PACKET_0_0_2);
movq(xmm0, Address(rsp, 0));
movq(xmm1, Address(rsp, 0));
addl(eax, 16);
cmpl(eax, 32768);
jcc(Assembler::aboveEqual, L_2TAG_PACKET_2_0_2);
cmpl(eax, 16);
jcc(Assembler::below, L_2TAG_PACKET_3_0_2);
bind(L_2TAG_PACKET_4_0_2);
addsd(xmm0, xmm0);
jmp(B1_5);
bind(L_2TAG_PACKET_5_0_2);
jcc(Assembler::above, L_2TAG_PACKET_4_0_2);
cmpl(edx, 0);
jcc(Assembler::above, L_2TAG_PACKET_4_0_2);
jmp(L_2TAG_PACKET_6_0_2);
bind(L_2TAG_PACKET_3_0_2);
xorpd(xmm1, xmm1);
addsd(xmm1, xmm0);
movdl(edx, xmm1);
psrlq(xmm1, 32);
movdl(ecx, xmm1);
orl(edx, ecx);
cmpl(edx, 0);
jcc(Assembler::equal, L_2TAG_PACKET_7_0_2);
xorpd(xmm1, xmm1);
movl(eax, 18416);
pinsrw(xmm1, eax, 3);
mulsd(xmm0, xmm1);
movdqu(xmm1, xmm0);
pextrw(eax, xmm0, 3);
por(xmm0, xmm2);
psrlq(xmm0, 27);
movl(ecx, 18416);
psrld(xmm0, 2);
rcpps(xmm0, xmm0);
psllq(xmm1, 12);
pshufd(xmm6, xmm5, 228);
psrlq(xmm1, 12);
jmp(L_2TAG_PACKET_1_0_2);
bind(L_2TAG_PACKET_2_0_2);
movdl(edx, xmm1);
psrlq(xmm1, 32);
movdl(ecx, xmm1);
addl(ecx, ecx);
cmpl(ecx, -2097152);
jcc(Assembler::aboveEqual, L_2TAG_PACKET_5_0_2);
orl(edx, ecx);
cmpl(edx, 0);
jcc(Assembler::equal, L_2TAG_PACKET_7_0_2);
bind(L_2TAG_PACKET_6_0_2);
xorpd(xmm1, xmm1);
xorpd(xmm0, xmm0);
movl(eax, 32752);
pinsrw(xmm1, eax, 3);
mulsd(xmm0, xmm1);
movl(Address(rsp, 16), 3);
jmp(L_2TAG_PACKET_8_0_2);
bind(L_2TAG_PACKET_7_0_2);
xorpd(xmm1, xmm1);
xorpd(xmm0, xmm0);
movl(eax, 49136);
pinsrw(xmm0, eax, 3);
divsd(xmm0, xmm1);
movl(Address(rsp, 16), 2);
bind(L_2TAG_PACKET_8_0_2);
movq(Address(rsp, 8), xmm0);
bind(B1_3);
movq(xmm0, Address(rsp, 8));
bind(B1_5);
addq(rsp, 24);
}
static int
main_swapon(int argc, char *argv[]) {
int status = 0;
int c, i;
while ((c = getopt_long(argc, argv, "ahdefp:svVL:U:",
longswaponopts, NULL)) != -1) {
switch (c) {
case 'a': /* all */
++all;
break;
case 'h': /* help */
swapon_usage(stdout, 0);
break;
case 'p': /* priority */
priority = atoi(optarg);
break;
case 'L':
addl(optarg);
break;
case 'U':
addu(optarg);
break;
case 'd':
discard = 1;
break;
case 'e': /* ifexists */
ifexists = 1;
break;
case 'f':
fixpgsz = 1;
break;
case 's': /* status report */
status = display_summary();
exit(status);
case 'v': /* be chatty */
++verbose;
break;
case 'V': /* version */
printf(_("%s (%s)\n"), progname, PACKAGE_STRING);
exit(EXIT_SUCCESS);
case 0:
break;
case '?':
default:
swapon_usage(stderr, 1);
}
}
argv += optind;
if (!all && !llct && !ulct && *argv == NULL)
swapon_usage(stderr, 2);
if (ifexists && (!all || strcmp(progname, "swapon")))
swapon_usage(stderr, 1);
if (all)
status |= swapon_all();
for (i = 0; i < llct; i++)
status |= swapon_by_label(llist[i], priority, discard);
for (i = 0; i < ulct; i++)
status |= swapon_by_uuid(ulist[i], priority, discard);
while (*argv != NULL)
status |= do_swapon(*argv++, priority, discard, !CANONIC);
return status;
}
void NativeGenerator::generate_native_system_entries() {
comment_section("Native entry points for system functions");
rom_linkable_entry("native_jvm_unchecked_byte_arraycopy_entry");
jmp(Constant("native_system_arraycopy_entry"));
rom_linkable_entry_end();
rom_linkable_entry("native_jvm_unchecked_char_arraycopy_entry");
jmp(Constant("native_system_arraycopy_entry"));
rom_linkable_entry_end();
rom_linkable_entry("native_jvm_unchecked_int_arraycopy_entry");
jmp(Constant("native_system_arraycopy_entry"));
rom_linkable_entry_end();
rom_linkable_entry("native_jvm_unchecked_long_arraycopy_entry");
jmp(Constant("native_system_arraycopy_entry"));
rom_linkable_entry_end();
rom_linkable_entry("native_jvm_unchecked_obj_arraycopy_entry");
jmp(Constant("native_system_arraycopy_entry"));
rom_linkable_entry_end();
rom_linkable_entry("native_system_arraycopy_entry");
wtk_profile_quick_call(/* param_size*/ 5);
Label bailout, cont, try_2_byte, try_4_byte, try_8_byte, do_4_byte;
// public static native void arraycopy(Object src, int src_position,
// Object dst, int dst_position,
// int length);
comment("preserve method");
pushl(ebx);
// 8 is for the preserved method and the return address
int length_offset = JavaFrame::arg_offset_from_sp(0) + 8,
dst_pos_offset = JavaFrame::arg_offset_from_sp(1) + 8,
dst_offset = JavaFrame::arg_offset_from_sp(2) + 8,
src_pos_offset = JavaFrame::arg_offset_from_sp(3) + 8,
src_offset = JavaFrame::arg_offset_from_sp(4) + 8;
comment("load arguments to registers");
movl(ecx, Address(esp, Constant(length_offset)));
movl(edi, Address(esp, Constant(dst_pos_offset)));
movl(edx, Address(esp, Constant(dst_offset)));
movl(esi, Address(esp, Constant(src_pos_offset)));
movl(eax, Address(esp, Constant(src_offset)));
// eax = src
// ebx = tmp register
// edx = dst
// ecx = length
// esi = src_pos
// edi = dst_pos
comment("if (src == NULL) goto bailout;");
testl( eax, eax );
jcc(zero, Constant(bailout));
comment("if (dst == NULL) goto bailout;");
testl( edx, edx );
jcc(zero, Constant(bailout));
comment("if (length < 0 || src_pos < 0 || dst_pos < 0) goto bailout;");
movl(ebx, ecx);
orl(ebx, esi);
orl(ebx, edi);
jcc(negative, Constant(bailout));
comment("if ((unsigned int) dst.length < (unsigned int) dst_pos + (unsigned int) length) goto bailout;");
movl(ebx, ecx);
addl(ebx, edi);
cmpl(Address(edx, Constant(Array::length_offset())), ebx);
jcc(below, Constant(bailout));
comment("if ((unsigned int) src.length < (unsigned int) src_pos + (unsigned int) length) goto bailout;");
movl(ebx, ecx);
addl(ebx, esi);
cmpl(Address(eax, Constant(Array::length_offset())), ebx);
jcc(below, Constant(bailout));
comment("Same near test");
comment("if (src.near != dst.near) goto bailout;");
movl(ebx, Address(eax, Constant(Oop::klass_offset())));
cmpl(ebx, Address(edx, Constant(Oop::klass_offset())));
jcc(not_equal, Constant(bailout));
comment("load the instance_size");
movl(ebx, Address(ebx, Constant(JavaNear::klass_offset())));
movsxw(ebx, Address(ebx, Constant(FarClass::instance_size_offset())));
comment("if (instance_size != size_type_array_1()) goto try_2_byte");
cmpl(ebx, Constant(InstanceSize::size_type_array_1));
jcc(not_equal, Constant(try_2_byte));
leal(esi, Address(eax, esi, times_1, Constant(Array::base_offset())));
leal(edi, Address(edx, edi, times_1, Constant(Array::base_offset())));
jmp(Constant(cont));
bind(try_2_byte);
comment("if (instance_size != size_type_array_2()) goto try_4_byte");
cmpl(ebx, Constant(InstanceSize::size_type_array_2));
jcc(not_equal, Constant(try_4_byte));
leal(esi, Address(eax, esi, times_2, Constant(Array::base_offset())));
leal(edi, Address(edx, edi, times_2, Constant(Array::base_offset())));
shll(ecx, Constant(1));
jmp(Constant(cont));
bind(try_4_byte);
comment("if (instance_size == size_type_array_4()) goto do_4_byte");
cmpl(ebx, Constant(InstanceSize::size_type_array_4));
jcc(equal, Constant(do_4_byte) );
comment("if (instance_size != size_obj_array()) goto bailout");
cmpl(ebx, Constant(InstanceSize::size_obj_array));
jcc(not_equal, Constant(bailout));
comment("if (dst < old_generation_end) goto bailout");
cmpl( edx, Address( Constant( "_old_generation_end" ) ) );
jcc( below, Constant(bailout));
bind(do_4_byte);
leal(esi, Address(eax, esi, times_4, Constant(Array::base_offset())));
leal(edi, Address(edx, edi, times_4, Constant(Array::base_offset())));
shll(ecx, Constant(2));
bind(cont);
comment("memmove(edi, esi, ecx);");
pushl(ecx);
pushl(esi);
pushl(edi);
call(Constant("memmove"));
addl(esp, Constant(16));
ret(Constant(5 * BytesPerStackElement));
comment("Bail out to the general arraycopy 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_system_arraycopy_entry
}
void NativeGenerator::generate_native_math_entries() {
comment_section("Native entry points for math functions");
int offset = 0;
#if ENABLE_FLOAT
stop_code_segment();
start_data_segment();
stop_data_segment();
start_code_segment();
// Generate sinus entry.
offset = 0;
rom_linkable_entry("native_math_sin_entry");
comment("store return address");
popl(edi);
pop_double(eax, ecx);
pushl(ecx);
pushl(eax);
call(Constant("jvm_sin"));
addl(esp, Constant(8));
push_from_fpu_stack(double_tag, offset, true);
jmp(edi);
rom_linkable_entry_end(); // native_math_sin_entry
// Generate cosinus entry.
offset = 0;
rom_linkable_entry("native_math_cos_entry");
comment("store return address");
popl(edi);
pop_double(eax, ecx);
pushl(ecx);
pushl(eax);
call(Constant("jvm_cos"));
addl(esp, Constant(8));
push_from_fpu_stack(double_tag, offset, true);
jmp(edi);
rom_linkable_entry_end(); // native_math_cos_entry
// Generate tangent entry.
offset = 0;
rom_linkable_entry("native_math_tan_entry");
comment("store return address");
popl(edi);
pop_double(eax, ecx);
pushl(ecx);
pushl(eax);
call(Constant("jvm_tan"));
addl(esp, Constant(8));
push_from_fpu_stack(double_tag, offset, true);
jmp(edi);
rom_linkable_entry_end(); // native_math_tan_entry
// Generate square root entry.
offset = 0;
rom_linkable_entry("native_math_sqrt_entry");
comment("store return address");
popl(edi);
pop_double(eax, ecx);
pushl(ecx);
pushl(eax);
call(Constant("jvm_sqrt"));
addl(esp, Constant(8));
push_from_fpu_stack(double_tag, offset, true);
jmp(edi);
rom_linkable_entry_end(); // native_math_sqrt_entry
// Generate ceil entry.
offset = 0;
rom_linkable_entry("native_math_ceil_entry");
comment("store return address");
popl(edi);
pop_double(eax, ecx);
pushl(ecx);
pushl(eax);
call(Constant("jvm_ceil"));
addl(esp, Constant(8));
push_from_fpu_stack(double_tag, offset, true);
jmp(edi);
rom_linkable_entry_end(); // native_math_ceil_entry
// Generate floor entry.
offset = 0;
rom_linkable_entry("native_math_floor_entry");
comment("store return address");
popl(edi);
pop_double(eax, ecx);
pushl(ecx);
pushl(eax);
call(Constant("jvm_floor"));
addl(esp, Constant(8));
push_from_fpu_stack(double_tag, offset, true);
jmp(edi);
rom_linkable_entry_end(); // native_math_floor_entry
#endif /* ENABLE_FLOAT */
}
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
}
int main(void)
{
largeInt l1, l2,l3,sum,diff,product;
largeNum n1, n2,sumn;
div_result divi;
int x,prime_n1,prime_n2;
printf("Enter 1st number:");
readint(&l1);
printf("\n");
printf("Enter 2nd number:");
readint(&l2);
printf("\nThe 1st number is :\n");
showI(l1);
printf("\nThe 2nd number is :\n");
showI(l2);
printf("\n");
// printf("chk_equal=%d",chk_equal(l1,l2));
// printf("\n");
// showI(increment1(l1));
// fwriteI(l3);
// printf("\nequal zero: %d",equal_to_zero(n1));
// shift(&n1,3);
// showN(n1);
// shift(&n1,-2);
// showN(n1);
// printf("\nAfter removing all zeroes from left;");
// rem_all_zeros_from_left(&n1);
// showN(n1);
// x=equal_to_zero(l1);
// printf("\n Value of x: %d\n",x);
// x=greaterthan(l1,l2);
// printf("\n Value of x: %d\n",x);
sum=addl(l1,l2); // Addition..
printf("\n\nSum=");
showI(sum);
// sumn=add_n_times(n1,2);
// printf("\nSUM_N=");
// showN(sumn);
diff=subl(l1,l2);
printf("\n\nDifference=");
showI(diff);
product=multl(l1,l2);
printf("\n\nproduct=");
showI(product);
printf("\n\n");
// append_n_zeros_right(&n1,2);
// showN(n1);
// remove_one_zero_right(&n1);
// printf("\n");
// showN(n1);
divi=divl(l1,l2);
showDiv(divi);
printf("\nmodulus of 1st and 2nd number:");
showI(modl(l1,l2));
x=Isprime(l1);
if(x==1)
printf("\nPRIME");
else
printf("\nNOT PRIME\n");
return 0;
}
static int
main_swapoff(int argc, char *argv[]) {
FILE *fp;
struct mntent *fstab;
int status = 0;
int c, i;
while ((c = getopt_long(argc, argv, "ahvVL:U:",
longswapoffopts, NULL)) != -1) {
switch (c) {
case 'a': /* all */
++all;
break;
case 'h': /* help */
swapoff_usage(stdout, 0);
break;
case 'v': /* be chatty */
++verbose;
break;
case 'V': /* version */
printf(_("%s (%s)\n"), progname, PACKAGE_STRING);
exit(EXIT_SUCCESS);
case 'L':
addl(optarg);
break;
case 'U':
addu(optarg);
break;
case 0:
break;
case '?':
default:
swapoff_usage(stderr, 1);
}
}
argv += optind;
if (!all && !llct && !ulct && *argv == NULL)
swapoff_usage(stderr, 2);
/*
* swapoff any explicitly given arguments.
* Complain in case the swapoff call fails.
*/
for (i = 0; i < llct; i++)
status |= swapoff_by_label(llist[i], !QUIET);
for (i = 0; i < ulct; i++)
status |= swapoff_by_uuid(ulist[i], !QUIET);
while (*argv != NULL)
status |= do_swapoff(*argv++, !QUIET, !CANONIC);
if (all) {
/*
* In case /proc/swaps exists, unswap stuff listed there.
* We are quiet but report errors in status.
* Errors might mean that /proc/swaps
* exists as ordinary file, not in procfs.
* do_swapoff() exits immediately on EPERM.
*/
read_proc_swaps();
for(i=0; i<numSwaps; i++)
status |= do_swapoff(swapFiles[i], QUIET, CANONIC);
/*
* Unswap stuff mentioned in /etc/fstab.
* Probably it was unmounted already, so errors are not bad.
* Doing swapoff -a twice should not give error messages.
*/
fp = setmntent(_PATH_MNTTAB, "r");
if (fp == NULL)
err(2, _("%s: open failed"), _PATH_MNTTAB);
while ((fstab = getmntent(fp)) != NULL) {
const char *special;
if (!streq(fstab->mnt_type, MNTTYPE_SWAP))
continue;
special = fsprobe_get_devname_by_spec(fstab->mnt_fsname);
if (!special)
continue;
if (!is_in_proc_swaps(special))
do_swapoff(special, QUIET, CANONIC);
}
fclose(fp);
}
return status;
}
void MacroAssembler::fast_exp(XMMRegister xmm0, XMMRegister xmm1, XMMRegister xmm2, XMMRegister xmm3, XMMRegister xmm4, XMMRegister xmm5, XMMRegister xmm6, XMMRegister xmm7, Register eax, Register ecx, Register edx, Register tmp) {
Label L_2TAG_PACKET_0_0_2, L_2TAG_PACKET_1_0_2, L_2TAG_PACKET_2_0_2, L_2TAG_PACKET_3_0_2;
Label L_2TAG_PACKET_4_0_2, L_2TAG_PACKET_5_0_2, L_2TAG_PACKET_6_0_2, L_2TAG_PACKET_7_0_2;
Label L_2TAG_PACKET_8_0_2, L_2TAG_PACKET_9_0_2, L_2TAG_PACKET_10_0_2, L_2TAG_PACKET_11_0_2;
Label L_2TAG_PACKET_12_0_2, B1_3, B1_5, start;
assert_different_registers(tmp, eax, ecx, edx);
jmp(start);
address cv = (address)_cv;
address Shifter = (address)_shifter;
address mmask = (address)_mmask;
address bias = (address)_bias;
address Tbl_addr = (address)_Tbl_addr;
address ALLONES = (address)_ALLONES;
address ebias = (address)_ebias;
address XMAX = (address)_XMAX;
address XMIN = (address)_XMIN;
address INF = (address)_INF;
address ZERO = (address)_ZERO;
address ONE_val = (address)_ONE_val;
bind(start);
subq(rsp, 24);
movsd(Address(rsp, 8), xmm0);
unpcklpd(xmm0, xmm0);
movdqu(xmm1, ExternalAddress(cv)); // 0x652b82feUL, 0x40571547UL, 0x652b82feUL, 0x40571547UL
movdqu(xmm6, ExternalAddress(Shifter)); // 0x00000000UL, 0x43380000UL, 0x00000000UL, 0x43380000UL
movdqu(xmm2, ExternalAddress(16+cv)); // 0xfefa0000UL, 0x3f862e42UL, 0xfefa0000UL, 0x3f862e42UL
movdqu(xmm3, ExternalAddress(32+cv)); // 0xbc9e3b3aUL, 0x3d1cf79aUL, 0xbc9e3b3aUL, 0x3d1cf79aUL
pextrw(eax, xmm0, 3);
andl(eax, 32767);
movl(edx, 16527);
subl(edx, eax);
subl(eax, 15504);
orl(edx, eax);
cmpl(edx, INT_MIN);
jcc(Assembler::aboveEqual, L_2TAG_PACKET_0_0_2);
mulpd(xmm1, xmm0);
addpd(xmm1, xmm6);
movapd(xmm7, xmm1);
subpd(xmm1, xmm6);
mulpd(xmm2, xmm1);
movdqu(xmm4, ExternalAddress(64+cv)); // 0xe3289860UL, 0x3f56c15cUL, 0x555b9e25UL, 0x3fa55555UL
mulpd(xmm3, xmm1);
movdqu(xmm5, ExternalAddress(80+cv)); // 0xc090cf0fUL, 0x3f811115UL, 0x55548ba1UL, 0x3fc55555UL
subpd(xmm0, xmm2);
movdl(eax, xmm7);
movl(ecx, eax);
andl(ecx, 63);
shll(ecx, 4);
sarl(eax, 6);
movl(edx, eax);
movdqu(xmm6, ExternalAddress(mmask)); // 0xffffffc0UL, 0x00000000UL, 0xffffffc0UL, 0x00000000UL
pand(xmm7, xmm6);
movdqu(xmm6, ExternalAddress(bias)); // 0x0000ffc0UL, 0x00000000UL, 0x0000ffc0UL, 0x00000000UL
paddq(xmm7, xmm6);
psllq(xmm7, 46);
subpd(xmm0, xmm3);
lea(tmp, ExternalAddress(Tbl_addr));
movdqu(xmm2, Address(ecx,tmp));
mulpd(xmm4, xmm0);
movapd(xmm6, xmm0);
movapd(xmm1, xmm0);
mulpd(xmm6, xmm6);
mulpd(xmm0, xmm6);
addpd(xmm5, xmm4);
mulsd(xmm0, xmm6);
mulpd(xmm6, ExternalAddress(48+cv)); // 0xfffffffeUL, 0x3fdfffffUL, 0xfffffffeUL, 0x3fdfffffUL
addsd(xmm1, xmm2);
unpckhpd(xmm2, xmm2);
mulpd(xmm0, xmm5);
addsd(xmm1, xmm0);
por(xmm2, xmm7);
unpckhpd(xmm0, xmm0);
addsd(xmm0, xmm1);
addsd(xmm0, xmm6);
addl(edx, 894);
cmpl(edx, 1916);
jcc (Assembler::above, L_2TAG_PACKET_1_0_2);
mulsd(xmm0, xmm2);
addsd(xmm0, xmm2);
jmp (B1_5);
bind(L_2TAG_PACKET_1_0_2);
xorpd(xmm3, xmm3);
movdqu(xmm4, ExternalAddress(ALLONES)); // 0xffffffffUL, 0xffffffffUL, 0xffffffffUL, 0xffffffffUL
movl(edx, -1022);
subl(edx, eax);
movdl(xmm5, edx);
psllq(xmm4, xmm5);
movl(ecx, eax);
sarl(eax, 1);
pinsrw(xmm3, eax, 3);
movdqu(xmm6, ExternalAddress(ebias)); // 0x00000000UL, 0x3ff00000UL, 0x00000000UL, 0x3ff00000UL
psllq(xmm3, 4);
psubd(xmm2, xmm3);
mulsd(xmm0, xmm2);
cmpl(edx, 52);
jcc(Assembler::greater, L_2TAG_PACKET_2_0_2);
pand(xmm4, xmm2);
paddd(xmm3, xmm6);
subsd(xmm2, xmm4);
addsd(xmm0, xmm2);
cmpl(ecx, 1023);
jcc(Assembler::greaterEqual, L_2TAG_PACKET_3_0_2);
pextrw(ecx, xmm0, 3);
andl(ecx, 32768);
orl(edx, ecx);
cmpl(edx, 0);
jcc(Assembler::equal, L_2TAG_PACKET_4_0_2);
movapd(xmm6, xmm0);
addsd(xmm0, xmm4);
mulsd(xmm0, xmm3);
pextrw(ecx, xmm0, 3);
andl(ecx, 32752);
cmpl(ecx, 0);
jcc(Assembler::equal, L_2TAG_PACKET_5_0_2);
jmp(B1_5);
bind(L_2TAG_PACKET_5_0_2);
mulsd(xmm6, xmm3);
mulsd(xmm4, xmm3);
movdqu(xmm0, xmm6);
pxor(xmm6, xmm4);
psrad(xmm6, 31);
pshufd(xmm6, xmm6, 85);
psllq(xmm0, 1);
psrlq(xmm0, 1);
pxor(xmm0, xmm6);
psrlq(xmm6, 63);
paddq(xmm0, xmm6);
paddq(xmm0, xmm4);
movl(Address(rsp,0), 15);
jmp(L_2TAG_PACKET_6_0_2);
bind(L_2TAG_PACKET_4_0_2);
addsd(xmm0, xmm4);
mulsd(xmm0, xmm3);
jmp(B1_5);
bind(L_2TAG_PACKET_3_0_2);
addsd(xmm0, xmm4);
mulsd(xmm0, xmm3);
pextrw(ecx, xmm0, 3);
andl(ecx, 32752);
cmpl(ecx, 32752);
jcc(Assembler::aboveEqual, L_2TAG_PACKET_7_0_2);
jmp(B1_5);
bind(L_2TAG_PACKET_2_0_2);
paddd(xmm3, xmm6);
addpd(xmm0, xmm2);
mulsd(xmm0, xmm3);
movl(Address(rsp,0), 15);
jmp(L_2TAG_PACKET_6_0_2);
bind(L_2TAG_PACKET_8_0_2);
cmpl(eax, 2146435072);
jcc(Assembler::aboveEqual, L_2TAG_PACKET_9_0_2);
movl(eax, Address(rsp,12));
cmpl(eax, INT_MIN);
jcc(Assembler::aboveEqual, L_2TAG_PACKET_10_0_2);
movsd(xmm0, ExternalAddress(XMAX)); // 0xffffffffUL, 0x7fefffffUL
mulsd(xmm0, xmm0);
bind(L_2TAG_PACKET_7_0_2);
movl(Address(rsp,0), 14);
jmp(L_2TAG_PACKET_6_0_2);
bind(L_2TAG_PACKET_10_0_2);
movsd(xmm0, ExternalAddress(XMIN)); // 0x00000000UL, 0x00100000UL
mulsd(xmm0, xmm0);
movl(Address(rsp,0), 15);
jmp(L_2TAG_PACKET_6_0_2);
bind(L_2TAG_PACKET_9_0_2);
movl(edx, Address(rsp,8));
cmpl(eax, 2146435072);
jcc(Assembler::above, L_2TAG_PACKET_11_0_2);
cmpl(edx, 0);
jcc(Assembler::notEqual, L_2TAG_PACKET_11_0_2);
movl(eax, Address(rsp,12));
cmpl(eax, 2146435072);
jcc(Assembler::notEqual, L_2TAG_PACKET_12_0_2);
movsd(xmm0, ExternalAddress(INF)); // 0x00000000UL, 0x7ff00000UL
jmp(B1_5);
bind(L_2TAG_PACKET_12_0_2);
movsd(xmm0, ExternalAddress(ZERO)); // 0x00000000UL, 0x00000000UL
jmp(B1_5);
bind(L_2TAG_PACKET_11_0_2);
movsd(xmm0, Address(rsp, 8));
addsd(xmm0, xmm0);
jmp(B1_5);
bind(L_2TAG_PACKET_0_0_2);
movl(eax, Address(rsp, 12));
andl(eax, 2147483647);
cmpl(eax, 1083179008);
jcc(Assembler::aboveEqual, L_2TAG_PACKET_8_0_2);
movsd(Address(rsp, 8), xmm0);
addsd(xmm0, ExternalAddress(ONE_val)); // 0x00000000UL, 0x3ff00000UL
jmp(B1_5);
bind(L_2TAG_PACKET_6_0_2);
movq(Address(rsp, 16), xmm0);
bind(B1_3);
movq(xmm0, Address(rsp, 16));
bind(B1_5);
addq(rsp, 24);
}
void MacroAssembler::fast_exp(XMMRegister xmm0, XMMRegister xmm1, XMMRegister xmm2, XMMRegister xmm3, XMMRegister xmm4, XMMRegister xmm5, XMMRegister xmm6, XMMRegister xmm7, Register eax, Register ecx, Register edx, Register tmp) {
Label L_2TAG_PACKET_0_0_2, L_2TAG_PACKET_1_0_2, L_2TAG_PACKET_2_0_2, L_2TAG_PACKET_3_0_2;
Label L_2TAG_PACKET_4_0_2, L_2TAG_PACKET_5_0_2, L_2TAG_PACKET_6_0_2, L_2TAG_PACKET_7_0_2;
Label L_2TAG_PACKET_8_0_2, L_2TAG_PACKET_9_0_2, L_2TAG_PACKET_10_0_2, L_2TAG_PACKET_11_0_2;
Label L_2TAG_PACKET_12_0_2, L_2TAG_PACKET_13_0_2, B1_3, B1_5, start;
assert_different_registers(tmp, eax, ecx, edx);
jmp(start);
address static_const_table = (address)_static_const_table;
bind(start);
subl(rsp, 120);
movl(Address(rsp, 64), tmp);
lea(tmp, ExternalAddress(static_const_table));
movdqu(xmm0, Address(rsp, 128));
unpcklpd(xmm0, xmm0);
movdqu(xmm1, Address(tmp, 64)); // 0x652b82feUL, 0x40571547UL, 0x652b82feUL, 0x40571547UL
movdqu(xmm6, Address(tmp, 48)); // 0x00000000UL, 0x43380000UL, 0x00000000UL, 0x43380000UL
movdqu(xmm2, Address(tmp, 80)); // 0xfefa0000UL, 0x3f862e42UL, 0xfefa0000UL, 0x3f862e42UL
movdqu(xmm3, Address(tmp, 96)); // 0xbc9e3b3aUL, 0x3d1cf79aUL, 0xbc9e3b3aUL, 0x3d1cf79aUL
pextrw(eax, xmm0, 3);
andl(eax, 32767);
movl(edx, 16527);
subl(edx, eax);
subl(eax, 15504);
orl(edx, eax);
cmpl(edx, INT_MIN);
jcc(Assembler::aboveEqual, L_2TAG_PACKET_0_0_2);
mulpd(xmm1, xmm0);
addpd(xmm1, xmm6);
movapd(xmm7, xmm1);
subpd(xmm1, xmm6);
mulpd(xmm2, xmm1);
movdqu(xmm4, Address(tmp, 128)); // 0xe3289860UL, 0x3f56c15cUL, 0x555b9e25UL, 0x3fa55555UL
mulpd(xmm3, xmm1);
movdqu(xmm5, Address(tmp, 144)); // 0xc090cf0fUL, 0x3f811115UL, 0x55548ba1UL, 0x3fc55555UL
subpd(xmm0, xmm2);
movdl(eax, xmm7);
movl(ecx, eax);
andl(ecx, 63);
shll(ecx, 4);
sarl(eax, 6);
movl(edx, eax);
movdqu(xmm6, Address(tmp, 16)); // 0xffffffc0UL, 0x00000000UL, 0xffffffc0UL, 0x00000000UL
pand(xmm7, xmm6);
movdqu(xmm6, Address(tmp, 32)); // 0x0000ffc0UL, 0x00000000UL, 0x0000ffc0UL, 0x00000000UL
paddq(xmm7, xmm6);
psllq(xmm7, 46);
subpd(xmm0, xmm3);
movdqu(xmm2, Address(tmp, ecx, Address::times_1, 160));
mulpd(xmm4, xmm0);
movapd(xmm6, xmm0);
movapd(xmm1, xmm0);
mulpd(xmm6, xmm6);
mulpd(xmm0, xmm6);
addpd(xmm5, xmm4);
mulsd(xmm0, xmm6);
mulpd(xmm6, Address(tmp, 112)); // 0xfffffffeUL, 0x3fdfffffUL, 0xfffffffeUL, 0x3fdfffffUL
addsd(xmm1, xmm2);
unpckhpd(xmm2, xmm2);
mulpd(xmm0, xmm5);
addsd(xmm1, xmm0);
por(xmm2, xmm7);
unpckhpd(xmm0, xmm0);
addsd(xmm0, xmm1);
addsd(xmm0, xmm6);
addl(edx, 894);
cmpl(edx, 1916);
jcc (Assembler::above, L_2TAG_PACKET_1_0_2);
mulsd(xmm0, xmm2);
addsd(xmm0, xmm2);
jmp(L_2TAG_PACKET_2_0_2);
bind(L_2TAG_PACKET_1_0_2);
fnstcw(Address(rsp, 24));
movzwl(edx, Address(rsp, 24));
orl(edx, 768);
movw(Address(rsp, 28), edx);
fldcw(Address(rsp, 28));
movl(edx, eax);
sarl(eax, 1);
subl(edx, eax);
movdqu(xmm6, Address(tmp, 0)); // 0x00000000UL, 0xfff00000UL, 0x00000000UL, 0xfff00000UL
pandn(xmm6, xmm2);
addl(eax, 1023);
movdl(xmm3, eax);
psllq(xmm3, 52);
por(xmm6, xmm3);
addl(edx, 1023);
movdl(xmm4, edx);
psllq(xmm4, 52);
movsd(Address(rsp, 8), xmm0);
fld_d(Address(rsp, 8));
movsd(Address(rsp, 16), xmm6);
fld_d(Address(rsp, 16));
fmula(1);
faddp(1);
movsd(Address(rsp, 8), xmm4);
fld_d(Address(rsp, 8));
fmulp(1);
fstp_d(Address(rsp, 8));
movsd(xmm0,Address(rsp, 8));
fldcw(Address(rsp, 24));
pextrw(ecx, xmm0, 3);
andl(ecx, 32752);
cmpl(ecx, 32752);
jcc(Assembler::greaterEqual, L_2TAG_PACKET_3_0_2);
cmpl(ecx, 0);
jcc(Assembler::equal, L_2TAG_PACKET_4_0_2);
jmp(L_2TAG_PACKET_2_0_2);
cmpl(ecx, INT_MIN);
jcc(Assembler::less, L_2TAG_PACKET_3_0_2);
cmpl(ecx, -1064950997);
jcc(Assembler::less, L_2TAG_PACKET_2_0_2);
jcc(Assembler::greater, L_2TAG_PACKET_4_0_2);
movl(edx, Address(rsp, 128));
cmpl(edx ,-17155601);
jcc(Assembler::less, L_2TAG_PACKET_2_0_2);
jmp(L_2TAG_PACKET_4_0_2);
bind(L_2TAG_PACKET_3_0_2);
movl(edx, 14);
jmp(L_2TAG_PACKET_5_0_2);
bind(L_2TAG_PACKET_4_0_2);
movl(edx, 15);
bind(L_2TAG_PACKET_5_0_2);
movsd(Address(rsp, 0), xmm0);
movsd(xmm0, Address(rsp, 128));
fld_d(Address(rsp, 0));
jmp(L_2TAG_PACKET_6_0_2);
bind(L_2TAG_PACKET_7_0_2);
cmpl(eax, 2146435072);
jcc(Assembler::greaterEqual, L_2TAG_PACKET_8_0_2);
movl(eax, Address(rsp, 132));
cmpl(eax, INT_MIN);
jcc(Assembler::greaterEqual, L_2TAG_PACKET_9_0_2);
movsd(xmm0, Address(tmp, 1208)); // 0xffffffffUL, 0x7fefffffUL
mulsd(xmm0, xmm0);
movl(edx, 14);
jmp(L_2TAG_PACKET_5_0_2);
bind(L_2TAG_PACKET_9_0_2);
movsd(xmm0, Address(tmp, 1216));
mulsd(xmm0, xmm0);
movl(edx, 15);
jmp(L_2TAG_PACKET_5_0_2);
bind(L_2TAG_PACKET_8_0_2);
movl(edx, Address(rsp, 128));
cmpl(eax, 2146435072);
jcc(Assembler::above, L_2TAG_PACKET_10_0_2);
cmpl(edx, 0);
jcc(Assembler::notEqual, L_2TAG_PACKET_10_0_2);
movl(eax, Address(rsp, 132));
cmpl(eax, 2146435072);
jcc(Assembler::notEqual, L_2TAG_PACKET_11_0_2);
movsd(xmm0, Address(tmp, 1192)); // 0x00000000UL, 0x7ff00000UL
jmp(L_2TAG_PACKET_2_0_2);
bind(L_2TAG_PACKET_11_0_2);
movsd(xmm0, Address(tmp, 1200)); // 0x00000000UL, 0x00000000UL
jmp(L_2TAG_PACKET_2_0_2);
bind(L_2TAG_PACKET_10_0_2);
movsd(xmm0, Address(rsp, 128));
addsd(xmm0, xmm0);
jmp(L_2TAG_PACKET_2_0_2);
bind(L_2TAG_PACKET_0_0_2);
movl(eax, Address(rsp, 132));
andl(eax, 2147483647);
cmpl(eax, 1083179008);
jcc(Assembler::aboveEqual, L_2TAG_PACKET_7_0_2);
movsd(xmm0, Address(rsp, 128));
addsd(xmm0, Address(tmp, 1184)); // 0x00000000UL, 0x3ff00000UL
jmp(L_2TAG_PACKET_2_0_2);
bind(L_2TAG_PACKET_2_0_2);
movsd(Address(rsp, 48), xmm0);
fld_d(Address(rsp, 48));
bind(L_2TAG_PACKET_6_0_2);
movl(tmp, Address(rsp, 64));
}
void CompilerStubs::generate_compiler_new_type_array() {
comment_section("Compiler stub: new type array");
comment("- ecx holds the array size");
comment("- ebx holds the prototypical near of the array class");
entry("compiler_new_type_array");
comment("Get array length");
// BytesPerWord added because of the return address
movl(edx, Address(esp, Constant(BytesPerWord + JavaFrame::arg_offset_from_sp(0))));
Label slow_case;
comment("Check if the array length is too large or negative");
cmpl(edx, Constant(maximum_safe_array_length));
jcc(above, Constant(slow_case));
comment("Get _inline_allocation_top");
movl(eax, Address(Constant("_inline_allocation_top")));
if (GenerateDebugAssembly) {
comment("Check ExcessiveGC");
testl(Address(Constant("ExcessiveGC")), Constant(0));
jcc(not_zero, Constant(slow_case));
}
comment("Compute new top and check for overflow");
addl(ecx, eax);
jcc(carry_set, Constant(slow_case)); // if the carry bit is set the addition has overflowed
comment("Compare against _inline_allocation_end");
cmpl(ecx, Address(Constant("_inline_allocation_end")));
jcc(above, Constant(slow_case));
comment("Allocation succeeded, set _inline_allocation_top");
movl(Address(Constant("_inline_allocation_top")), ecx);
comment("Set prototypical near in object; no need for write barrier");
movl(Address(eax), ebx);
comment("Set the length");
movl(Address(eax, Constant(Array::length_offset())), edx);
comment("Compute remaining size");
subl(ecx, eax);
subl(ecx, Constant(Array::base_offset()));
comment("One-word object?");
Label init_done;
jcc(zero, Constant(init_done));
comment("Zero object fields");
xorl(edx, edx);
Label init_loop;
bind(init_loop);
movl(Address(eax, ecx, times_1, Constant(Array::base_offset() - oopSize)), edx);
decrement(ecx, oopSize);
jcc(not_zero, Constant(init_loop));
bind(init_done);
comment("The newly allocated array is in register eax");
ret();
comment("Slow case - call the VM runtime system");
bind(slow_case);
leal(eax, Address(Constant("newarray")));
goto_shared_call_vm(T_ARRAY);
entry_end(); // compiler_new_type_array
}