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(); } }