[wasm][debugger] Implement support to modify values.

src/mono/mono/mini/debugger-agent.c

@@ -5673,24 +5673,6 @@ set_var (MonoType *t, MonoDebugVarInfo *var, MonoContext *ctx, MonoDomain *domai
 	}
 }
 
-static void
-set_interp_var (MonoType *t, gpointer addr, guint8 *val_buf)
-{
-	int size;
-
-	if (t->byref) {
-		addr = *(gpointer*)addr;
-		g_assert (addr);
-	}
-
-	if (MONO_TYPE_IS_REFERENCE (t))
-		size = sizeof (gpointer);
-	else
-		size = mono_class_value_size (mono_class_from_mono_type_internal (t), NULL);
-
-	memcpy (addr, val_buf, size);
-}
-
 static void
 clear_event_request (int req_id, int etype)
 {
@@ -9009,7 +8991,7 @@ frame_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
 					addr = (guint8*)mini_get_interp_callbacks ()->frame_get_arg (frame->interp_frame, pos);
 				else
 					addr = (guint8*)mini_get_interp_callbacks ()->frame_get_local (frame->interp_frame, pos);
-				set_interp_var (t, addr, val_buf);
+				mono_de_set_interp_var (t, addr, val_buf);
 			} else {
 				set_var (t, var, &frame->ctx, frame->de.domain, val_buf, frame->reg_locations, &tls->restore_state.ctx);
 			}
@@ -9040,7 +9022,7 @@ frame_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
 			guint8 *addr;
 
 			addr = (guint8*)mini_get_interp_callbacks ()->frame_get_this (frame->interp_frame);
