private static jthread alloc_thread(JNIEnvHandle jniEnv) { jniNativeInterface nativeInterface = (jniNativeInterface)Marshal.PtrToStructure(Marshal.ReadIntPtr(jniEnv.Handle), typeof(jniNativeInterface)); jclass @class = nativeInterface.FindClass(jniEnv, "java/lang/Thread"); if (@class == jclass.Null) { throw new Exception("ERROR: JNI: Cannot find %s with FindClass."); } nativeInterface.ExceptionClear(jniEnv); jmethodID method = nativeInterface.GetMethodID(jniEnv, @class, "<init>", "()V"); if (method == jmethodID.Null) { throw new Exception("Cannot find Thread constructor method."); } nativeInterface.ExceptionClear(jniEnv); jthread result = (jthread)nativeInterface.NewObject(jniEnv, @class, method); if (result == jthread.Null) { throw new Exception("Cannot create new Thread object"); } nativeInterface.ExceptionClear(jniEnv); return(result); }
public JNIResult CallVoidMethodA(jobject* obj, jmethodID* methodID, params jvalue[] args) { if (callVoidMethodA == null) { Util.GetDelegateForFunctionPointer(functions.CallVoidMethodA, ref callVoidMethodA); } return callVoidMethodA(real, obj, methodID, args); }
private void HandleCompiledMethodUnload(jvmtiEnvHandle env, jmethodID methodId, IntPtr codeAddress) { JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); JvmMethod method = new JvmMethod(environment, methodId); foreach (var processor in _processors) { processor.HandleCompiledMethodUnload(environment, method, codeAddress); } }
private void HandleCompiledMethodLoad(jvmtiEnvHandle env, jmethodID method, int codeSize, IntPtr codeAddress, int mapLength, jvmtiAddressLocationMap[] map, IntPtr compileInfo) { JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); foreach (var processor in _processors) { throw new NotImplementedException(); //processor.HandleCompiledMethodLoad(environment, method, codeSize, codeAddress, map2, compileInfo); } }
static PrintStream() { var setup = JNetHost.Run(runtime => { var clz_PrintStream = runtime.FindClass("java/io/PrintStream"); var mid_println_A = runtime.GetMethodID(clz_PrintStream, "println", "(Ljava/lang/String;)V"); clz_PrintStream = (jclass)runtime.NewGlobalRef(clz_PrintStream); return(clz_PrintStream, mid_println_A); }); clz_PrintStream = setup.clz_PrintStream; mid_println_A = setup.mid_println_A; }
static System() { var setup = JNetHost.Run(runtime => { var clz_System = runtime.FindClass("java/lang/System"); var fid_out = runtime.GetStaticFieldID(clz_System, "out", "Ljava/io/PrintStream;"); var mid_getProperty = runtime.GetStaticMethodID(clz_System, "getProperty", "(Ljava/lang/String;)Ljava/lang/String;"); clz_System = (jclass)runtime.NewGlobalRef(clz_System); return(clz_System, fid_out, mid_getProperty); }); clz_System = setup.clz_System; fid_out = setup.fid_out; mid_getProperty = setup.mid_getProperty; }
public override bool ProcessEvent(JvmtiEnvironment environment, JniEnvironment nativeEnvironment, EventProcessor processor, ThreadId thread, TaggedReferenceTypeId @class, Location?location) { if (!base.ProcessEvent(environment, nativeEnvironment, processor, thread, @class, location)) { return(false); } // Step Out is implemented with Frame Pop events set at the correct depth if (_depth == StepDepth.Out) { if (location.HasValue && !location.Value.Method.Equals(_lastMethod)) { _lastLocation = new jlocation((long)location.Value.Index); _lastMethod = location.Value.Method; UpdateLastLine(environment); } return(true); } using (var threadHandle = environment.VirtualMachine.GetLocalReferenceForThread(nativeEnvironment, thread)) { int stackDepth; JvmtiErrorHandler.ThrowOnFailure(environment.GetFrameCount(threadHandle.Value, out stackDepth)); if (_hasMethodInfo && stackDepth > _stackDepth) { bool convertToFramePop; if (location.HasValue && (!_convertedToFramePop || !_framePopMethod.Equals(location.Value.Method)) && ShouldSkipCurrentMethod(processor.VirtualMachine, environment, nativeEnvironment, threadHandle.Value, stackDepth, location.Value, out convertToFramePop)) { if (convertToFramePop) { // remove the single step event JvmtiErrorHandler.ThrowOnFailure((jvmtiError)processor.ClearEventInternal(EventKind.FramePop, this.RequestId)); JvmtiErrorHandler.ThrowOnFailure((jvmtiError)processor.ClearEventInternal(EventKind.SingleStep, this.RequestId)); // set an actual step filter to respond when the thread arrives back in this frame JvmtiErrorHandler.ThrowOnFailure((jvmtiError)processor.SetEventInternal(environment, nativeEnvironment, EventKind.FramePop, this)); _convertedToFramePop = true; _framePopMethod = location.Value.Method; } return(false); } else { _convertedToFramePop = false; return(true); } } else if (stackDepth == _stackDepth) { if (_size == StepSize.Statement && _disassembledMethod != null) { int instructionIndex = _disassembledMethod.Instructions.FindIndex(i => (uint)i.Offset == location.Value.Index); if (instructionIndex >= 0 && _evaluationStackDepths != null && (_evaluationStackDepths[instructionIndex] ?? 0) != 0) { return(false); } else if (instructionIndex >= 0 && _disassembledMethod.Instructions[instructionIndex].OpCode.FlowControl == JavaFlowControl.Branch) { // follow branch instructions before stopping return(false); } } else if (_lastLine != null) { // see if we're on the same line LineNumberData[] lines; jvmtiError error = environment.GetLineNumberTable(location.Value.Method, out lines); if (error == jvmtiError.None) { LineNumberData entry = lines.LastOrDefault(i => i.LineCodeIndex <= (long)location.Value.Index); if (entry.LineNumber == _lastLine) { return(false); } } } } if (location.HasValue) { _lastLocation = new jlocation((long)location.Value.Index); _lastMethod = location.Value.Method; UpdateLastLine(environment); } _stackDepth = stackDepth; return(true); } }
internal JvmMethodRemoteHandle(jmethodID method) { Handle = method.Handle.ToInt64(); }
private void HandleFieldModification(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jmethodID method, jlocation jlocation, jclass fieldClassHandle, jobject @objectHandle, jfieldID fieldId, byte signatureType, jvalue newValue) { JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); JvmThreadReference thread = JvmThreadReference.FromHandle(environment, jniEnv, threadHandle, true); JvmLocation location = new JvmLocation(environment, method, jlocation); JvmClassReference fieldClass = JvmClassReference.FromHandle(environment, jniEnv, fieldClassHandle, true); JvmObjectReference @object = JvmObjectReference.FromHandle(environment, jniEnv, objectHandle, true); JvmField field = new JvmField(environment, fieldId); foreach (var processor in _processors) { processor.HandleFieldModification(environment, thread, location, fieldClass, @object, field, signatureType, newValue); } }
private void HandleSingleStep(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jmethodID methodId, jlocation jlocation) { JvmtiEnvironment environment = JvmtiEnvironment.GetOrCreateInstance(_service.VirtualMachine, env); JniEnvironment nativeEnvironment = JniEnvironment.GetOrCreateInstance(jniEnv); ThreadId threadId = VirtualMachine.TrackLocalThreadReference(threadHandle, environment, nativeEnvironment, false); TaggedReferenceTypeId declaringClass; MethodId method = new MethodId(methodId.Handle); ulong index = (ulong)jlocation.Value; JvmtiErrorHandler.ThrowOnFailure(environment.GetMethodDeclaringClass(nativeEnvironment, method, out declaringClass)); Location location = new Location(declaringClass, method, index); EventFilter[] filters = GetEventFilters(EventKind.SingleStep); foreach (var filter in filters) { if (filter.ProcessEvent(environment, nativeEnvironment, this, threadId, default(TaggedReferenceTypeId), location)) { SendSingleStepEvent(environment, filter, threadId, location); } } }
private void HandleExceptionCatch(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jmethodID method, jlocation jlocation, jobject exceptionHandle) { JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); JvmThreadReference thread = JvmThreadReference.FromHandle(environment, jniEnv, threadHandle, true); JvmLocation location = new JvmLocation(environment, method, jlocation); JvmObjectReference exception = JvmObjectReference.FromHandle(environment, jniEnv, exceptionHandle, true); foreach (var processor in _processors) { processor.HandleExceptionCatch(environment, thread, location, exception); } }
internal JvmMethod(JvmEnvironment environment, jmethodID methodId) { _environment = environment; _methodId = methodId; }
private void HandleMethodExit(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jmethodID methodId, bool wasPoppedByException, jvalue returnValue) { JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); JvmThreadReference thread = JvmThreadReference.FromHandle(environment, jniEnv, threadHandle, true); JvmMethod method = new JvmMethod(environment, methodId); foreach (var processor in _processors) { processor.HandleMethodExit(environment, thread, method, wasPoppedByException, returnValue); } }
private void HandleBreakpoint(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jmethodID methodId, jlocation jlocation) { if (!VirtualMachine.IsAgentThread.Value) { // ignore events before VMInit if (AgentEventDispatcher == null) return; // dispatch this call to an agent thread Action<jvmtiEnvHandle, JNIEnvHandle, jthread, jmethodID, jlocation> invokeMethod = HandleBreakpoint; AgentEventDispatcher.Invoke(invokeMethod, env, jniEnv, threadHandle, methodId, jlocation); return; } JvmtiEnvironment environment = JvmtiEnvironment.GetOrCreateInstance(_service.VirtualMachine, env); JniEnvironment nativeEnvironment; JniErrorHandler.ThrowOnFailure(VirtualMachine.AttachCurrentThreadAsDaemon(environment, out nativeEnvironment, false)); ThreadId threadId = VirtualMachine.TrackLocalThreadReference(threadHandle, environment, nativeEnvironment, false); TaggedReferenceTypeId declaringClass; MethodId method = new MethodId(methodId.Handle); ulong index = (ulong)jlocation.Value; JvmtiErrorHandler.ThrowOnFailure(environment.GetMethodDeclaringClass(nativeEnvironment, method, out declaringClass)); Location location = new Location(declaringClass, method, index); EventFilter[] filters = GetEventFilters(EventKind.Breakpoint); foreach (var filter in filters) { if (filter.ProcessEvent(environment, nativeEnvironment, this, threadId, default(TaggedReferenceTypeId), location)) { ApplySuspendPolicy(environment, nativeEnvironment, filter.SuspendPolicy, threadId); Callback.Breakpoint(filter.SuspendPolicy, filter.RequestId, threadId, location); } } }
private void HandleMethodExit(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jmethodID methodId, bool wasPoppedByException, jvalue returnValue) { if (!VirtualMachine.IsAgentThread.Value) { // ignore events before VMInit if (AgentEventDispatcher == null) return; // dispatch this call to an agent thread Action<jvmtiEnvHandle, JNIEnvHandle, jthread, jmethodID, bool, jvalue> method = HandleMethodExit; AgentEventDispatcher.Invoke(method, env, jniEnv, threadHandle, methodId, wasPoppedByException, returnValue); return; } //JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); //JvmThreadReference thread = JvmThreadReference.FromHandle(environment, jniEnv, threadHandle, true); //JvmMethod method = new JvmMethod(environment, methodId); //foreach (var processor in _processors) //{ // processor.HandleMethodExit(environment, thread, method, wasPoppedByException, returnValue); //} }
public override bool ProcessEvent(JvmtiEnvironment environment, JniEnvironment nativeEnvironment, EventProcessor processor, ThreadId thread, TaggedReferenceTypeId @class, Location? location) { if (!base.ProcessEvent(environment, nativeEnvironment, processor, thread, @class, location)) return false; // Step Out is implemented with Frame Pop events set at the correct depth if (_depth == StepDepth.Out) { if (location.HasValue && !location.Value.Method.Equals(_lastMethod)) { _lastLocation = new jlocation((long)location.Value.Index); _lastMethod = location.Value.Method; UpdateLastLine(environment); } return true; } using (var threadHandle = environment.VirtualMachine.GetLocalReferenceForThread(nativeEnvironment, thread)) { int stackDepth; JvmtiErrorHandler.ThrowOnFailure(environment.GetFrameCount(threadHandle.Value, out stackDepth)); if (_hasMethodInfo && stackDepth > _stackDepth) { bool convertToFramePop; if (location.HasValue && (!_convertedToFramePop || !_framePopMethod.Equals(location.Value.Method)) && ShouldSkipCurrentMethod(processor.VirtualMachine, environment, nativeEnvironment, threadHandle.Value, stackDepth, location.Value, out convertToFramePop)) { if (convertToFramePop) { // remove the single step event JvmtiErrorHandler.ThrowOnFailure((jvmtiError)processor.ClearEventInternal(EventKind.FramePop, this.RequestId)); JvmtiErrorHandler.ThrowOnFailure((jvmtiError)processor.ClearEventInternal(EventKind.SingleStep, this.RequestId)); // set an actual step filter to respond when the thread arrives back in this frame JvmtiErrorHandler.ThrowOnFailure((jvmtiError)processor.SetEventInternal(environment, nativeEnvironment, EventKind.FramePop, this)); _convertedToFramePop = true; _framePopMethod = location.Value.Method; } return false; } else { _convertedToFramePop = false; return true; } } else if (stackDepth == _stackDepth) { if (_size == StepSize.Statement && _disassembledMethod != null) { int instructionIndex = _disassembledMethod.Instructions.FindIndex(i => (uint)i.Offset == location.Value.Index); if (instructionIndex >= 0 && _evaluationStackDepths != null && (_evaluationStackDepths[instructionIndex] ?? 0) != 0) { return false; } else if (instructionIndex >= 0 && _disassembledMethod.Instructions[instructionIndex].OpCode.FlowControl == JavaFlowControl.Branch) { // follow branch instructions before stopping return false; } } else if (_lastLine != null) { // see if we're on the same line LineNumberData[] lines; jvmtiError error = environment.GetLineNumberTable(location.Value.Method, out lines); if (error == jvmtiError.None) { LineNumberData entry = lines.LastOrDefault(i => i.LineCodeIndex <= (long)location.Value.Index); if (entry.LineNumber == _lastLine) return false; } } } if (location.HasValue) { _lastLocation = new jlocation((long)location.Value.Index); _lastMethod = location.Value.Method; UpdateLastLine(environment); } _stackDepth = stackDepth; return true; } }
public jobject NewObject(jclass @class, jmethodID ctorMethodId, params jvalue[] args) { jobject result = RawInterface.NewObjectA(this, @class, ctorMethodId, args); HandleException(); return result; }
internal jvmtiError ClearBreakpoint(jmethodID methodId, jlocation location) { return RawInterface.ClearBreakpoint(this, methodId, location); }
public jvmtiError GetFrameLocation(jthread thread, int depth, out jmethodID method, out jlocation location) { return RawInterface.GetFrameLocation(this, thread, depth, out method, out location); }
private void HandleMethodEntry(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jmethodID methodId) { JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); JvmThreadReference thread = JvmThreadReference.FromHandle(environment, jniEnv, threadHandle, true); JvmMethod method = new JvmMethod(environment, methodId); foreach (var processor in _processors) { processor.HandleMethodEntry(environment, thread, method); } }
private void HandleBreakpoint(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jmethodID method, jlocation jlocation) { JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); JvmThreadReference thread = JvmThreadReference.FromHandle(environment, jniEnv, threadHandle, true); JvmLocation location = new JvmLocation(environment, method, jlocation); foreach (var processor in _processors) { processor.HandleBreakpoint(environment, thread, location); } }
private void HandleCompiledMethodLoad(jvmtiEnvHandle env, jmethodID methodId, int codeSize, IntPtr codeAddress, int mapLength, jvmtiAddressLocationMap[] map, IntPtr compileInfo) { if (!VirtualMachine.IsAgentThread.Value) { // ignore events before VMInit if (AgentEventDispatcher == null) return; // dispatch this call to an agent thread Action<jvmtiEnvHandle, jmethodID, int, IntPtr, int, jvmtiAddressLocationMap[], IntPtr> method = HandleCompiledMethodLoad; AgentEventDispatcher.Invoke(method, env, methodId, codeSize, codeAddress, mapLength, map, compileInfo); return; } //JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); //foreach (var processor in _processors) //{ // throw new NotImplementedException(); // //processor.HandleCompiledMethodLoad(environment, method, codeSize, codeAddress, map2, compileInfo); //} }
internal JvmLocation(JvmEnvironment environment, jmethodID method, jlocation location) { throw new NotImplementedException(); }
private void HandleException(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jmethodID methodId, jlocation jlocation, jobject exceptionHandle, jmethodID catchMethodId, jlocation catchjLocation) { // don't send exception events from an agent thread if (VirtualMachine.IsAgentThread.Value) return; JvmtiEnvironment environment = JvmtiEnvironment.GetOrCreateInstance(_service.VirtualMachine, env); JniEnvironment nativeEnvironment = JniEnvironment.GetOrCreateInstance(jniEnv); TaggedReferenceTypeId declaringClass; MethodId method = new MethodId(methodId.Handle); ulong index = (ulong)jlocation.Value; JvmtiErrorHandler.ThrowOnFailure(environment.GetMethodDeclaringClass(nativeEnvironment, method, out declaringClass)); Location location = new Location(declaringClass, method, index); Location catchLocation; method = new MethodId(catchMethodId.Handle); index = (ulong)catchjLocation.Value; if (catchMethodId.Handle != IntPtr.Zero) { JvmtiErrorHandler.ThrowOnFailure(environment.GetMethodDeclaringClass(nativeEnvironment, method, out declaringClass)); catchLocation = new Location(declaringClass, method, index); } else { catchLocation = default(Location); } TaggedObjectId exceptionId = VirtualMachine.TrackLocalObjectReference(exceptionHandle, environment, nativeEnvironment, false); ThreadId threadId = VirtualMachine.TrackLocalThreadReference(threadHandle, environment, nativeEnvironment, false); EventFilter[] filters = GetEventFilters(EventKind.Exception); foreach (var filter in filters) { if (filter.ProcessEvent(environment, nativeEnvironment, this, threadId, default(TaggedReferenceTypeId), location)) { SendExceptionEvent(environment, filter, threadId, location, exceptionId, catchLocation); } } ////Location location = new Location(); ////Location catchLocation = new Location(); //throw new NotImplementedException(); #if false ThreadId threadId = GetObjectId(ref threadHandle); TaggedObjectId exception = GetObjectId(ref exceptionHandle); EventFilter[] filters = GetEventFilters(EventKind.Exception); foreach (var filter in filters) { if (filter.ProcessEvent(threadId, default(TaggedReferenceTypeId))) { ApplySuspendPolicy(environment, filter.SuspendPolicy, threadId); Callback.HandleException(filter.SuspendPolicy, filter.RequestId, threadId, location, exception, catchLocation); } } #endif //JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); //JvmThreadReference thread = JvmThreadReference.FromHandle(environment, jniEnv, threadHandle, true); //JvmLocation location = new JvmLocation(environment, method, jlocation); //JvmObjectReference exception = JvmObjectReference.FromHandle(environment, jniEnv, exceptionHandle, true); //JvmLocation catchLocation = new JvmLocation(environment, catchMethod, catchjLocation); //foreach (var processor in _processors) //{ // processor.HandleException(environment, thread, location, exception, catchLocation); //} }
internal bool CallStaticBooleanMethodA(jclass classHandle, jmethodID methodId, params jvalue[] args) { var result = RawInterface.CallStaticBooleanMethodA(this, classHandle, methodId, args) != 0; HandleException(); return result; }
private void HandleNativeMethodBind(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jmethodID methodId, IntPtr address, ref IntPtr newAddressPtr) { JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); JvmThreadReference thread = JvmThreadReference.FromHandle(environment, jniEnv, threadHandle, true); JvmMethod method = new JvmMethod(environment, methodId); foreach (var processor in _processors) { IntPtr?newAddress = null; processor.HandleNativeMethodBind(environment, thread, method, address, ref newAddress); } }
private void HandleFieldModification(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jmethodID methodId, jlocation jlocation, jclass fieldClassHandle, jobject objectHandle, jfieldID fieldId, byte signatureType, jvalue newValue) { if (!VirtualMachine.IsAgentThread.Value) { // ignore events before VMInit if (AgentEventDispatcher == null) return; // dispatch this call to an agent thread Action<jvmtiEnvHandle, JNIEnvHandle, jthread, jmethodID, jlocation, jclass, jobject, jfieldID, byte, jvalue> method = HandleFieldModification; AgentEventDispatcher.Invoke(method, env, jniEnv, threadHandle, methodId, jlocation, fieldClassHandle, objectHandle, fieldId, signatureType, newValue); return; } //JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); //JvmThreadReference thread = JvmThreadReference.FromHandle(environment, jniEnv, threadHandle, true); //JvmLocation location = new JvmLocation(environment, method, jlocation); //JvmClassReference fieldClass = JvmClassReference.FromHandle(environment, jniEnv, fieldClassHandle, true); //JvmObjectReference @object = JvmObjectReference.FromHandle(environment, jniEnv, objectHandle, true); //JvmField field = new JvmField(environment, fieldId); //foreach (var processor in _processors) //{ // processor.HandleFieldModification(environment, thread, location, fieldClass, @object, field, signatureType, newValue); //} }
internal jobject CallStaticObjectMethodA(jclass classHandle, jmethodID methodId, params jvalue[] args) { var result = RawInterface.CallStaticObjectMethodA(this, classHandle, methodId, args); HandleException(); return result; }
private void HandleNativeMethodBind(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jmethodID methodId, IntPtr address, ref IntPtr newAddressPtr) { if (!VirtualMachine.IsAgentThread.Value) { // ignore events before VMInit if (AgentEventDispatcher == null) return; // dispatch this call to an agent thread //Action<jvmtiEnvHandle, JNIEnvHandle, jthread, jmethodID, IntPtr, ReferenceTypeData intptr> method = HandleNativeMethodBind; //AgentEventDispatcher.Invoke(method, env, jniEnv); //return; throw new NotImplementedException(); } //JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); //JvmThreadReference thread = JvmThreadReference.FromHandle(environment, jniEnv, threadHandle, true); //JvmMethod method = new JvmMethod(environment, methodId); //foreach (var processor in _processors) //{ // IntPtr? newAddress = null; // processor.HandleNativeMethodBind(environment, thread, method, address, ref newAddress); //} }
internal bool CallBooleanMethodA(jobject instanceHandle, jmethodID methodId, params jvalue[] args) { var result = RawInterface.CallBooleanMethodA(this, instanceHandle, methodId, args) != 0; HandleException(); return result; }
private void HandleCompiledMethodUnload(jvmtiEnvHandle env, jmethodID methodId, IntPtr codeAddress) { if (!VirtualMachine.IsAgentThread.Value) { // ignore events before VMInit if (AgentEventDispatcher == null) return; // dispatch this call to an agent thread Action<jvmtiEnvHandle, jmethodID, IntPtr> method = HandleCompiledMethodUnload; AgentEventDispatcher.Invoke(method, env, methodId, codeAddress); return; } //JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); //JvmMethod method = new JvmMethod(environment, methodId); //foreach (var processor in _processors) //{ // processor.HandleCompiledMethodUnload(environment, method, codeAddress); //} }
internal short CallShortMethodA(jobject instanceHandle, jmethodID methodId, params jvalue[] args) { var result = RawInterface.CallShortMethodA(this, instanceHandle, methodId, args); HandleException(); return result; }
private void HandleExceptionCatch(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jmethodID methodId, jlocation jlocation, jobject exceptionHandle) { if (!VirtualMachine.IsAgentThread.Value) { // ignore events before VMInit if (AgentEventDispatcher == null) return; // dispatch this call to an agent thread Action<jvmtiEnvHandle, JNIEnvHandle, jthread, jmethodID, jlocation, jobject> method = HandleExceptionCatch; AgentEventDispatcher.Invoke(method, env, jniEnv, threadHandle, methodId, jlocation, exceptionHandle); return; } //JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); //JvmThreadReference thread = JvmThreadReference.FromHandle(environment, jniEnv, threadHandle, true); //JvmLocation location = new JvmLocation(environment, method, jlocation); //JvmObjectReference exception = JvmObjectReference.FromHandle(environment, jniEnv, exceptionHandle, true); //foreach (var processor in _processors) //{ // processor.HandleExceptionCatch(environment, thread, location, exception); //} }
internal void CallNonvirtualVoidMethodA(jobject instanceHandle, jclass classHandle, jmethodID methodId, params jvalue[] args) { RawInterface.CallNonvirtualVoidMethodA(this, instanceHandle, classHandle, methodId, args); HandleException(); }
private void HandleFramePop(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jmethodID methodId, bool wasPoppedByException) { try { JvmtiEnvironment environment = JvmtiEnvironment.GetOrCreateInstance(_service.VirtualMachine, env); JniEnvironment nativeEnvironment = JniEnvironment.GetOrCreateInstance(jniEnv); TaggedReferenceTypeId declaringClass; MethodId method = new MethodId(methodId.Handle); jlocation jlocation; JvmtiErrorHandler.ThrowOnFailure(environment.GetFrameLocation(threadHandle, 1, out methodId, out jlocation)); ulong index = (ulong)jlocation.Value; JvmtiErrorHandler.ThrowOnFailure(environment.GetMethodDeclaringClass(nativeEnvironment, method, out declaringClass)); Location location = new Location(declaringClass, method, index); ThreadId threadId = VirtualMachine.TrackLocalThreadReference(threadHandle, environment, nativeEnvironment, false); EventFilter[] filters = GetEventFilters(EventKind.FramePop); foreach (var filter in filters) { if (filter.ProcessEvent(environment, nativeEnvironment, this, threadId, default(TaggedReferenceTypeId), location)) { if (filter.InternalEventKind == EventKind.SingleStep) { // remove the frame pop event JvmtiErrorHandler.ThrowOnFailure((jvmtiError)ClearEventInternal(EventKind.FramePop, filter.RequestId)); // set an actual step filter to respond when the thread arrives in the parent frame JvmtiErrorHandler.ThrowOnFailure((jvmtiError)SetEventInternal(environment, nativeEnvironment, EventKind.SingleStep, filter)); } else { SendFramePopEvent(environment, filter, threadId, location, wasPoppedByException); } } } } catch (Exception e) { string caption = "Exception while handling a frame pop event"; System.Windows.Forms.MessageBox.Show(e.Message + System.Environment.NewLine + System.Environment.NewLine + e.StackTrace, caption, MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1); throw; } }
internal jobject CallNonvirtualObjectMethodA(jobject instanceHandle, jclass classHandle, jmethodID methodId, params jvalue[] args) { var result = RawInterface.CallNonvirtualObjectMethodA(this, instanceHandle, classHandle, methodId, args); HandleException(); return result; }