Subversion Repositories openrisc

// natFrame.cc -- native support for VMFrame.java

/* 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 <jvm.h>

#include <jvmti.h>

#include "jvmti-int.h"

#include <java-interp.h>

#include <gnu/classpath/jdwp/VMFrame.h>

#include <gnu/classpath/jdwp/VMVirtualMachine.h>

#include <gnu/classpath/jdwp/exception/InvalidFrameException.h>

#include <gnu/classpath/jdwp/exception/InvalidSlotException.h>

#include <gnu/classpath/jdwp/exception/InvalidThreadException.h>

#include <gnu/classpath/jdwp/exception/JdwpInternalErrorException.h>

#include <gnu/classpath/jdwp/exception/TypeMismatchException.h>

#include <gnu/classpath/jdwp/util/NullObject.h>

#include <gnu/classpath/jdwp/value/ArrayValue.h>

#include <gnu/classpath/jdwp/value/ByteValue.h>

#include <gnu/classpath/jdwp/value/BooleanValue.h>

#include <gnu/classpath/jdwp/value/CharValue.h>

#include <gnu/classpath/jdwp/value/DoubleValue.h>

#include <gnu/classpath/jdwp/value/FloatValue.h>

#include <gnu/classpath/jdwp/value/IntValue.h>

#include <gnu/classpath/jdwp/value/LongValue.h>

#include <gnu/classpath/jdwp/value/ObjectValue.h>

#include <gnu/classpath/jdwp/value/ShortValue.h>

#include <gnu/classpath/jdwp/value/Value.h>

#include <gnu/classpath/jdwp/value/VoidValue.h>

using namespace java::lang;

using namespace gnu::classpath::jdwp;

using namespace gnu::classpath::jdwp::exception;

// All the jvmti GetLocalXX and SetLocalXX functions return the same potential

// errors, so this function handles them all and throws the appropriate JDWP

// exception.

static void

checkJVMTIError (jvmtiEnv *env, jthread thread, jvmtiError jerr, jint slot,

                 jbyte sig)

{

  if (jerr != JVMTI_ERROR_NONE)

    {

      char *error;

      env->GetErrorName (jerr, &error);

      String *msg = reinterpret_cast<String *> (JvNewStringUTF (error));

      env->Deallocate ((unsigned char *) error);

      if (jerr == JVMTI_ERROR_INVALID_THREAD)

        throw new InvalidThreadException ((jlong) thread);

      else if (jerr == JVMTI_ERROR_NO_MORE_FRAMES)

        throw new InvalidFrameException (msg);

      else if (jerr == JVMTI_ERROR_INVALID_SLOT)

        throw new InvalidSlotException (slot);

      else if (jerr == JVMTI_ERROR_TYPE_MISMATCH)

        throw new TypeMismatchException (sig);

      else

        throw new JdwpInternalErrorException (msg);

    }

}

static jobject

getObjectJVMTI (jvmtiEnv *env, jthread thread, jint slot, jint depth, jbyte sig)

{

  jobject value;

  jvmtiError jerr = env->GetLocalObject (thread, depth, slot, &value);

  checkJVMTIError (env, thread, jerr, slot, sig);

  return value;

}

static void

setObjectJVMTI (jvmtiEnv *env, jthread thread, jint slot, jint depth,

                jbyte sig, jobject value)

{

  if (value->getClass ()->isAssignableFrom (&util::NullObject::class$))

    value = NULL;

  jvmtiError jerr = env->SetLocalObject (thread, depth, slot, value);

  checkJVMTIError (env, thread, jerr, slot, sig);

}

static jint

getIntJVMTI (jvmtiEnv *env, jthread thread, jint slot, jint depth, jbyte sig)

{

  jint value;

  jvmtiError jerr = env->GetLocalInt (thread, depth, slot, &value);

  checkJVMTIError (env, thread, jerr, slot, sig);

  return value;

}

static void

setIntJVMTI (jvmtiEnv *env, jthread thread, jint slot, jint depth, jbyte sig,

             jint value)

{

  jvmtiError jerr = env->SetLocalInt (thread, depth, slot, value);

  checkJVMTIError (env, thread, jerr, slot, sig);

}

static jlong

getLongJVMTI (jvmtiEnv *env, jthread thread, jint slot, jint depth, jbyte sig)

{

  jlong value;

  jvmtiError jerr = env->GetLocalLong (thread, depth, slot, &value);

  checkJVMTIError (env, thread, jerr, slot, sig);

  return value;

}

static void

setLongJVMTI (jvmtiEnv *env, jthread thread, jint slot, jint depth, jbyte sig,

              jlong value)

{

  jvmtiError jerr = env->SetLocalLong (thread, depth, slot, value);

  checkJVMTIError (env, thread, jerr, slot, sig);

}

static jfloat

getFloatJVMTI (jvmtiEnv *env, jthread thread, jint slot, jint depth, jbyte sig)

{

  jfloat value;

  jvmtiError jerr = env->GetLocalFloat (thread, depth, slot, &value);

  checkJVMTIError (env, thread, jerr, slot, sig);

  return value;

}

static void

setFloatJVMTI (jvmtiEnv *env, jthread thread, jint slot, jint depth, jbyte sig,

               jfloat value)

{

  jvmtiError jerr = env->SetLocalFloat (thread, depth, slot, value);

  checkJVMTIError (env, thread, jerr, slot, sig);

}

static jdouble

getDoubleJVMTI (jvmtiEnv *env, jthread thread, jint slot, jint depth,

                jbyte sig)

{

  jdouble value;

  jvmtiError jerr = env->GetLocalDouble (thread, depth, slot, &value);

  checkJVMTIError (env, thread, jerr, slot, sig);

  return value;

}

static void

setDoubleJVMTI (jvmtiEnv *env, jthread thread, jint slot, jint depth,

                jbyte sig, jdouble value)

{

  jvmtiError jerr = env->SetLocalDouble (thread, depth, slot, value);

  checkJVMTIError (env, thread, jerr, slot, sig);

}

// This is necessary since JVMTI requires a stack depth as a parameter in all

// its local variable functions.  Since JDWP needs frameids, we have to run

// through the call stack to translate these ids into the parameters JVMTI

// wants.

static jint

getFrameDepth (_Jv_Frame *frame)

{

  jint depth = 0;

  _Jv_Frame *top_frame = (_Jv_Frame *) frame->thread->frame;

  jint num_frames = VMVirtualMachine::getFrameCount (frame->thread);

  while (frame != top_frame)

    {

      top_frame = top_frame->next;

      depth++;

      if (depth >= num_frames || top_frame == NULL)

        throw new InvalidFrameException ((jlong) frame);

    }

  return depth;

}

using namespace gnu::classpath::jdwp::value;

Value *

gnu::classpath::jdwp::VMFrame::getValue (jint slot, jbyte sig)

{

  _Jv_Frame *frame = reinterpret_cast<_Jv_Frame *> (id);

  jint depth = getFrameDepth (frame);

  jthread thread = reinterpret_cast<jthread> (frame->thread);

  jvmtiEnv *env = _Jv_GetJDWP_JVMTIEnv ();

  Value *value = NULL;

  switch (sig)

    {

    case 'B':

      value = new ByteValue ((jbyte) getIntJVMTI (env, thread, slot, depth,

                                                  sig));

      break;

    case 'Z':

      value = new BooleanValue ((jboolean) getIntJVMTI (env, thread, slot,

                                                        depth, sig));

      break;

    case 'C':

      value = new CharValue ((jchar) getIntJVMTI (env, thread, slot, depth,

                                                  sig));

      break;

    case 'S':

      value = new ShortValue ((jshort) getIntJVMTI (env, thread, slot, depth,

                                                    sig));

      break;

    case 'I':

      value = new IntValue (getIntJVMTI (env, thread, slot, depth, sig));

      break;

    case 'J':

      value = new LongValue (getLongJVMTI (env, thread, slot, depth, sig));

      break;

    case 'F':

      value = new FloatValue (getFloatJVMTI (env, thread, slot, depth, sig));

      break;

    case 'D':

      value = new DoubleValue (getDoubleJVMTI (env, thread, slot, depth, sig));

      break;

    case 'V':

      value = new VoidValue ();

      break;

    case '[':

      {

        Object *obj = getObjectJVMTI (env, thread, slot, depth, sig);

        if (obj == NULL)

          obj = new util::NullObject ();

        value = new ArrayValue (obj);

        break;

      }

    default:

      Object *obj = getObjectJVMTI (env, thread, slot, depth, sig);

      if (obj == NULL)

        obj = new util::NullObject ();

      value = new ObjectValue (obj);

      break;

    }

  return value;

}

void

gnu::classpath::jdwp::VMFrame::setValue (jint slot, Value* value)

{

  jbyte sig = value->getTag ();

  _Jv_Frame *frame = reinterpret_cast<_Jv_Frame *> (id);

  jint depth = getFrameDepth (frame);

  jthread thread = reinterpret_cast<jthread> (frame->thread);

  jvmtiEnv *env = _Jv_GetJDWP_JVMTIEnv ();

  switch (sig)

    {

    case 'B':

      {

        ByteValue *val = reinterpret_cast<ByteValue *> (value);

        setIntJVMTI (env, thread, slot, depth, sig, (jint) val->getValue ());

        break;

      }

    case 'Z':

      {

        BooleanValue *val = reinterpret_cast<BooleanValue *> (value);

        setIntJVMTI (env, thread, slot, depth, sig, (jint) val->getValue ());

        break;

      }

    case 'C':

      {

        CharValue *val = reinterpret_cast<CharValue *> (value);

        setIntJVMTI (env, thread, slot, depth, sig, (jint) val->getValue ());

        break;

      }

    case 'S':

      {

        ShortValue *val = reinterpret_cast<ShortValue *> (value);

        setIntJVMTI (env, thread, slot, depth, sig, (jint) val->getValue ());

        break;

      }

    case 'I':

      {

        IntValue *val = reinterpret_cast<IntValue *> (value);

        setIntJVMTI (env, thread, slot, depth, sig, val->getValue ());

        break;

      }

    case 'J':

      {

        LongValue *val = reinterpret_cast<LongValue *> (value);

        setLongJVMTI (env, thread, slot, depth, sig, val->getValue ());

        break;

      }

    case 'F':

      {

        FloatValue *val = reinterpret_cast<FloatValue *> (value);

        setFloatJVMTI (env, thread, slot, depth, sig, val->getValue ());

        break;

      }

    case 'D':

      {

        DoubleValue *val = reinterpret_cast<DoubleValue *> (value);

        setDoubleJVMTI (env, thread, slot, depth, sig, val->getValue ());

        break;

      }

    case 'V':

      break;

    case '[':

      {

        ArrayValue *val = reinterpret_cast<ArrayValue *> (value);

        setObjectJVMTI (env, thread, slot, depth, sig, val->getObject ());

        break;

      }

    default:

      {

        ObjectValue *val = reinterpret_cast<ObjectValue *> (value);

        setObjectJVMTI (env, thread, slot, depth, sig, val->getObject());

        break;

      }

    }

}