gcc-4.3.1/libjava/gnu/classpath/jdwp/natVMVirtualMachine.cc

// natVMVirtualMachine.cc - native support for VMVirtualMachine

/* Copyright (C) 2006, 2007 Free Software Foundation

   This file is part of libgcj.

This software is copyrighted work licensed under the terms of the
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
details. */

#include <config.h>
#include <gcj/cni.h>
#include <java-assert.h>
#include <java-interp.h>
#include <jvm.h>
#include <jvmti.h>

#include <java/lang/Class.h>
#include <java/lang/ClassLoader.h>
#include <java/lang/Integer.h>
#include <java/lang/String.h>
#include <java/lang/StringBuilder.h>
#include <java/lang/Thread.h>
#include <java/lang/Throwable.h>
#include <java/nio/ByteBuffer.h>
#include <java/nio/ByteBufferImpl.h>
#include <java/util/ArrayList.h>
#include <java/util/Collection.h>
#include <java/util/Hashtable.h>
#include <java/util/Iterator.h>

#include <gnu/classpath/jdwp/Jdwp.h>
#include <gnu/classpath/jdwp/JdwpConstants$StepDepth.h>
#include <gnu/classpath/jdwp/JdwpConstants$StepSize.h>
#include <gnu/classpath/jdwp/JdwpConstants$ThreadStatus.h>
#include <gnu/classpath/jdwp/VMFrame.h>
#include <gnu/classpath/jdwp/VMMethod.h>
#include <gnu/classpath/jdwp/VMVirtualMachine.h>
#include <gnu/classpath/jdwp/event/BreakpointEvent.h>
#include <gnu/classpath/jdwp/event/ClassPrepareEvent.h>
#include <gnu/classpath/jdwp/event/ExceptionEvent.h>
#include <gnu/classpath/jdwp/event/EventManager.h>
#include <gnu/classpath/jdwp/event/EventRequest.h>
#include <gnu/classpath/jdwp/event/SingleStepEvent.h>
#include <gnu/classpath/jdwp/event/ThreadEndEvent.h>
#include <gnu/classpath/jdwp/event/ThreadStartEvent.h>
#include <gnu/classpath/jdwp/event/VmDeathEvent.h>
#include <gnu/classpath/jdwp/event/VmInitEvent.h>
#include <gnu/classpath/jdwp/event/filters/IEventFilter.h>
#include <gnu/classpath/jdwp/event/filters/LocationOnlyFilter.h>
#include <gnu/classpath/jdwp/event/filters/StepFilter.h>
#include <gnu/classpath/jdwp/exception/AbsentInformationException.h>
#include <gnu/classpath/jdwp/exception/InvalidFrameException.h>
#include <gnu/classpath/jdwp/exception/InvalidLocationException.h>
#include <gnu/classpath/jdwp/exception/InvalidMethodException.h>
#include <gnu/classpath/jdwp/exception/JdwpInternalErrorException.h>
#include <gnu/classpath/jdwp/id/ThreadId.h>
#include <gnu/classpath/jdwp/util/Location.h>
#include <gnu/classpath/jdwp/util/MethodResult.h>
#include <gnu/gcj/jvmti/Breakpoint.h>
#include <gnu/gcj/jvmti/BreakpointManager.h>

using namespace java::lang;
using namespace gnu::classpath::jdwp::event;
using namespace gnu::classpath::jdwp::util;

// Stepping information
struct step_info
{
  jint size;   // See gnu.classpath.jdwp.JdwpConstants.StepSize
  jint depth;  // See gnu.classpath.jdwp.JdwpConstants.StepDepth
  int stack_depth;  // stack depth at start of stepping
  jmethodID method; // method in which we are stepping
};

// Forward declarations
static jvmtiError get_linetable (jvmtiEnv *, jmethodID, jint *,
				 jvmtiLineNumberEntry **);
static Location *get_request_location (EventRequest *);
static gnu::classpath::jdwp::event::filters::StepFilter *
get_request_step_filter (EventRequest *);
static void handle_single_step (jvmtiEnv *, struct step_info *, jthread,
				jmethodID, jlocation);
static void JNICALL jdwpBreakpointCB (jvmtiEnv *, JNIEnv *, jthread,
				      jmethodID, jlocation);
static void JNICALL jdwpClassPrepareCB (jvmtiEnv *, JNIEnv *, jthread, jclass);
static void JNICALL jdwpExceptionCB (jvmtiEnv *, JNIEnv *jni_env, jthread,
				     jmethodID, jlocation, jobject,
				     jmethodID, jlocation);
static void JNICALL jdwpSingleStepCB (jvmtiEnv *, JNIEnv *, jthread,
				      jmethodID, jlocation);
static void JNICALL jdwpThreadEndCB (jvmtiEnv *, JNIEnv *, jthread);
static void JNICALL jdwpThreadStartCB (jvmtiEnv *, JNIEnv *, jthread);
static void JNICALL jdwpVMDeathCB (jvmtiEnv *, JNIEnv *);
static void JNICALL jdwpVMInitCB (jvmtiEnv *, JNIEnv *, jthread);
static void throw_jvmti_error (jvmtiError);

