void SeniorVMHandle::exit()
{
pcode->v_push_register(T_RET);
pushf();
pushad();
db(HANDLE.ret.handle);
}
//---------------------------------------------------------------------------
// The following routine generates a subroutine to throw an asynchronous
// UnknownError when an unsafe access gets a fault that could not be
// reasonably prevented by the programmer. (Example: SIGBUS/OBJERR.)
address generate_handler_for_unsafe_access() {
StubCodeMark mark(this, "StubRoutines", "handler_for_unsafe_access");
address start = __ pc();
__ pushl(0); // hole for return address-to-be
__ pushad(); // push registers
Address next_pc(esp, RegisterImpl::number_of_registers * BytesPerWord);
__ call(CAST_FROM_FN_PTR(address, handle_unsafe_access), relocInfo::runtime_call_type);
__ movl(next_pc, eax); // stuff next address
__ popad();
__ ret(0); // jump to next address
return start;
}
address generate_verify_oop() {
StubCodeMark mark(this, "StubRoutines", "verify_oop");
address start = __ pc();
// Incoming arguments on stack after saving eax:
//
// [tos ]: saved edx
// [tos + 1]: saved EFLAGS
// [tos + 2]: return address
// [tos + 3]: char* error message
// [tos + 4]: oop object to verify
// [tos + 5]: saved eax - saved by caller and bashed
Label exit, error;
__ pushfd();
__ incl(Address((int)StubRoutines::verify_oop_count_addr(), relocInfo::none));
__ pushl(edx); // save edx
// make sure object is 'reasonable'
__ movl(eax, Address(esp, 4 * wordSize)); // get object
__ testl(eax, eax);
__ jcc(Assembler::zero, exit); // if obj is NULL it is ok
// Check if the oop is in the right area of memory
const int oop_mask = Universe::verify_oop_mask();
const int oop_bits = Universe::verify_oop_bits();
__ movl(edx, eax);
__ andl(edx, oop_mask);
__ cmpl(edx, oop_bits);
__ jcc(Assembler::notZero, error);
// make sure klass is 'reasonable'
__ movl(eax, Address(eax, oopDesc::klass_offset_in_bytes())); // get klass
__ testl(eax, eax);
__ jcc(Assembler::zero, error); // if klass is NULL it is broken
// Check if the klass is in the right area of memory
const int klass_mask = Universe::verify_klass_mask();
const int klass_bits = Universe::verify_klass_bits();
__ movl(edx, eax);
__ andl(edx, klass_mask);
__ cmpl(edx, klass_bits);
__ jcc(Assembler::notZero, error);
// make sure klass' klass is 'reasonable'
__ movl(eax, Address(eax, oopDesc::klass_offset_in_bytes())); // get klass' klass
__ testl(eax, eax);
__ jcc(Assembler::zero, error); // if klass' klass is NULL it is broken
__ movl(edx, eax);
__ andl(edx, klass_mask);
__ cmpl(edx, klass_bits);
__ jcc(Assembler::notZero, error); // if klass not in right area
// of memory it is broken too.
// return if everything seems ok
__ bind(exit);
__ movl(eax, Address(esp, 5 * wordSize)); // get saved eax back
__ popl(edx); // restore edx
__ popfd(); // restore EFLAGS
__ ret(3 * wordSize); // pop arguments
// handle errors
__ bind(error);
__ movl(eax, Address(esp, 5 * wordSize)); // get saved eax back
__ popl(edx); // get saved edx back
__ popfd(); // get saved EFLAGS off stack -- will be ignored
__ pushad(); // push registers (eip = return address & msg are already pushed)
__ call(CAST_FROM_FN_PTR(address, MacroAssembler::debug), relocInfo::runtime_call_type);
__ popad();
__ ret(3 * wordSize); // pop arguments
return start;
}
StressTest(int seed, int tests, int level, bool copyProp, bool loadElim, bool spillElim) : CodeGenerator(false)
{
if(copyProp) enableCopyPropagation(); else disableCopyPropagation();
if(loadElim) enableLoadElimination(); else disableLoadElimination();
if(spillElim) enableSpillElimination(); else disableSpillElimination();
#if 0
Int a;
Int b;
Int c;
pushad();
prologue(1024);
freeAll();
for(int i = 0; i < 3; i++)
{
add(r32(&x[2 * i + 0]), r32(&x[2 * i + 1]));
}
nop();
a = (a + b) * c;
nop();
for(int i = 2; i >= 1; i--)
{
add(r32(&x[2 * i + 0]), r32(&x[2 * i + 1]));
}
nop();
spillAll();
epilogue();
popad();
ret();
return;
#else
// -------------------------------------------------
srand(seed);
for(int i = 0; i < 16; i++)
{
w[i] = rand();
}
for(int i = 0; i < 16; i++)
{
x[i] = w[i];
}
if(level & 0x01) for(int i = 0; i < tests; i++)
{
x[q()] = x[q()];
if(i % 3 == 0 && rand() < RAND_MAX / 2)
{
int a = q(); int b = q();
x[b] += x[a];
}
}
if(level & 0x02) for(int i = 0; i < tests; i++)
{
int a = q(); int b = q();
x[b] += x[a];
if(i % 3 == 0 && rand() < RAND_MAX / 2)
{
x[q()] = x[q()];
}
}
if(level & 0x04) for(int i = 0; i < tests; i++)
{
int a = q(); int b = q();
x[b] += x[a];
if(i % 3 == 0 && rand() < RAND_MAX / 2)
{
x[q()]; // spill(reg)
}
}
if(level & 0x08) for(int i = 0; i < tests; i++)
{
if(q() < q() / 2) {int a = q(); int b = q(); x[b] += x[a];} // add(r(), r());
if(q() < q() / 2) {x[q()] = x[q()];} // mov(r(), r());
if(q() < q() / 2) q(); // spill(r());
}
for(int i = 0; i < 16; i++)
{
y[i] = x[i];
}
// -------------------------------------------------
srand(seed);
for(int i = 0; i < 16; i++)
{
w[i] = rand();
}
pushad();
for(int i = 0; i < 16; i++)
{
mov(eax, dword_ptr [&w[i]]);
mov(dword_ptr [&x[i]], eax);
}
freeAll();
nop();
if(level & 0x01) for(int i = 0; i < tests; i++)
{
mov(r(), r());
if(i % 3 == 0 && rand() < RAND_MAX / 2)
{
add(r(), r());
}
}
if(level & 0x02) for(int i = 0; i < tests; i++)
{
add(r(), r());
if(i % 3 == 0 && rand() < RAND_MAX / 2)
{
mov(r(), r());
}
}
if(level & 0x04) for(int i = 0; i < tests; i++)
{
add(r(), r());
if(i % 3 == 0 && rand() < RAND_MAX / 2)
{
spill(r());
}
}
if(level & 0x08) for(int i = 0; i < tests; i++)
{
if(q() < q() / 2) add(r(), r());
if(q() < q() / 2) mov(r(), r());
if(q() < q() / 2) spill(r());
}
nop();
spillAll();
nop();
for(int i = 0; i < 16; i++)
{
mov(eax, dword_ptr [&x[i]]);
mov(dword_ptr [&z[i]], eax);
}
popad();
ret();
#endif
}
