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; }); }
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 Error CreateArrayInstance(out TaggedObjectId newArray, ArrayTypeId arrayType, int length) { 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 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; }