#define DEFINE_CALLBACK(Cb,Event) Cb.Event = jdwp ## Event ## CB
#define DISABLE_EVENT(Event,Thread)					\
  _jdwp_jvmtiEnv->SetEventNotificationMode (JVMTI_DISABLE,		\
					    JVMTI_EVENT_ ## Event, Thread)
#define ENABLE_EVENT(Event,Thread)					\
  _jdwp_jvmtiEnv->SetEventNotificationMode (JVMTI_ENABLE,		\
					    JVMTI_EVENT_ ## Event, Thread)
// JVMTI environment
static jvmtiEnv *_jdwp_jvmtiEnv;

jvmtiEnv *
_Jv_GetJDWP_JVMTIEnv (void)
{
  return _jdwp_jvmtiEnv;
}

void
gnu::classpath::jdwp::VMVirtualMachine::initialize ()
{
  _jdwp_suspend_counts = new ::java::util::Hashtable ();
  _stepping_threads = new ::java::util::Hashtable ();
  _event_list = new ::java::util::ArrayList ();

  JavaVM *vm = _Jv_GetJavaVM ();
  union
  {
    void *ptr;
    jvmtiEnv *env;
  } foo;
  vm->GetEnv (&(foo.ptr), JVMTI_VERSION_1_0);
  _jdwp_jvmtiEnv = foo.env;

  // Wait for VM_INIT to do more initialization
  jvmtiEventCallbacks callbacks;
  DEFINE_CALLBACK (callbacks, VMInit);
  _jdwp_jvmtiEnv->SetEventCallbacks (&callbacks, sizeof (callbacks));
  ENABLE_EVENT (VM_INIT, NULL);
}

void
gnu::classpath::jdwp::VMVirtualMachine::suspendThread (Thread *thread)
{
  jint value;
  Integer *count;
  {
    JvSynchronize dummy (_jdwp_suspend_counts);
    count = reinterpret_cast<Integer *> (_jdwp_suspend_counts->get (thread));
    if (count == NULL)
      {
	// New -- suspend thread
	value = 0;
      }
    else
      {
	// Thread already suspended
	value = count->intValue ();
      }

    count = Integer::valueOf (++value);
    _jdwp_suspend_counts->put (thread, count);
  }

  if (value == 1)
    {
      // Suspend the thread
      jvmtiError err = _jdwp_jvmtiEnv->SuspendThread (thread);
      if (err != JVMTI_ERROR_NONE)
	{
	  using namespace gnu::gcj::runtime;
	  using namespace gnu::classpath::jdwp::exception;
	  char *reason;
	  _jdwp_jvmtiEnv->GetErrorName (err, &reason);
	  String *txt = JvNewStringLatin1 ("could not suspend thread: ");
	  StringBuilder *msg = new StringBuilder (txt);
	  msg->append (JvNewStringLatin1 (reason));
	  _jdwp_jvmtiEnv->Deallocate ((unsigned char *) reason);
	  throw new JdwpInternalErrorException (msg->toString ());
	}
    }
}

void
gnu::classpath::jdwp::VMVirtualMachine::resumeThread (Thread *thread)
{
  jint value;
  {
    JvSynchronize dummy (_jdwp_suspend_counts);
    Integer *count
      = reinterpret_cast<Integer *> (_jdwp_suspend_counts->get (thread));
    if (count == NULL)
      {
	// Thread not suspended: ThreadReference.Resume says to ignore it.
	return;
      }
    else
      {
	// Decrement suspend count
	value = count->intValue () - 1;
      }

    if (value == 0)
      {
	// Thread will be resumed, remove from table
	_jdwp_suspend_counts->remove (thread);
      }
    else
      {
	// Thread stays suspended: record new suspend count
	count = Integer::valueOf (value);
	_jdwp_suspend_counts->put (thread, count);
      }
  }

  if (value == 0)
    {
      jvmtiError err = _jdwp_jvmtiEnv->ResumeThread (thread);
      if (err != JVMTI_ERROR_NONE)
	{
	  using namespace gnu::gcj::runtime;
	  using namespace gnu::classpath::jdwp::exception;
	  char *reason;
	  _jdwp_jvmtiEnv->GetErrorName (err, &reason);
	  String *txt = JvNewStringLatin1 ("could not resume thread: ");
	  StringBuilder *msg = new StringBuilder (txt);
	  msg->append (JvNewStringLatin1 (reason));
	  _jdwp_jvmtiEnv->Deallocate ((unsigned char *) reason);
	  throw new JdwpInternalErrorException (msg->toString ());
	}
    }
}

jint
gnu::classpath::jdwp::VMVirtualMachine::getSuspendCount (Thread *thread)
{
  jint suspensions = 0;
  Integer *count
    = reinterpret_cast<Integer *> (_jdwp_suspend_counts->get (thread));
  if (count != NULL)
    suspensions = count->intValue ();
  return suspensions;
}

void
gnu::classpath::jdwp::VMVirtualMachine::registerEvent (EventRequest *request)
{
  switch (request->getEventKind ())
    {
    case EventRequest::EVENT_SINGLE_STEP:
      {
	Thread *thread;
	filters::StepFilter *filter = get_request_step_filter (request);
	if (filter == NULL)
	  {
	    // No filter specified: report every step in every
	    // thread.
	    thread = NULL;
	  }
	else
	  {
	    // Add stepping information to list of stepping threads
	    thread = filter->getThread ()->getThread ();
	    _Jv_InterpFrame *frame
	      = reinterpret_cast<_Jv_InterpFrame *> (thread->interp_frame);
	    struct step_info *sinfo
	      = (struct step_info *) JvAllocBytes (sizeof (struct step_info));
	    sinfo->size = filter->getSize ();
	    sinfo->depth = filter->getDepth ();
	    sinfo->stack_depth = frame->depth ();
	    sinfo->method = frame->self->get_method ();
	    _stepping_threads->put (thread, (jobject) sinfo);
	  }

	ENABLE_EVENT (SINGLE_STEP, thread);
      }
      break;

    case EventRequest::EVENT_BREAKPOINT:
      {
	using namespace ::gnu::gcj::jvmti;
	Location *loc = get_request_location (request);
	if (loc == NULL)
	  {
	    using namespace gnu::classpath::jdwp::exception;
	    throw new InvalidLocationException ();
	  }

	jlong method = loc->getMethod ()->getId ();
	jlocation index = loc->getIndex ();
	Breakpoint  *bp = BreakpointManager::getBreakpoint (method, index);
	if (bp == NULL)
	  {
	    // Breakpoint not in interpreter yet
	    bp = BreakpointManager::newBreakpoint (method, index);
	  }
	else
	  {
	    // Ignore the duplicate
	  }
      }
      break;

    case EventRequest::EVENT_FRAME_POP:
      break;

    case EventRequest::EVENT_EXCEPTION:
      break;

    case EventRequest::EVENT_USER_DEFINED:
      break;

    case EventRequest::EVENT_THREAD_START:
      break;

    case EventRequest::EVENT_THREAD_END:
      break;

    case EventRequest::EVENT_CLASS_PREPARE:
      break;

    case EventRequest::EVENT_CLASS_LOAD:
      break;

    case EventRequest::EVENT_CLASS_UNLOAD:
      break;

    case EventRequest::EVENT_FIELD_ACCESS:
      break;

    case EventRequest::EVENT_FIELD_MODIFY:
      break;

    case EventRequest::EVENT_METHOD_ENTRY:
      break;

    case EventRequest::EVENT_METHOD_EXIT:
      break;

    case EventRequest::EVENT_VM_INIT:
      break;

    case EventRequest::EVENT_VM_DEATH:
      break;
    }
}

void
gnu::classpath::jdwp::VMVirtualMachine::unregisterEvent (EventRequest *request)
{
  switch (request->getEventKind ())
    {
    case EventRequest::EVENT_SINGLE_STEP:
      {
	Thread *thread;
	filters::StepFilter *filter = get_request_step_filter (request);
	if (filter == NULL)
	  thread = NULL;
	else
	  {
	    thread = filter->getThread ()->getThread ();
	    _stepping_threads->remove (thread);
	  }

	DISABLE_EVENT (SINGLE_STEP, thread);
      }
      break;

    case EventRequest::EVENT_BREAKPOINT:
      {
	using namespace gnu::gcj::jvmti;
	::java::util::Collection *breakpoints;
	EventManager *em = EventManager::getDefault ();
	breakpoints = em->getRequests (EventRequest::EVENT_BREAKPOINT);

	// Check for duplicates
	int matches = 0;
	Location *the_location = get_request_location (request);

	// This should not be possible: we REQUIRE a Location
	// to install a breakpoint
	JvAssert (the_location != NULL);

	::java::util::Iterator *iter = breakpoints->iterator ();
	while (iter->hasNext ())
	  {
	    EventRequest *er
	      = reinterpret_cast<EventRequest *> (iter->next ());
	    Location *loc = get_request_location (er);
	    JvAssert (loc != NULL);
	    if (loc->equals (the_location) && ++matches == 2)
	      {
		// Short-circuit: already more than one breakpoint
		return;
	      }
	  }

	if (matches == 0)
	  {
	    using namespace gnu::classpath::jdwp::exception;
	    jstring msg
	      = JvNewStringLatin1 ("attempt to remove unknown breakpoint");
	    throw new JdwpInternalErrorException (msg);
	  }

	jlong methodId = the_location->getMethod ()->getId ();
	BreakpointManager::deleteBreakpoint (methodId,
					     the_location->getIndex ());
      }
      break;

    case EventRequest::EVENT_FRAME_POP:
      break;

    case EventRequest::EVENT_EXCEPTION:
      break;

    case EventRequest::EVENT_USER_DEFINED:
      break;

    case EventRequest::EVENT_THREAD_START:
      break;

    case EventRequest::EVENT_THREAD_END:
      break;

    case EventRequest::EVENT_CLASS_PREPARE:
      break;

    case EventRequest::EVENT_CLASS_LOAD:
      break;

    case EventRequest::EVENT_CLASS_UNLOAD:
      break;

    case EventRequest::EVENT_FIELD_ACCESS:
      break;

    case EventRequest::EVENT_FIELD_MODIFY:
      break;

    case EventRequest::EVENT_METHOD_ENTRY:
      break;

    case EventRequest::EVENT_METHOD_EXIT:
      break;

    case EventRequest::EVENT_VM_INIT:
      break;

    case EventRequest::EVENT_VM_DEATH:
      break;
    }
}

void
gnu::classpath::jdwp::VMVirtualMachine::clearEvents (MAYBE_UNUSED jbyte kind)
{
}

java::util::Collection *
gnu::classpath::jdwp::VMVirtualMachine::getAllLoadedClasses (void)
{
  using namespace ::java::util;
  return (Collection *) new ArrayList ();
}

jint
gnu::classpath::jdwp::VMVirtualMachine::
getClassStatus (jclass klass)
{
  jint flags = 0;
  jvmtiError err = _jdwp_jvmtiEnv->GetClassStatus (klass, &flags);
  if (err != JVMTI_ERROR_NONE)
    throw_jvmti_error (err);

  using namespace gnu::classpath::jdwp::event;
  jint status = 0;
  if (flags & JVMTI_CLASS_STATUS_VERIFIED)
    status |= ClassPrepareEvent::STATUS_VERIFIED;
  if (flags & JVMTI_CLASS_STATUS_PREPARED)
    status |= ClassPrepareEvent::STATUS_PREPARED;
  if (flags & JVMTI_CLASS_STATUS_ERROR)
    status |= ClassPrepareEvent::STATUS_ERROR;
  if (flags & JVMTI_CLASS_STATUS_INITIALIZED)
    status |= ClassPrepareEvent::STATUS_INITIALIZED;

  return status;
}

JArray<gnu::classpath::jdwp::VMMethod *> *
gnu::classpath::jdwp::VMVirtualMachine::
getAllClassMethods (jclass klass)
{
  jint count;
  jmethodID *methods;
  jvmtiError err = _jdwp_jvmtiEnv->GetClassMethods (klass, &count, &methods);
  if (err != JVMTI_ERROR_NONE)
    throw_jvmti_error (err);

  JArray<VMMethod *> *result
    = (JArray<VMMethod *> *) JvNewObjectArray (count,
					       &VMMethod::class$, NULL);
  VMMethod **rmeth = elements (result);
  for (int i = 0; i < count; ++i)
    {
      jlong id = reinterpret_cast<jlong> (methods[i]);
      rmeth[i] = getClassMethod (klass, id);
    }

  _jdwp_jvmtiEnv->Deallocate ((unsigned char *) methods);
  return result;
}

gnu::classpath::jdwp::VMMethod *
gnu::classpath::jdwp::VMVirtualMachine::
getClassMethod (jclass klass, jlong id)
{
  jint count;
  jmethodID *methods;
  jvmtiError err = _jdwp_jvmtiEnv->GetClassMethods (klass, &count, &methods);
  if (err != JVMTI_ERROR_NONE)
    throw_jvmti_error (err);

  jmethodID meth_id = reinterpret_cast<jmethodID> (id);

  using namespace gnu::classpath::jdwp;

  // Check if this method is defined for the given class and if so return a
  // VMMethod representing it.
  for (int i = 0; i < count; i++)
    {
      if (methods[i] == meth_id)
        return new VMMethod (klass, reinterpret_cast<jlong> (meth_id));
    }

  throw new exception::InvalidMethodException (id);
}

java::util::ArrayList *
gnu::classpath::jdwp::VMVirtualMachine::getFrames (Thread *thread, jint start,
                                                   jint length)
{
  jint frame_count = getFrameCount (thread);
  ::java::util::ArrayList *frame_list;
  
  // Calculate the max number of frames to be returned.
  jint num_frames = frame_count - start;
  
  // Check if num_frames is valid.
  if (num_frames < 0)
    num_frames = 0;
  
  // Check if there are more than length frames left after start.
  // If length ios -1 return all remaining frames.
  if (length != -1 && num_frames > length)
    num_frames = length;
     
  frame_list = new ::java::util::ArrayList (num_frames);
  
  _Jv_Frame *vm_frame = reinterpret_cast<_Jv_Frame *> (thread->frame);
  
  // Take start frames off the top of the stack
  while (vm_frame != NULL && start > 0)
    {
      start--;
      vm_frame = vm_frame->next;
    }
  
  // Use as a counter for the number of frames returned.
  num_frames = 0;
  
  while (vm_frame != NULL && (num_frames < length || length == -1))
    {  
      jlong frameId = reinterpret_cast<jlong> (vm_frame);
      
      VMFrame *frame = getFrame (thread, frameId);
      frame_list->add (frame);
      vm_frame = vm_frame->next;
      num_frames++;
    }
  
  return frame_list;
}

gnu::classpath::jdwp::VMFrame *
gnu::classpath::jdwp::VMVirtualMachine::
getFrame (Thread *thread, jlong frameID)
{
  using namespace gnu::classpath::jdwp::exception;
  
  _Jv_Frame *vm_frame = (_Jv_Frame *) thread->frame;
  jint depth = 0;
  _Jv_Frame *frame = reinterpret_cast<_Jv_Frame *> (frameID); 
  
  // We need to find the stack depth of the frame, so search through the call
  // stack to find it.  This also checks for a valid frameID.
  while (vm_frame != frame)
    {
      vm_frame = vm_frame->next;
      depth++;
      if (vm_frame == NULL)
        throw new InvalidFrameException (frameID);
    }
  
  Location *loc = NULL;
  jvmtiFrameInfo info;
  jvmtiError jerr;
  jint num_frames;
  jclass klass;
  
  // Get the info for the frame of interest
  jerr = _jdwp_jvmtiEnv->GetStackTrace (thread, depth, 1, &info, &num_frames);
   
  if (jerr != JVMTI_ERROR_NONE)
    throw_jvmti_error (jerr);
  
  jerr = _jdwp_jvmtiEnv->GetMethodDeclaringClass (info.method, &klass);
      
  if (jerr != JVMTI_ERROR_NONE)
    throw_jvmti_error (jerr);

  VMMethod *meth 
    = getClassMethod (klass, reinterpret_cast<jlong> (info.method));
  
  jobject this_obj;
  
  if (info.location == -1)
    {
      loc = new Location (meth, 0);
      this_obj = NULL;
    }
  else
    {
      loc = new Location (meth, info.location);
      _Jv_InterpFrame *iframe = reinterpret_cast<_Jv_InterpFrame *> (vm_frame);
      this_obj = iframe->get_this_ptr ();
    }
  
  return new VMFrame (thread, reinterpret_cast<jlong> (vm_frame), loc,
                      this_obj); 
}

jint
gnu::classpath::jdwp::VMVirtualMachine::
getFrameCount (Thread *thread)
{
  jint frame_count;
  
  jvmtiError jerr = _jdwp_jvmtiEnv->GetFrameCount (thread, &frame_count);
  
  if (jerr != JVMTI_ERROR_NONE)
    throw_jvmti_error (jerr);
  
  return frame_count;
}

jint
gnu::classpath::jdwp::VMVirtualMachine::
getThreadStatus (Thread *thread)
{
  jint thr_state, status;
  
  jvmtiError jerr = _jdwp_jvmtiEnv->GetThreadState (thread, &thr_state);
  if (jerr != JVMTI_ERROR_NONE)
    throw_jvmti_error (jerr);
  
  if (thr_state & JVMTI_THREAD_STATE_SLEEPING)
    status = gnu::classpath::jdwp::JdwpConstants$ThreadStatus::SLEEPING;
  else if (thr_state & JVMTI_THREAD_STATE_RUNNABLE)
    status = gnu::classpath::jdwp::JdwpConstants$ThreadStatus::RUNNING;
  else if (thr_state & JVMTI_THREAD_STATE_WAITING)
    {
      if (thr_state & (JVMTI_THREAD_STATE_IN_OBJECT_WAIT
                       | JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER))
        status = gnu::classpath::jdwp::JdwpConstants$ThreadStatus::MONITOR;
      else
        status = gnu::classpath::jdwp::JdwpConstants$ThreadStatus::WAIT;
    }
  else
    {
      // The thread is not SLEEPING, MONITOR, or WAIT.  It may, however, be
      // alive but not yet started.
      if (!(thr_state & (JVMTI_THREAD_STATE_ALIVE 
                         | JVMTI_THREAD_STATE_TERMINATED)))
        status = gnu::classpath::jdwp::JdwpConstants$ThreadStatus::RUNNING;
      status = gnu::classpath::jdwp::JdwpConstants$ThreadStatus::ZOMBIE;     
    }   

  return status;
}

java::util::ArrayList *
gnu::classpath::jdwp::VMVirtualMachine::
getLoadRequests (MAYBE_UNUSED ClassLoader *cl)
{
  return new ::java::util::ArrayList ();
}

MethodResult *
gnu::classpath::jdwp::VMVirtualMachine::
executeMethod (MAYBE_UNUSED jobject obj, MAYBE_UNUSED Thread *thread,
	       MAYBE_UNUSED jclass clazz, MAYBE_UNUSED VMMethod *method,
	       MAYBE_UNUSED JArray<value::Value *> *values,
	       MAYBE_UNUSED jint options)
{
  return NULL;
}

jstring
gnu::classpath::jdwp::VMVirtualMachine::
getSourceFile (jclass clazz)
{
  jstring file = _Jv_GetInterpClassSourceFile (clazz);
  
  // Check if the source file was found.
  if (file == NULL)
    throw new exception::AbsentInformationException (
                           _Jv_NewStringUTF("Source file not found"));
  
  return file;
}

void
gnu::classpath::jdwp::VMVirtualMachine::
redefineClasses (MAYBE_UNUSED JArray<jclass> *types,
		 MAYBE_UNUSED JArray<jbyteArray> *bytecodes)
{
}

void
gnu::classpath::jdwp::VMVirtualMachine::
setDefaultStratum (MAYBE_UNUSED jstring stratum)
{
}

jstring
gnu::classpath::jdwp::VMVirtualMachine::
getSourceDebugExtension (MAYBE_UNUSED jclass klass)
{
  return NULL;
}

jbyteArray
gnu::classpath::jdwp::VMVirtualMachine::
getBytecodes (MAYBE_UNUSED gnu::classpath::jdwp::VMMethod *method)
{
  return NULL;
}

gnu::classpath::jdwp::util::MonitorInfo *
gnu::classpath::jdwp::VMVirtualMachine::
getMonitorInfo (MAYBE_UNUSED jobject obj)
{
  return NULL;
}

jobjectArray
gnu::classpath::jdwp::VMVirtualMachine::
getOwnedMonitors (MAYBE_UNUSED ::java::lang::Thread *thread)
{
  return NULL;
}

jobject
gnu::classpath::jdwp::VMVirtualMachine::
getCurrentContendedMonitor (MAYBE_UNUSED ::java::lang::Thread *thread)
{
  return NULL;
}

void
gnu::classpath::jdwp::VMVirtualMachine::
popFrames (MAYBE_UNUSED ::java::lang::Thread *thread,
	   MAYBE_UNUSED jlong frameId)
{
}

// A simple caching function used while single-stepping
static jvmtiError
get_linetable (jvmtiEnv *env, jmethodID method, jint *count_ptr,
	       jvmtiLineNumberEntry **table_ptr)
{
  static jint last_count = 0;
  static jvmtiLineNumberEntry *last_table = NULL;
  static jmethodID last_method = 0;

  if (method == last_method)
    {
      *count_ptr = last_count;
      *table_ptr = last_table;
      return JVMTI_ERROR_NONE;
    }

  jvmtiError err;
  jint count;
  jvmtiLineNumberEntry *table;
  err = env->GetLineNumberTable (method, &count, &table);
  if (err != JVMTI_ERROR_NONE)
    {
      // Keep last table in cache
      return err;
    }

  env->Deallocate ((unsigned char *) last_table);
  last_table = *table_ptr = table;
  last_count = *count_ptr = count;
  return JVMTI_ERROR_NONE;
}

static gnu::classpath::jdwp::event::filters::StepFilter *
get_request_step_filter (EventRequest *request)
{
  ::java::util::Collection *filters = request->getFilters ();
  ::java::util::Iterator *iter = filters->iterator ();
  filters::StepFilter *filter = NULL;
  while (iter->hasNext ())
    {
      using namespace gnu::classpath::jdwp::event::filters;
      IEventFilter *next = (IEventFilter *) iter->next ();
      if (next->getClass () == &StepFilter::class$)
	{
	  filter = reinterpret_cast<StepFilter *> (next);
	  break;
	}
    }

  return filter;
}

static Location *
get_request_location (EventRequest *request)
{
  Location *loc = NULL;
  ::java::util::Collection *filters = request->getFilters ();
  ::java::util::Iterator *iter = filters->iterator ();
  while (iter->hasNext ())
    {
      using namespace gnu::classpath::jdwp::event::filters;
      IEventFilter *filter = (IEventFilter *) iter->next ();
      if (filter->getClass () == &LocationOnlyFilter::class$)
	{
	  LocationOnlyFilter *lof
	    = reinterpret_cast<LocationOnlyFilter *> (filter);
	  loc = lof->getLocation ();
	}
    }

  return loc;
}

static void
handle_single_step (jvmtiEnv *env, struct step_info *sinfo, jthread thread,
		    jmethodID method, jlocation location)
{
  using namespace gnu::classpath::jdwp;

  if (sinfo == NULL || sinfo->size == JdwpConstants$StepSize::MIN)
    {
      // Stop now
      goto send_notification;
    }
  else
    {
      // Check if we're on a new source line
      /* This is a little inefficient when we're stepping OVER,
	 but this must be done when stepping INTO. */
      jint count;
      jvmtiLineNumberEntry *table;
      if (get_linetable (env, method, &count, &table) == JVMTI_ERROR_NONE)
	{
	  jint i;
	  for (i = 0; i < count; ++i)
	    {
	      if (table[i].start_location == location)
		{
		  // This is the start of a new line -- stop
		  goto send_notification;
		}
	    }

	  // Not at a new source line -- just keep stepping
	  return;
	}
      else
	{
	  /* Something went wrong: either "absent information"
	     or "out of memory" ("invalid method id" and "native
	     method" aren't possible -- those are validated before
	     single stepping is enabled).

	     Do what gdb does: just keep going. */
	  return;
	}
    }

 send_notification:
  jclass klass;
  jvmtiError err = env->GetMethodDeclaringClass (method, &klass);
  if (err != JVMTI_ERROR_NONE)
    {
      fprintf (stderr, "libgcj: internal error: could not find class for method while single stepping -- continuing\n");
      return;
    }

  VMMethod *vmmethod = new VMMethod (klass, reinterpret_cast<jlong> (method));
  Location *loc = new Location (vmmethod, location);
  JvAssert (thread->frame.frame_type == frame_interpreter);
  _Jv_InterpFrame *iframe
    = reinterpret_cast<_Jv_InterpFrame *> (thread->interp_frame);  
  jobject instance = iframe->get_this_ptr ();
  event::SingleStepEvent *event
    = new event::SingleStepEvent (thread, loc, instance);

  // We only want to send the notification (and consequently
  // suspend) if we are not about to execute a breakpoint.
  _Jv_InterpMethod *im = reinterpret_cast<_Jv_InterpMethod *> (iframe->self);
  if (im->breakpoint_at (location))
    {
      // Next insn is a breakpoint -- record event and
      // wait for the JVMTI breakpoint notification to
      // enforce a suspension policy.
      VMVirtualMachine::_event_list->add (event);
    }
  else
    {
      // Next insn is not a breakpoint, so send notification
      // and enforce the suspend policy.
      Jdwp::notify (event);
    }
}

static void
throw_jvmti_error (jvmtiError err)
{
  char *error;
  jstring msg;
  if (_jdwp_jvmtiEnv->GetErrorName (err, &error) == JVMTI_ERROR_NONE)
    {
      msg = JvNewStringLatin1 (error);
      _jdwp_jvmtiEnv->Deallocate ((unsigned char *) error);
    }
  else
    msg = JvNewStringLatin1 ("out of memory");

  using namespace gnu::classpath::jdwp::exception;
  throw new JdwpInternalErrorException (msg);
}

static void JNICALL
jdwpBreakpointCB (jvmtiEnv *env, MAYBE_UNUSED JNIEnv *jni_env,
		  jthread thread, jmethodID method, jlocation location)
{
  jclass klass;
  jvmtiError err;
  err = env->GetMethodDeclaringClass (method, &klass);
  JvAssert (err == JVMTI_ERROR_NONE);

  using namespace gnu::classpath::jdwp;
  using namespace gnu::classpath::jdwp::event;

  jlong methodId = reinterpret_cast<jlong> (method);
  VMMethod *meth = VMVirtualMachine::getClassMethod (klass, methodId);
  Location *loc = new Location (meth, location);
  JvAssert (thread->frame.frame_type == frame_interpreter);
  _Jv_InterpFrame *iframe
    = reinterpret_cast<_Jv_InterpFrame *> (thread->interp_frame);
  jobject instance = iframe->get_this_ptr ();
  BreakpointEvent *event = new BreakpointEvent (thread, loc, instance);
  
  VMVirtualMachine::_event_list->add (event);
  JArray<Event *> *events
    = ((JArray<Event *> *)
       JvNewObjectArray (VMVirtualMachine::_event_list->size (),
			 &Event::class$, NULL));
  VMVirtualMachine::_event_list->toArray ((jobjectArray) events);
  VMVirtualMachine::_event_list->clear ();
  Jdwp::notify (events);
}

static void JNICALL
jdwpClassPrepareCB (MAYBE_UNUSED jvmtiEnv *env, MAYBE_UNUSED JNIEnv *jni_env,
		    jthread thread, jclass klass)
{
  using namespace gnu::classpath::jdwp;

  jint status = VMVirtualMachine::getClassStatus (klass);
  event::ClassPrepareEvent *event
    = new event::ClassPrepareEvent (thread, klass, status);
  Jdwp::notify (event);
}

static void JNICALL
jdwpExceptionCB (jvmtiEnv *env, MAYBE_UNUSED JNIEnv *jni_env, jthread thread,
		 jmethodID method, jlocation location, jobject exception,
		 jmethodID catch_method, jlocation catch_location)
{
  using namespace gnu::classpath::jdwp;
  jclass throw_klass;
  jvmtiError err = env->GetMethodDeclaringClass (method, &throw_klass);
  if (err != JVMTI_ERROR_NONE)
    {
      fprintf (stderr, "libgcj: internal error: could not find class for ");
      fprintf (stderr, "method throwing exception -- continuing\n");
      return;
    }

  VMMethod *vmmethod = new VMMethod (throw_klass,
				     reinterpret_cast<jlong> (method));
  Location *throw_loc = new Location (vmmethod, location);  
  Location *catch_loc = NULL;
  if (catch_method == 0)
    catch_loc = Location::getEmptyLocation ();
  else
    {
      jclass catch_klass;
      err = env->GetMethodDeclaringClass (catch_method, &catch_klass);
      if (err != JVMTI_ERROR_NONE)
	{
	  fprintf (stderr,
		   "libgcj: internal error: could not find class for ");
	  fprintf (stderr,
		   "method catching exception -- ignoring\n");
	}
      else
	{
	  vmmethod = new VMMethod (catch_klass,
				   reinterpret_cast<jlong> (catch_method));
	  catch_loc = new Location (vmmethod, catch_location);
	}
    }

  _Jv_InterpFrame *iframe
    = reinterpret_cast<_Jv_InterpFrame *> (thread->interp_frame);
  jobject instance = (iframe == NULL) ? NULL : iframe->get_this_ptr ();
  Throwable *throwable = reinterpret_cast<Throwable *> (exception);
  event::ExceptionEvent *e = new ExceptionEvent (throwable, thread,
						 throw_loc, catch_loc,
						 throw_klass, instance);
  Jdwp::notify (e);
}

static void JNICALL
jdwpSingleStepCB (jvmtiEnv *env, MAYBE_UNUSED JNIEnv *jni_env, jthread thread,
		  jmethodID method, jlocation location)
{
  jobject si =
    gnu::classpath::jdwp::VMVirtualMachine::_stepping_threads->get (thread);
  struct step_info *sinfo = reinterpret_cast<struct step_info *> (si);

  if (sinfo == NULL)
    {
      // no step filter for this thread - simply report it
      handle_single_step (env, NULL, thread, method, location);
    }
  else
    {
      // A step filter exists for this thread
      using namespace gnu::classpath::jdwp;

      _Jv_InterpFrame *frame
	= reinterpret_cast<_Jv_InterpFrame *> (thread->interp_frame);

      switch (sinfo->depth)
	{
	case JdwpConstants$StepDepth::INTO:
	  /* This is the easy case. We ignore the method and
	     simply stop at either the next insn, or the next source
	     line. */
	  handle_single_step (env, sinfo, thread, method, location);
	  break;

	case JdwpConstants$StepDepth::OVER:
	  /* This is also a pretty easy case. We just make sure that
	     the methods are the same and that we are at the same
	     stack depth, but we should also stop on the next
	     insn/line if the stack depth is LESS THAN it was when
	     we started stepping. */
	  if (method == sinfo->method)
	    {
	      // Still in the same method -- must be at same stack depth
	      // to avoid confusion with recursive methods.
	      if (frame->depth () == sinfo->stack_depth)
		handle_single_step (env, sinfo, thread, method, location);
	    }
	  else if (frame->depth () < sinfo->stack_depth)
	    {
	      // The method in which we were stepping was popped off
	      // the stack. We simply need to stop at the next insn/line.
	      handle_single_step (env, sinfo, thread, method, location);
	    }
	  break;

	case JdwpConstants$StepDepth::OUT:
	  // All we need to do is check the stack depth
	  if (sinfo->stack_depth > frame->depth ())
	    handle_single_step (env, sinfo, thread, method, location);
	  break;

	default:
	  /* This should not happen. The JDWP back-end should have
	     validated the StepFilter. */
	  fprintf (stderr,
		   "libgcj: unknown step depth while single stepping\n");
	  return;
	}
    }
}

static void JNICALL
jdwpThreadEndCB (MAYBE_UNUSED jvmtiEnv *env, MAYBE_UNUSED JNIEnv *jni_env,
		 jthread thread)
{
  using namespace gnu::classpath::jdwp::event;

  ThreadEndEvent *e = new ThreadEndEvent (thread);
  gnu::classpath::jdwp::Jdwp::notify (e);
}

static void JNICALL
jdwpThreadStartCB (MAYBE_UNUSED jvmtiEnv *env, MAYBE_UNUSED JNIEnv *jni_env,
		   jthread thread)
{
  using namespace gnu::classpath::jdwp::event;

  ThreadStartEvent *e = new ThreadStartEvent (thread);
  gnu::classpath::jdwp::Jdwp::notify (e);
}

static void JNICALL
jdwpVMDeathCB (MAYBE_UNUSED jvmtiEnv *env, MAYBE_UNUSED JNIEnv *jni_env)
{
  using namespace gnu::classpath::jdwp::event;
  gnu::classpath::jdwp::Jdwp::notify (new VmDeathEvent ());
}

static void JNICALL
jdwpVMInitCB (MAYBE_UNUSED jvmtiEnv *env, MAYBE_UNUSED JNIEnv *jni_env,
	      jthread thread)
{
  // The VM is now initialized, add our callbacks
  jvmtiEventCallbacks callbacks;
  DEFINE_CALLBACK (callbacks, Breakpoint);
  DEFINE_CALLBACK (callbacks, ClassPrepare);
  DEFINE_CALLBACK (callbacks, Exception);
  DEFINE_CALLBACK (callbacks, SingleStep);
  DEFINE_CALLBACK (callbacks, ThreadEnd);
  DEFINE_CALLBACK (callbacks, ThreadStart);
  DEFINE_CALLBACK (callbacks, VMDeath);
  _jdwp_jvmtiEnv->SetEventCallbacks (&callbacks, sizeof (callbacks));

  // Enable callbacks
  ENABLE_EVENT (BREAKPOINT, NULL);
  ENABLE_EVENT (CLASS_PREPARE, NULL);
  ENABLE_EVENT (EXCEPTION, NULL);
  // SingleStep is enabled only when needed
  ENABLE_EVENT (THREAD_END, NULL);
  ENABLE_EVENT (THREAD_START, NULL);
  ENABLE_EVENT (VM_DEATH, NULL);

  // Send JDWP VMInit
  using namespace gnu::classpath::jdwp::event;
  gnu::classpath::jdwp::Jdwp::notify (new VmInitEvent (thread));
}