-			set_interp_var (m_class_get_this_arg (frame->actual_method->klass), addr, val_buf);
+			mono_de_set_interp_var (m_class_get_this_arg (frame->actual_method->klass), addr, val_buf);
 		} else {
 			var = jit->this_var;
 			if (!var) {

src/mono/mono/mini/debugger-engine.c

@@ -1754,5 +1754,22 @@ get_notify_debugger_of_wait_completion_method (void)
 	return notify_debugger_of_wait_completion_method_cache;
 }
 
+void
+mono_de_set_interp_var (MonoType *t, gpointer addr, guint8 *val_buf)
+{
+	int size;
+
+	if (t->byref) {
+		addr = *(gpointer*)addr;
+		g_assert (addr);
+	}
+
+	if (MONO_TYPE_IS_REFERENCE (t))
+		size = sizeof (gpointer);
+	else
+		size = mono_class_value_size (mono_class_from_mono_type_internal (t), NULL);
+
+	memcpy (addr, val_buf, size);
+}
 
 #endif

src/mono/mono/mini/debugger-engine.h

@@ -510,6 +510,8 @@ DbgEngineErrorCode mono_de_ss_create (MonoInternalThread *thread, StepSize size,
 void mono_de_cancel_ss (SingleStepReq *req);
 void mono_de_cancel_all_ss (void);
 
+void mono_de_set_interp_var (MonoType *t, gpointer addr, guint8 *val_buf);
+
 gboolean set_set_notification_for_wait_completion_flag (DbgEngineStackFrame *frame);
 MonoClass * get_class_to_get_builder_field(DbgEngineStackFrame *frame);
 gpointer get_this_addr (DbgEngineStackFrame *the_frame);

src/mono/mono/mini/mini-wasm-debugger.c

@@ -53,6 +53,8 @@ EMSCRIPTEN_KEEPALIVE gboolean mono_wasm_invoke_getter_on_object (int object_id,
 EMSCRIPTEN_KEEPALIVE gboolean mono_wasm_invoke_getter_on_value (void *value, MonoClass *klass, const char *name);
 EMSCRIPTEN_KEEPALIVE gboolean mono_wasm_get_deref_ptr_value (void *value_addr, MonoClass *klass);
 EMSCRIPTEN_KEEPALIVE void mono_wasm_set_is_debugger_attached (gboolean is_attached);
+EMSCRIPTEN_KEEPALIVE gboolean mono_wasm_set_variable_value_native (int scope, int index, const char* name, const char* value);
+EMSCRIPTEN_KEEPALIVE gboolean mono_wasm_set_value_on_object (int object_id, const char* name, const char* value);
 
 //JS functions imported that we use
 extern void mono_wasm_add_frame (int il_offset, int method_token, int frame_id, const char *assembly_name, const char *method_name);
@@ -862,6 +864,16 @@ typedef struct {
 	gboolean found;
 } FrameDescData;
 
+
+typedef struct {
+	int cur_frame;
+	int target_frame;
+	int pos;
+	const char* new_value;
+	gboolean found;
+	gboolean error;
+} SetVariableValueData;
+
 /*
  * this returns a string formatted like
  *
@@ -1514,6 +1526,168 @@ describe_variable (InterpFrame *frame, MonoMethod *method, MonoMethodHeader *hea
 	return describe_value(type, addr, gpflags);
 }
 
+static gboolean
+decode_value (MonoType *t, guint8 *addr, const char* variableValue)
+{
+	char* endptr;
+	errno = 0;
+	switch (t->type) {
+		case MONO_TYPE_BOOLEAN:
+			if (!strcasecmp (variableValue, "True"))
+				*(guint8*)addr = 1;
+			else if (!strcasecmp (variableValue, "False"))
+				*(guint8*)addr = 0;
+			else 
+				return FALSE;
+			break;
+		case MONO_TYPE_CHAR:
+			*(gunichar2*)addr = variableValue [0];
+			break;
+		case MONO_TYPE_I1: {
+			intmax_t val = strtoimax (variableValue, &endptr, 10);
+			if (errno != 0)
+				return FALSE;
+			if (val >= -128 && val <= 127)
+				*(gint8*)addr = val;
+			else 
+				return FALSE;
+			break;
+		}
+		case MONO_TYPE_U1: {
+			intmax_t val = strtoimax (variableValue, &endptr, 10);
+			if (errno != 0)
+				return FALSE;
+			if (val >= 0 && val <= 255)
+				*(guint8*)addr = val;
+			else 
+				return FALSE;
+			break;
+		}
+		case MONO_TYPE_I2: {
+			intmax_t val = strtoimax (variableValue, &endptr, 10);
+			if (errno != 0)
+				return FALSE;
+			if (val >= -32768 && val <= 32767)
+				*(gint16*)addr = val;
+			else 
+				return FALSE;
+			break;
+		}
+		case MONO_TYPE_U2: {
+			intmax_t val = strtoimax (variableValue, &endptr, 10);
+			if (errno != 0)
+				return FALSE;
+			if (val >= 0 && val <= 65535)
+				*(guint16*)addr = val;
+			else 
+				return FALSE;
+			break;
+		}
+		case MONO_TYPE_I4: {
+			intmax_t val = strtoimax (variableValue, &endptr, 10);
+			if (errno != 0)
+				return FALSE;
+			if (val >= -2147483648 && val <= 2147483647)
+				*(gint32*)addr = val;
+			else 
+				return FALSE;
+			break;
+		}
+		case MONO_TYPE_U4: {
+			intmax_t val = strtoimax (variableValue, &endptr, 10);
+			if (errno != 0)
+				return FALSE;
+			if (val >= 0 && val <= 4294967295)				
+				*(guint32*)addr = val;
+			else 
+				return FALSE;
+			break;
+		}
+		case MONO_TYPE_I8: {
+			long long val = strtoll (variableValue, &endptr, 10);
+			if (errno != 0)
+				return FALSE;
+			*(gint64*)addr = val;
+			break;
+		}
+		case MONO_TYPE_U8: {
+			long long val = strtoll (variableValue, &endptr, 10);
+			if (errno != 0)
+				return FALSE;
+			*(guint64*)addr = val;
+			break;
+		}
+		case MONO_TYPE_R4: {
+			gfloat val = strtof (variableValue, &endptr);
+			if (errno != 0)
+				return FALSE;
+			*(gfloat*)addr = val;
+			break;
+		}
+		case MONO_TYPE_R8: {
+			gdouble val = strtof (variableValue, &endptr);
+			if (errno != 0)
+				return FALSE;
+			*(gdouble*)addr = val;
+			break;
+		}
+	}
+	return TRUE;
+}
+
+static gboolean
+set_variable_value_on_frame (MonoStackFrameInfo *info, MonoContext *ctx, gpointer ud)
+{
+	ERROR_DECL (error);
+	SetVariableValueData *data = (SetVariableValueData*)ud;
+	gboolean is_arg = FALSE;
+	MonoType *t = NULL;
+	guint8 *val_buf = NULL;
+
+	++data->cur_frame;
+
+	//skip wrappers
+	if (info->type != FRAME_TYPE_MANAGED && info->type != FRAME_TYPE_INTERP) {
+		return FALSE;
+	}
+
+	if (data->cur_frame != data->target_frame)
+		return FALSE;
+
+	data->found = TRUE;
+
+	InterpFrame *frame = (InterpFrame*)info->interp_frame;
+	MonoMethod *method = frame->imethod->method;
+	MonoMethodSignature *sig = mono_method_signature_internal (method);
+	MonoMethodHeader *header = mono_method_get_header_checked (method, error);
+	int pos = data->pos;
+
+	if (pos < 0) {
+		pos = - pos - 1;
+		is_arg = TRUE;
+		t = sig->params [pos];
+	}
+	else {
+		t = header->locals [pos];
+	}
+
+	guint8 *addr;
+	if (is_arg)
+		addr = (guint8*)mini_get_interp_callbacks ()->frame_get_arg (frame, pos);
+	else
+		addr = (guint8*)mini_get_interp_callbacks ()->frame_get_local (frame, pos);
+
+	val_buf = (guint8 *)g_alloca (mono_class_instance_size (mono_class_from_mono_type_internal (t)));
+
+	if (!decode_value(t, val_buf, data->new_value)) {
+		data->error = TRUE;
+		return TRUE;
+	}
+
+	mono_de_set_interp_var (t, addr, val_buf);
+	return TRUE;
+}
+
 static gboolean
 describe_variables_on_frame (MonoStackFrameInfo *info, MonoContext *ctx, gpointer ud)
 {
@@ -1552,6 +1726,23 @@ describe_variables_on_frame (MonoStackFrameInfo *info, MonoContext *ctx, gpointe
 	mono_metadata_free_mh (header);
 	return TRUE;
 }
+EMSCRIPTEN_KEEPALIVE gboolean
+mono_wasm_set_variable_value_native (int scope, int index, const char* name, const char* value)
+{
+	if (scope < 0)
+		return FALSE;
+
+	SetVariableValueData data;
+	data.target_frame = scope;
+	data.cur_frame = -1;
+	data.pos = index;
+	data.found = FALSE;
+	data.new_value = value;
+	data.error = FALSE;
+
+	mono_walk_stack_with_ctx (set_variable_value_on_frame, NULL, MONO_UNWIND_NONE, &data);
+	return !data.error;
+}
 
 EMSCRIPTEN_KEEPALIVE gboolean
 mono_wasm_get_deref_ptr_value (void *value_addr, MonoClass *klass)
@@ -1611,6 +1802,65 @@ mono_wasm_invoke_getter_on_object (int object_id, const char* name)
 	return invoke_getter (obj, mono_object_class (obj), name);
 }
 
+EMSCRIPTEN_KEEPALIVE gboolean
+mono_wasm_set_value_on_object (int object_id, const char* name, const char* value)
+{
+	PRINT_DEBUG_MSG (1,  "mono_wasm_set_value_on_object %d, name: %s, value: %s\n", object_id, name, value);
+	MonoObject *obj = get_object_from_id (object_id);
+
+	if (!obj || !name) {
+		PRINT_DEBUG_MSG (2, "mono_wasm_set_value_on_object: none of the arguments can be null");
+		return FALSE;
+	}
+	MonoClass* klass = mono_object_class (obj);
+
+	gpointer iter;
+handle_parent:
+	iter = NULL;
+	MonoClassField *f;
+	while ((f = mono_class_get_fields_internal (klass, &iter))) {
+		if (!f->name || strcasecmp (f->name, name) != 0)
+			continue;
+		guint8 *val_buf = (guint8 *)g_alloca (mono_class_instance_size (mono_class_from_mono_type_internal (f->type)));
+
+		if (!decode_value(f->type, val_buf, value)) {
+			return FALSE;
+		}		
+		mono_de_set_interp_var (f->type, (guint8*)obj + f->offset, val_buf);
+		return TRUE;
+	}
+
+	iter = NULL;
+	MonoProperty *p;
+	MonoObject *exc;
+	ERROR_DECL (error);
+	while ((p = mono_class_get_properties (klass, &iter))) {
+		if (!p->name || strcasecmp (p->name, name) != 0)
+			continue;
+		if (!p->set)
+			break;
+		MonoType *type = mono_method_signature_internal (p->set)->params [0];
+		guint8 *val_buf = (guint8 *)g_alloca (mono_class_instance_size (mono_class_from_mono_type_internal (type)));
+
+		if (!decode_value(type, val_buf, value)) {
+			return FALSE;
+		}					
+		mono_runtime_try_invoke (p->set, obj, (void **)&val_buf, &exc, error);
+		if (!is_ok (error) && exc == NULL)
+			exc = (MonoObject*) mono_error_convert_to_exception (error);
+		if (exc) {
+			const char *error_message = mono_string_to_utf8_checked_internal (((MonoException *)exc)->message, error);
+			PRINT_DEBUG_MSG (2, "mono_wasm_set_value_on_object exception: %s\n", error_message);
+			return FALSE;
+		}
+		return TRUE;
+	}
+
+	if ((klass = m_class_get_parent(klass)))
+		goto handle_parent;
+	return FALSE;
+}
+
 EMSCRIPTEN_KEEPALIVE gboolean
 mono_wasm_invoke_getter_on_value (void *value, MonoClass *klass, const char *name)
 {

src/mono/wasm/debugger/BrowserDebugProxy/DevToolsHelper.cs

@@ -192,6 +192,11 @@ public static MonoCommands GetScopeVariables(int scopeId, params VarInfo[] vars)
             return new MonoCommands($"MONO.mono_wasm_get_variables({scopeId}, {JsonConvert.SerializeObject(var_ids)})");
         }
 
+        public static MonoCommands SetVariableValue(int scopeId, int index, string name, string newValue)
+        {
+            return new MonoCommands($"MONO.mono_wasm_set_variable_value({scopeId}, {index}, '{name}', '{newValue}')");
+        }
+
         public static MonoCommands EvaluateMemberAccess(int scopeId, string expr, params VarInfo[] vars)
         {
             var var_ids = vars.Select(v => new { index = v.Index, name = v.Name }).ToArray();