public jvmtiError GetSourceFileName(JvmVirtualMachineRemoteHandle virtualMachine, JvmClassRemoteHandle @class, out string sourceName)
{
JavaVM machine = JavaVM.GetInstance(virtualMachine);
string sourceNameResult = null;
jvmtiError result = jvmtiError.Internal;
machine.InvokeOnJvmThread(
(environment) =>
{
jvmtiInterface rawInterface = environment.RawInterface;
IntPtr sourceNamePtr = IntPtr.Zero;
try
{
result = rawInterface.GetSourceFileName(environment.Handle, @class, out sourceNamePtr);
unsafe
{
if (sourceNamePtr != IntPtr.Zero)
{
sourceNameResult = ModifiedUTF8Encoding.GetString((byte *)sourceNamePtr);
}
}
}
finally
{
rawInterface.Deallocate(environment.Handle, sourceNamePtr);
}
});
sourceName = sourceNameResult;
return(result);
}
public jvmtiError GetThreadInfo(JvmVirtualMachineRemoteHandle virtualMachine, JvmThreadRemoteHandle thread, out JvmThreadRemoteInfo info)
{
JavaVM machine = JavaVM.GetInstance(virtualMachine);
jvmtiThreadInfo threadInfo = default(jvmtiThreadInfo);
jvmtiError result = jvmtiError.Internal;
machine.InvokeOnJvmThread(
(environment) =>
{
jvmtiInterface rawInterface = environment.RawInterface;
result = rawInterface.GetThreadInfo(environment.Handle, thread, out threadInfo);
});
info = new JvmThreadRemoteInfo()
{
Name = threadInfo.Name,
Priority = threadInfo._priority,
IsDaemon = threadInfo._isDaemon != 0,
ContextClassLoader = new JvmObjectRemoteHandle(threadInfo._contextClassLoader),
ThreadGroup = new JvmThreadGroupRemoteHandle(threadInfo._threadGroup)
};
return(result);
}
public jvmtiError Deallocate(JvmVirtualMachineRemoteHandle virtualMachine, long address)
{
JavaVM machine = JavaVM.GetInstance(virtualMachine);
jvmtiError result = jvmtiError.Internal;
machine.InvokeOnJvmThread(
(environment) =>
{
jvmtiInterface rawInterface = environment.RawInterface;
result = rawInterface.Deallocate(environment.Handle, (IntPtr)address);
});
return(result);
}
public jvmtiError SetTag(JvmVirtualMachineRemoteHandle virtualMachine, JvmObjectRemoteHandle @object, long tag)
{
JavaVM machine = JavaVM.GetInstance(virtualMachine);
jvmtiError result = jvmtiError.Internal;
machine.InvokeOnJvmThread(
(environment) =>
{
jvmtiInterface rawInterface = environment.RawInterface;
result = rawInterface.SetTag(environment.Handle, @object, tag);
});
return(result);
}
public jvmtiError GetCurrentThread(JvmVirtualMachineRemoteHandle virtualMachine, out JvmThreadRemoteHandle threadHandle)
{
JavaVM machine = JavaVM.GetInstance(virtualMachine);
jthread thread = jthread.Null;
jvmtiError result = jvmtiError.Internal;
machine.InvokeOnJvmThread(
(environment) =>
{
jvmtiInterface rawInterface = environment.RawInterface;
result = rawInterface.GetCurrentThread(environment.Handle, out thread);
});
threadHandle = new JvmThreadRemoteHandle(thread);
return(result);
}
public jvmtiError GetObjectHashCode(JvmVirtualMachineRemoteHandle virtualMachine, JvmObjectRemoteHandle @object, out int hashCode)
{
JavaVM machine = JavaVM.GetInstance(virtualMachine);
int hashCodeResult = 0;
jvmtiError result = jvmtiError.Internal;
machine.InvokeOnJvmThread(
(environment) =>
{
jvmtiInterface rawInterface = environment.RawInterface;
result = rawInterface.GetObjectHashCode(environment.Handle, @object, out hashCodeResult);
});
hashCode = hashCodeResult;
return(result);
}
public jvmtiError GetThreadState(JvmVirtualMachineRemoteHandle virtualMachine, JvmThreadRemoteHandle thread, out jvmtiThreadState threadState)
{
JavaVM machine = JavaVM.GetInstance(virtualMachine);
jvmtiThreadState threadStateResult = jvmtiThreadState.None;
jvmtiError result = jvmtiError.Internal;
machine.InvokeOnJvmThread(
(environment) =>
{
jvmtiInterface rawInterface = environment.RawInterface;
result = rawInterface.GetThreadState(environment.Handle, thread, out threadStateResult);
});
threadState = threadStateResult;
return(result);
}
public jvmtiError Allocate(JvmVirtualMachineRemoteHandle virtualMachine, long size, out long address)
{
JavaVM machine = JavaVM.GetInstance(virtualMachine);
jvmtiError result = jvmtiError.Internal;
IntPtr memory = IntPtr.Zero;
machine.InvokeOnJvmThread(
(environment) =>
{
jvmtiInterface rawInterface = environment.RawInterface;
result = rawInterface.Allocate(environment.Handle, size, out memory);
});
address = memory.ToInt64();
return(result);
}
public jvmtiError GetClassSignature(JvmVirtualMachineRemoteHandle virtualMachine, JvmClassRemoteHandle @class, out string signature, out string generic)
{
JavaVM machine = JavaVM.GetInstance(virtualMachine);
string signatureResult = null;
string genericResult = null;
jvmtiError result = jvmtiError.Internal;
machine.InvokeOnJvmThread(
(environment) =>
{
jvmtiInterface rawInterface = environment.RawInterface;
IntPtr signaturePtr = IntPtr.Zero;
IntPtr genericPtr = IntPtr.Zero;
try
{
result = rawInterface.GetClassSignature(environment.Handle, @class, out signaturePtr, out genericPtr);
unsafe
{
if (signaturePtr != IntPtr.Zero)
{
signatureResult = ModifiedUTF8Encoding.GetString((byte *)signaturePtr);
}
if (genericPtr != IntPtr.Zero)
{
genericResult = ModifiedUTF8Encoding.GetString((byte *)genericPtr);
}
}
}
finally
{
rawInterface.Deallocate(environment.Handle, signaturePtr);
rawInterface.Deallocate(environment.Handle, genericPtr);
}
});
signature = signatureResult;
generic = genericResult;
return(result);
}
public jvmtiError GetLineNumberTable(JvmVirtualMachineRemoteHandle virtualMachine, JvmMethodRemoteHandle method, out JvmLineNumberEntry[] lineNumbers)
{
JavaVM machine = JavaVM.GetInstance(virtualMachine);
List <JvmLineNumberEntry> lineNumbersList = new List <JvmLineNumberEntry>();
jvmtiError result = jvmtiError.Internal;
machine.InvokeOnJvmThread(
(environment) =>
{
jvmtiInterface rawInterface = environment.RawInterface;
IntPtr lineNumbersPtr = IntPtr.Zero;
try
{
int entryCount;
result = rawInterface.GetLineNumberTable(environment.Handle, (jmethodID)method, out entryCount, out lineNumbersPtr);
unsafe
{
jvmtiLineNumberEntry *rawLineNumbers = (jvmtiLineNumberEntry *)lineNumbersPtr;
for (int i = 0; i < entryCount; i++)
{
lineNumbersList.Add(new JvmLineNumberEntry(method, rawLineNumbers[i]));
}
}
}
finally
{
rawInterface.Deallocate(environment.Handle, lineNumbersPtr);
}
});
lineNumbers = lineNumbersList.ToArray();
return(result);
}
public jvmtiError GetClassMethods(JvmVirtualMachineRemoteHandle virtualMachine, JvmClassRemoteHandle @class, out JvmMethodRemoteHandle[] methods)
{
JavaVM machine = JavaVM.GetInstance(virtualMachine);
List <JvmMethodRemoteHandle> methodsList = new List <JvmMethodRemoteHandle>();
jvmtiError result = jvmtiError.Internal;
machine.InvokeOnJvmThread(
(environment) =>
{
jvmtiInterface rawInterface = environment.RawInterface;
IntPtr methodsPtr = IntPtr.Zero;
try
{
int methodCount;
result = rawInterface.GetClassMethods(environment.Handle, @class, out methodCount, out methodsPtr);
unsafe
{
jmethodID *rawMethods = (jmethodID *)methodsPtr;
for (int i = 0; i < methodCount; i++)
{
methodsList.Add(new JvmMethodRemoteHandle(rawMethods[i]));
}
}
}
finally
{
rawInterface.Deallocate(environment.Handle, methodsPtr);
}
});
methods = methodsList.ToArray();
return(result);
}
private JvmEnvironment(jvmtiEnvHandle env)
{
Contract.Requires <ArgumentException>(env != jvmtiEnvHandle.Null);
jvmtiInterface rawInterface = (jvmtiInterface)Marshal.PtrToStructure(Marshal.ReadIntPtr(env.Handle), typeof(jvmtiInterface));
Contract.Assert(rawInterface.GetCapabilities != null);
Contract.Assert(rawInterface.Allocate != null);
Contract.Assert(rawInterface.Deallocate != null);
Contract.Assert(rawInterface.GetThreadState != null);
Contract.Assert(rawInterface.GetCurrentThread != null);
Contract.Assert(rawInterface.GetAllThreads != null);
Contract.Assert(rawInterface.GetThreadInfo != null);
Contract.Assert(rawInterface.RunAgentThread != null);
Contract.Assert(rawInterface.SetThreadLocalStorage != null);
Contract.Assert(rawInterface.GetThreadLocalStorage != null);
Contract.Assert(rawInterface.GetTopThreadGroups != null);
Contract.Assert(rawInterface.GetThreadGroupInfo != null);
Contract.Assert(rawInterface.GetThreadGroupChildren != null);
Contract.Assert(rawInterface.GetStackTrace != null);
Contract.Assert(rawInterface.GetAllStackTraces != null);
Contract.Assert(rawInterface.GetThreadListStackTraces != null);
Contract.Assert(rawInterface.GetFrameCount != null);
Contract.Assert(rawInterface.GetFrameLocation != null);
Contract.Assert(rawInterface.ForceGarbageCollection != null);
Contract.Assert(rawInterface.GetLoadedClasses != null);
Contract.Assert(rawInterface.GetClassLoaderClasses != null);
Contract.Assert(rawInterface.GetClassSignature != null);
Contract.Assert(rawInterface.GetClassStatus != null);
Contract.Assert(rawInterface.GetClassModifiers != null);
Contract.Assert(rawInterface.GetClassMethods != null);
Contract.Assert(rawInterface.GetClassFields != null);
Contract.Assert(rawInterface.GetImplementedInterfaces != null);
Contract.Assert(rawInterface.GetClassVersionNumbers != null);
Contract.Assert(rawInterface.IsInterface != null);
Contract.Assert(rawInterface.IsArrayClass != null);
Contract.Assert(rawInterface.IsModifiableClass != null);
Contract.Assert(rawInterface.GetClassLoader != null);
Contract.Assert(rawInterface.GetObjectSize != null);
Contract.Assert(rawInterface.GetObjectHashCode != null);
Contract.Assert(rawInterface.GetFieldName != null);
Contract.Assert(rawInterface.GetFieldDeclaringClass != null);
Contract.Assert(rawInterface.GetFieldModifiers != null);
Contract.Assert(rawInterface.GetMethodName != null);
Contract.Assert(rawInterface.GetMethodDeclaringClass != null);
Contract.Assert(rawInterface.GetMethodModifiers != null);
Contract.Assert(rawInterface.GetMaxLocals != null);
Contract.Assert(rawInterface.GetArgumentsSize != null);
Contract.Assert(rawInterface.GetMethodLocation != null);
Contract.Assert(rawInterface.IsMethodNative != null);
Contract.Assert(rawInterface.IsMethodObsolete != null);
Contract.Assert(rawInterface.CreateRawMonitor != null);
Contract.Assert(rawInterface.DestroyRawMonitor != null);
Contract.Assert(rawInterface.RawMonitorEnter != null);
Contract.Assert(rawInterface.RawMonitorExit != null);
Contract.Assert(rawInterface.RawMonitorWait != null);
Contract.Assert(rawInterface.RawMonitorNotify != null);
Contract.Assert(rawInterface.RawMonitorNotifyAll != null);
Contract.Assert(rawInterface.SetJNIFunctionTable != null);
Contract.Assert(rawInterface.GetJNIFunctionTable != null);
Contract.Assert(rawInterface.SetEventCallbacks != null);
Contract.Assert(rawInterface.SetEventNotificationMode != null);
Contract.Assert(rawInterface.GenerateEvents != null);
Contract.Assert(rawInterface.GetExtensionFunctions != null);
Contract.Assert(rawInterface.GetExtensionEvents != null);
Contract.Assert(rawInterface.SetExtensionEventCallback != null);
Contract.Assert(rawInterface.GetPotentialCapabilities != null);
Contract.Assert(rawInterface.AddCapabilities != null);
Contract.Assert(rawInterface.RelinquishCapabilities != null);
Contract.Assert(rawInterface.GetCapabilities != null);
Contract.Assert(rawInterface.GetTimerInfo != null);
Contract.Assert(rawInterface.GetTime != null);
Contract.Assert(rawInterface.GetAvailableProcessors != null);
Contract.Assert(rawInterface.AddToBootstrapClassLoaderSearch != null);
Contract.Assert(rawInterface.AddToSystemClassLoaderSearch != null);
Contract.Assert(rawInterface.GetSystemProperties != null);
Contract.Assert(rawInterface.GetSystemProperty != null);
Contract.Assert(rawInterface.SetSystemProperty != null);
Contract.Assert(rawInterface.GetPhase != null);
Contract.Assert(rawInterface.DisposeEnvironment != null);
Contract.Assert(rawInterface.SetEnvironmentLocalStorage != null);
Contract.Assert(rawInterface.GetEnvironmentLocalStorage != null);
Contract.Assert(rawInterface.GetVersionNumber != null);
Contract.Assert(rawInterface.GetErrorName != null);
Contract.Assert(rawInterface.SetVerboseFlag != null);
Contract.Assert(rawInterface.GetJLocationFormat != null);
jvmtiCapabilities capabilities;
if (rawInterface.GetPotentialCapabilities(env, out capabilities) != jvmtiError.None)
{
throw new InvalidOperationException();
}
Contract.Assert(!capabilities.CanSuspend || rawInterface.SuspendThread != null);
Contract.Assert(!capabilities.CanSuspend || rawInterface.SuspendThreadList != null);
Contract.Assert(!capabilities.CanSuspend || rawInterface.ResumeThread != null);
Contract.Assert(!capabilities.CanSuspend || rawInterface.ResumeThreadList != null);
Contract.Assert(!capabilities.CanSignalThread || rawInterface.StopThread != null);
Contract.Assert(!capabilities.CanSignalThread || rawInterface.InterruptThread != null);
Contract.Assert(!capabilities.CanGetOwnedMonitorInfo || rawInterface.GetOwnedMonitorInfo != null);
Contract.Assert(!capabilities.CanGetOwnedMonitorStackDepthInfo || rawInterface.GetOwnedMonitorStackDepthInfo != null);
Contract.Assert(!capabilities.CanGetCurrentContendedMonitor || rawInterface.GetCurrentContendedMonitor != null);
Contract.Assert(!capabilities.CanPopFrame || rawInterface.PopFrame != null);
Contract.Assert(!capabilities.CanGenerateFramePopEvents || rawInterface.NotifyFramePop != null);
Contract.Assert(!capabilities.CanForceEarlyReturn || rawInterface.ForceEarlyReturnObject != null);
Contract.Assert(!capabilities.CanForceEarlyReturn || rawInterface.ForceEarlyReturnInt != null);
Contract.Assert(!capabilities.CanForceEarlyReturn || rawInterface.ForceEarlyReturnLong != null);
Contract.Assert(!capabilities.CanForceEarlyReturn || rawInterface.ForceEarlyReturnFloat != null);
Contract.Assert(!capabilities.CanForceEarlyReturn || rawInterface.ForceEarlyReturnDouble != null);
Contract.Assert(!capabilities.CanForceEarlyReturn || rawInterface.ForceEarlyReturnVoid != null);
Contract.Assert(!capabilities.CanTagObjects || rawInterface.FollowReferences != null);
Contract.Assert(!capabilities.CanTagObjects || rawInterface.IterateThroughHeap != null);
Contract.Assert(!capabilities.CanTagObjects || rawInterface.GetTag != null);
Contract.Assert(!capabilities.CanTagObjects || rawInterface.SetTag != null);
Contract.Assert(!capabilities.CanTagObjects || rawInterface.GetObjectsWithTags != null);
Contract.Assert(!capabilities.CanAccessLocalVariables || rawInterface.GetLocalObject != null);
Contract.Assert(!capabilities.CanAccessLocalVariables || rawInterface.GetLocalInstance != null);
Contract.Assert(!capabilities.CanAccessLocalVariables || rawInterface.GetLocalInt != null);
Contract.Assert(!capabilities.CanAccessLocalVariables || rawInterface.GetLocalLong != null);
Contract.Assert(!capabilities.CanAccessLocalVariables || rawInterface.GetLocalFloat != null);
Contract.Assert(!capabilities.CanAccessLocalVariables || rawInterface.GetLocalDouble != null);
Contract.Assert(!capabilities.CanAccessLocalVariables || rawInterface.SetLocalObject != null);
Contract.Assert(!capabilities.CanAccessLocalVariables || rawInterface.SetLocalInt != null);
Contract.Assert(!capabilities.CanAccessLocalVariables || rawInterface.SetLocalLong != null);
Contract.Assert(!capabilities.CanAccessLocalVariables || rawInterface.SetLocalFloat != null);
Contract.Assert(!capabilities.CanAccessLocalVariables || rawInterface.SetLocalDouble != null);
Contract.Assert(!capabilities.CanGenerateBreakpointEvents || rawInterface.SetBreakpoint != null);
Contract.Assert(!capabilities.CanGenerateBreakpointEvents || rawInterface.ClearBreakpoint != null);
Contract.Assert(!capabilities.CanGenerateFieldAccessEvents || rawInterface.SetFieldAccessWatch != null);
Contract.Assert(!capabilities.CanGenerateFieldAccessEvents || rawInterface.ClearFieldAccessWatch != null);
Contract.Assert(!capabilities.CanGenerateFieldModificationEvents || rawInterface.SetFieldModificationWatch != null);
Contract.Assert(!capabilities.CanGenerateFieldModificationEvents || rawInterface.ClearFieldModificationWatch != null);
Contract.Assert(!capabilities.CanGetSourceFileName || rawInterface.GetSourceFileName != null);
Contract.Assert(!capabilities.CanGetConstantPool || rawInterface.GetConstantPool != null);
Contract.Assert(!capabilities.CanGetSourceDebugExtension || rawInterface.GetSourceDebugExtension != null);
Contract.Assert(!capabilities.CanRetransformClasses || rawInterface.RetransformClasses != null);
Contract.Assert(!capabilities.CanRedefineClasses || rawInterface.RedefineClasses != null);
Contract.Assert(!capabilities.CanGetMonitorInfo || rawInterface.GetObjectMonitorUsage != null);
Contract.Assert(!capabilities.CanGetSyntheticAttribute || rawInterface.IsFieldSynthetic != null);
Contract.Assert(!capabilities.CanGetLineNumbers || rawInterface.GetLineNumberTable != null);
Contract.Assert(!capabilities.CanAccessLocalVariables || rawInterface.GetLocalVariableTable != null);
Contract.Assert(!capabilities.CanGetBytecodes || rawInterface.GetBytecodes != null);
Contract.Assert(!capabilities.CanGetSyntheticAttribute || rawInterface.IsMethodSynthetic != null);
Contract.Assert(!capabilities.CanSetNativeMethodPrefix || rawInterface.SetNativeMethodPrefix != null);
Contract.Assert(!capabilities.CanSetNativeMethodPrefix || rawInterface.SetNativeMethodPrefixes != null);
Contract.Assert(!capabilities.CanGetCurrentThreadCpuTime || rawInterface.GetCurrentThreadCpuTimerInfo != null);
Contract.Assert(!capabilities.CanGetCurrentThreadCpuTime || rawInterface.GetCurrentThreadCpuTime != null);
Contract.Assert(!capabilities.CanGetThreadCpuTime || rawInterface.GetCurrentThreadCpuTimerInfo != null);
Contract.Assert(!capabilities.CanGetThreadCpuTime || rawInterface.GetCurrentThreadCpuTime != null);
capabilities = new jvmtiCapabilities(
jvmtiCapabilities.CapabilityFlags1.CanTagObjects
| jvmtiCapabilities.CapabilityFlags1.CanGetSourceFileName
| jvmtiCapabilities.CapabilityFlags1.CanGetLineNumbers
);
rawInterface.AddCapabilities(env, ref capabilities);
_env = env;
_rawInterface = rawInterface;
_eventManager = new JvmEventManager(this);
_eventManager.Attach();
}
