ReturnOop LocationModifier::new_location(InstanceClass *ic,
Method *m, jlong offset,
LocationModifier *location)
{
UsingFastOops fast_oops;
LocationModifier::Fast loc;
if (location == NULL) {
loc = allocate_modifier();
if (loc.is_null()) {
return NULL;
}
} else {
loc = *location;
}
loc().set_thread_id(JavaDebugger::get_thread_id_by_ref(Thread::current()));
loc().set_clazz_id(JavaDebugger::get_object_id_by_ref(ic));
loc().set_method_id(JavaDebugger::get_method_id(ic,m));
if (loc().method_id() == -1) {
// we may have a debug rom breakpoint here. Try to find the
// correct method id
loc().find_and_set_rom_method_id(m);
}
if (loc().method_id() == -1) {
// couldn't find the method, return NULL
return NULL;
}
loc().set_offset(offset);
return loc;
}
void handle_exception_info(Thread *thread) {
UsingFastOops fast_oops;
JavaFrame throw_frame(thread);
VMEvent::Fast info_event =
VMEvent::find_event((jbyte)VM_EXCEPTION_INFO_EVENT);
if (info_event.not_null()) {
VMEvent::remove_event_request(&info_event);
}
info_event = VMEvent::create_vm_event_request();
LocationModifier::Fast loc = LocationModifier::new_location(&throw_frame);
if (info_event.is_null() || loc.is_null()) {
// punt, out of memory or we couldn't find this location
return;
}
info_event().set_event_kind((jbyte)VM_EXCEPTION_INFO_EVENT);
loc().set_mod_kind(JDWP_EventRequest_Set_Out_modifiers_Modifier_LocationOnly);
info_event().set_mods(&loc);
info_event().set_next((VMEvent *)Universe::vmevent_request_head());
*Universe::vmevent_request_head() = info_event;
}
ReturnOop VMEventModifier::new_modifier(PacketInputStream *in,
PacketOutputStream *out, bool& error) {
UsingFastOops fast_oops;
jbyte mod_kind = in->read_byte();
VMEventModifier::Fast newMod;
Thread::Fast thread;
newMod = allocate_modifier();
if (newMod.is_null()) {
error = true;
out->set_error(JDWP_Error_OUT_OF_MEMORY);
return NULL;
}
newMod().set_mod_kind(mod_kind);
#ifdef AZZERT
if (TraceDebugger) {
tty->print_cr("Modifier: modkind = %d", mod_kind);
}
#endif
switch(mod_kind) {
case JDWP_EventRequest_Set_Out_modifiers_Modifier_FieldOnly:
// unsupported
in->read_class_id();
in->read_class_id();
in->read_int();
return NULL;
case JDWP_EventRequest_Set_Out_modifiers_Modifier_Conditional:
// unsupported
in->read_int();
return NULL;
case JDWP_EventRequest_Set_Out_modifiers_Modifier_ClassExclude:
// unsupported
in->read_string();
return NULL;
case JDWP_EventRequest_Set_Out_modifiers_Modifier_ThreadOnly:
newMod().set_thread_id(in->read_thread_id());
return newMod;
case JDWP_EventRequest_Set_Out_modifiers_Modifier_Count:
newMod().set_count(in->read_int());
return newMod;
case JDWP_EventRequest_Set_Out_modifiers_Modifier_ClassOnly:
{
newMod().set_clazz_id(in->read_class_id());
#ifdef AZZERT
if (TraceDebugger) {
tty->print_cr("Modifier: class_id = %d", newMod().clazz_id());
}
#endif
return newMod;
}
case JDWP_EventRequest_Set_Out_modifiers_Modifier_ClassMatch:
{
UsingFastOops fast_oops_2;
int length;
SETUP_ERROR_CHECKER_ARG;
TypeArray::Fast ta = in->read_raw_string(length JVM_NO_CHECK);
if (ta.is_null()) {
// Out of memory?? Things will fall apart soon enough,
// We just punt on this modifier
return newMod;
}
for (int i = length - 1; i >= 0; i--) {
if (ta().byte_at(i) == '.') {
ta().byte_at_put(i, '/');
}
}
Symbol::Fast tmpName = Universe::new_symbol(&ta,
(utf8)(ta().base_address()), length JVM_NO_CHECK);
if (tmpName.is_null()) {
error = true;
out->set_error(JDWP_Error_OUT_OF_MEMORY);
return NULL;
}
#ifdef AZZERT
if (TraceDebugger) {
tty->print("Modifier: class match = ");
tmpName().print_symbol_on(tty);
tty->cr();
}
#endif
ClassMatchModifier::Fast class_match_modifier = newMod().obj();
class_match_modifier().set_class_match_name(&tmpName);
return newMod;
}
case JDWP_EventRequest_Set_Out_modifiers_Modifier_LocationOnly:
{
UsingFastOops fast_oops_3;
jbyte tag = in->read_byte(); (void)tag;
LocationModifier::Fast lmod = newMod.obj();
lmod().set_clazz_id(in->read_class_id());
if (lmod().clazz_id() == 0) {
return NULL; /* Class ID == 0 is invalid */
}
lmod().set_method_id(in->read_method_id());
lmod().set_offset(in->read_long());
#ifdef AZZERT
if (TraceDebugger) {
tty->print_cr("Loc: class: 0x%x, method: 0x%x, off: 0x%x",
lmod().clazz_id(),
(int)(lmod().method_id() & 0xFFFFFFFF),
lmod().offset());
}
#endif
return lmod;
}
case JDWP_EventRequest_Set_Out_modifiers_Modifier_ExceptionOnly:
{
UsingFastOops fast_oops_4;
ExceptionModifier::Fast emod = newMod.obj();
emod().set_clazz_id(in->read_class_id());
emod().set_sig_caught(in->read_boolean());
emod().set_sig_uncaught(in->read_boolean());
return emod;
}
case JDWP_EventRequest_Set_Out_modifiers_Modifier_Step:
{
UsingFastOops fast_oops_5;
int thread_id = in->read_thread_id();
thread = JavaDebugger::get_thread_by_id(thread_id);
if (!JavaDebugger::is_valid_thread(&thread) ||
!thread().last_java_frame_exists()) {
error = true;
out->set_error(JDWP_Error_INVALID_THREAD);
return NULL;
}
Frame fr(&thread);
GUARANTEE(fr.is_java_frame(), "Single step must start at JavaFrame");
JavaFrame jf = fr.as_JavaFrame();
LocationModifier::Fast loc = LocationModifier::new_location(&jf);
if (loc.is_null()) {
error = true;
out->set_error(JDWP_Error_OUT_OF_MEMORY);
return NULL;
}
#ifdef AZZERT
if (TraceDebugger) {
tty->print_cr("StepLoc: thread: 0x%x, class: 0x%x, method: 0x%x, off: 0x%x",
thread_id, loc().clazz_id(),
(int)(loc().method_id() & 0xFFFFFFFF),
loc().offset());
}
#endif
loc().set_mod_kind(mod_kind);
StepModifier::Fast smod = loc.obj();
smod().set_thread_id(thread_id);
if (thread.is_null() /* || (thread.state() & THREAD_DEAD) */) {
/*
* If you try to single step after suspending because
* of an uncaught exception event we'll get sent the
* thread id of the thread that had the exception.
* That thread is dead though.
*/
error = true;
out->set_error(JDWP_Error_INVALID_THREAD);
return NULL;
}
smod().set_step_size(in->read_int());
smod().set_step_depth(in->read_int());
/* query the _proxy_ for next line location */
{
UsingFastOops fast_oops_6;
DebuggerEvent d_event;
d_event.set_event_kind((jbyte)VM_STEPINFO_EVENT);
VMEvent::stepping_info_request(&d_event, in->transport(),
&smod);
/*
* At this point, the proxy has made sure no more commands
* from the debugger get sent until we get our line number
* info from the proxy
*/
JavaDebugger::set_loop_count(1);
JavaDebugger::process_command_loop();
/*
* Once we get back here, then we know we've gotten the
* command from the proxy with the line number info put into
* the StepModifier object in the step_info_event above.
*/
/* setup the relevant info */
thread().set_is_stepping(true);
// set the _debugger_active flag for the interpreter loop
JavaDebugger::set_stepping(true);
// smod = step_info_event().mods();
// smod().set_step_target_offset(stepData().step_target_offset());
smod().unlink_method();
if (smod().step_depth() == JDWP_StepDepth_OUT) {
// if stepping out to the caller, we really should unlink any
// compiled code from here to the caller frame, for now assume
// one frame up. It could be re-compiled but we may luck out.
Method::Fast m;
Frame caller(jf);
jf.caller_is(caller);
if (!caller.is_entry_frame()) {
m = caller.as_JavaFrame().method();
#if ENABLE_COMPILER
if (m().has_compiled_code()) {
m().unlink_compiled_code();
}
#endif
}
}
smod().set_step_starting_fp(DISTANCE(thread().stack_base(), jf.fp()));
smod().set_step_starting_offset(jf.bci());
// smod().set_dup_current_line_offset(stepData().dup_current_line_offset());
// smod().set_post_dup_line_offset(stepData().post_dup_line_offset());
thread().set_step_info(&smod);
}
return smod;
}
}
error = true;
out->set_error(JDWP_Error_NOT_IMPLEMENTED);
return NULL;
}
void
VMEvent::clear_impossible_to_compile(LocationModifier *mod, VMEvent *ep)
{
UsingFastOops fast_oops;
// If we are using the compiler then we should reset the
// impossible_to_compile flag for this method (and potentially one frame
// up if it's a single step).
// We also check the previous state of the method, if it was
// "impossible_to_compile" we don't reset the flag.
InstanceClass::Fast clazz;
Method::Fast method, callerMethod;
LocationModifier::Fast thisMod;
Method::Fast m = mod->method();
// if (!m().has_compiled_code()) {
// if method does not have compiled code then just return
// return;
// }
if (m.is_null()) {
// Method was removed. Most likely it was a <clinit> method
return;
}
VMEvent::Fast epm;
VMEventStream es;
bool found_one = false;
while (!es.at_end()) {
epm = es.next();
if ((epm().event_kind() == JDWP_EventKind_BREAKPOINT ||
epm().event_kind() == JDWP_EventKind_SINGLE_STEP) &&
(ep == NULL || !epm.equals(ep))) {
thisMod = get_modifier(&epm,
JDWP_EventRequest_Set_Out_modifiers_Modifier_LocationOnly);
if (thisMod.not_null()) {
method = thisMod().method();
if (method.equals(&m)) {
// another breakpoint in this method, keep impossible_to_compile set
found_one = true;
break;
}
}
}
}
if (!found_one) {
// we must have looped through the whole list and not found another
// breakpoint in this method so clear the impossible_to_compile flag
if (mod->rom_debug_method() != NULL) {
// This method is in ROM, let's check all method pointers on the java
// stack to see if any of them point to this rom_debug_method.
// We may be called as a result of JVM::cleanup(). Thread doesn't have
// a stack in that case.
Thread *thread = Thread::current();
if (thread->last_java_fp() != NULL && thread->last_java_sp() != NULL) {
Frame fr(Thread::current());
while (true) {
if (fr.is_entry_frame()) {
EntryFrame e = fr.as_EntryFrame();
if (e.is_first_frame()) {
break;
}
e.caller_is(fr);
} else if (fr.is_java_frame()) {
JavaFrame jf = fr.as_JavaFrame();
if (jf.method() == mod->rom_debug_method()) {
MethodDesc *md = (MethodDesc *)mod->method();
// fix up the stored bcp in this frame
int bci = jf.bci_with_flags();
jf.set_raw_method(md);
Method::Raw m = jf.method();
jf.set_raw_bcp((address)(bci + m().code_base()));
}
jf.caller_is(fr);
}
}
}
}
// We also check the previous state of the method, if it was
// "impossible_to_compile" we don't reset the flag.
if (mod->compile_state() == true) {
// Method was compilable so set entry to default
m().set_default_entry(false);
} else {
if (ep->event_kind() == JDWP_EventKind_BREAKPOINT) {
// May have been a special native method like String.charAt.
// Just replace the entry with what we had saved earlier
GUARANTEE(!ObjectHeap::contains((OopDesc*)mod->saved_method_entry()),
"ROM method entry is in heap");
m().variable_part()->set_execution_entry(mod->saved_method_entry());
}
}
}
}
void VMEvent::exception_event(Throwable *exception,
JavaFrame *catch_frame,
DebuggerEvent *d_event, int catch_offset)
{
check_notify_wanted(Dbg_EventKind_EXCEPTION);
UsingFastOops fast_oops;
VMEvent::Fast ep, ep_2;
jlong throw_offset = 0;
int event_count = 0;
jbyte suspend_policy = JDWP_SuspendPolicy_NONE;
InstanceClass::Fast ic;
LocationModifier::Fast location;
Method::Fast catch_method;
Method::Fast throw_method;
int data_len = JDWP_EVENT_LEN;
ep = ep_2 = get_event_request(d_event, event_count, suspend_policy);
if (ep.is_null()) {
return;
}
// Flush any packets waiting in the queue. This helps avoid a race
// condition where we may have a resume command in the queue for a
// previous event, we send this event, process the resume command
// out of order
JavaDebugger::dispatch(0);
// Calculate packet length
data_len += (JDWP_EVENT_EXCEPTION_LEN * event_count);
Transport::Fast transport = ep().transport();
PacketOutputStream out(&transport, data_len, JDWP_COMMAND_SET(Event),
JDWP_COMMAND(Event, Composite));
// Create a buffered output stream so we can asynchronously send an error
// Calculate the size based on half of the items being 'longs'
UsingFastOops fast_oops_2;
Thread::Fast thread = JavaDebugger::get_thread_by_id(d_event->thread_id());
VMEventModifier::deoptimize_frame(&thread, true);
VMEvent::Fast info_event = find_event((jbyte)VM_EXCEPTION_INFO_EVENT);
if (!info_event.is_null()) {
location = get_modifier(&info_event,
JDWP_EventRequest_Set_Out_modifiers_Modifier_LocationOnly);
GUARANTEE(!location.is_null(), "No location modifier in info event");
throw_method = location().method();
throw_offset = location().offset();
remove_event_request(&info_event);
} else {
UsingFastOops fast_oops_3;
ObjArray::Fast trace, methods;
TypeArray::Fast offsets;
trace = exception->backtrace();
if (!trace.is_null()) {
methods = trace().obj_at(0);
offsets = trace().obj_at(1);
if (!methods.is_null() && !offsets.is_null()) {
throw_method = methods().obj_at(0);
throw_offset = (jlong)(offsets().int_at(0));
}
}
}
DEBUGGER_EVENT(("Exception"));
out.write_byte(suspend_policy);
out.write_int(event_count);
while (ep.not_null()) {
out.write_byte(JDWP_EventKind_EXCEPTION);
out.write_int(ep().event_id());
// thread with exception
out.write_int(d_event->thread_id());
// location of exception throw
if (throw_method.not_null()) {
ic = throw_method().holder();
}
DebuggerEvent throw_event(JDWP_EventKind_EXCEPTION,
0, // don't need thread
JavaDebugger::get_object_id_by_ref(&ic),
JavaDebugger::get_method_id(&ic, &throw_method),
(jlong)throw_offset);
throw_event.write_as_location(&out);
// thrown exception
out.write_byte('L');
out.write_object(exception);
// location of catch, or 0 if not caught
if (catch_frame == NULL) {
LocationModifier::write_null_location(&out);
} else {
catch_method = catch_frame->method();
ic = catch_method().holder();
DebuggerEvent catch_event(JDWP_EventKind_EXCEPTION,
0, // don't need thread
JavaDebugger::get_object_id_by_ref(&ic),
JavaDebugger::get_method_id(&ic, &catch_method),
(jlong)catch_offset);
catch_event.write_as_location(&out);
}
ep = ep().send_next();
}
out.send_packet();
JavaDebugger::process_suspend_policy(suspend_policy, &thread,
true);
}
