public jobject NewObject(jclass @class, jmethodID ctorMethodId, params jvalue[] args)
{
jobject result = RawInterface.NewObjectA(this, @class, ctorMethodId, args);
HandleException();
return(result);
}
public int GetArrayLength(jobject arrayHandle)
{
int result = RawInterface.GetArrayLength(this, arrayHandle);
HandleException();
return(result);
}
public int GetStringUTFLength(jobject stringHandle)
{
int result = RawInterface.GetStringUTFLength(this, stringHandle);
HandleException();
return(result);
}
public bool IsSameObject(jobject x, jobject y)
{
byte result = RawInterface.IsSameObject(this, x, y);
HandleException();
return(result != 0);
}
public jweak NewWeakGlobalReference(jobject @object)
{
jweak result = RawInterface.NewWeakGlobalRef(this, @object);
HandleException();
return(result);
}
public jobject NewLocalReference(jobject @object)
{
jobject result = RawInterface.NewLocalRef(this, @object);
HandleException();
return(result);
}
internal bool GetBooleanField(jobject objectHandle, jfieldID fieldId)
{
var result = RawInterface.GetBooleanField(this, objectHandle, fieldId) != 0;
HandleException();
return(result);
}
internal double GetDoubleField(jobject objectHandle, jfieldID fieldId)
{
var result = RawInterface.GetDoubleField(this, objectHandle, fieldId);
HandleException();
return(result);
}
public jobject NewString(string value)
{
if (value == null)
{
return(jobject.Null);
}
jobject result = RawInterface.NewString(this, value, value.Length);
HandleException();
return(result);
}
internal void HandleVMInit(JvmtiEnvironment environment, JniEnvironment nativeEnvironment, jthread thread)
{
jclass threadClass = nativeEnvironment.GetObjectClass(thread);
_threadClass = FindBaseClass(environment, nativeEnvironment, threadClass, "Ljava/lang/Thread;");
{
jclass classClass = nativeEnvironment.GetObjectClass(threadClass);
_classClass = FindBaseClass(environment, nativeEnvironment, classClass, "Ljava/lang/Class;");
nativeEnvironment.DeleteLocalReference(classClass);
}
{
jvmtiThreadInfo threadInfo;
JvmtiErrorHandler.ThrowOnFailure(environment.GetThreadInfo(thread, out threadInfo));
jclass threadGroupClass = nativeEnvironment.GetObjectClass(threadInfo._threadGroup);
_threadGroupClass = FindBaseClass(environment, nativeEnvironment, threadGroupClass, "Ljava/lang/ThreadGroup;");
jclass classLoaderClass = nativeEnvironment.GetObjectClass(threadInfo._contextClassLoader);
_classLoaderClass = FindBaseClass(environment, nativeEnvironment, classLoaderClass, "Ljava/lang/ClassLoader;");
nativeEnvironment.DeleteLocalReference(classLoaderClass);
nativeEnvironment.DeleteLocalReference(threadGroupClass);
nativeEnvironment.DeleteLocalReference(threadInfo._contextClassLoader);
nativeEnvironment.DeleteLocalReference(threadInfo._threadGroup);
environment.Deallocate(threadInfo._name);
}
nativeEnvironment.DeleteLocalReference(threadClass);
jobject stringObject = nativeEnvironment.NewString(string.Empty);
jclass stringClass = nativeEnvironment.GetObjectClass(stringObject);
_stringClass = FindBaseClass(environment, nativeEnvironment, stringClass, "Ljava/lang/String;");
nativeEnvironment.DeleteLocalReference(stringObject);
nativeEnvironment.DeleteLocalReference(stringClass);
}
public jvmtiError TagClassLoader(jobject classLoaderHandle, out long tag)
{
if (classLoaderHandle == jobject.Null)
{
tag = 0;
return(jvmtiError.None);
}
var error = GetTag(classLoaderHandle, out tag);
if (error != jvmtiError.None)
{
return(error);
}
if (tag != 0)
{
return(jvmtiError.None);
}
tag = Interlocked.Increment(ref _nextClassLoaderTag);
error = SetTag(classLoaderHandle, tag);
return(error);
}
public jvmtiError GetLocalObject(jthread thread, int depth, int slot, out jobject value)
{
return(RawInterface.GetLocalObject(this, thread, depth, slot, out value));
}
public jvmtiError GetTag(jobject objectHandle, out long tag)
{
return(RawInterface.GetTag(this, objectHandle, out tag));
}
internal jvmtiError AddGlobalReference(JvmtiEnvironment environment, JniEnvironment nativeEnvironment, jobject obj)
{
long tag;
jvmtiError error = environment.GetTag(obj, out tag);
if (error != jvmtiError.None)
{
return(error);
}
if (tag == 0)
{
return(jvmtiError.IllegalArgument);
}
_globalReferences.AddOrUpdate(tag,
t =>
{
return(Tuple.Create(nativeEnvironment.NewGlobalReference(obj), 1));
},
(t, v) =>
{
if (v.Item2 == 0)
{
return(Tuple.Create(nativeEnvironment.NewGlobalReference(obj), 1));
}
else
{
return(Tuple.Create(v.Item1, v.Item2 + 1));
}
});
return(jvmtiError.None);
}
internal jvmtiError RemoveGlobalReference(JvmtiEnvironment environment, JniEnvironment nativeEnvironment, jobject obj)
{
long tag;
jvmtiError error = environment.GetTag(obj, out tag);
if (error != jvmtiError.None)
{
return(error);
}
if (tag == 0)
{
return(jvmtiError.IllegalArgument);
}
var result = _globalReferences.AddOrUpdate(tag,
t =>
{
return(Tuple.Create(jobject.Null, 0));
},
(t, v) =>
{
if (v.Item2 == 0)
{
return(Tuple.Create(jobject.Null, 0));
}
else if (v.Item2 == 1)
{
nativeEnvironment.DeleteGlobalReference(v.Item1);
return(Tuple.Create(jobject.Null, 0));
}
else
{
return(Tuple.Create(v.Item1, v.Item2 - 1));
}
});
return(jvmtiError.None);
}
internal TaggedObjectId TrackLocalObjectReference(jobject @object, JvmtiEnvironment environment, JniEnvironment nativeEnvironment, bool freeLocalReference)
{
if (@object == jobject.Null)
{
return(new TaggedObjectId(Tag.Object, new ObjectId(0), default(TaggedReferenceTypeId)));
}
long tag;
JvmtiErrorHandler.ThrowOnFailure(environment.GetTag(@object, out tag));
TaggedReferenceTypeId type = default(TaggedReferenceTypeId);
Tag objectKind;
if (tag == 0)
{
long uniqueTag = Interlocked.Increment(ref _nextTag);
/* first figure out what type of object we're dealing with. could be:
* - String
* - Thread
* - ThreadGroup
* - ClassLoader
* - ClassObject
* - Array
* - Object
*/
// check for array
jclass objectClass = nativeEnvironment.GetObjectClass(@object);
try
{
type = TrackLocalClassReference(objectClass, environment, nativeEnvironment, false);
bool isArray = type.TypeTag == TypeTag.Array;
if (isArray)
{
objectKind = Tag.Array;
}
else
{
if (_stringClass != jclass.Null && nativeEnvironment.IsInstanceOf(@object, _stringClass))
{
objectKind = Tag.String;
}
else if (_threadClass != jclass.Null && nativeEnvironment.IsInstanceOf(@object, _threadClass))
{
objectKind = Tag.Thread;
}
else if (_threadGroupClass != jclass.Null && nativeEnvironment.IsInstanceOf(@object, _threadGroupClass))
{
objectKind = Tag.ThreadGroup;
}
else if (_classClass != jclass.Null && nativeEnvironment.IsInstanceOf(@object, _classClass))
{
objectKind = Tag.ClassObject;
}
else if (_classLoaderClass != jclass.Null && nativeEnvironment.IsInstanceOf(@object, _classLoaderClass))
{
objectKind = Tag.ClassLoader;
}
else
{
objectKind = Tag.Object;
}
}
}
finally
{
nativeEnvironment.DeleteLocalReference(objectClass);
}
tag = (uniqueTag << 8) | (uint)objectKind;
JvmtiErrorHandler.ThrowOnFailure(environment.SetTag(@object, tag));
lock (_objects)
{
_objects.Add(new ObjectId(tag), nativeEnvironment.NewWeakGlobalReference(@object));
}
}
else
{
jclass objectClass = nativeEnvironment.GetObjectClass(@object);
type = TrackLocalClassReference(objectClass, environment, nativeEnvironment, true);
}
if (freeLocalReference)
{
nativeEnvironment.DeleteLocalReference(@object);
}
objectKind = (Tag)(tag & 0xFF);
return(new TaggedObjectId(objectKind, new ObjectId(tag), type));
}
public void DeleteGlobalReference(jobject @object)
{
RawInterface.DeleteGlobalRef(this, @object);
HandleException();
}
internal void GetShortArrayRegion(jobject arrayHandle, int start, int len, short[] buf)
{
RawInterface.GetShortArrayRegion(this, arrayHandle, start, len, buf);
HandleException();
}
internal void GetDoubleArrayRegion(jobject arrayHandle, int start, int len, double[] buf)
{
RawInterface.GetDoubleArrayRegion(this, arrayHandle, start, len, buf);
HandleException();
}
public void GetStringUTFRegion(jobject stringHandle, int start, int length, byte[] buffer)
{
RawInterface.GetStringUTFRegion(this, stringHandle, start, length, buffer);
HandleException();
}
public jvmtiError GetClassLoader(jclass @class, out jobject classLoader)
{
return(RawInterface.GetClassLoader(this, @class, out classLoader));
}
public jvmtiError SetTag(jobject objectHandle, long tag)
{
return(RawInterface.SetTag(this, objectHandle, tag));
}
internal void CallNonvirtualVoidMethodA(jobject instanceHandle, jclass classHandle, jmethodID methodId, params jvalue[] args)
{
RawInterface.CallNonvirtualVoidMethodA(this, instanceHandle, classHandle, methodId, args);
HandleException();
}
internal void GetBooleanArrayRegion(jobject arrayHandle, int start, int len, bool[] buf)
{
RawInterface.GetBooleanArrayRegion(this, arrayHandle, start, len, buf);
HandleException();
}
public jvmtiError GetObjectHashCode(jobject obj, out int result)
{
return(RawInterface.GetObjectHashCode(this, obj, out result));
}
public jvalue(JavaVM virtualMachine, JvmtiEnvironment environment, JniEnvironment nativeEnvironment, Value value)
: this()
{
if (value.Data == 0)
{
return;
}
switch (value.Tag)
{
case Tag.Byte:
ByteValue = (byte)value.Data;
break;
case Tag.Char:
CharValue = (char)value.Data;
break;
case Tag.Float:
IntValue = (int)(uint)value.Data;
break;
case Tag.Int:
IntValue = (int)value.Data;
break;
case Tag.Double:
LongValue = (long)(ulong)value.Data;
break;
case Tag.Long:
LongValue = value.Data;
break;
case Tag.Short:
ShortValue = (short)value.Data;
break;
case Tag.Boolean:
break;
case Tag.Array:
case Tag.Object:
case Tag.String:
case Tag.Thread:
case Tag.ThreadGroup:
case Tag.ClassLoader:
case Tag.ClassObject:
if (value.Data == 0)
{
return;
}
ObjectValue = virtualMachine.GetLocalReferenceForObject(nativeEnvironment, new ObjectId(value.Data)).Value;
break;
case Tag.Void:
case Tag.Invalid:
default:
throw new ArgumentException();
}
}
