internal ObjectReference GetMirrorOf(TaggedObjectId @object)
{
if (@object == default(TaggedObjectId))
{
return(null);
}
ReferenceType type = GetMirrorOf(@object.Type);
return(GetMirrorOf(@object.Tag, @object.ObjectId, type));
}
public Task <string> GetExceptionMessageAsync(TaggedObjectId exceptionObject)
{
if (_failedToFindThrowableDetailedMessageField)
{
return(null);
}
// TODO: this logic could be factored out into a "ReferenceTypeFieldValueRetriever" (find
// a better name...) class, and could also be used to directly show List<T> as
// array type in the watch window and similar fancy things.
return(Task.Factory.StartNew(() =>
{
if (_throwableDetailedMessageFieldId == null)
{
Process.ReferenceTypeManager.RefreshClassesWithSignatureAsync(ThrowableClassSignature)
.Await(DalvikProcess.VmTimeout);
var refType = Process.ReferenceTypeManager.FindBySignature(ThrowableClassSignature);
if (refType == null)
{
_failedToFindThrowableDetailedMessageField = true;
return null;
}
var fieldInfo = Debugger.ReferenceType.FieldsAsync(refType.Id).Await(DalvikProcess.VmTimeout)
.FirstOrDefault(f => f.Name == ThrowableDetailMessageFieldName);
if (fieldInfo == null)
{
_failedToFindThrowableDetailedMessageField = true;
return null;
}
_throwableDetailedMessageFieldId = fieldInfo.Id;
}
var val = Debugger.ObjectReference.GetValuesAsync(exceptionObject.Object, new[] { _throwableDetailedMessageFieldId })
.Await(DalvikProcess.VmTimeout).First();
var objectId = (ObjectId)val.ValueObject;
if (objectId.IsNull)
{
return null;
}
var ret = Debugger.StringReference.ValueAsync(objectId).Await(DalvikProcess.VmTimeout);
return ret;
}));
}
/// <summary>
/// Default ctor
/// </summary>
protected BaseFieldEvent(JdwpPacket.DataReaderWriter reader)
: base(reader)
{
refTypeTag = (DebuggerLib.Jdwp.TypeTag)reader.GetByte();
switch (refTypeTag)
{
case DebuggerLib.Jdwp.TypeTag.Class:
typeId = new ClassId(reader);
break;
case DebuggerLib.Jdwp.TypeTag.Interface:
typeId = new InterfaceId(reader);
break;
case DebuggerLib.Jdwp.TypeTag.Array:
typeId = new ArrayTypeId(reader);
break;
default:
throw new ArgumentException("Unknown type tag " + (int)refTypeTag);
}
fieldId = new FieldId(reader);
objectId = new TaggedObjectId(reader);
}
public Task<string> GetExceptionMessageAsync(TaggedObjectId exceptionObject)
{
if (_failedToFindThrowableDetailedMessageField)
return null;
// TODO: this logic could be factored out into a "ReferenceTypeFieldValueRetriever" (find
// a better name...) class, and could also be used to directly show List<T> as
// array type in the watch window and similar fancy things.
return Task.Factory.StartNew(() =>
{
if (_throwableDetailedMessageFieldId == null)
{
Process.ReferenceTypeManager.RefreshClassesWithSignatureAsync(ThrowableClassSignature)
.Await(DalvikProcess.VmTimeout);
var refType = Process.ReferenceTypeManager.FindBySignature(ThrowableClassSignature);
if (refType == null)
{
_failedToFindThrowableDetailedMessageField = true;
return null;
}
var fieldInfo = Debugger.ReferenceType.FieldsAsync(refType.Id).Await(DalvikProcess.VmTimeout)
.FirstOrDefault(f => f.Name == ThrowableDetailMessageFieldName);
if (fieldInfo == null)
{
_failedToFindThrowableDetailedMessageField = true;
return null;
}
_throwableDetailedMessageFieldId = fieldInfo.Id;
}
var val = Debugger.ObjectReference.GetValuesAsync(exceptionObject.Object, new[] { _throwableDetailedMessageFieldId })
.Await(DalvikProcess.VmTimeout).First();
var objectId = (ObjectId)val.ValueObject;
if(objectId.IsNull)
return null;
var ret = Debugger.StringReference.ValueAsync(objectId).Await(DalvikProcess.VmTimeout);
return ret;
});
}
/// <summary>
/// Default ctor
/// </summary>
protected BaseFieldEvent(JdwpPacket.DataReaderWriter reader)
: base(reader)
{
refTypeTag = (DebuggerLib.Jdwp.TypeTag)reader.GetByte();
switch (refTypeTag)
{
case DebuggerLib.Jdwp.TypeTag.Class:
typeId = new ClassId(reader);
break;
case DebuggerLib.Jdwp.TypeTag.Interface:
typeId = new InterfaceId(reader);
break;
case DebuggerLib.Jdwp.TypeTag.Array:
typeId = new ArrayTypeId(reader);
break;
default:
throw new ArgumentException("Unknown type tag " + (int)refTypeTag);
}
fieldId = new FieldId(reader);
objectId = new TaggedObjectId(reader);
}
public Error GetInstances(out TaggedObjectId[] instances, ReferenceTypeId referenceType, int maxInstances)
{
throw new NotImplementedException();
}
public jvmtiError GetLocalObject(JniEnvironment nativeEnvironment, jthread thread, int depth, int slot, out TaggedObjectId value)
{
value = default(TaggedObjectId);
jobject obj;
jvmtiError error = RawInterface.GetLocalObject(this, thread, depth, slot, out obj);
if (error != jvmtiError.None)
{
return(error);
}
value = VirtualMachine.TrackLocalObjectReference(obj, this, nativeEnvironment, true);
return(jvmtiError.None);
}
public Error GetThisObject(out TaggedObjectId thisObject, ThreadId thread, FrameId frame)
{
int frameIndex = (int)frame.Handle;
FrameLocationData[] frames = new FrameLocationData[1];
Error errorCode = GetRawThreadFrames(out frames, thread, frameIndex, 1);
if (errorCode != Error.None)
{
thisObject = default(TaggedObjectId);
return errorCode;
}
frame = frames[0].FrameId;
byte[] packet = new byte[HeaderSize + ThreadIdSize + FrameIdSize];
int id = GetMessageId();
SerializeHeader(packet, id, StackFrameCommand.ThisObject);
WriteObjectId(packet, HeaderSize, thread);
WriteFrameId(packet, HeaderSize + ThreadIdSize, frame);
byte[] response = SendPacket(id, packet);
errorCode = ReadErrorCode(response);
if (errorCode != Error.None)
{
thisObject = default(TaggedObjectId);
return errorCode;
}
int offset = HeaderSize;
thisObject = ReadTaggedObjectId(response, ref offset);
return Error.None;
}
public Error GetThreadCurrentContendedMonitor(out TaggedObjectId monitor, ThreadId thread)
{
throw new NotImplementedException();
}
public Error GetThreadOwnedMonitors(out TaggedObjectId[] monitors, ThreadId thread)
{
throw new NotImplementedException();
}
public void MonitorContendedWaited(Types.SuspendPolicy suspendPolicy, RequestId requestId, ThreadId thread, TaggedObjectId @object, Types.Location location, bool timedOut)
{
throw new NotImplementedException();
}
public void FieldModification(Types.SuspendPolicy suspendPolicy, RequestId requestId, ThreadId thread, Types.Location location, TypeTag typeTag, ReferenceTypeId typeId, FieldId field, TaggedObjectId @object, Types.Value newValue)
{
throw new NotImplementedException();
}
public void Exception(Types.SuspendPolicy suspendPolicy, RequestId requestId, ThreadId threadId, Types.Location location, TaggedObjectId exception, Types.Location catchLocation)
{
EventRequest request = VirtualMachine.EventRequestManager.GetEventRequest(EventKind.Exception, requestId);
ThreadReference thread = VirtualMachine.GetMirrorOf(threadId);
Location loc = VirtualMachine.GetMirrorOf(location);
ObjectReference exceptionReference = VirtualMachine.GetMirrorOf(exception);
Location catchLoc = VirtualMachine.GetMirrorOf(catchLocation);
ExceptionEventArgs e = new ExceptionEventArgs(VirtualMachine, (SuspendPolicy)suspendPolicy, request, thread, loc, exceptionReference, catchLoc);
VirtualMachine.EventQueue.OnException(e);
}
internal ObjectReference GetMirrorOf(TaggedObjectId @object)
{
if (@object == default(TaggedObjectId))
return null;
ReferenceType type = GetMirrorOf(@object.Type);
return GetMirrorOf(@object.Tag, @object.ObjectId, type);
}
private void SendExceptionEvent(JvmtiEnvironment environment, EventFilter filter, ThreadId threadId, Location location, TaggedObjectId exceptionId, Location catchLocation)
{
if (!VirtualMachine.IsAgentThread.Value)
{
// ignore events before VMInit
if (AgentEventDispatcher == null)
return;
// dispatch this call to an agent thread
Action<JvmtiEnvironment, EventFilter, ThreadId, Location, TaggedObjectId, Location> invokeMethod = SendExceptionEvent;
AgentEventDispatcher.Invoke(invokeMethod, environment, filter, threadId, location, exceptionId, catchLocation);
return;
}
JniEnvironment nativeEnvironment;
JniErrorHandler.ThrowOnFailure(VirtualMachine.AttachCurrentThreadAsDaemon(environment, out nativeEnvironment, false));
ApplySuspendPolicy(environment, nativeEnvironment, filter.SuspendPolicy, threadId);
Callback.Exception(filter.SuspendPolicy, filter.RequestId, threadId, location, exceptionId, catchLocation);
}
/// <summary>
/// Create from given source.
/// </summary>
public Value(TaggedObjectId source)
{
Tag = source.Tag;
ValueObject = source.Object;
}
public Error CreateArrayInstance(ArrayTypeId arrayType, int length, out TaggedObjectId newArray)
{
newArray = default(TaggedObjectId);
JniEnvironment nativeEnvironment;
JvmtiEnvironment environment;
jvmtiError error = GetEnvironment(out environment, out nativeEnvironment);
if (error != jvmtiError.None)
return GetStandardError(error);
using (var arrayTypeHandle = VirtualMachine.GetLocalReferenceForClass(nativeEnvironment, arrayType))
{
if (!arrayTypeHandle.IsAlive)
return Error.InvalidClass;
string signature;
string genericSignature;
error = environment.GetClassSignature(arrayTypeHandle.Value, out signature, out genericSignature);
if (error != jvmtiError.None)
return GetStandardError(error);
jobject array;
switch (signature[1])
{
case 'Z':
array = nativeEnvironment.NewBooleanArray(length);
break;
case 'B':
array = nativeEnvironment.NewByteArray(length);
break;
case 'C':
array = nativeEnvironment.NewCharArray(length);
break;
case 'D':
array = nativeEnvironment.NewDoubleArray(length);
break;
case 'F':
array = nativeEnvironment.NewFloatArray(length);
break;
case 'I':
array = nativeEnvironment.NewIntegerArray(length);
break;
case 'J':
array = nativeEnvironment.NewLongArray(length);
break;
case 'S':
array = nativeEnvironment.NewShortArray(length);
break;
case '[':
case 'L':
throw new NotImplementedException();
//array = nativeEnvironment.NewObjectArray(length, elementType, jobject.Null);
//break;
case 'V':
default:
throw new FormatException();
}
if (array == jobject.Null)
throw new NotImplementedException();
newArray = VirtualMachine.TrackLocalObjectReference(array, environment, nativeEnvironment, false);
VirtualMachine.AddGlobalReference(environment, nativeEnvironment, array);
nativeEnvironment.DeleteLocalReference(array);
return Error.None;
}
}
public Error InvokeClassMethod(ClassId @class, ThreadId thread, MethodId method, InvokeOptions options, Value[] arguments, out Value returnValue, out TaggedObjectId thrownException)
{
returnValue = default(Value);
thrownException = default(TaggedObjectId);
JniEnvironment nativeEnvironment;
JvmtiEnvironment environment;
jvmtiError error = GetEnvironment(out environment, out nativeEnvironment);
if (error != jvmtiError.None)
return GetStandardError(error);
string name;
string signature;
string genericSignature;
error = environment.GetMethodName(method, out name, out signature, out genericSignature);
if (error != jvmtiError.None)
return GetStandardError(error);
if (thread != default(ThreadId))
throw new NotImplementedException();
List<string> argumentTypeSignatures;
string returnTypeSignature;
SignatureHelper.ParseMethodSignature(signature, out argumentTypeSignatures, out returnTypeSignature);
using (var classHandle = VirtualMachine.GetLocalReferenceForClass(nativeEnvironment, @class))
{
if (!classHandle.IsAlive)
return Error.InvalidClass;
// don't do argument conversion if the signature is invalid
switch (returnTypeSignature[0])
{
case 'Z':
case 'B':
case 'C':
case 'D':
case 'F':
case 'I':
case 'J':
case 'S':
case '[':
case 'L':
break;
case 'V':
default:
return Error.InvalidMethodid;
}
jvalue[] args = arguments.Select(value => new jvalue(VirtualMachine, environment, nativeEnvironment, value)).ToArray();
switch (returnTypeSignature[0])
{
case 'Z':
returnValue = nativeEnvironment.CallStaticBooleanMethodA(classHandle.Value, method, args);
break;
case 'B':
returnValue = nativeEnvironment.CallStaticByteMethodA(classHandle.Value, method, args);
break;
case 'C':
returnValue = nativeEnvironment.CallStaticCharMethodA(classHandle.Value, method, args);
break;
case 'D':
returnValue = nativeEnvironment.CallStaticDoubleMethodA(classHandle.Value, method, args);
break;
case 'F':
returnValue = nativeEnvironment.CallStaticFloatMethodA(classHandle.Value, method, args);
break;
case 'I':
returnValue = nativeEnvironment.CallStaticIntMethodA(classHandle.Value, method, args);
break;
case 'J':
returnValue = nativeEnvironment.CallStaticLongMethodA(classHandle.Value, method, args);
break;
case 'S':
returnValue = nativeEnvironment.CallStaticShortMethodA(classHandle.Value, method, args);
break;
case '[':
case 'L':
jobject result = nativeEnvironment.CallStaticObjectMethodA(classHandle.Value, method, args);
returnValue = VirtualMachine.TrackLocalObjectReference(result, environment, nativeEnvironment, false);
VirtualMachine.AddGlobalReference(environment, nativeEnvironment, result);
nativeEnvironment.DeleteLocalReference(result);
break;
case 'V':
default:
Contract.Assert(false, "not reachable");
break;
}
if (nativeEnvironment.ExceptionOccurred() != jthrowable.Null)
{
throw new NotImplementedException();
}
for (int i = 0; i < arguments.Length; i++)
{
switch (arguments[i].Tag)
{
case Tag.Array:
case Tag.Object:
case Tag.String:
case Tag.Thread:
case Tag.ThreadGroup:
case Tag.ClassLoader:
case Tag.ClassObject:
nativeEnvironment.DeleteLocalReference(args[i].ObjectValue);
break;
default:
break;
}
}
return Error.None;
}
}
public Error GetThisObject(ThreadId thread, FrameId frame, out TaggedObjectId thisObject)
{
thisObject = default(TaggedObjectId);
JniEnvironment nativeEnvironment;
JvmtiEnvironment environment;
jvmtiError error = GetEnvironment(out environment, out nativeEnvironment);
if (error != jvmtiError.None)
return GetStandardError(error);
using (LocalThreadReferenceHolder threadHandle = VirtualMachine.GetLocalReferenceForThread(nativeEnvironment, thread))
{
if (!threadHandle.IsAlive)
return Error.InvalidThread;
int depth = (int)frame.Handle;
jmethodID method;
jlocation location;
error = environment.GetFrameLocation(threadHandle.Value, depth, out method, out location);
if (error != jvmtiError.None)
return GetStandardError(error);
JvmAccessModifiers modifiers;
error = environment.GetMethodModifiers(method, out modifiers);
if (error != jvmtiError.None)
return GetStandardError(error);
if ((modifiers & JvmAccessModifiers.Static) != 0)
return Error.None;
error = environment.GetLocalObject(nativeEnvironment, threadHandle.Value, depth, 0, out thisObject);
if (error != jvmtiError.None)
return GetStandardError(error);
return Error.None;
}
}
/// <summary>
/// Default ctor
/// </summary>
public Exception(JdwpPacket.DataReaderWriter reader)
: base(reader)
{
exception = new TaggedObjectId(reader);
catchLocation = new Location(reader);
}
public Error InvokeClassMethod(out Value returnValue, out TaggedObjectId thrownException, ClassId @class, ThreadId thread, MethodId method, InvokeOptions options, Value[] arguments)
{
throw new NotImplementedException();
}
public Error CreateClassInstance(out TaggedObjectId newObject, out TaggedObjectId thrownException, ClassId @class, ThreadId thread, MethodId method, InvokeOptions options, Value[] arguments)
{
throw new NotImplementedException();
}
public void MonitorContendedWaited(Types.SuspendPolicy suspendPolicy, RequestId requestId, ThreadId thread, TaggedObjectId @object, Types.Location location, bool timedOut)
{
throw new NotImplementedException();
}
public Error CreateArrayInstance(out TaggedObjectId newArray, ArrayTypeId arrayType, int length)
{
throw new NotImplementedException();
}
public void FieldModification(Types.SuspendPolicy suspendPolicy, RequestId requestId, ThreadId thread, Types.Location location, TypeTag typeTag, ReferenceTypeId typeId, FieldId field, TaggedObjectId @object, Types.Value newValue)
{
throw new NotImplementedException();
}
public Error InvokeObjectMethod(out Value returnValue, out TaggedObjectId thrownException, ObjectId @object, ThreadId thread, ClassId @class, MethodId method, InvokeOptions options, Value[] arguments)
{
if (thread == default(ThreadId))
throw new ArgumentException();
byte[] packet = new byte[HeaderSize + ObjectIdSize + ThreadIdSize + ClassIdSize + MethodIdSize + sizeof(int)];
WriteObjectId(packet, HeaderSize, @object);
WriteObjectId(packet, HeaderSize + ObjectIdSize, thread);
WriteReferenceTypeId(packet, HeaderSize + ObjectIdSize + ThreadIdSize, @class);
WriteMethodId(packet, HeaderSize + ObjectIdSize + ThreadIdSize + ClassIdSize, method);
WriteInt32(packet, HeaderSize + ObjectIdSize + ThreadIdSize + ClassIdSize + MethodIdSize, arguments.Length);
List<byte> packetData = new List<byte>(packet);
foreach (Value argument in arguments)
{
switch (argument.Tag)
{
case Tag.Byte:
throw new NotImplementedException();
case Tag.Char:
throw new NotImplementedException();
case Tag.Float:
throw new NotImplementedException();
case Tag.Double:
throw new NotImplementedException();
case Tag.Int:
throw new NotImplementedException();
case Tag.Long:
throw new NotImplementedException();
case Tag.Short:
throw new NotImplementedException();
case Tag.Boolean:
throw new NotImplementedException();
case Tag.Array:
case Tag.Object:
case Tag.String:
case Tag.Thread:
case Tag.ThreadGroup:
case Tag.ClassLoader:
case Tag.ClassObject:
throw new NotImplementedException();
case Tag.Void:
throw new NotImplementedException();
case Tag.Invalid:
default:
throw new InvalidOperationException();
}
}
byte[] optionsData = new byte[sizeof(int)];
WriteInt32(optionsData, 0, (int)options);
packetData.AddRange(optionsData);
packet = packetData.ToArray();
int id = GetMessageId();
SerializeHeader(packet, id, ObjectReferenceCommand.InvokeMethod);
byte[] response = SendPacket(id, packet);
Error errorCode = ReadErrorCode(response);
if (errorCode != Error.None)
{
returnValue = default(Value);
thrownException = default(TaggedObjectId);
return errorCode;
}
int offset = HeaderSize;
returnValue = ReadValue(response, ref offset);
thrownException = ReadTaggedObjectId(response, ref offset);
return Error.None;
}
public void Exception(Types.SuspendPolicy suspendPolicy, RequestId requestId, ThreadId threadId, Types.Location location, TaggedObjectId exception, Types.Location catchLocation)
{
EventRequest request = VirtualMachine.EventRequestManager.GetEventRequest(EventKind.Exception, requestId);
ThreadReference thread = VirtualMachine.GetMirrorOf(threadId);
Location loc = VirtualMachine.GetMirrorOf(location);
ObjectReference exceptionReference = VirtualMachine.GetMirrorOf(exception);
Location catchLoc = VirtualMachine.GetMirrorOf(catchLocation);
ExceptionEventArgs e = new ExceptionEventArgs(VirtualMachine, (SuspendPolicy)suspendPolicy, request, thread, loc, exceptionReference, catchLoc);
VirtualMachine.EventQueue.OnException(e);
}
public jvmtiError GetLocalObject(JniEnvironment nativeEnvironment, jthread thread, int depth, int slot, out TaggedObjectId value)
{
value = default(TaggedObjectId);
jobject obj;
jvmtiError error = RawInterface.GetLocalObject(this, thread, depth, slot, out obj);
if (error != jvmtiError.None)
return error;
value = VirtualMachine.TrackLocalObjectReference(obj, this, nativeEnvironment, true);
return jvmtiError.None;
}
