From b4eaff3433408d6221c0a1ac07f3e0cec19f8354 Mon Sep 17 00:00:00 2001 From: "DESKTOP-GEPIA6N\\Thays" Date: Mon, 21 Jun 2021 23:59:27 -0300 Subject: [PATCH 01/35] First version of componentize debugger --- .../Directory.Build.props | 7 + src/mono/mono/component/CMakeLists.txt | 19 + .../mono/{mini => component}/debugger-agent.c | 96 +++-- .../mono/{mini => component}/debugger-agent.h | 0 .../{mini => component}/debugger-engine.c | 41 ++- .../{mini => component}/debugger-engine.h | 157 +-------- .../debugger-state-machine.c | 5 +- .../debugger-state-machine.h | 0 src/mono/mono/component/debugger-stub.c | 328 ++++++++++++++++++ src/mono/mono/component/debugger.c | 33 ++ src/mono/mono/component/debugger.h | 226 ++++++++++++ src/mono/mono/metadata/components.c | 8 + src/mono/mono/metadata/components.h | 9 + src/mono/mono/mini/CMakeLists.txt | 10 +- src/mono/mono/mini/aot-runtime.c | 7 +- src/mono/mono/mini/debugger-agent-external.c | 37 ++ src/mono/mono/mini/debugger-agent-external.h | 19 + src/mono/mono/mini/driver.c | 1 - src/mono/mono/mini/interp/interp.c | 86 +---- src/mono/mono/mini/method-to-ir.c | 14 +- src/mono/mono/mini/mini-exceptions.c | 17 +- src/mono/mono/mini/mini-runtime.c | 54 +-- src/mono/mono/mini/mini-runtime.h | 5 - src/mono/mono/mini/mini-wasm-debugger.c | 45 +-- src/mono/mono/mini/mini.c | 1 - src/mono/mono/mini/tramp-amd64.c | 5 +- 26 files changed, 839 insertions(+), 391 deletions(-) rename src/mono/mono/{mini => component}/debugger-agent.c (99%) rename src/mono/mono/{mini => component}/debugger-agent.h (100%) rename src/mono/mono/{mini => component}/debugger-engine.c (96%) rename src/mono/mono/{mini => component}/debugger-engine.h (79%) rename src/mono/mono/{mini => component}/debugger-state-machine.c (99%) rename src/mono/mono/{mini => component}/debugger-state-machine.h (100%) create mode 100644 src/mono/mono/component/debugger-stub.c create mode 100644 src/mono/mono/component/debugger.c create mode 100644 src/mono/mono/component/debugger.h create mode 100644 src/mono/mono/mini/debugger-agent-external.c create mode 100644 src/mono/mono/mini/debugger-agent-external.h diff --git a/src/installer/pkg/sfx/Microsoft.NETCore.App/Directory.Build.props b/src/installer/pkg/sfx/Microsoft.NETCore.App/Directory.Build.props index 3efbe093fb75eb..171be1106ee288 100644 --- a/src/installer/pkg/sfx/Microsoft.NETCore.App/Directory.Build.props +++ b/src/installer/pkg/sfx/Microsoft.NETCore.App/Directory.Build.props @@ -193,6 +193,13 @@ + + + + + + + diff --git a/src/mono/mono/component/CMakeLists.txt b/src/mono/mono/component/CMakeLists.txt index f523d14e568dd0..f13d83c40d51a0 100644 --- a/src/mono/mono/component/CMakeLists.txt +++ b/src/mono/mono/component/CMakeLists.txt @@ -6,6 +6,7 @@ set(MONO_EVENTPIPE_GEN_INCLUDE_PATH "${CMAKE_CURRENT_BINARY_DIR}/eventpipe") set(MONO_HOT_RELOAD_COMPONENT_NAME "hot_reload") set(MONO_DIAGNOSTICS_TRACING_COMPONENT_NAME "diagnostics_tracing") +set(MONO_DEBUGGER_COMPONENT_NAME "debugger") # a list of every component. set(components "") @@ -14,6 +15,24 @@ set(components "") # component_name-sources list for each component, and a # component_name-stub-sources list for the component stub. +# debugger +list(APPEND components + ${MONO_DEBUGGER_COMPONENT_NAME} +) +set(${MONO_DEBUGGER_COMPONENT_NAME}-sources + ${MONO_COMPONENT_PATH}/debugger.c + ${MONO_COMPONENT_PATH}/debugger.h + ${MONO_COMPONENT_PATH}/debugger-agent.c + ${MONO_COMPONENT_PATH}/debugger-agent.h + ${MONO_COMPONENT_PATH}/debugger-engine.c + ${MONO_COMPONENT_PATH}/debugger-engine.h + ${MONO_COMPONENT_PATH}/debugger-state-machine.h + ${MONO_COMPONENT_PATH}/debugger-state-machine.c + ) +set(${MONO_DEBUGGER_COMPONENT_NAME}-stub-sources + ${MONO_COMPONENT_PATH}/debugger-stub.c + ) + # hot_reload list(APPEND components ${MONO_HOT_RELOAD_COMPONENT_NAME} diff --git a/src/mono/mono/mini/debugger-agent.c b/src/mono/mono/component/debugger-agent.c similarity index 99% rename from src/mono/mono/mini/debugger-agent.c rename to src/mono/mono/component/debugger-agent.c index eb0e2a248dc33c..93b997264ef96d 100644 --- a/src/mono/mono/mini/debugger-agent.c +++ b/src/mono/mono/component/debugger-agent.c @@ -78,16 +78,18 @@ #include #include #include -#include "debugger-state-machine.h" + +#include #include "debugger-agent.h" -#include "mini.h" -#include "seq-points.h" -#include "aot-runtime.h" -#include "mini-runtime.h" -#include "interp/interp.h" +#include +#include +#include +#include +#include #include "debugger-engine.h" -#include "mono/metadata/debug-mono-ppdb.h" -#include "mono/metadata/custom-attrs-internals.h" +#include +#include +#include #ifdef HAVE_UCONTEXT_H #include @@ -262,14 +264,6 @@ struct _DebuggerTlsData { gboolean gc_finalizing; }; -typedef struct { - const char *name; - void (*connect) (const char *address); - void (*close1) (void); - void (*close2) (void); - gboolean (*send) (void *buf, int len); - int (*recv) (void *buf, int len); -} DebuggerTransport; /* Buffered reply packets */ static ReplyPacket reply_packets [128]; @@ -560,7 +554,7 @@ parse_flag (const char *option, char *flag) } } -static void +void debugger_agent_parse_options (char *options) { char **args, **ptr; @@ -723,7 +717,7 @@ debugger_agent_init (void) cbs.ss_args_destroy = ss_args_destroy; cbs.handle_multiple_ss_requests = handle_multiple_ss_requests; - mono_de_init (&cbs); + mono_component_debugger ()->mono_de_init (&cbs); transport_init (); @@ -748,7 +742,7 @@ debugger_agent_init (void) mono_profiler_set_jit_failed_callback (prof, jit_failed); mono_profiler_set_gc_finalizing_callback (prof, gc_finalizing); mono_profiler_set_gc_finalized_callback (prof, gc_finalized); - + mono_native_tls_alloc (&debugger_tls_id, NULL); /* Needed by the hash_table_new_type () call below */ @@ -808,6 +802,7 @@ debugger_agent_init (void) if (!agent_config.onuncaught && !agent_config.onthrow) finish_agent_init (TRUE); + mono_component_debugger ()->init (); } /* @@ -1287,15 +1282,6 @@ static DebuggerTransport *transport; static DebuggerTransport transports [MAX_TRANSPORTS]; static int ntransports; -MONO_API void -mono_debugger_agent_register_transport (DebuggerTransport *trans); - -void -mono_debugger_agent_register_transport (DebuggerTransport *trans) -{ - register_transport (trans); -} - static void register_transport (DebuggerTransport *trans) { @@ -1373,7 +1359,7 @@ transport_recv (void *buf, int len) return result; } -gboolean +static gboolean mono_debugger_agent_transport_handshake (void) { gboolean result; @@ -10091,36 +10077,36 @@ debugger_thread (void *arg) return 0; } -void -mono_debugger_agent_init (void) +static void +mono_debugger_agent_parse_options (char *options) { - MonoDebuggerCallbacks cbs; - - memset (&cbs, 0, sizeof (cbs)); - cbs.version = MONO_DBG_CALLBACKS_VERSION; - cbs.parse_options = debugger_agent_parse_options; - cbs.init = debugger_agent_init; - cbs.breakpoint_hit = debugger_agent_breakpoint_hit; - cbs.single_step_event = debugger_agent_single_step_event; - cbs.single_step_from_context = debugger_agent_single_step_from_context; - cbs.breakpoint_from_context = debugger_agent_breakpoint_from_context; - cbs.free_mem_manager = debugger_agent_free_mem_manager; - cbs.unhandled_exception = debugger_agent_unhandled_exception; - cbs.handle_exception = debugger_agent_handle_exception; - cbs.begin_exception_filter = debugger_agent_begin_exception_filter; - cbs.end_exception_filter = debugger_agent_end_exception_filter; - cbs.user_break = debugger_agent_user_break; - cbs.debug_log = debugger_agent_debug_log; - cbs.debug_log_is_enabled = debugger_agent_debug_log_is_enabled; - cbs.send_crash = mono_debugger_agent_send_crash; - - mini_install_dbg_callbacks (&cbs); + sdb_options = options; } void -mono_debugger_agent_parse_options (char *options) -{ - sdb_options = options; +debugger_agent_add_function_pointers(MonoComponentDebugger* fn_table) +{ + fn_table->parse_options = debugger_agent_parse_options; + fn_table->init = debugger_agent_init; + fn_table->breakpoint_hit = debugger_agent_breakpoint_hit; + fn_table->single_step_event = debugger_agent_single_step_event; + fn_table->single_step_from_context = debugger_agent_single_step_from_context; + fn_table->breakpoint_from_context = debugger_agent_breakpoint_from_context; + fn_table->free_mem_manager = debugger_agent_free_mem_manager; + fn_table->unhandled_exception = debugger_agent_unhandled_exception; + fn_table->handle_exception = debugger_agent_handle_exception; + fn_table->begin_exception_filter = debugger_agent_begin_exception_filter; + fn_table->end_exception_filter = debugger_agent_end_exception_filter; + fn_table->user_break = debugger_agent_user_break; + fn_table->debug_log = debugger_agent_debug_log; + fn_table->debug_log_is_enabled = debugger_agent_debug_log_is_enabled; + fn_table->send_crash = mono_debugger_agent_send_crash; + + fn_table->register_transport = register_transport; + fn_table->mono_debugger_agent_parse_options = mono_debugger_agent_parse_options; + fn_table->mono_debugger_agent_transport_handshake = mono_debugger_agent_transport_handshake; } + + #endif /* DISABLE_SDB */ diff --git a/src/mono/mono/mini/debugger-agent.h b/src/mono/mono/component/debugger-agent.h similarity index 100% rename from src/mono/mono/mini/debugger-agent.h rename to src/mono/mono/component/debugger-agent.h diff --git a/src/mono/mono/mini/debugger-engine.c b/src/mono/mono/component/debugger-engine.c similarity index 96% rename from src/mono/mono/mini/debugger-engine.c rename to src/mono/mono/component/debugger-engine.c index c9d85b9099c73a..edfc0044277154 100644 --- a/src/mono/mono/mini/debugger-engine.c +++ b/src/mono/mono/component/debugger-engine.c @@ -10,13 +10,13 @@ */ #include -#include "mini-runtime.h" +#include #if !defined (DISABLE_SDB) || defined(TARGET_WASM) #include -#include "seq-points.h" -#include "aot-runtime.h" +#include +#include #include "debugger-engine.h" #include "debugger-state-machine.h" #include @@ -24,6 +24,9 @@ static void mono_de_ss_start (SingleStepReq *ss_req, SingleStepArgs *ss_args); static gboolean mono_de_ss_update (SingleStepReq *req, MonoJitInfo *ji, SeqPoint *sp, void *tls, MonoContext *ctx, MonoMethod* method); +static void mono_de_init(DebuggerEngineCallbacks* cbs); +static gpointer get_this_addr(DbgEngineStackFrame* the_frame); +static MonoMethod* get_set_notification_method(MonoClass* async_builder_class); static DebuggerEngineCallbacks rt_callbacks; @@ -782,7 +785,7 @@ mono_de_cancel_ss (SingleStepReq *req) } void -mono_de_cancel_all_ss () +mono_de_cancel_all_ss (void) { int i; for (i = 0; i < the_ss_reqs->len; ++i) { @@ -1576,7 +1579,7 @@ mono_de_set_log_level (int level, FILE *file) * * Inits the shared debugger engine. Not reentrant. */ -void +static void mono_de_init (DebuggerEngineCallbacks *cbs) { rt_callbacks = *cbs; @@ -1678,7 +1681,7 @@ get_object_id_for_debugger_method (MonoClass* async_builder_class) return method; } -gpointer +static gpointer get_this_addr (DbgEngineStackFrame *the_frame) { StackFrame *frame = (StackFrame *)the_frame; @@ -1723,7 +1726,7 @@ get_async_method_builder (DbgEngineStackFrame *frame) return builder; } -MonoMethod* +static MonoMethod* get_set_notification_method (MonoClass* async_builder_class) { ERROR_DECL (error); @@ -1775,4 +1778,28 @@ mono_de_set_interp_var (MonoType *t, gpointer addr, guint8 *val_buf) return ERR_NONE; } + +void +debugger_engine_add_function_pointers(MonoComponentDebugger* fn_table) +{ + fn_table->mono_debugger_free_objref = mono_debugger_free_objref; + fn_table->mono_de_init = mono_de_init; + fn_table->mono_de_set_log_level = mono_de_set_log_level; + fn_table->mono_de_add_pending_breakpoints = mono_de_add_pending_breakpoints; + fn_table->mono_de_clear_breakpoint = mono_de_clear_breakpoint; + fn_table->mono_de_process_single_step = mono_de_process_single_step; + fn_table->mono_de_process_breakpoint = mono_de_process_breakpoint; + fn_table->mono_de_set_breakpoint = mono_de_set_breakpoint; + fn_table->mono_de_cancel_all_ss = mono_de_cancel_all_ss; + fn_table->mono_de_ss_create = mono_de_ss_create; + fn_table->mono_de_domain_add = mono_de_domain_add; + fn_table->mono_de_collect_breakpoints_by_sp = mono_de_collect_breakpoints_by_sp; + fn_table->mono_de_get_breakpoint_by_id = mono_de_get_breakpoint_by_id; + fn_table->mono_de_set_interp_var = mono_de_set_interp_var; + fn_table->set_set_notification_for_wait_completion_flag = set_set_notification_for_wait_completion_flag; + fn_table->get_notify_debugger_of_wait_completion_method = get_notify_debugger_of_wait_completion_method; + fn_table->get_class_to_get_builder_field = get_class_to_get_builder_field; + fn_table->get_object_id_for_debugger_method = get_object_id_for_debugger_method; +} + #endif diff --git a/src/mono/mono/mini/debugger-engine.h b/src/mono/mono/component/debugger-engine.h similarity index 79% rename from src/mono/mono/mini/debugger-engine.h rename to src/mono/mono/component/debugger-engine.h index 24ad575093e696..275f0381670b73 100644 --- a/src/mono/mono/mini/debugger-engine.h +++ b/src/mono/mono/component/debugger-engine.h @@ -2,12 +2,12 @@ * \file */ -#ifndef __MONO_DEBUGGER_ENGINE_H__ -#define __MONO_DEBUGGER_ENGINE_H__ +#ifndef __MONO_DEBUGGER_ENGINE_COMPONENT_H__ +#define __MONO_DEBUGGER_ENGINE_COMPONENT_H__ -#include "mini.h" +#include #include -#include +#include #include #include #include @@ -263,59 +263,6 @@ #define FRAME_FLAG_DEBUGGER_INVOKE MDBGPROT_FRAME_FLAG_DEBUGGER_INVOKE #define FRAME_FLAG_NATIVE_TRANSITION MDBGPROT_FRAME_FLAG_NATIVE_TRANSITION -typedef struct { - ModifierKind kind; - union { - int count; /* For kind == MOD_KIND_COUNT */ - MonoInternalThread *thread; /* For kind == MOD_KIND_THREAD_ONLY */ - MonoClass *exc_class; /* For kind == MONO_KIND_EXCEPTION_ONLY */ - MonoAssembly **assemblies; /* For kind == MONO_KIND_ASSEMBLY_ONLY */ - GHashTable *source_files; /* For kind == MONO_KIND_SOURCE_FILE_ONLY */ - GHashTable *type_names; /* For kind == MONO_KIND_TYPE_NAME_ONLY */ - StepFilter filter; /* For kind == MOD_KIND_STEP */ - } data; - gboolean caught, uncaught, subclasses, not_filtered_feature, everything_else; /* For kind == MOD_KIND_EXCEPTION_ONLY */ -} Modifier; - -typedef struct{ - int id; - int event_kind; - int suspend_policy; - int nmodifiers; - gpointer info; - Modifier modifiers [MONO_ZERO_LEN_ARRAY]; -} EventRequest; - -/* - * Describes a single step request. - */ -typedef struct { - EventRequest *req; - MonoInternalThread *thread; - StepDepth depth; - StepSize size; - StepFilter filter; - gpointer last_sp; - gpointer start_sp; - MonoMethod *start_method; - MonoMethod *last_method; - int last_line; - /* Whenever single stepping is performed using start/stop_single_stepping () */ - gboolean global; - /* The list of breakpoints used to implement step-over */ - GSList *bps; - /* The number of frames at the start of a step-over */ - int nframes; - /* If set, don't stop in methods that are not part of user assemblies */ - MonoAssembly** user_assemblies; - /* Used to distinguish stepping breakpoint hits in parallel tasks executions */ - int async_id; - /* Used to know if we are in process of async step-out and distishing from exception breakpoints */ - MonoMethod* async_stepout_method; - int refcount; -} SingleStepReq; - - /* * Contains information about an inserted breakpoint. */ @@ -326,64 +273,6 @@ typedef struct { MonoDomain *domain; } BreakpointInstance; -/* - * Contains generic information about a breakpoint. - */ -typedef struct { - /* - * The method where the breakpoint is placed. Can be NULL in which case it - * is inserted into every method. This is used to implement method entry/ - * exit events. Can be a generic method definition, in which case the - * breakpoint is inserted into every instance. - */ - MonoMethod *method; - long il_offset; - EventRequest *req; - /* - * A list of BreakpointInstance structures describing where the breakpoint - * was inserted. There could be more than one because of - * generics/appdomains/method entry/exit. - */ - GPtrArray *children; -} MonoBreakpoint; - -typedef struct { - MonoJitInfo *ji; - MonoDomain *domain; - MonoMethod *method; - guint32 native_offset; -} DbgEngineStackFrame; - -typedef struct { - /* - * Method where to start single stepping - */ - MonoMethod *method; - - /* - * If ctx is set, tls must belong to the same thread. - */ - MonoContext *ctx; - void *tls; - - /* - * Stopped at a throw site - */ - gboolean step_to_catch; - - /* - * Sequence point to start from. - */ - SeqPoint sp; - MonoSeqPointInfo *info; - - /* - * Frame data, will be freed at the end of ss_start if provided - */ - DbgEngineStackFrame **frames; - int nframes; -} SingleStepArgs; - /* * OBJECT IDS */ @@ -430,9 +319,9 @@ typedef struct gboolean has_ctx; } StackFrame; -void mono_debugger_free_objref (gpointer value); +void +debugger_engine_add_function_pointers(MonoComponentDebugger* fn_table); -typedef int DbgEngineErrorCode; #define DE_ERR_NONE 0 // WARNING WARNING WARNING // Error codes MUST match those of sdb for now @@ -453,32 +342,6 @@ mono_debugger_set_thread_state (DebuggerTlsData *ref, MonoDebuggerThreadState ex MonoDebuggerThreadState mono_debugger_get_thread_state (DebuggerTlsData *ref); -typedef struct { - MonoContext *(*tls_get_restore_state) (void *tls); - gboolean (*try_process_suspend) (void *tls, MonoContext *ctx, gboolean from_breakpoint); - gboolean (*begin_breakpoint_processing) (void *tls, MonoContext *ctx, MonoJitInfo *ji, gboolean from_signal); - void (*begin_single_step_processing) (MonoContext *ctx, gboolean from_signal); - - void (*ss_discard_frame_context) (void *tls); - void (*ss_calculate_framecount) (void *tls, MonoContext *ctx, gboolean force_use_ctx, DbgEngineStackFrame ***frames, int *nframes); - gboolean (*ensure_jit) (DbgEngineStackFrame *frame); - int (*ensure_runtime_is_suspended) (void); - - int (*get_this_async_id) (DbgEngineStackFrame *frame); - - void* (*create_breakpoint_events) (GPtrArray *ss_reqs, GPtrArray *bp_reqs, MonoJitInfo *ji, EventKind kind); - void (*process_breakpoint_events) (void *_evts, MonoMethod *method, MonoContext *ctx, int il_offset); - - gboolean (*set_set_notification_for_wait_completion_flag) (DbgEngineStackFrame *f); - MonoMethod* (*get_notify_debugger_of_wait_completion_method)(void); - - int (*ss_create_init_args) (SingleStepReq *ss_req, SingleStepArgs *args); - void (*ss_args_destroy) (SingleStepArgs *ss_args); - int (*handle_multiple_ss_requests)(void); -} DebuggerEngineCallbacks; - - -void mono_de_init (DebuggerEngineCallbacks *cbs); void mono_de_cleanup (void); void mono_de_set_log_level (int level, FILE *file); @@ -489,14 +352,14 @@ void mono_de_unlock (void); // domain handling void mono_de_foreach_domain (GHFunc func, gpointer user_data); void mono_de_domain_add (MonoDomain *domain); -void mono_de_domain_remove (MonoDomain *domain); +void mono_de_domain_remove (MonoDomain *domain); //never called, can remove? //breakpoints void mono_de_clear_breakpoint (MonoBreakpoint *bp); MonoBreakpoint* mono_de_set_breakpoint (MonoMethod *method, long il_offset, EventRequest *req, MonoError *error); void mono_de_collect_breakpoints_by_sp (SeqPoint *sp, MonoJitInfo *ji, GPtrArray *ss_reqs, GPtrArray *bp_reqs); void mono_de_clear_breakpoints_for_domain (MonoDomain *domain); -void mono_de_add_pending_breakpoints (MonoMethod *method, MonoJitInfo *ji); +void mono_de_add_pending_breakpoints(MonoMethod* method, MonoJitInfo* ji); void mono_de_clear_all_breakpoints (void); MonoBreakpoint * mono_de_get_breakpoint_by_id (int id); @@ -514,12 +377,12 @@ DbgEngineErrorCode mono_de_set_interp_var (MonoType *t, gpointer addr, guint8 *v 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); gpointer get_async_method_builder (DbgEngineStackFrame *frame); -MonoMethod* get_set_notification_method (MonoClass* async_builder_class); MonoMethod* get_notify_debugger_of_wait_completion_method (void); MonoMethod* get_object_id_for_debugger_method (MonoClass* async_builder_class); +void mono_debugger_free_objref(gpointer value); + #ifdef HOST_ANDROID #define PRINT_DEBUG_MSG(level, ...) do { if (G_UNLIKELY ((level) <= log_level)) { g_print (__VA_ARGS__); } } while (0) #define DEBUG(level,s) do { if (G_UNLIKELY ((level) <= log_level)) { s; } } while (0) diff --git a/src/mono/mono/mini/debugger-state-machine.c b/src/mono/mono/component/debugger-state-machine.c similarity index 99% rename from src/mono/mono/mini/debugger-state-machine.c rename to src/mono/mono/component/debugger-state-machine.c index 1aff76cbade321..c5b96b7aada531 100644 --- a/src/mono/mono/mini/debugger-state-machine.c +++ b/src/mono/mono/component/debugger-state-machine.c @@ -12,11 +12,10 @@ #include #include -#include -#include +#include "debugger-state-machine.h" #include #include -#include +#include "debugger-engine.h" #include #include diff --git a/src/mono/mono/mini/debugger-state-machine.h b/src/mono/mono/component/debugger-state-machine.h similarity index 100% rename from src/mono/mono/mini/debugger-state-machine.h rename to src/mono/mono/component/debugger-state-machine.h diff --git a/src/mono/mono/component/debugger-stub.c b/src/mono/mono/component/debugger-stub.c new file mode 100644 index 00000000000000..392406c8afa323 --- /dev/null +++ b/src/mono/mono/component/debugger-stub.c @@ -0,0 +1,328 @@ +debugger-stub.c// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// + +#include + +#include "mono/mini/mini-runtime.h" +#include "debugger-agent.h" + +#include + +static bool +debugger_avaliable (void); + +static void +stub_debugger_parse_options (char *options); + +static void +stub_debugger_init (void); + +static void +stub_debugger_breakpoint_hit (void *sigctx); + +static void +stub_debugger_single_step_event (void *sigctx); + +static void +stub_debugger_free_mem_manager (gpointer mem_manager); + +static void +stub_debugger_handle_exception (MonoException *exc, MonoContext *throw_ctx, MonoContext *catch_ctx, StackFrameInfo *catch_frame); + +static void +stub_debugger_begin_exception_filter (MonoException *exc, MonoContext *ctx, MonoContext *orig_ctx); + +static void +stub_debugger_end_exception_filter (MonoException *exc, MonoContext *ctx, MonoContext *orig_ctx); + +static void +stub_debugger_user_break (void); + +static void +stub_debugger_debug_log (int level, MonoString *category, MonoString *message); + +static gboolean +stub_debugger_debug_log_is_enabled (void); + +static void +stub_debugger_unhandled_exception (MonoException *exc); + +static void +stub_debugger_single_step_from_context (MonoContext *ctx); + +static void +stub_debugger_breakpoint_from_context (MonoContext *ctx); + +static void +stub_debugger_send_crash (char *json_dump, MonoStackHash *hashes, int pause); + +static void stub_register_transport (DebuggerTransport *trans); //debugger-agent +static gboolean stub_mono_debugger_agent_transport_handshake (void); +static void stub_mono_debugger_agent_parse_options (char *options); +static void stub_mono_de_init (DebuggerEngineCallbacks *cbs); //debugger-engine +static void stub_mono_debugger_free_objref (gpointer value); //debugger-engine removeAfterMergeWasmPR +static void stub_mono_de_set_log_level (int level, FILE *file); //debugger-engine removeAfterMergeWasmPR +static void stub_mono_de_add_pending_breakpoints (MonoMethod *method, MonoJitInfo *ji); //debugger-engine removeAfterMergeWasmPR +static void stub_mono_de_clear_breakpoint (MonoBreakpoint *bp); //debugger-engine removeAfterMergeWasmPR +static void stub_mono_de_process_single_step (void *tls, gboolean from_signal); //debugger-engine removeAfterMergeWasmPR +static void stub_mono_de_process_breakpoint (void *tls, gboolean from_signal); //debugger-engine removeAfterMergeWasmPR +static MonoBreakpoint *stub_mono_de_set_breakpoint (MonoMethod *method, long il_offset, EventRequest *req, MonoError *error); //debugger-engine removeAfterMergeWasmPR +static void stub_mono_de_cancel_all_ss (void); //debugger-engine removeAfterMergeWasmPR +static DbgEngineErrorCode stub_mono_de_ss_create (MonoInternalThread *thread, MdbgProtStepSize size, MdbgProtStepDepth depth, MdbgProtStepFilter filter, EventRequest *req); //debugger-engine removeAfterMergeWasmPR +static void stub_mono_de_domain_add (MonoDomain *domain); //debugger-engine removeAfterMergeWasmPR +static void stub_mono_de_collect_breakpoints_by_sp (SeqPoint *sp, MonoJitInfo *ji, GPtrArray *ss_reqs, GPtrArray *bp_reqs); //debugger-engine removeAfterMergeWasmPR +static MonoBreakpoint *stub_mono_de_get_breakpoint_by_id (int id); //debugger-engine removeAfterMergeWasmPR +static DbgEngineErrorCode stub_mono_de_set_interp_var (MonoType *t, gpointer addr, guint8 *val_buf); //debugger-engine removeAfterMergeWasmPR +static gboolean stub_set_set_notification_for_wait_completion_flag (DbgEngineStackFrame *frame); //debugger-engine removeAfterMergeWasmPR +static MonoMethod *stub_get_notify_debugger_of_wait_completion_method (void); //debugger-engine removeAfterMergeWasmPR +static MonoClass *stub_get_class_to_get_builder_field (DbgEngineStackFrame *frame); //debugger-engine removeAfterMergeWasmPR +static MonoMethod *stub_get_object_id_for_debugger_method (MonoClass *async_builder_class); //debugger-engine removeAfterMergeWasmPR + +static MonoComponentDebugger fn_table = { + { MONO_COMPONENT_ITF_VERSION, &debugger_avaliable }, + &stub_debugger_parse_options, + &stub_debugger_init, + &stub_debugger_breakpoint_hit, + &stub_debugger_single_step_event, + &stub_debugger_single_step_from_context, + &stub_debugger_breakpoint_from_context, + &stub_debugger_free_mem_manager, + &stub_debugger_unhandled_exception, + &stub_debugger_handle_exception, + &stub_debugger_begin_exception_filter, + &stub_debugger_end_exception_filter, + &stub_debugger_user_break, + &stub_debugger_debug_log, + &stub_debugger_debug_log_is_enabled, + &stub_debugger_send_crash, + &stub_register_transport, + &stub_mono_debugger_agent_transport_handshake, + &stub_mono_debugger_agent_parse_options, + &stub_mono_de_init, + &stub_mono_debugger_free_objref, + &stub_mono_de_set_log_level, + &stub_mono_de_add_pending_breakpoints, + &stub_mono_de_clear_breakpoint, + &stub_mono_de_process_single_step, + &stub_mono_de_process_breakpoint, + &stub_mono_de_set_breakpoint, + &stub_mono_de_cancel_all_ss, + &stub_mono_de_ss_create, + &stub_mono_de_domain_add, + &stub_mono_de_collect_breakpoints_by_sp, + &stub_mono_de_get_breakpoint_by_id, + &stub_mono_de_set_interp_var, + &stub_set_set_notification_for_wait_completion_flag, + &stub_get_notify_debugger_of_wait_completion_method, + &stub_get_class_to_get_builder_field, + &stub_get_object_id_for_debugger_method +}; + +static bool +debugger_avaliable (void) +{ + return false; +} + +MonoComponentDebugger * +mono_component_debugger_init (void) +{ + return &fn_table; +} + +static void +stub_debugger_parse_options (char *options) +{ + g_error ("This runtime is configured with the debugger agent disabled."); +} + +static void +stub_debugger_init (void) +{ +} + +static void +stub_debugger_breakpoint_hit (void *sigctx) +{ +} + +static void +stub_debugger_single_step_event (void *sigctx) +{ +} + +static void +stub_debugger_free_mem_manager (gpointer mem_manager) +{ +} + +static void +stub_debugger_handle_exception (MonoException *exc, MonoContext *throw_ctx, + MonoContext *catch_ctx, StackFrameInfo *catch_frame) +{ +} + +static void +stub_debugger_begin_exception_filter (MonoException *exc, MonoContext *ctx, MonoContext *orig_ctx) +{ +} + +static void +stub_debugger_end_exception_filter (MonoException *exc, MonoContext *ctx, MonoContext *orig_ctx) +{ +} + +static void +stub_debugger_user_break (void) +{ + G_BREAKPOINT (); +} + +static void +stub_debugger_debug_log (int level, MonoString *category, MonoString *message) +{ +} + +static gboolean +stub_debugger_debug_log_is_enabled (void) +{ + return FALSE; +} + +static void +stub_debugger_unhandled_exception (MonoException *exc) +{ + g_assert_not_reached (); +} + +static void +stub_debugger_single_step_from_context (MonoContext *ctx) +{ + g_assert_not_reached (); +} + +static void +stub_debugger_breakpoint_from_context (MonoContext *ctx) +{ + g_assert_not_reached (); +} + +static void +stub_debugger_send_crash (char *json_dump, MonoStackHash *hashes, int pause) +{ +} + +static void +stub_register_transport(DebuggerTransport *trans) //debugger-agent +{ +} + +static gboolean +stub_mono_debugger_agent_transport_handshake(void) +{ + g_assert_not_reached(); +} + +static void +stub_mono_debugger_agent_parse_options (char *options) +{ +} + +static void +stub_mono_de_init (DebuggerEngineCallbacks *cbs) +{ +} + +static void +stub_mono_debugger_free_objref (gpointer value) +{ +} + +static void +stub_mono_de_set_log_level (int level, FILE *file) +{ +} + +static void +stub_mono_de_add_pending_breakpoints (MonoMethod *method, MonoJitInfo *ji) +{ +} + +static void +stub_mono_de_clear_breakpoint (MonoBreakpoint *bp) +{ +} + +static void +stub_mono_de_process_single_step (void *tls, gboolean from_signal) +{ +} + +static void +stub_mono_de_process_breakpoint (void *tls, gboolean from_signal) +{ +} + +static MonoBreakpoint * +stub_mono_de_set_breakpoint (MonoMethod *method, long il_offset, EventRequest *req, MonoError *error) +{ + g_assert_not_reached(); +} + +static void +stub_mono_de_cancel_all_ss (void) +{ +} + +static DbgEngineErrorCode +stub_mono_de_ss_create (MonoInternalThread *thread, MdbgProtStepSize size, MdbgProtStepDepth depth, MdbgProtStepFilter filter, EventRequest *req) +{ + g_assert_not_reached(); +} + +static void +stub_mono_de_domain_add (MonoDomain *domain) +{ +} + +static void +stub_mono_de_collect_breakpoints_by_sp (SeqPoint *sp, MonoJitInfo *ji, GPtrArray *ss_reqs, GPtrArray *bp_reqs) +{ +} + +static MonoBreakpoint * +stub_mono_de_get_breakpoint_by_id (int id) +{ + g_assert_not_reached(); +} + +static DbgEngineErrorCode +stub_mono_de_set_interp_var (MonoType *t, gpointer addr, guint8 *val_buf) +{ + g_assert_not_reached(); +} + +static gboolean +stub_set_set_notification_for_wait_completion_flag (DbgEngineStackFrame *frame) +{ + g_assert_not_reached(); +} + +static MonoMethod * +stub_get_notify_debugger_of_wait_completion_method (void) +{ + g_assert_not_reached(); +} + +static MonoClass * +stub_get_class_to_get_builder_field (DbgEngineStackFrame *frame) +{ + g_assert_not_reached(); +} + +static MonoMethod * +stub_get_object_id_for_debugger_method (MonoClass *async_builder_class) +{ + g_assert_not_reached(); +} diff --git a/src/mono/mono/component/debugger.c b/src/mono/mono/component/debugger.c new file mode 100644 index 00000000000000..207f3eb3e748f5 --- /dev/null +++ b/src/mono/mono/component/debugger.c @@ -0,0 +1,33 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// + +#include + +#include "mono/mini/mini-runtime.h" + +#include +#include "debugger-agent.h" +#include "debugger-engine.h" + +static bool +debugger_avaliable (void); + +static MonoComponentDebugger fn_table = { + { MONO_COMPONENT_ITF_VERSION, &debugger_avaliable } +}; + +static bool +debugger_avaliable (void) +{ + return true; +} + + +MonoComponentDebugger * +mono_component_debugger_init (void) +{ + debugger_agent_add_function_pointers (&fn_table); + debugger_engine_add_function_pointers (&fn_table); + return &fn_table; +} diff --git a/src/mono/mono/component/debugger.h b/src/mono/mono/component/debugger.h new file mode 100644 index 00000000000000..8c619ea0c5d09b --- /dev/null +++ b/src/mono/mono/component/debugger.h @@ -0,0 +1,226 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// + +#ifndef _MONO_COMPONENT_DEBUGGER_H +#define _MONO_COMPONENT_DEBUGGER_H + +#include +#include "mono/metadata/threads-types.h" +#include "mono/utils/mono-error.h" +#include "mono/utils/mono-context.h" +#include "mono/utils/mono-stack-unwinding.h" +#include "mono/component/component.h" +#include "mono/mini/debugger-protocol.h" +#include "mono/metadata/seq-points-data.h" + +typedef struct { + MdbgProtModifierKind kind; + union { + int count; /* For kind == MOD_KIND_COUNT */ + MonoInternalThread *thread; /* For kind == MOD_KIND_THREAD_ONLY */ + MonoClass *exc_class; /* For kind == MONO_KIND_EXCEPTION_ONLY */ + MonoAssembly **assemblies; /* For kind == MONO_KIND_ASSEMBLY_ONLY */ + GHashTable *source_files; /* For kind == MONO_KIND_SOURCE_FILE_ONLY */ + GHashTable *type_names; /* For kind == MONO_KIND_TYPE_NAME_ONLY */ + MdbgProtStepFilter filter; /* For kind == MOD_KIND_STEP */ + } data; + gboolean caught, uncaught, subclasses, not_filtered_feature, everything_else; /* For kind == MOD_KIND_EXCEPTION_ONLY */ +} Modifier; + +typedef struct{ + int id; + int event_kind; + int suspend_policy; + int nmodifiers; + gpointer info; + Modifier modifiers [MONO_ZERO_LEN_ARRAY]; +} EventRequest; + +typedef struct { + MonoJitInfo *ji; + MonoDomain *domain; + MonoMethod *method; + guint32 native_offset; +} DbgEngineStackFrame; + + +typedef struct { + /* + * Method where to start single stepping + */ + MonoMethod *method; + + /* + * If ctx is set, tls must belong to the same thread. + */ + MonoContext *ctx; + void *tls; + + /* + * Stopped at a throw site + */ + gboolean step_to_catch; + + /* + * Sequence point to start from. + */ + SeqPoint sp; + MonoSeqPointInfo *info; + + /* + * Frame data, will be freed at the end of ss_start if provided + */ + DbgEngineStackFrame **frames; + int nframes; +} SingleStepArgs; + +typedef struct { + const char* name; + void (*connect) (const char* address); + void (*close1) (void); + void (*close2) (void); + gboolean(*send) (void* buf, int len); + int (*recv) (void* buf, int len); +} DebuggerTransport; + +typedef struct { + EventRequest *req; + MonoInternalThread *thread; + MdbgProtStepDepth depth; + MdbgProtStepSize size; + MdbgProtStepFilter filter; + gpointer last_sp; + gpointer start_sp; + MonoMethod *start_method; + MonoMethod *last_method; + int last_line; + /* Whenever single stepping is performed using start/stop_single_stepping () */ + gboolean global; + /* The list of breakpoints used to implement step-over */ + GSList *bps; + /* The number of frames at the start of a step-over */ + int nframes; + /* If set, don't stop in methods that are not part of user assemblies */ + MonoAssembly** user_assemblies; + /* Used to distinguish stepping breakpoint hits in parallel tasks executions */ + int async_id; + /* Used to know if we are in process of async step-out and distishing from exception breakpoints */ + MonoMethod* async_stepout_method; + int refcount; +} SingleStepReq; + +typedef struct { + MonoContext *(*tls_get_restore_state) (void *tls); + gboolean (*try_process_suspend) (void *tls, MonoContext *ctx, gboolean from_breakpoint); + gboolean (*begin_breakpoint_processing) (void *tls, MonoContext *ctx, MonoJitInfo *ji, gboolean from_signal); + void (*begin_single_step_processing) (MonoContext *ctx, gboolean from_signal); + + void (*ss_discard_frame_context) (void *tls); + void (*ss_calculate_framecount) (void *tls, MonoContext *ctx, gboolean force_use_ctx, DbgEngineStackFrame ***frames, int *nframes); + gboolean (*ensure_jit) (DbgEngineStackFrame *frame); + int (*ensure_runtime_is_suspended) (void); + + int (*get_this_async_id) (DbgEngineStackFrame *frame); + + void* (*create_breakpoint_events) (GPtrArray *ss_reqs, GPtrArray *bp_reqs, MonoJitInfo *ji, MdbgProtEventKind kind); + void (*process_breakpoint_events) (void *_evts, MonoMethod *method, MonoContext *ctx, int il_offset); + + gboolean (*set_set_notification_for_wait_completion_flag) (DbgEngineStackFrame *f); + MonoMethod* (*get_notify_debugger_of_wait_completion_method)(void); + + int (*ss_create_init_args) (SingleStepReq *ss_req, SingleStepArgs *args); + void (*ss_args_destroy) (SingleStepArgs *ss_args); + int (*handle_multiple_ss_requests)(void); +} DebuggerEngineCallbacks; + +/* + * Contains generic information about a breakpoint. + */ +typedef struct { + /* + * The method where the breakpoint is placed. Can be NULL in which case it + * is inserted into every method. This is used to implement method entry/ + * exit events. Can be a generic method definition, in which case the + * breakpoint is inserted into every instance. + */ + MonoMethod* method; + long il_offset; + EventRequest* req; + /* + * A list of BreakpointInstance structures describing where the breakpoint + * was inserted. There could be more than one because of + * generics/appdomains/method entry/exit. + */ + GPtrArray* children; +} MonoBreakpoint; + +typedef int DbgEngineErrorCode; + +typedef struct MonoComponentDebugger { + MonoComponent component; + void (*parse_options) (char *options); + void (*init) (void); + void (*breakpoint_hit) (void *sigctx); + void (*single_step_event) (void *sigctx); + void (*single_step_from_context) (MonoContext *ctx); + void (*breakpoint_from_context) (MonoContext *ctx); + void (*free_mem_manager) (gpointer mem_manager); + void (*unhandled_exception) (MonoException *exc); + void (*handle_exception) (MonoException *exc, MonoContext *throw_ctx, + MonoContext *catch_ctx, MonoStackFrameInfo *catch_frame); + void (*begin_exception_filter) (MonoException *exc, MonoContext *ctx, MonoContext *orig_ctx); + void (*end_exception_filter) (MonoException *exc, MonoContext *ctx, MonoContext *orig_ctx); + void (*user_break) (void); + void (*debug_log) (int level, MonoString *category, MonoString *message); + gboolean (*debug_log_is_enabled) (void); + void (*send_crash) (char *json_dump, MonoStackHash *hashes, int pause); + void (*register_transport) (DebuggerTransport* trans); //debugger-agent + gboolean (*mono_debugger_agent_transport_handshake) (void); + void (*mono_debugger_agent_parse_options) (char* options); + void (*mono_de_init) (DebuggerEngineCallbacks *cbs); //debugger-engine + void (*mono_debugger_free_objref) (gpointer value); //debugger-engine removeAfterMergeWasmPR + void (*mono_de_set_log_level) (int level, FILE* file); //debugger-engine removeAfterMergeWasmPR + void (*mono_de_add_pending_breakpoints) (MonoMethod* method, MonoJitInfo* ji); //debugger-engine removeAfterMergeWasmPR + void (*mono_de_clear_breakpoint) (MonoBreakpoint* bp); //debugger-engine removeAfterMergeWasmPR + void (*mono_de_process_single_step) (void* tls, gboolean from_signal); //debugger-engine removeAfterMergeWasmPR + void (*mono_de_process_breakpoint) (void* tls, gboolean from_signal); //debugger-engine removeAfterMergeWasmPR + MonoBreakpoint* (*mono_de_set_breakpoint) (MonoMethod* method, long il_offset, EventRequest* req, MonoError* error); //debugger-engine removeAfterMergeWasmPR + void (*mono_de_cancel_all_ss) (void); //debugger-engine removeAfterMergeWasmPR + DbgEngineErrorCode (*mono_de_ss_create) (MonoInternalThread* thread, MdbgProtStepSize size, MdbgProtStepDepth depth, MdbgProtStepFilter filter, EventRequest* req); //debugger-engine removeAfterMergeWasmPR + void (*mono_de_domain_add) (MonoDomain* domain); //debugger-engine removeAfterMergeWasmPR + void (*mono_de_collect_breakpoints_by_sp) (SeqPoint* sp, MonoJitInfo* ji, GPtrArray* ss_reqs, GPtrArray* bp_reqs); //debugger-engine removeAfterMergeWasmPR + MonoBreakpoint* (*mono_de_get_breakpoint_by_id) (int id); //debugger-engine removeAfterMergeWasmPR + DbgEngineErrorCode (*mono_de_set_interp_var) (MonoType* t, gpointer addr, guint8* val_buf); //debugger-engine removeAfterMergeWasmPR + gboolean (*set_set_notification_for_wait_completion_flag) (DbgEngineStackFrame* frame); //debugger-engine removeAfterMergeWasmPR + MonoMethod* (*get_notify_debugger_of_wait_completion_method) (void); //debugger-engine removeAfterMergeWasmPR + MonoClass* (*get_class_to_get_builder_field) (DbgEngineStackFrame* frame); //debugger-engine removeAfterMergeWasmPR + MonoMethod* (*get_object_id_for_debugger_method) (MonoClass* async_builder_class); //debugger-engine removeAfterMergeWasmPR +} MonoComponentDebugger; + + +typedef int DbgEngineErrorCodeTHAYS; +#define DE_ERR_NONE 0 +// WARNING WARNING WARNING +// Error codes MUST match those of sdb for now +#define DE_ERR_NOT_IMPLEMENTED 100 + +#if defined(HOST_WIN32) && !HAVE_API_SUPPORT_WIN32_CONSOLE +void win32_debugger_log(FILE *stream, const gchar *format, ...); +#define PRINT_ERROR_MSG(...) win32_debugger_log (log_file, __VA_ARGS__) +#define PRINT_MSG(...) win32_debugger_log (log_file, __VA_ARGS__) +#else +#define PRINT_ERROR_MSG(...) g_printerr (__VA_ARGS__) +#define PRINT_MSG(...) g_print (__VA_ARGS__) +#endif + +typedef struct _DebuggerTlsData DebuggerTlsDataTHAYS; + +MONO_COMPONENT_EXPORT_ENTRYPOINT +MonoComponentDebugger * +mono_component_debugger_init (void); + +#define MONO_DBG_CALLBACKS_VERSION (4) + + +#endif/*_MONO_COMPONENT_DEBUGGER_H*/ diff --git a/src/mono/mono/metadata/components.c b/src/mono/mono/metadata/components.c index 765bc726a2efee..d0a2c1257f23db 100644 --- a/src/mono/mono/metadata/components.c +++ b/src/mono/mono/metadata/components.c @@ -6,6 +6,7 @@ #include #include #include "mono/component/component.h" +#include "mono/component/debugger.h" #include "mono/component/hot_reload.h" #include "mono/component/event_pipe.h" #include "mono/component/diagnostics_server.h" @@ -32,8 +33,14 @@ typedef struct _MonoComponentEntry { #define HOT_RELOAD_LIBRARY_NAME "hot_reload" #define HOT_RELOAD_COMPONENT_NAME HOT_RELOAD_LIBRARY_NAME + +#define DEBUGGER_LIBRARY_NAME "debugger" +#define DEBUGGER_COMPONENT_NAME DEBUGGER_LIBRARY_NAME + MonoComponentHotReload *hot_reload = NULL; +MonoComponentDebugger *debugger = NULL; + MonoComponentEventPipe *event_pipe = NULL; MonoComponentDiagnosticsServer *diagnostics_server = NULL; @@ -44,6 +51,7 @@ MonoComponentDiagnosticsServer *diagnostics_server = NULL; /* One per component */ MonoComponentEntry components[] = { + { DEBUGGER_LIBRARY_NAME, DEBUGGER_COMPONENT_NAME, COMPONENT_INIT_FUNC (debugger), (MonoComponent**)&debugger, NULL }, { HOT_RELOAD_LIBRARY_NAME, HOT_RELOAD_COMPONENT_NAME, COMPONENT_INIT_FUNC (hot_reload), (MonoComponent**)&hot_reload, NULL }, { DIAGNOSTICS_TRACING_LIBRARY_NAME, EVENT_PIPE_COMPONENT_NAME, COMPONENT_INIT_FUNC (event_pipe), (MonoComponent**)&event_pipe, NULL }, { DIAGNOSTICS_TRACING_LIBRARY_NAME, DIAGNOSTICS_SERVER_COMPONENT_NAME, COMPONENT_INIT_FUNC (diagnostics_server), (MonoComponent**)&diagnostics_server, NULL }, diff --git a/src/mono/mono/metadata/components.h b/src/mono/mono/metadata/components.h index 0a022e349a28b3..2aceed820c9d3d 100644 --- a/src/mono/mono/metadata/components.h +++ b/src/mono/mono/metadata/components.h @@ -9,6 +9,7 @@ #include #include #include +#include void mono_component_event_pipe_100ns_ticks_start (void); @@ -44,4 +45,12 @@ mono_component_diagnostics_server (void) return diagnostics_server; } +static inline +MonoComponentDebugger * +mono_component_debugger (void) +{ + extern MonoComponentDebugger *debugger; + return debugger; +} + #endif/*_MONO_METADATA_COMPONENTS_H*/ diff --git a/src/mono/mono/mini/CMakeLists.txt b/src/mono/mono/mini/CMakeLists.txt index ba786bcf9d89e1..6a8d50f7a5fcd8 100644 --- a/src/mono/mono/mini/CMakeLists.txt +++ b/src/mono/mono/mini/CMakeLists.txt @@ -168,15 +168,11 @@ set(mini_common_sources monovm.c) set(debugger_sources - debugger-engine.h - debugger-engine.c - debugger-agent.h - debugger-agent.c + debugger-agent-external.h + debugger-agent-external.c debugger-protocol.h debugger-protocol.c - debugger-agent-stubs.c - debugger-state-machine.h - debugger-state-machine.c) + ) set(amd64_sources mini-amd64.c diff --git a/src/mono/mono/mini/aot-runtime.c b/src/mono/mono/mini/aot-runtime.c index 6a181644fee5fb..5efa6184fb60a1 100644 --- a/src/mono/mono/mini/aot-runtime.c +++ b/src/mono/mono/mini/aot-runtime.c @@ -65,7 +65,6 @@ #include "mini.h" #include "seq-points.h" -#include "debugger-agent.h" #include "aot-compiler.h" #include "aot-runtime.h" #include "jit-icalls.h" @@ -73,6 +72,8 @@ #include "mono-private-unstable.h" #include "llvmonly-runtime.h" +#include + #ifndef DISABLE_AOT #ifdef MONO_ARCH_CODE_EXEC_ONLY @@ -5321,10 +5322,10 @@ load_function_full (MonoAotModule *amodule, const char *name, MonoTrampInfo **ou MONO_AOT_ICALL (mono_exception_from_token) case MONO_JIT_ICALL_mono_debugger_agent_single_step_from_context: - target = (gpointer)mini_get_dbg_callbacks ()->single_step_from_context; + target = (gpointer)mono_component_debugger ()->single_step_from_context; break; case MONO_JIT_ICALL_mono_debugger_agent_breakpoint_from_context: - target = (gpointer)mini_get_dbg_callbacks ()->breakpoint_from_context; + target = (gpointer)mono_component_debugger ()->breakpoint_from_context; break; case MONO_JIT_ICALL_mono_throw_exception: target = mono_get_throw_exception_addr (); diff --git a/src/mono/mono/mini/debugger-agent-external.c b/src/mono/mono/mini/debugger-agent-external.c new file mode 100644 index 00000000000000..1c64fb4da014d8 --- /dev/null +++ b/src/mono/mono/mini/debugger-agent-external.c @@ -0,0 +1,37 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// + +#include +#include + +#ifndef DISABLE_SDB + +MONO_API void +mono_debugger_agent_register_transport (DebuggerTransport *trans); + +void +mono_debugger_agent_register_transport (DebuggerTransport *trans) +{ + mono_component_debugger ()->register_transport (trans); +} + +gboolean +mono_debugger_agent_transport_handshake (void) +{ + return mono_component_debugger ()->mono_debugger_agent_transport_handshake (); +} + +void +mono_debugger_agent_init (void) +{ + //not need to do anything anymore +} + +void +mono_debugger_agent_parse_options (char *options) +{ + mono_component_debugger ()->mono_debugger_agent_parse_options (options); +} + +#endif /* DISABLE_SDB */ diff --git a/src/mono/mono/mini/debugger-agent-external.h b/src/mono/mono/mini/debugger-agent-external.h new file mode 100644 index 00000000000000..0066255521305d --- /dev/null +++ b/src/mono/mono/mini/debugger-agent-external.h @@ -0,0 +1,19 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// + +#ifndef __MONO_DEBUGGER_AGENT_H__ +#define __MONO_DEBUGGER_AGENT_H__ + +#include "mini.h" + +MONO_API void +mono_debugger_agent_init (void); + +MONO_API void +mono_debugger_agent_parse_options (char *options); + +MONO_API MONO_RT_EXTERNAL_ONLY gboolean +mono_debugger_agent_transport_handshake (void); + +#endif \ No newline at end of file diff --git a/src/mono/mono/mini/driver.c b/src/mono/mono/mini/driver.c index 4c694d5d0c558f..5ecb4ee07d2bab 100644 --- a/src/mono/mono/mini/driver.c +++ b/src/mono/mono/mini/driver.c @@ -66,7 +66,6 @@ #include #include #include -#include "debugger-agent.h" #if TARGET_OSX # include #endif diff --git a/src/mono/mono/mini/interp/interp.c b/src/mono/mono/mini/interp/interp.c index 1c7468ba3cadc7..f16527f17ad9be 100644 --- a/src/mono/mono/mini/interp/interp.c +++ b/src/mono/mono/mini/interp/interp.c @@ -29,6 +29,7 @@ #include #include #include +#include #ifdef HAVE_ALLOCA_H # include @@ -72,7 +73,6 @@ #include #include #include -#include #include #include @@ -1620,9 +1620,6 @@ interp_init_delegate (MonoDelegate *del, MonoError *error) } if (del->method_ptr && !del->method) { /* Delegate created from methodInfo.MethodHandle.GetFunctionPointer() */ del->interp_method = (InterpMethod *)del->method_ptr; - if (mono_llvm_only) - // FIXME: - g_assert_not_reached (); } else if (del->method) { /* Delegate created dynamically */ del->interp_method = mono_interp_get_imethod (del->method, error); @@ -1662,57 +1659,13 @@ interp_init_delegate (MonoDelegate *del, MonoError *error) } } -/* Convert a function pointer for a managed method to an InterpMethod* */ -static InterpMethod* -ftnptr_to_imethod (gpointer addr) -{ - InterpMethod *imethod; - - if (mono_llvm_only) { - ERROR_DECL (error); - /* Function pointers are represented by a MonoFtnDesc structure */ - MonoFtnDesc *ftndesc = (MonoFtnDesc*)addr; - g_assert (ftndesc); - g_assert (ftndesc->method); - - imethod = ftndesc->interp_method; - if (!imethod) { - imethod = mono_interp_get_imethod (ftndesc->method, error); - mono_error_assert_ok (error); - mono_memory_barrier (); - ftndesc->interp_method = imethod; - } - } else { - /* Function pointers are represented by their InterpMethod */ - imethod = (InterpMethod*)addr; - } - return imethod; -} - -static gpointer -imethod_to_ftnptr (InterpMethod *imethod) -{ - if (mono_llvm_only) { - ERROR_DECL (error); - /* Function pointers are represented by a MonoFtnDesc structure */ - MonoFtnDesc *ftndesc = imethod->ftndesc; - if (!ftndesc) { - ftndesc = mini_llvmonly_load_method_ftndesc (imethod->method, FALSE, FALSE, error); - mono_error_assert_ok (error); - mono_memory_barrier (); - imethod->ftndesc = ftndesc; - } - return ftndesc; - } else { - return imethod; - } -} - static void interp_delegate_ctor (MonoObjectHandle this_obj, MonoObjectHandle target, gpointer addr, MonoError *error) { - /* addr is the result of an LDFTN opcode */ - InterpMethod *imethod = ftnptr_to_imethod (addr); + /* + * addr is the result of an LDFTN opcode, i.e. an InterpMethod + */ + InterpMethod *imethod = (InterpMethod*)addr; if (!(imethod->method->flags & METHOD_ATTRIBUTE_STATIC)) { MonoMethod *invoke = mono_get_delegate_invoke_internal (mono_handle_class (this_obj)); @@ -3286,7 +3239,7 @@ interp_exec_method (InterpFrame *frame, ThreadContext *context, FrameClauseArgs MINT_IN_BREAK; MINT_IN_CASE(MINT_BREAK) ++ip; - do_debugger_tramp (mini_get_dbg_callbacks ()->user_break, frame); + do_debugger_tramp (mono_component_debugger ()->user_break, frame); MINT_IN_BREAK; MINT_IN_CASE(MINT_BREAKPOINT) ++ip; @@ -3467,9 +3420,7 @@ interp_exec_method (InterpFrame *frame, ThreadContext *context, FrameClauseArgs csignature = (MonoMethodSignature*)frame->imethod->data_items [ip [4]]; - /* In mixed mode, stay in the interpreter for simplicity even if there is an AOT version of the callee */ - cmethod = ftnptr_to_imethod (LOCAL_VAR (ip [2], gpointer)); - + cmethod = LOCAL_VAR (ip [2], InterpMethod*); if (cmethod->method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) { cmethod = mono_interp_get_imethod (mono_marshal_get_native_wrapper (cmethod->method, FALSE, FALSE), error); mono_interp_error_cleanup (error); /* FIXME: don't swallow the error */ @@ -6504,15 +6455,8 @@ MINT_IN_CASE(MINT_BRTRUE_I8_SP) ZEROP_SP(gint64, !=); MINT_IN_BREAK; #undef RELOP_FP #undef RELOP_CAST - MINT_IN_CASE(MINT_LDFTN_ADDR) { - LOCAL_VAR (ip [1], gpointer) = frame->imethod->data_items [ip [2]]; - ip += 3; - MINT_IN_BREAK; - } MINT_IN_CASE(MINT_LDFTN) { - InterpMethod *m = (InterpMethod*)frame->imethod->data_items [ip [2]]; - - LOCAL_VAR (ip [1], gpointer) = imethod_to_ftnptr (m); + LOCAL_VAR (ip [1], gpointer) = frame->imethod->data_items [ip [2]]; ip += 3; MINT_IN_BREAK; } @@ -6520,20 +6464,16 @@ MINT_IN_CASE(MINT_BRTRUE_I8_SP) ZEROP_SP(gint64, !=); MINT_IN_BREAK; InterpMethod *m = (InterpMethod*)frame->imethod->data_items [ip [3]]; MonoObject *o = LOCAL_VAR (ip [2], MonoObject*); NULL_CHECK (o); - - m = get_virtual_method (m, o->vtable); - LOCAL_VAR (ip [1], gpointer) = imethod_to_ftnptr (m); + + LOCAL_VAR (ip [1], gpointer) = get_virtual_method (m, o->vtable); ip += 4; MINT_IN_BREAK; } MINT_IN_CASE(MINT_LDFTN_DYNAMIC) { error_init_reuse (error); - - MonoMethod *cmethod = LOCAL_VAR (ip [2], MonoMethod*); - - InterpMethod *m = mono_interp_get_imethod (cmethod, error); + InterpMethod *m = mono_interp_get_imethod (LOCAL_VAR (ip [2], MonoMethod*), error); mono_error_assert_ok (error); - LOCAL_VAR (ip [1], gpointer) = imethod_to_ftnptr (m); + LOCAL_VAR (ip [1], gpointer) = m; ip += 3; MINT_IN_BREAK; } @@ -6715,7 +6655,7 @@ MINT_IN_CASE(MINT_BRTRUE_I8_SP) ZEROP_SP(gint64, !=); MINT_IN_BREAK; mono_error_assert_ok (error); } g_assert (del->interp_method); - LOCAL_VAR (ip [1], gpointer) = imethod_to_ftnptr (del->interp_method); + LOCAL_VAR (ip [1], gpointer) = del->interp_method; ip += 3; MINT_IN_BREAK; } diff --git a/src/mono/mono/mini/method-to-ir.c b/src/mono/mono/mini/method-to-ir.c index 964d31d41269e0..a26805db41b7eb 100644 --- a/src/mono/mono/mini/method-to-ir.c +++ b/src/mono/mono/mini/method-to-ir.c @@ -80,7 +80,6 @@ #include "jit-icalls.h" #include "jit.h" -#include "debugger-agent.h" #include "seq-points.h" #include "aot-compiler.h" #include "mini-llvm.h" @@ -7155,10 +7154,7 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b goto calli_end; } } - if (cfg->llvm_only && !(cfg->method->wrapper_type && cfg->method->wrapper_type != MONO_WRAPPER_DYNAMIC_METHOD)) - ins = mini_emit_llvmonly_calli (cfg, fsig, sp, addr); - else - ins = (MonoInst*)mini_emit_calli_full (cfg, fsig, sp, addr, NULL, NULL, tailcall); + ins = (MonoInst*)mini_emit_calli_full (cfg, fsig, sp, addr, NULL, NULL, tailcall); goto calli_end; } case MONO_CEE_CALL: @@ -7392,11 +7388,9 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b } /* Conversion to a JIT intrinsic */ - gboolean ins_type_initialized; - if ((ins = mini_emit_inst_for_method (cfg, cmethod, fsig, sp, &ins_type_initialized))) { + if ((ins = mini_emit_inst_for_method (cfg, cmethod, fsig, sp))) { if (!MONO_TYPE_IS_VOID (fsig->ret)) { - if (!ins_type_initialized) - mini_type_to_eval_stack_type ((cfg), fsig->ret, ins); + mini_type_to_eval_stack_type ((cfg), fsig->ret, ins); emit_widen = FALSE; } // FIXME This is only missed if in fact the intrinsic involves a call. @@ -10260,7 +10254,7 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b EMIT_NEW_PCONST (cfg, ins, rt); } ins->type = STACK_OBJ; - ins->klass = mono_defaults.runtimetype_class; + ins->klass = cmethod->klass; il_op = (MonoOpcodeEnum)next_ip [0]; next_ip += 5; } else { diff --git a/src/mono/mono/mini/mini-exceptions.c b/src/mono/mono/mini/mini-exceptions.c index 9ffc8410766046..d6df5b150120d4 100644 --- a/src/mono/mono/mini/mini-exceptions.c +++ b/src/mono/mono/mini/mini-exceptions.c @@ -70,11 +70,10 @@ #include #include #include +#include #include "mini.h" #include "trace.h" -#include "debugger-agent.h" -#include "debugger-engine.h" #include "seq-points.h" #include "llvm-runtime.h" #include "mini-llvm.h" @@ -2392,7 +2391,7 @@ handle_exception_first_pass (MonoContext *ctx, MonoObject *obj, gint32 *out_filt #endif } - mini_get_dbg_callbacks ()->begin_exception_filter (mono_ex, ctx, &initial_ctx); + mono_component_debugger ()->begin_exception_filter (mono_ex, ctx, &initial_ctx); if (G_UNLIKELY (mono_profiler_clauses_enabled ())) { jit_tls->orig_ex_ctx_set = TRUE; @@ -2416,7 +2415,7 @@ handle_exception_first_pass (MonoContext *ctx, MonoObject *obj, gint32 *out_filt if (enable_trace) g_print ("[%p:] EXCEPTION filter result: %d\n", (void*)(gsize)mono_native_thread_id_get (), filtered); - mini_get_dbg_callbacks ()->end_exception_filter (mono_ex, ctx, &initial_ctx); + mono_component_debugger ()->end_exception_filter (mono_ex, ctx, &initial_ctx); if (filtered && out_filter_idx) *out_filter_idx = filter_idx; if (out_ji) @@ -2657,7 +2656,7 @@ mono_handle_exception_internal (MonoContext *ctx, MonoObject *obj, gboolean resu if (res == MONO_FIRST_PASS_UNHANDLED) { if (mini_debug_options.break_on_exc) G_BREAKPOINT (); - mini_get_dbg_callbacks ()->handle_exception ((MonoException *)obj, ctx, NULL, NULL); + mono_component_debugger ()->handle_exception ((MonoException *)obj, ctx, NULL, NULL); // FIXME: This runs managed code so it might cause another stack overflow when // we are handling a stack overflow @@ -2667,21 +2666,21 @@ mono_handle_exception_internal (MonoContext *ctx, MonoObject *obj, gboolean resu gboolean unhandled = FALSE; if (unhandled) - mini_get_dbg_callbacks ()->handle_exception ((MonoException *)obj, ctx, NULL, NULL); + mono_component_debugger ()->handle_exception ((MonoException *)obj, ctx, NULL, NULL); else if (!ji || (jinfo_get_method (ji)->wrapper_type == MONO_WRAPPER_RUNTIME_INVOKE)) { if (last_mono_wrapper_runtime_invoke && !mono_thread_internal_current ()->threadpool_thread) { - mini_get_dbg_callbacks ()->handle_exception ((MonoException *)obj, ctx, NULL, NULL); + mono_component_debugger ()->handle_exception ((MonoException *)obj, ctx, NULL, NULL); if (mini_get_debug_options ()->top_runtime_invoke_unhandled) { mini_set_abort_threshold (&catch_frame); mono_unhandled_exception_internal (obj); } } else { - mini_get_dbg_callbacks ()->handle_exception ((MonoException *)obj, ctx, &ctx_cp, &catch_frame); + mono_component_debugger ()->handle_exception ((MonoException *)obj, ctx, &ctx_cp, &catch_frame); } } else if (res != MONO_FIRST_PASS_CALLBACK_TO_NATIVE) if (!is_caught_unmanaged) - mini_get_dbg_callbacks ()->handle_exception ((MonoException *)obj, ctx, &ctx_cp, &catch_frame); + mono_component_debugger ()->handle_exception ((MonoException *)obj, ctx, &ctx_cp, &catch_frame); } } diff --git a/src/mono/mono/mini/mini-runtime.c b/src/mono/mono/mini/mini-runtime.c index 09944b33a7234b..ed6a91c820dded 100644 --- a/src/mono/mono/mini/mini-runtime.c +++ b/src/mono/mono/mini/mini-runtime.c @@ -86,7 +86,6 @@ #include "mini-gc.h" #include "mini-llvm.h" -#include "debugger-agent.h" #include "lldb.h" #include "mini-runtime.h" #include "interp/interp.h" @@ -2687,22 +2686,6 @@ mono_jit_compile_method_jit_only (MonoMethod *method, MonoError *error) return code; } -/* - * get_ftnptr_for_method: - * - * Return a function pointer for METHOD which is indirectly callable from managed code. - * On llvmonly, this returns a MonoFtnDesc, otherwise it returns a normal function pointer. - */ -static gpointer -get_ftnptr_for_method (MonoMethod *method, MonoError *error) -{ - if (!mono_llvm_only) { - return mono_jit_compile_method (method, error); - } else { - return mini_llvmonly_load_method_ftndesc (method, FALSE, FALSE, error); - } -} - #ifdef MONO_ARCH_HAVE_INVALIDATE_METHOD static void invalidated_delegate_trampoline (char *desc) @@ -3507,10 +3490,10 @@ MONO_SIG_HANDLER_FUNC (, mono_sigsegv_signal_handler) #if defined(MONO_ARCH_SOFT_DEBUG_SUPPORTED) && defined(HAVE_SIG_INFO) if (mono_arch_is_single_step_event (info, ctx)) { - mini_get_dbg_callbacks ()->single_step_event (ctx); + mono_component_debugger ()->single_step_event (ctx); return; } else if (mono_arch_is_breakpoint_event (info, ctx)) { - mini_get_dbg_callbacks ()->breakpoint_hit (ctx); + mono_component_debugger ()->breakpoint_hit (ctx); return; } #endif @@ -4141,7 +4124,7 @@ free_jit_mem_manager (MonoMemoryManager *mem_manager) g_hash_table_destroy (info->seq_points); g_hash_table_destroy (info->arch_seq_points); if (info->agent_info) - mini_get_dbg_callbacks ()->free_mem_manager (info); + mono_component_debugger ()->free_mem_manager (info); g_hash_table_destroy (info->gsharedvt_arg_tramp_hash); if (info->llvm_jit_callees) { g_hash_table_foreach (info->llvm_jit_callees, free_jit_callee_list, NULL); @@ -4208,21 +4191,6 @@ mini_install_interp_callbacks (const MonoEECallbacks *cbs) mono_interp_callbacks_pointer = cbs; } -static MonoDebuggerCallbacks dbg_cbs; - -void -mini_install_dbg_callbacks (MonoDebuggerCallbacks *cbs) -{ - g_assert (cbs->version == MONO_DBG_CALLBACKS_VERSION); - memcpy (&dbg_cbs, cbs, sizeof (MonoDebuggerCallbacks)); -} - -MonoDebuggerCallbacks* -mini_get_dbg_callbacks (void) -{ - return &dbg_cbs; -} - int mono_ee_api_version (void) { @@ -4281,13 +4249,8 @@ mini_init (const char *filename, const char *runtime_version) mono_ee_interp_init (mono_interp_opts_string); #endif - mono_debugger_agent_stub_init (); -#ifndef DISABLE_SDB - mono_debugger_agent_init (); -#endif - if (sdb_options) - mini_get_dbg_callbacks ()->parse_options (sdb_options); + mono_component_debugger ()->parse_options (sdb_options); mono_os_mutex_init_recursive (&jit_mutex); @@ -4326,8 +4289,8 @@ mini_init (const char *filename, const char *runtime_version) callbacks.get_runtime_build_info = mono_get_runtime_build_info; callbacks.get_runtime_build_version = mono_get_runtime_build_version; callbacks.set_cast_details = mono_set_cast_details; - callbacks.debug_log = mini_get_dbg_callbacks ()->debug_log; - callbacks.debug_log_is_enabled = mini_get_dbg_callbacks ()->debug_log_is_enabled; + callbacks.debug_log = mono_component_debugger ()->debug_log; + callbacks.debug_log_is_enabled = mono_component_debugger ()->debug_log_is_enabled; callbacks.get_vtable_trampoline = mini_get_vtable_trampoline; callbacks.get_imt_trampoline = mini_get_imt_trampoline; callbacks.imt_entry_inited = mini_imt_entry_inited; @@ -4342,7 +4305,6 @@ mini_init (const char *filename, const char *runtime_version) callbacks.create_jit_trampoline = mono_create_jit_trampoline; callbacks.create_delegate_trampoline = mono_create_delegate_trampoline; callbacks.free_method = mono_jit_free_method; - callbacks.get_ftnptr = get_ftnptr_for_method; #endif callbacks.is_interpreter_enabled = mini_is_interpreter_enabled; callbacks.get_weak_field_indexes = mono_aot_get_weak_field_indexes; @@ -4422,7 +4384,7 @@ mini_init (const char *filename, const char *runtime_version) if (default_opt & MONO_OPT_AOT) mono_aot_init (); - mini_get_dbg_callbacks ()->init (); + mono_component_debugger ()->init (); #ifdef TARGET_WASM mono_wasm_debugger_init (); @@ -4803,7 +4765,7 @@ register_icalls (void) register_icall (mono_fill_class_rgctx, mono_icall_sig_ptr_ptr_int, FALSE); register_icall (mono_fill_method_rgctx, mono_icall_sig_ptr_ptr_int, FALSE); - register_dyn_icall (mini_get_dbg_callbacks ()->user_break, mono_debugger_agent_user_break, mono_icall_sig_void, FALSE); + register_dyn_icall (mono_component_debugger ()->user_break, mono_debugger_agent_user_break, mono_icall_sig_void, FALSE); register_icall (mini_llvm_init_method, mono_icall_sig_void_ptr_ptr_ptr_ptr, TRUE); register_icall_no_wrapper (mini_llvmonly_resolve_iface_call_gsharedvt, mono_icall_sig_ptr_object_int_ptr_ptr); diff --git a/src/mono/mono/mini/mini-runtime.h b/src/mono/mono/mini/mini-runtime.h index 67d441495bcc84..0cf831ab62d3d6 100644 --- a/src/mono/mono/mini/mini-runtime.h +++ b/src/mono/mono/mini/mini-runtime.h @@ -510,11 +510,6 @@ MonoEECallbacks* mono_interp_callbacks_pointer; #define mini_get_interp_callbacks() (mono_interp_callbacks_pointer) -typedef struct _MonoDebuggerCallbacks MonoDebuggerCallbacks; - -void mini_install_dbg_callbacks (MonoDebuggerCallbacks *cbs); -MonoDebuggerCallbacks *mini_get_dbg_callbacks (void); - MonoDomain* mini_init (const char *filename, const char *runtime_version); void mini_cleanup (MonoDomain *domain); MONO_API MonoDebugOptions *mini_get_debug_options (void); diff --git a/src/mono/mono/mini/mini-wasm-debugger.c b/src/mono/mono/mini/mini-wasm-debugger.c index 352bb81deb9232..3fda2920950d97 100644 --- a/src/mono/mono/mini/mini-wasm-debugger.c +++ b/src/mono/mono/mini/mini-wasm-debugger.c @@ -11,6 +11,7 @@ #include #include #include +#include //XXX This is dirty, extend ee.h to support extracting info from MonoInterpFrameHandle #include @@ -140,13 +141,13 @@ inplace_tolower (char *c) static void jit_done (MonoProfiler *prof, MonoMethod *method, MonoJitInfo *jinfo) { - mono_de_add_pending_breakpoints (method, jinfo); + mono_component_debugger ()->mono_de_add_pending_breakpoints (method, jinfo); } static void appdomain_load (MonoProfiler *prof, MonoDomain *domain) { - mono_de_domain_add (domain); + mono_component_debugger ()->mono_de_domain_add (domain); } /* Frame state handling */ @@ -309,11 +310,11 @@ get_this_async_id (DbgEngineStackFrame *frame) if (!builder) return 0; - builder_field = mono_class_get_field_from_name_full (get_class_to_get_builder_field(frame), "<>t__builder", NULL); + builder_field = mono_class_get_field_from_name_full (mono_component_debugger ()->get_class_to_get_builder_field(frame), "<>t__builder", NULL); if (!builder_field) return 0; - method = get_object_id_for_debugger_method (mono_class_from_mono_type_internal (builder_field->type)); + method = mono_component_debugger ()->get_object_id_for_debugger_method (mono_class_from_mono_type_internal (builder_field->type)); if (!method) { return 0; } @@ -346,7 +347,7 @@ process_breakpoint_events (void *_evts, MonoMethod *method, MonoContext *ctx, in BpEvents *evts = (BpEvents*)_evts; if (evts) { if (evts->is_ss) - mono_de_cancel_all_ss (); + mono_component_debugger ()->mono_de_cancel_all_ss (); mono_wasm_fire_bp (); g_free (evts); } @@ -400,7 +401,7 @@ ss_args_destroy (SingleStepArgs *ss_args) static int handle_multiple_ss_requests (void) { - mono_de_cancel_all_ss (); + mono_component_debugger ()->mono_de_cancel_all_ss (); return 1; } @@ -420,8 +421,8 @@ mono_wasm_debugger_init (void) .ensure_jit = ensure_jit, .ensure_runtime_is_suspended = ensure_runtime_is_suspended, .get_this_async_id = get_this_async_id, - .set_set_notification_for_wait_completion_flag = set_set_notification_for_wait_completion_flag, - .get_notify_debugger_of_wait_completion_method = get_notify_debugger_of_wait_completion_method, + .set_set_notification_for_wait_completion_flag = mono_component_debugger ()->set_set_notification_for_wait_completion_flag, + .get_notify_debugger_of_wait_completion_method = mono_component_debugger ()->get_notify_debugger_of_wait_completion_method, .create_breakpoint_events = create_breakpoint_events, .process_breakpoint_events = process_breakpoint_events, .ss_create_init_args = ss_create_init_args, @@ -430,8 +431,8 @@ mono_wasm_debugger_init (void) }; mono_debug_init (MONO_DEBUG_FORMAT_MONO); - mono_de_init (&cbs); - mono_de_set_log_level (log_level, stdout); + mono_component_debugger ()->mono_de_init (&cbs); + mono_component_debugger ()->mono_de_set_log_level (log_level, stdout); mini_debug_options.gen_sdb_seq_points = TRUE; mini_debug_options.mdb_optimizations = TRUE; @@ -445,7 +446,7 @@ mono_wasm_debugger_init (void) mono_profiler_set_assembly_loaded_callback (prof, assembly_loaded); obj_to_objref = g_hash_table_new (NULL, NULL); - objrefs = g_hash_table_new_full (NULL, NULL, NULL, mono_debugger_free_objref); + objrefs = g_hash_table_new_full (NULL, NULL, NULL, mono_component_debugger ()->mono_debugger_free_objref); mini_get_dbg_callbacks ()->handle_exception = handle_exception; mini_get_dbg_callbacks ()->user_break = mono_wasm_user_break; @@ -501,7 +502,7 @@ mono_wasm_setup_single_step (int kind) g_error ("[dbg] unknown step kind %d", kind); } - DbgEngineErrorCode err = mono_de_ss_create (THREAD_TO_INTERNAL (mono_thread_current ()), size, depth, filter, req); + DbgEngineErrorCode err = mono_component_debugger ()->mono_de_ss_create (THREAD_TO_INTERNAL (mono_thread_current ()), size, depth, filter, req); if (err != DE_ERR_NONE) { PRINT_DEBUG_MSG (1, "[dbg] Failed to setup single step request"); } @@ -517,7 +518,7 @@ mono_wasm_setup_single_step (int kind) } } if (!isBPOnNativeCode) { - mono_de_cancel_all_ss (); + mono_component_debugger ()->mono_de_cancel_all_ss (); } return isBPOnNativeCode; } @@ -637,7 +638,7 @@ mono_wasm_set_breakpoint (const char *assembly_name, int method_token, int il_of req->nmodifiers = 0; //funny thing, // BreakPointRequest *req = breakpoint_request_new (assembly, method, il_offset); - MonoBreakpoint *bp = mono_de_set_breakpoint (method, il_offset, req, error); + MonoBreakpoint *bp = mono_component_debugger ()->mono_de_set_breakpoint (method, il_offset, req, error); if (!bp) { PRINT_DEBUG_MSG (1, "Could not set breakpoint to %s\n", mono_error_get_message (error)); @@ -652,24 +653,24 @@ mono_wasm_set_breakpoint (const char *assembly_name, int method_token, int il_of EMSCRIPTEN_KEEPALIVE int mono_wasm_remove_breakpoint (int bp_id) { - MonoBreakpoint *bp = mono_de_get_breakpoint_by_id (bp_id); + MonoBreakpoint *bp = mono_component_debugger ()->mono_de_get_breakpoint_by_id (bp_id); if (!bp) return 0; - mono_de_clear_breakpoint (bp); + mono_component_debugger ()->mono_de_clear_breakpoint (bp); return 1; } void mono_wasm_single_step_hit (void) { - mono_de_process_single_step (NULL, FALSE); + mono_component_debugger ()->mono_de_process_single_step (NULL, FALSE); } void mono_wasm_breakpoint_hit (void) { - mono_de_process_breakpoint (NULL, FALSE); + mono_component_debugger ()->mono_de_process_breakpoint (NULL, FALSE); // mono_wasm_fire_bp (); } @@ -710,7 +711,7 @@ mono_wasm_current_bp_id (void) GPtrArray *bp_reqs = g_ptr_array_new (); - mono_de_collect_breakpoints_by_sp (&sp, ji, NULL, bp_reqs); + mono_component_debugger ()->mono_de_collect_breakpoints_by_sp (&sp, ji, NULL, bp_reqs); if (bp_reqs->len == 0) { PRINT_DEBUG_MSG (1, "BP NOT FOUND for method %s JI %p il_offset %d\n", method->name, ji, sp.il_offset); @@ -1712,7 +1713,7 @@ set_variable_value_on_frame (MonoStackFrameInfo *info, MonoContext *ctx, gpointe if (!decode_value(t, val_buf, data->new_value)) goto exit_with_error; - DbgEngineErrorCode errorCode = mono_de_set_interp_var (t, addr, val_buf); + DbgEngineErrorCode errorCode = mono_component_debugger ()->mono_de_set_interp_var (t, addr, val_buf); if (errorCode != ERR_NONE) { goto exit_with_error; } @@ -1865,7 +1866,7 @@ mono_wasm_set_value_on_object (int object_id, const char* name, const char* valu if (!decode_value(f->type, val_buf, value)) { return FALSE; } - DbgEngineErrorCode errorCode = mono_de_set_interp_var (f->type, (guint8*)obj + f->offset, val_buf); + DbgEngineErrorCode errorCode = mono_component_debugger ()->mono_de_set_interp_var (f->type, (guint8*)obj + f->offset, val_buf); if (errorCode != ERR_NONE) { return FALSE; } @@ -1965,4 +1966,4 @@ mono_wasm_debugger_init (void) { } -#endif // HOST_WASM +#endif // HOST_WASM \ No newline at end of file diff --git a/src/mono/mono/mini/mini.c b/src/mono/mono/mini/mini.c index b54bb2cb2a9be5..75d7089e202d1a 100644 --- a/src/mono/mono/mini/mini.c +++ b/src/mono/mono/mini/mini.c @@ -71,7 +71,6 @@ #include "jit-icalls.h" #include "mini-gc.h" -#include "debugger-agent.h" #include "llvm-runtime.h" #include "mini-llvm.h" #include "lldb.h" diff --git a/src/mono/mono/mini/tramp-amd64.c b/src/mono/mono/mini/tramp-amd64.c index 086796f51daa8a..6fed857316153a 100644 --- a/src/mono/mono/mini/tramp-amd64.c +++ b/src/mono/mono/mini/tramp-amd64.c @@ -34,6 +34,7 @@ #include "interp/interp.h" #endif #include "mono/utils/mono-tls-inline.h" +#include #ifdef MONO_ARCH_CODE_EXEC_ONLY #include "aot-runtime.h" @@ -963,9 +964,9 @@ mono_arch_create_sdb_trampoline (gboolean single_step, MonoTrampInfo **info, gbo code = mono_arch_emit_load_aotconst (buf, code, &ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, GUINT_TO_POINTER (MONO_JIT_ICALL_mono_debugger_agent_breakpoint_from_context)); } else { if (single_step) - amd64_mov_reg_imm (code, AMD64_R11, mini_get_dbg_callbacks ()->single_step_from_context); + amd64_mov_reg_imm (code, AMD64_R11, mono_component_debugger ()->single_step_from_context); else - amd64_mov_reg_imm (code, AMD64_R11, mini_get_dbg_callbacks ()->breakpoint_from_context); + amd64_mov_reg_imm (code, AMD64_R11, mono_component_debugger ()->breakpoint_from_context); } amd64_call_reg (code, AMD64_R11); From 3911ba47b16e8dd17bf45f8a7a386e1338e61866 Mon Sep 17 00:00:00 2001 From: "DESKTOP-GEPIA6N\\Thays" Date: Tue, 22 Jun 2021 00:01:38 -0300 Subject: [PATCH 02/35] Trying to save history of debugger-agent.h --- src/mono/mono/component/debugger-agent.h | 42 +++--------------------- 1 file changed, 5 insertions(+), 37 deletions(-) diff --git a/src/mono/mono/component/debugger-agent.h b/src/mono/mono/component/debugger-agent.h index 500e8e610c3b54..5c02ef45735644 100644 --- a/src/mono/mono/component/debugger-agent.h +++ b/src/mono/mono/component/debugger-agent.h @@ -2,48 +2,16 @@ * \file */ -#ifndef __MONO_DEBUGGER_AGENT_H__ -#define __MONO_DEBUGGER_AGENT_H__ +#ifndef __MONO_DEBUGGER_AGENT_COMPONENT_H__ +#define __MONO_DEBUGGER_AGENT_COMPONENT_H__ -#include "mini.h" +#include +#include "debugger.h" #include -#define MONO_DBG_CALLBACKS_VERSION (4) -// 2. debug_log parameters changed from MonoString* to MonoStringHandle -// 3. debug_log parameters changed from MonoStringHandle back to MonoString* - -struct _MonoDebuggerCallbacks { - int version; - void (*parse_options) (char *options); - void (*init) (void); - void (*breakpoint_hit) (void *sigctx); - void (*single_step_event) (void *sigctx); - void (*single_step_from_context) (MonoContext *ctx); - void (*breakpoint_from_context) (MonoContext *ctx); - void (*free_mem_manager) (gpointer mem_manager); - void (*unhandled_exception) (MonoException *exc); - void (*handle_exception) (MonoException *exc, MonoContext *throw_ctx, - MonoContext *catch_ctx, StackFrameInfo *catch_frame); - void (*begin_exception_filter) (MonoException *exc, MonoContext *ctx, MonoContext *orig_ctx); - void (*end_exception_filter) (MonoException *exc, MonoContext *ctx, MonoContext *orig_ctx); - void (*user_break) (void); - void (*debug_log) (int level, MonoString *category, MonoString *message); - gboolean (*debug_log_is_enabled) (void); - void (*send_crash) (char *json_dump, MonoStackHash *hashes, int pause); -}; - typedef struct _DebuggerTlsData DebuggerTlsData; -MONO_API void -mono_debugger_agent_init (void); - -MONO_API void -mono_debugger_agent_parse_options (char *options); - void -mono_debugger_agent_stub_init (void); - -MONO_API MONO_RT_EXTERNAL_ONLY gboolean -mono_debugger_agent_transport_handshake (void); +debugger_agent_add_function_pointers (MonoComponentDebugger* fn_table); #endif From 3b33a777c511b8044f1d933429490396059c47e6 Mon Sep 17 00:00:00 2001 From: "DESKTOP-GEPIA6N\\Thays" Date: Tue, 22 Jun 2021 00:02:51 -0300 Subject: [PATCH 03/35] adding debugger-agent.h as a new file --- src/mono/mono/component/debugger-agent.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/mono/mono/component/debugger-agent.h b/src/mono/mono/component/debugger-agent.h index 5c02ef45735644..b96abfbeeb6ccd 100644 --- a/src/mono/mono/component/debugger-agent.h +++ b/src/mono/mono/component/debugger-agent.h @@ -1,6 +1,6 @@ -/** - * \file - */ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// #ifndef __MONO_DEBUGGER_AGENT_COMPONENT_H__ #define __MONO_DEBUGGER_AGENT_COMPONENT_H__ From ebf7cfb11c98dfb830cc86f0016b01cc3f2f7c5b Mon Sep 17 00:00:00 2001 From: "DESKTOP-GEPIA6N\\Thays" Date: Tue, 22 Jun 2021 00:09:00 -0300 Subject: [PATCH 04/35] Fixing compilation --- src/mono/mono/component/debugger-stub.c | 2 +- src/mono/mono/mini/intrinsics.c | 1 - src/mono/mono/mini/method-to-ir.c | 13 +++++++++---- src/mono/mono/mini/mini-amd64-gsharedvt.c | 1 - src/mono/mono/mini/mini-amd64.c | 1 - src/mono/mono/mini/tramp-amd64-gsharedvt.c | 1 - src/mono/mono/mini/tramp-amd64.c | 1 - 7 files changed, 10 insertions(+), 10 deletions(-) diff --git a/src/mono/mono/component/debugger-stub.c b/src/mono/mono/component/debugger-stub.c index 392406c8afa323..0518b3cd1f8592 100644 --- a/src/mono/mono/component/debugger-stub.c +++ b/src/mono/mono/component/debugger-stub.c @@ -1,4 +1,4 @@ -debugger-stub.c// Licensed to the .NET Foundation under one or more agreements. +// Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // diff --git a/src/mono/mono/mini/intrinsics.c b/src/mono/mono/mini/intrinsics.c index 5ad1eb487a10cb..491847801ad163 100644 --- a/src/mono/mono/mini/intrinsics.c +++ b/src/mono/mono/mini/intrinsics.c @@ -14,7 +14,6 @@ #include "mini-runtime.h" #include "ir-emit.h" #include "jit-icalls.h" -#include "debugger-agent.h" #include #include diff --git a/src/mono/mono/mini/method-to-ir.c b/src/mono/mono/mini/method-to-ir.c index a26805db41b7eb..e4c7a4e0cff7d8 100644 --- a/src/mono/mono/mini/method-to-ir.c +++ b/src/mono/mono/mini/method-to-ir.c @@ -7154,7 +7154,10 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b goto calli_end; } } - ins = (MonoInst*)mini_emit_calli_full (cfg, fsig, sp, addr, NULL, NULL, tailcall); + if (cfg->llvm_only && !(cfg->method->wrapper_type && cfg->method->wrapper_type != MONO_WRAPPER_DYNAMIC_METHOD)) + ins = mini_emit_llvmonly_calli (cfg, fsig, sp, addr); + else + ins = (MonoInst*)mini_emit_calli_full (cfg, fsig, sp, addr, NULL, NULL, tailcall); goto calli_end; } case MONO_CEE_CALL: @@ -7388,9 +7391,11 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b } /* Conversion to a JIT intrinsic */ - if ((ins = mini_emit_inst_for_method (cfg, cmethod, fsig, sp))) { + gboolean ins_type_initialized; + if ((ins = mini_emit_inst_for_method (cfg, cmethod, fsig, sp, &ins_type_initialized))) { if (!MONO_TYPE_IS_VOID (fsig->ret)) { - mini_type_to_eval_stack_type ((cfg), fsig->ret, ins); + if (!ins_type_initialized) + mini_type_to_eval_stack_type ((cfg), fsig->ret, ins); emit_widen = FALSE; } // FIXME This is only missed if in fact the intrinsic involves a call. @@ -10254,7 +10259,7 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b EMIT_NEW_PCONST (cfg, ins, rt); } ins->type = STACK_OBJ; - ins->klass = cmethod->klass; + ins->klass = mono_defaults.runtimetype_class; il_op = (MonoOpcodeEnum)next_ip [0]; next_ip += 5; } else { diff --git a/src/mono/mono/mini/mini-amd64-gsharedvt.c b/src/mono/mono/mini/mini-amd64-gsharedvt.c index c18131d883cff9..3a7d769e589942 100644 --- a/src/mono/mono/mini/mini-amd64-gsharedvt.c +++ b/src/mono/mono/mini/mini-amd64-gsharedvt.c @@ -27,7 +27,6 @@ #include "mini.h" #include "mini-amd64.h" #include "mini-amd64-gsharedvt.h" -#include "debugger-agent.h" #if defined (MONO_ARCH_GSHAREDVT_SUPPORTED) diff --git a/src/mono/mono/mini/mini-amd64.c b/src/mono/mono/mini/mini-amd64.c index 150791b62c3dde..87c0b175ee6c7a 100644 --- a/src/mono/mono/mini/mini-amd64.c +++ b/src/mono/mono/mini/mini-amd64.c @@ -44,7 +44,6 @@ #include "ir-emit.h" #include "mini-amd64.h" #include "cpu-amd64.h" -#include "debugger-agent.h" #include "mini-gc.h" #include "mini-runtime.h" #include "aot-runtime.h" diff --git a/src/mono/mono/mini/tramp-amd64-gsharedvt.c b/src/mono/mono/mini/tramp-amd64-gsharedvt.c index 63fec1dffea982..0d564fbeefe45d 100644 --- a/src/mono/mono/mini/tramp-amd64-gsharedvt.c +++ b/src/mono/mono/mini/tramp-amd64-gsharedvt.c @@ -26,7 +26,6 @@ #include "mini.h" #include "mini-amd64.h" #include "mini-amd64-gsharedvt.h" -#include "debugger-agent.h" #if defined (MONO_ARCH_GSHAREDVT_SUPPORTED) diff --git a/src/mono/mono/mini/tramp-amd64.c b/src/mono/mono/mini/tramp-amd64.c index 6fed857316153a..ad749405c15112 100644 --- a/src/mono/mono/mini/tramp-amd64.c +++ b/src/mono/mono/mini/tramp-amd64.c @@ -28,7 +28,6 @@ #include "mini.h" #include "mini-amd64.h" #include "mini-runtime.h" -#include "debugger-agent.h" #ifndef DISABLE_INTERPRETER #include "interp/interp.h" From 12a02eb94a9a05bcc7753c326d1f4e1a9b89c848 Mon Sep 17 00:00:00 2001 From: "DESKTOP-GEPIA6N\\Thays" Date: Tue, 22 Jun 2021 00:26:25 -0300 Subject: [PATCH 05/35] Fixing wasm compilation --- src/mono/mono/mini/mini-wasm-debugger.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/mono/mono/mini/mini-wasm-debugger.c b/src/mono/mono/mini/mini-wasm-debugger.c index 3fda2920950d97..b0c109fd603a7c 100644 --- a/src/mono/mono/mini/mini-wasm-debugger.c +++ b/src/mono/mono/mini/mini-wasm-debugger.c @@ -10,8 +10,9 @@ #include #include #include -#include #include +#include +#include //XXX This is dirty, extend ee.h to support extracting info from MonoInterpFrameHandle #include @@ -448,8 +449,8 @@ mono_wasm_debugger_init (void) obj_to_objref = g_hash_table_new (NULL, NULL); objrefs = g_hash_table_new_full (NULL, NULL, NULL, mono_component_debugger ()->mono_debugger_free_objref); - mini_get_dbg_callbacks ()->handle_exception = handle_exception; - mini_get_dbg_callbacks ()->user_break = mono_wasm_user_break; + mono_component_debugger ()->handle_exception = handle_exception; + mono_component_debugger ()->user_break = mono_wasm_user_break; } MONO_API void From ffa2ba8ca5959fa84d9711b7112bad51bbfdd263 Mon Sep 17 00:00:00 2001 From: "DESKTOP-GEPIA6N\\Thays" Date: Tue, 22 Jun 2021 14:46:44 -0300 Subject: [PATCH 06/35] Fixing wasm compilation. --- src/mono/mono/component/debugger-engine.c | 2 ++ src/mono/mono/component/debugger-stub.c | 15 ++++++++++++++- src/mono/mono/component/debugger.h | 2 ++ src/mono/mono/mini/mini-wasm-debugger.c | 4 ++-- 4 files changed, 20 insertions(+), 3 deletions(-) diff --git a/src/mono/mono/component/debugger-engine.c b/src/mono/mono/component/debugger-engine.c index edfc0044277154..fc5eca66c74336 100644 --- a/src/mono/mono/component/debugger-engine.c +++ b/src/mono/mono/component/debugger-engine.c @@ -1800,6 +1800,8 @@ debugger_engine_add_function_pointers(MonoComponentDebugger* fn_table) fn_table->get_notify_debugger_of_wait_completion_method = get_notify_debugger_of_wait_completion_method; fn_table->get_class_to_get_builder_field = get_class_to_get_builder_field; fn_table->get_object_id_for_debugger_method = get_object_id_for_debugger_method; + fn_table->mono_de_clear_all_breakpoints = mono_de_clear_all_breakpoints; + fn_table->get_async_method_builder = get_async_method_builder; } #endif diff --git a/src/mono/mono/component/debugger-stub.c b/src/mono/mono/component/debugger-stub.c index 0518b3cd1f8592..1f61b4fb3d4c41 100644 --- a/src/mono/mono/component/debugger-stub.c +++ b/src/mono/mono/component/debugger-stub.c @@ -78,6 +78,8 @@ static gboolean stub_set_set_notification_for_wait_completion_flag (DbgEngineSta static MonoMethod *stub_get_notify_debugger_of_wait_completion_method (void); //debugger-engine removeAfterMergeWasmPR static MonoClass *stub_get_class_to_get_builder_field (DbgEngineStackFrame *frame); //debugger-engine removeAfterMergeWasmPR static MonoMethod *stub_get_object_id_for_debugger_method (MonoClass *async_builder_class); //debugger-engine removeAfterMergeWasmPR +static void stub_mono_de_clear_all_breakpoints (void); //debugger-engine removeAfterMergeWasmPR +static gpointer stub_get_async_method_builder (DbgEngineStackFrame *frame); //debugger-engine removeAfterMergeWasmPR static MonoComponentDebugger fn_table = { { MONO_COMPONENT_ITF_VERSION, &debugger_avaliable }, @@ -116,7 +118,9 @@ static MonoComponentDebugger fn_table = { &stub_set_set_notification_for_wait_completion_flag, &stub_get_notify_debugger_of_wait_completion_method, &stub_get_class_to_get_builder_field, - &stub_get_object_id_for_debugger_method + &stub_get_object_id_for_debugger_method, + &stub_mono_de_clear_all_breakpoints, + &stub_get_async_method_builder }; static bool @@ -326,3 +330,12 @@ stub_get_object_id_for_debugger_method (MonoClass *async_builder_class) { g_assert_not_reached(); } + +static void stub_mono_de_clear_all_breakpoints (void) +{ +} + +static gpointer stub_get_async_method_builder (DbgEngineStackFrame *frame) +{ + g_assert_not_reached(); +} diff --git a/src/mono/mono/component/debugger.h b/src/mono/mono/component/debugger.h index 8c619ea0c5d09b..a012b46399dde7 100644 --- a/src/mono/mono/component/debugger.h +++ b/src/mono/mono/component/debugger.h @@ -196,6 +196,8 @@ typedef struct MonoComponentDebugger { MonoMethod* (*get_notify_debugger_of_wait_completion_method) (void); //debugger-engine removeAfterMergeWasmPR MonoClass* (*get_class_to_get_builder_field) (DbgEngineStackFrame* frame); //debugger-engine removeAfterMergeWasmPR MonoMethod* (*get_object_id_for_debugger_method) (MonoClass* async_builder_class); //debugger-engine removeAfterMergeWasmPR + void (*mono_de_clear_all_breakpoints) (void); //debugger-engine removeAfterMergeWasmPR + gpointer (*get_async_method_builder) (DbgEngineStackFrame *frame); //debugger-engine removeAfterMergeWasmPR } MonoComponentDebugger; diff --git a/src/mono/mono/mini/mini-wasm-debugger.c b/src/mono/mono/mini/mini-wasm-debugger.c index b0c109fd603a7c..8bf756f1e42d1a 100644 --- a/src/mono/mono/mini/mini-wasm-debugger.c +++ b/src/mono/mono/mini/mini-wasm-debugger.c @@ -307,7 +307,7 @@ get_this_async_id (DbgEngineStackFrame *frame) * FRAME points to a method in a state machine class/struct. * Call the ObjectIdForDebugger method of the associated method builder type. */ - builder = get_async_method_builder (frame); + builder = mono_component_debugger ()->get_async_method_builder (frame); if (!builder) return 0; @@ -588,7 +588,7 @@ EMSCRIPTEN_KEEPALIVE void mono_wasm_clear_all_breakpoints (void) { PRINT_DEBUG_MSG (1, "CLEAR BREAKPOINTS\n"); - mono_de_clear_all_breakpoints (); + mono_component_debugger ()->mono_de_clear_all_breakpoints (); } EMSCRIPTEN_KEEPALIVE int From 02f75d9be67e547ef35dbd8be0cd47517df411aa Mon Sep 17 00:00:00 2001 From: "DESKTOP-GEPIA6N\\Thays" Date: Tue, 22 Jun 2021 18:11:27 -0300 Subject: [PATCH 07/35] Running wasm app. --- src/mono/mono/component/debugger-stub.c | 96 ++++++++++++++++++------- src/mono/mono/component/debugger.c | 24 ++++++- src/mono/mono/component/debugger.h | 4 +- src/mono/mono/metadata/metadata.c | 2 - src/mono/mono/mini/interp/interp.c | 85 ++++++++++++++++++---- src/mono/mono/mini/mini-runtime.c | 2 + 6 files changed, 171 insertions(+), 42 deletions(-) diff --git a/src/mono/mono/component/debugger-stub.c b/src/mono/mono/component/debugger-stub.c index 1f61b4fb3d4c41..70a54875ee5228 100644 --- a/src/mono/mono/component/debugger-stub.c +++ b/src/mono/mono/component/debugger-stub.c @@ -57,34 +57,81 @@ stub_debugger_breakpoint_from_context (MonoContext *ctx); static void stub_debugger_send_crash (char *json_dump, MonoStackHash *hashes, int pause); -static void stub_register_transport (DebuggerTransport *trans); //debugger-agent -static gboolean stub_mono_debugger_agent_transport_handshake (void); -static void stub_mono_debugger_agent_parse_options (char *options); -static void stub_mono_de_init (DebuggerEngineCallbacks *cbs); //debugger-engine -static void stub_mono_debugger_free_objref (gpointer value); //debugger-engine removeAfterMergeWasmPR -static void stub_mono_de_set_log_level (int level, FILE *file); //debugger-engine removeAfterMergeWasmPR -static void stub_mono_de_add_pending_breakpoints (MonoMethod *method, MonoJitInfo *ji); //debugger-engine removeAfterMergeWasmPR -static void stub_mono_de_clear_breakpoint (MonoBreakpoint *bp); //debugger-engine removeAfterMergeWasmPR -static void stub_mono_de_process_single_step (void *tls, gboolean from_signal); //debugger-engine removeAfterMergeWasmPR -static void stub_mono_de_process_breakpoint (void *tls, gboolean from_signal); //debugger-engine removeAfterMergeWasmPR -static MonoBreakpoint *stub_mono_de_set_breakpoint (MonoMethod *method, long il_offset, EventRequest *req, MonoError *error); //debugger-engine removeAfterMergeWasmPR -static void stub_mono_de_cancel_all_ss (void); //debugger-engine removeAfterMergeWasmPR -static DbgEngineErrorCode stub_mono_de_ss_create (MonoInternalThread *thread, MdbgProtStepSize size, MdbgProtStepDepth depth, MdbgProtStepFilter filter, EventRequest *req); //debugger-engine removeAfterMergeWasmPR -static void stub_mono_de_domain_add (MonoDomain *domain); //debugger-engine removeAfterMergeWasmPR -static void stub_mono_de_collect_breakpoints_by_sp (SeqPoint *sp, MonoJitInfo *ji, GPtrArray *ss_reqs, GPtrArray *bp_reqs); //debugger-engine removeAfterMergeWasmPR -static MonoBreakpoint *stub_mono_de_get_breakpoint_by_id (int id); //debugger-engine removeAfterMergeWasmPR -static DbgEngineErrorCode stub_mono_de_set_interp_var (MonoType *t, gpointer addr, guint8 *val_buf); //debugger-engine removeAfterMergeWasmPR -static gboolean stub_set_set_notification_for_wait_completion_flag (DbgEngineStackFrame *frame); //debugger-engine removeAfterMergeWasmPR -static MonoMethod *stub_get_notify_debugger_of_wait_completion_method (void); //debugger-engine removeAfterMergeWasmPR -static MonoClass *stub_get_class_to_get_builder_field (DbgEngineStackFrame *frame); //debugger-engine removeAfterMergeWasmPR -static MonoMethod *stub_get_object_id_for_debugger_method (MonoClass *async_builder_class); //debugger-engine removeAfterMergeWasmPR -static void stub_mono_de_clear_all_breakpoints (void); //debugger-engine removeAfterMergeWasmPR -static gpointer stub_get_async_method_builder (DbgEngineStackFrame *frame); //debugger-engine removeAfterMergeWasmPR +static void +stub_register_transport (DebuggerTransport *trans); //debugger-agent + +static gboolean +stub_mono_debugger_agent_transport_handshake (void); + +static void +stub_mono_debugger_agent_parse_options (char *options); + +static void +stub_mono_de_init (DebuggerEngineCallbacks *cbs); //debugger-engine + +static void +stub_mono_debugger_free_objref (gpointer value); //debugger-engine removeAfterMergeWasmPR + +static void +stub_mono_de_set_log_level (int level, FILE *file); //debugger-engine removeAfterMergeWasmPR + +static void +stub_mono_de_add_pending_breakpoints (MonoMethod *method, MonoJitInfo *ji); //debugger-engine removeAfterMergeWasmPR + +static void +stub_mono_de_clear_breakpoint (MonoBreakpoint *bp); //debugger-engine removeAfterMergeWasmPR + +static void +stub_mono_de_process_single_step (void *tls, gboolean from_signal); //debugger-engine removeAfterMergeWasmPR + +static void +stub_mono_de_process_breakpoint (void *tls, gboolean from_signal); //debugger-engine removeAfterMergeWasmPR + +static MonoBreakpoint * +stub_mono_de_set_breakpoint (MonoMethod *method, long il_offset, EventRequest *req, MonoError *error); //debugger-engine removeAfterMergeWasmPR + +static void +stub_mono_de_cancel_all_ss (void); //debugger-engine removeAfterMergeWasmPR + +static DbgEngineErrorCode +stub_mono_de_ss_create (MonoInternalThread *thread, MdbgProtStepSize size, MdbgProtStepDepth depth, MdbgProtStepFilter filter, EventRequest *req); //debugger-engine removeAfterMergeWasmPR + +static void +stub_mono_de_domain_add (MonoDomain *domain); //debugger-engine removeAfterMergeWasmPR + +static void +stub_mono_de_collect_breakpoints_by_sp (SeqPoint *sp, MonoJitInfo *ji, GPtrArray *ss_reqs, GPtrArray *bp_reqs); //debugger-engine removeAfterMergeWasmPR + +static MonoBreakpoint * +stub_mono_de_get_breakpoint_by_id (int id); //debugger-engine removeAfterMergeWasmPR + +static DbgEngineErrorCode +stub_mono_de_set_interp_var (MonoType *t, gpointer addr, guint8 *val_buf); //debugger-engine removeAfterMergeWasmPR + +static gboolean +stub_set_set_notification_for_wait_completion_flag (DbgEngineStackFrame *frame); //debugger-engine removeAfterMergeWasmPR + +static MonoMethod * +stub_get_notify_debugger_of_wait_completion_method (void); //debugger-engine removeAfterMergeWasmPR + +static MonoClass * +stub_get_class_to_get_builder_field (DbgEngineStackFrame *frame); //debugger-engine removeAfterMergeWasmPR + +static MonoMethod * +stub_get_object_id_for_debugger_method (MonoClass *async_builder_class); //debugger-engine removeAfterMergeWasmPR + +static void +stub_mono_de_clear_all_breakpoints (void); //debugger-engine removeAfterMergeWasmPR + +static gpointer +stub_get_async_method_builder (DbgEngineStackFrame *frame); //debugger-engine removeAfterMergeWasmPR + static MonoComponentDebugger fn_table = { { MONO_COMPONENT_ITF_VERSION, &debugger_avaliable }, - &stub_debugger_parse_options, &stub_debugger_init, + &stub_debugger_user_break, + &stub_debugger_parse_options, &stub_debugger_breakpoint_hit, &stub_debugger_single_step_event, &stub_debugger_single_step_from_context, @@ -94,7 +141,6 @@ static MonoComponentDebugger fn_table = { &stub_debugger_handle_exception, &stub_debugger_begin_exception_filter, &stub_debugger_end_exception_filter, - &stub_debugger_user_break, &stub_debugger_debug_log, &stub_debugger_debug_log_is_enabled, &stub_debugger_send_crash, diff --git a/src/mono/mono/component/debugger.c b/src/mono/mono/component/debugger.c index 207f3eb3e748f5..48196665ef9c52 100644 --- a/src/mono/mono/component/debugger.c +++ b/src/mono/mono/component/debugger.c @@ -13,8 +13,16 @@ static bool debugger_avaliable (void); +static void +debugger_init (void); + +static void +debugger_user_break (void); + static MonoComponentDebugger fn_table = { - { MONO_COMPONENT_ITF_VERSION, &debugger_avaliable } + { MONO_COMPONENT_ITF_VERSION, &debugger_avaliable }, + &debugger_init, + &debugger_user_break, }; static bool @@ -27,7 +35,21 @@ debugger_avaliable (void) MonoComponentDebugger * mono_component_debugger_init (void) { +#ifndef DISABLE_SDB debugger_agent_add_function_pointers (&fn_table); +#endif debugger_engine_add_function_pointers (&fn_table); return &fn_table; } + +static void +debugger_init (void) +{ + +} + +static void +debugger_user_break (void) +{ + +} \ No newline at end of file diff --git a/src/mono/mono/component/debugger.h b/src/mono/mono/component/debugger.h index a012b46399dde7..03e49e6ed59362 100644 --- a/src/mono/mono/component/debugger.h +++ b/src/mono/mono/component/debugger.h @@ -159,8 +159,9 @@ typedef int DbgEngineErrorCode; typedef struct MonoComponentDebugger { MonoComponent component; - void (*parse_options) (char *options); void (*init) (void); + void (*user_break) (void); + void (*parse_options) (char *options); void (*breakpoint_hit) (void *sigctx); void (*single_step_event) (void *sigctx); void (*single_step_from_context) (MonoContext *ctx); @@ -171,7 +172,6 @@ typedef struct MonoComponentDebugger { MonoContext *catch_ctx, MonoStackFrameInfo *catch_frame); void (*begin_exception_filter) (MonoException *exc, MonoContext *ctx, MonoContext *orig_ctx); void (*end_exception_filter) (MonoException *exc, MonoContext *ctx, MonoContext *orig_ctx); - void (*user_break) (void); void (*debug_log) (int level, MonoString *category, MonoString *message); gboolean (*debug_log_is_enabled) (void); void (*send_crash) (char *json_dump, MonoStackHash *hashes, int pause); diff --git a/src/mono/mono/metadata/metadata.c b/src/mono/mono/metadata/metadata.c index ca8cced208a76b..1e3cd55ed2d8f5 100644 --- a/src/mono/mono/metadata/metadata.c +++ b/src/mono/mono/metadata/metadata.c @@ -1967,8 +1967,6 @@ mono_metadata_init (void) for (i = 0; i < NBUILTIN_TYPES (); ++i) g_hash_table_insert (type_cache, (gpointer) &builtin_types [i], (gpointer) &builtin_types [i]); - mono_components_init (); - mono_metadata_update_init (); } diff --git a/src/mono/mono/mini/interp/interp.c b/src/mono/mono/mini/interp/interp.c index f16527f17ad9be..03c32b2a947108 100644 --- a/src/mono/mono/mini/interp/interp.c +++ b/src/mono/mono/mini/interp/interp.c @@ -29,7 +29,6 @@ #include #include #include -#include #ifdef HAVE_ALLOCA_H # include @@ -76,6 +75,8 @@ #include #include +#include + #ifdef TARGET_ARM #include #endif @@ -1620,6 +1621,9 @@ interp_init_delegate (MonoDelegate *del, MonoError *error) } if (del->method_ptr && !del->method) { /* Delegate created from methodInfo.MethodHandle.GetFunctionPointer() */ del->interp_method = (InterpMethod *)del->method_ptr; + if (mono_llvm_only) + // FIXME: + g_assert_not_reached (); } else if (del->method) { /* Delegate created dynamically */ del->interp_method = mono_interp_get_imethod (del->method, error); @@ -1659,13 +1663,57 @@ interp_init_delegate (MonoDelegate *del, MonoError *error) } } +/* Convert a function pointer for a managed method to an InterpMethod* */ +static InterpMethod* +ftnptr_to_imethod (gpointer addr) +{ + InterpMethod *imethod; + + if (mono_llvm_only) { + ERROR_DECL (error); + /* Function pointers are represented by a MonoFtnDesc structure */ + MonoFtnDesc *ftndesc = (MonoFtnDesc*)addr; + g_assert (ftndesc); + g_assert (ftndesc->method); + + imethod = ftndesc->interp_method; + if (!imethod) { + imethod = mono_interp_get_imethod (ftndesc->method, error); + mono_error_assert_ok (error); + mono_memory_barrier (); + ftndesc->interp_method = imethod; + } + } else { + /* Function pointers are represented by their InterpMethod */ + imethod = (InterpMethod*)addr; + } + return imethod; +} + +static gpointer +imethod_to_ftnptr (InterpMethod *imethod) +{ + if (mono_llvm_only) { + ERROR_DECL (error); + /* Function pointers are represented by a MonoFtnDesc structure */ + MonoFtnDesc *ftndesc = imethod->ftndesc; + if (!ftndesc) { + ftndesc = mini_llvmonly_load_method_ftndesc (imethod->method, FALSE, FALSE, error); + mono_error_assert_ok (error); + mono_memory_barrier (); + imethod->ftndesc = ftndesc; + } + return ftndesc; + } else { + return imethod; + } +} + static void interp_delegate_ctor (MonoObjectHandle this_obj, MonoObjectHandle target, gpointer addr, MonoError *error) { - /* - * addr is the result of an LDFTN opcode, i.e. an InterpMethod - */ - InterpMethod *imethod = (InterpMethod*)addr; + /* addr is the result of an LDFTN opcode */ + InterpMethod *imethod = ftnptr_to_imethod (addr); if (!(imethod->method->flags & METHOD_ATTRIBUTE_STATIC)) { MonoMethod *invoke = mono_get_delegate_invoke_internal (mono_handle_class (this_obj)); @@ -3420,7 +3468,9 @@ interp_exec_method (InterpFrame *frame, ThreadContext *context, FrameClauseArgs csignature = (MonoMethodSignature*)frame->imethod->data_items [ip [4]]; - cmethod = LOCAL_VAR (ip [2], InterpMethod*); + /* In mixed mode, stay in the interpreter for simplicity even if there is an AOT version of the callee */ + cmethod = ftnptr_to_imethod (LOCAL_VAR (ip [2], gpointer)); + if (cmethod->method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) { cmethod = mono_interp_get_imethod (mono_marshal_get_native_wrapper (cmethod->method, FALSE, FALSE), error); mono_interp_error_cleanup (error); /* FIXME: don't swallow the error */ @@ -6455,25 +6505,36 @@ MINT_IN_CASE(MINT_BRTRUE_I8_SP) ZEROP_SP(gint64, !=); MINT_IN_BREAK; #undef RELOP_FP #undef RELOP_CAST - MINT_IN_CASE(MINT_LDFTN) { + MINT_IN_CASE(MINT_LDFTN_ADDR) { LOCAL_VAR (ip [1], gpointer) = frame->imethod->data_items [ip [2]]; ip += 3; MINT_IN_BREAK; } + MINT_IN_CASE(MINT_LDFTN) { + InterpMethod *m = (InterpMethod*)frame->imethod->data_items [ip [2]]; + + LOCAL_VAR (ip [1], gpointer) = imethod_to_ftnptr (m); + ip += 3; + MINT_IN_BREAK; + } MINT_IN_CASE(MINT_LDVIRTFTN) { InterpMethod *m = (InterpMethod*)frame->imethod->data_items [ip [3]]; MonoObject *o = LOCAL_VAR (ip [2], MonoObject*); NULL_CHECK (o); - - LOCAL_VAR (ip [1], gpointer) = get_virtual_method (m, o->vtable); + + m = get_virtual_method (m, o->vtable); + LOCAL_VAR (ip [1], gpointer) = imethod_to_ftnptr (m); ip += 4; MINT_IN_BREAK; } MINT_IN_CASE(MINT_LDFTN_DYNAMIC) { error_init_reuse (error); - InterpMethod *m = mono_interp_get_imethod (LOCAL_VAR (ip [2], MonoMethod*), error); + + MonoMethod *cmethod = LOCAL_VAR (ip [2], MonoMethod*); + + InterpMethod *m = mono_interp_get_imethod (cmethod, error); mono_error_assert_ok (error); - LOCAL_VAR (ip [1], gpointer) = m; + LOCAL_VAR (ip [1], gpointer) = imethod_to_ftnptr (m); ip += 3; MINT_IN_BREAK; } @@ -6655,7 +6716,7 @@ MINT_IN_CASE(MINT_BRTRUE_I8_SP) ZEROP_SP(gint64, !=); MINT_IN_BREAK; mono_error_assert_ok (error); } g_assert (del->interp_method); - LOCAL_VAR (ip [1], gpointer) = del->interp_method; + LOCAL_VAR (ip [1], gpointer) = imethod_to_ftnptr (del->interp_method); ip += 3; MINT_IN_BREAK; } diff --git a/src/mono/mono/mini/mini-runtime.c b/src/mono/mono/mini/mini-runtime.c index ed6a91c820dded..44f751a99a6490 100644 --- a/src/mono/mono/mini/mini-runtime.c +++ b/src/mono/mono/mini/mini-runtime.c @@ -4249,6 +4249,8 @@ mini_init (const char *filename, const char *runtime_version) mono_ee_interp_init (mono_interp_opts_string); #endif + mono_components_init (); + if (sdb_options) mono_component_debugger ()->parse_options (sdb_options); From f786976e091a14a5ab7a6a4223d0aad3c19665dd Mon Sep 17 00:00:00 2001 From: "DESKTOP-GEPIA6N\\Thays" Date: Wed, 23 Jun 2021 09:34:54 -0300 Subject: [PATCH 08/35] Unrelated change. --- src/mono/mono/mini/mini-runtime.c | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/src/mono/mono/mini/mini-runtime.c b/src/mono/mono/mini/mini-runtime.c index 44f751a99a6490..e873006afd6ab4 100644 --- a/src/mono/mono/mini/mini-runtime.c +++ b/src/mono/mono/mini/mini-runtime.c @@ -2686,6 +2686,22 @@ mono_jit_compile_method_jit_only (MonoMethod *method, MonoError *error) return code; } +/* + * get_ftnptr_for_method: + * + * Return a function pointer for METHOD which is indirectly callable from managed code. + * On llvmonly, this returns a MonoFtnDesc, otherwise it returns a normal function pointer. + */ +static gpointer +get_ftnptr_for_method (MonoMethod *method, MonoError *error) +{ + if (!mono_llvm_only) { + return mono_jit_compile_method (method, error); + } else { + return mini_llvmonly_load_method_ftndesc (method, FALSE, FALSE, error); + } +} + #ifdef MONO_ARCH_HAVE_INVALIDATE_METHOD static void invalidated_delegate_trampoline (char *desc) @@ -4307,6 +4323,7 @@ mini_init (const char *filename, const char *runtime_version) callbacks.create_jit_trampoline = mono_create_jit_trampoline; callbacks.create_delegate_trampoline = mono_create_delegate_trampoline; callbacks.free_method = mono_jit_free_method; + callbacks.get_ftnptr = get_ftnptr_for_method; #endif callbacks.is_interpreter_enabled = mini_is_interpreter_enabled; callbacks.get_weak_field_indexes = mono_aot_get_weak_field_indexes; From 44a84be6b3b5bbc3e15c87e83677c21f531ae636 Mon Sep 17 00:00:00 2001 From: "DESKTOP-GEPIA6N\\Thays" Date: Wed, 23 Jun 2021 14:21:02 -0300 Subject: [PATCH 09/35] Fixing debugging console app --- src/mono/mono/component/debugger-agent.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/mono/mono/component/debugger-agent.c b/src/mono/mono/component/debugger-agent.c index 93b997264ef96d..517c45b8d67dd2 100644 --- a/src/mono/mono/component/debugger-agent.c +++ b/src/mono/mono/component/debugger-agent.c @@ -802,7 +802,6 @@ debugger_agent_init (void) if (!agent_config.onuncaught && !agent_config.onthrow) finish_agent_init (TRUE); - mono_component_debugger ()->init (); } /* @@ -1280,7 +1279,7 @@ register_socket_fd_transport (void) static DebuggerTransport *transport; static DebuggerTransport transports [MAX_TRANSPORTS]; -static int ntransports; +static int ntransports = 0; static void register_transport (DebuggerTransport *trans) From 079a00653f7b443b94dd936f8ac0ebe422b62085 Mon Sep 17 00:00:00 2001 From: Thays Grazia Date: Wed, 23 Jun 2021 18:49:49 +0000 Subject: [PATCH 10/35] Fixing compilation on linux --- src/mono/mono/mini/mini-posix.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/mono/mono/mini/mini-posix.c b/src/mono/mono/mini/mini-posix.c index 6ff3228ca06b3d..132b9c309887d2 100644 --- a/src/mono/mono/mini/mini-posix.c +++ b/src/mono/mono/mini/mini-posix.c @@ -69,13 +69,14 @@ #include #include #include -#include +#include +#include #include "mini.h" #include #include #include "trace.h" -#include "debugger-agent.h" +#include #include "mini-runtime.h" #include "jit-icalls.h" @@ -985,7 +986,7 @@ dump_native_stacktrace (const char *signal, MonoContext *mctx) // see if we can notify any attached debugger instances. // // At this point we are accepting that the below step might end in a crash - mini_get_dbg_callbacks ()->send_crash (output, &hashes, 0 /* wait # seconds */); + mono_component_debugger ()->send_crash (output, &hashes, 0 /* wait # seconds */); } output = NULL; mono_state_free_mem (&merp_mem); From 31069c3a818927efc92ecd40bbdd75cafa40d106 Mon Sep 17 00:00:00 2001 From: Thays Date: Mon, 28 Jun 2021 11:46:09 -0300 Subject: [PATCH 11/35] Fixing wasm debugger. --- src/mono/mono/component/debugger-agent.h | 2 - src/mono/mono/component/debugger-engine.c | 4 +- src/mono/mono/component/debugger-engine.h | 1 - src/mono/mono/component/debugger-stub.c | 122 +++++++++++++++++-- src/mono/mono/component/debugger.c | 4 +- src/mono/mono/component/debugger.h | 58 +++++++-- src/mono/mono/mini/debugger-agent-external.c | 4 +- src/mono/mono/mini/debugger-agent-external.h | 6 +- src/mono/mono/mini/mini-wasm-debugger.c | 25 ++-- src/mono/wasm/Makefile | 1 + src/mono/wasm/wasm.proj | 1 + 11 files changed, 184 insertions(+), 44 deletions(-) diff --git a/src/mono/mono/component/debugger-agent.h b/src/mono/mono/component/debugger-agent.h index b96abfbeeb6ccd..a39818014247d4 100644 --- a/src/mono/mono/component/debugger-agent.h +++ b/src/mono/mono/component/debugger-agent.h @@ -9,8 +9,6 @@ #include "debugger.h" #include -typedef struct _DebuggerTlsData DebuggerTlsData; - void debugger_agent_add_function_pointers (MonoComponentDebugger* fn_table); diff --git a/src/mono/mono/component/debugger-engine.c b/src/mono/mono/component/debugger-engine.c index 1a1cd78d3bc97d..b8768f86a6dea8 100644 --- a/src/mono/mono/component/debugger-engine.c +++ b/src/mono/mono/component/debugger-engine.c @@ -1793,8 +1793,10 @@ debugger_engine_add_function_pointers(MonoComponentDebugger* fn_table) fn_table->get_notify_debugger_of_wait_completion_method = get_notify_debugger_of_wait_completion_method; fn_table->get_class_to_get_builder_field = get_class_to_get_builder_field; fn_table->get_object_id_for_debugger_method = get_object_id_for_debugger_method; - fn_table->mono_de_clear_all_breakpoints = mono_de_clear_all_breakpoints; fn_table->get_async_method_builder = get_async_method_builder; + fn_table->mono_ss_create_init_args = mono_ss_create_init_args; + fn_table->mono_ss_args_destroy = mono_ss_args_destroy; + fn_table->mono_get_this_async_id = mono_get_this_async_id; } #endif diff --git a/src/mono/mono/component/debugger-engine.h b/src/mono/mono/component/debugger-engine.h index f042fc38a912ee..adfa825a4b43bc 100644 --- a/src/mono/mono/component/debugger-engine.h +++ b/src/mono/mono/component/debugger-engine.h @@ -360,7 +360,6 @@ MonoBreakpoint* mono_de_set_breakpoint (MonoMethod *method, long il_offset, Even void mono_de_collect_breakpoints_by_sp (SeqPoint *sp, MonoJitInfo *ji, GPtrArray *ss_reqs, GPtrArray *bp_reqs); void mono_de_clear_breakpoints_for_domain (MonoDomain *domain); void mono_de_add_pending_breakpoints(MonoMethod* method, MonoJitInfo* ji); -void mono_de_clear_all_breakpoints (void); MonoBreakpoint * mono_de_get_breakpoint_by_id (int id); //single stepping diff --git a/src/mono/mono/component/debugger-stub.c b/src/mono/mono/component/debugger-stub.c index 70a54875ee5228..1ae06da1db2827 100644 --- a/src/mono/mono/component/debugger-stub.c +++ b/src/mono/mono/component/debugger-stub.c @@ -120,12 +120,45 @@ stub_get_class_to_get_builder_field (DbgEngineStackFrame *frame); //debugger-eng static MonoMethod * stub_get_object_id_for_debugger_method (MonoClass *async_builder_class); //debugger-engine removeAfterMergeWasmPR -static void -stub_mono_de_clear_all_breakpoints (void); //debugger-engine removeAfterMergeWasmPR - static gpointer stub_get_async_method_builder (DbgEngineStackFrame *frame); //debugger-engine removeAfterMergeWasmPR +static MdbgProtErrorCode +stub_mono_process_dbg_packet (int id, MdbgProtCommandSet command_set, int command, gboolean *no_reply, guint8 *p, guint8 *end, MdbgProtBuffer *buf); + +static void +stub_mono_init_debugger_agent_for_wasm (int log_level); + +static void* +stub_mono_dbg_create_breakpoint_events (GPtrArray *ss_reqs, GPtrArray *bp_reqs, MonoJitInfo *ji, MdbgProtEventKind kind); + +static void +stub_mono_dbg_process_breakpoint_events (void *_evts, MonoMethod *method, MonoContext *ctx, int il_offset); + +static void +stub_mono_wasm_save_thread_context (void); + +static DebuggerTlsData * +stub_mono_wasm_get_tls (void); + +static MdbgProtErrorCode +stub_mono_do_invoke_method (DebuggerTlsData *tls, MdbgProtBuffer *buf, InvokeData *invoke, guint8 *p, guint8 **endp); + +static void +stub_mono_ss_discard_frame_context (void *the_tls); + +static void +stub_mono_ss_calculate_framecount (void *the_tls, MonoContext *ctx, gboolean force_use_ctx, DbgEngineStackFrame ***frames, int *nframes); + +static int +stub_mono_ss_create_init_args (SingleStepReq *ss_req, SingleStepArgs *args); + +static void +stub_mono_ss_args_destroy (SingleStepArgs *ss_args); + +static int +stub_mono_get_this_async_id (DbgEngineStackFrame *frame); + static MonoComponentDebugger fn_table = { { MONO_COMPONENT_ITF_VERSION, &debugger_avaliable }, @@ -147,6 +180,7 @@ static MonoComponentDebugger fn_table = { &stub_register_transport, &stub_mono_debugger_agent_transport_handshake, &stub_mono_debugger_agent_parse_options, + &stub_mono_de_init, &stub_mono_debugger_free_objref, &stub_mono_de_set_log_level, @@ -165,8 +199,20 @@ static MonoComponentDebugger fn_table = { &stub_get_notify_debugger_of_wait_completion_method, &stub_get_class_to_get_builder_field, &stub_get_object_id_for_debugger_method, - &stub_mono_de_clear_all_breakpoints, - &stub_get_async_method_builder + &stub_get_async_method_builder, + &stub_mono_ss_create_init_args, + &stub_mono_ss_args_destroy, + &stub_mono_get_this_async_id, + + &stub_mono_process_dbg_packet, + &stub_mono_init_debugger_agent_for_wasm, + &stub_mono_dbg_create_breakpoint_events, + &stub_mono_dbg_process_breakpoint_events, + &stub_mono_wasm_save_thread_context, + &stub_mono_wasm_get_tls, + &stub_mono_do_invoke_method, + &stub_mono_ss_discard_frame_context, + &stub_mono_ss_calculate_framecount }; static bool @@ -377,11 +423,73 @@ stub_get_object_id_for_debugger_method (MonoClass *async_builder_class) g_assert_not_reached(); } -static void stub_mono_de_clear_all_breakpoints (void) +static gpointer stub_get_async_method_builder (DbgEngineStackFrame *frame) { + g_assert_not_reached(); } -static gpointer stub_get_async_method_builder (DbgEngineStackFrame *frame) +static MdbgProtErrorCode +stub_mono_process_dbg_packet (int id, MdbgProtCommandSet command_set, int command, gboolean *no_reply, guint8 *p, guint8 *end, MdbgProtBuffer *buf) +{ + g_assert_not_reached(); +} + +static void +stub_mono_init_debugger_agent_for_wasm (int log_level) +{ +} + +static void* +stub_mono_dbg_create_breakpoint_events (GPtrArray *ss_reqs, GPtrArray *bp_reqs, MonoJitInfo *ji, MdbgProtEventKind kind) +{ + g_assert_not_reached(); +} + +static void +stub_mono_dbg_process_breakpoint_events (void *_evts, MonoMethod *method, MonoContext *ctx, int il_offset) +{ +} + +static void +stub_mono_wasm_save_thread_context (void) +{ +} + +static DebuggerTlsData * +stub_mono_wasm_get_tls (void) +{ + g_assert_not_reached(); +} + +static MdbgProtErrorCode +stub_mono_do_invoke_method (DebuggerTlsData *tls, MdbgProtBuffer *buf, InvokeData *invoke, guint8 *p, guint8 **endp) +{ + g_assert_not_reached(); +} + +static void +stub_mono_ss_discard_frame_context (void *the_tls) +{ +} + +static void +stub_mono_ss_calculate_framecount (void *the_tls, MonoContext *ctx, gboolean force_use_ctx, DbgEngineStackFrame ***frames, int *nframes) +{ +} + +static int +stub_mono_ss_create_init_args (SingleStepReq *ss_req, SingleStepArgs *args) +{ + g_assert_not_reached(); +} + +static void +stub_mono_ss_args_destroy (SingleStepArgs *ss_args) +{ +} + +static int +stub_mono_get_this_async_id (DbgEngineStackFrame *frame) { g_assert_not_reached(); } diff --git a/src/mono/mono/component/debugger.c b/src/mono/mono/component/debugger.c index 48196665ef9c52..149ff95c0bf0c2 100644 --- a/src/mono/mono/component/debugger.c +++ b/src/mono/mono/component/debugger.c @@ -35,9 +35,7 @@ debugger_avaliable (void) MonoComponentDebugger * mono_component_debugger_init (void) { -#ifndef DISABLE_SDB debugger_agent_add_function_pointers (&fn_table); -#endif debugger_engine_add_function_pointers (&fn_table); return &fn_table; } @@ -52,4 +50,4 @@ static void debugger_user_break (void) { -} \ No newline at end of file +} diff --git a/src/mono/mono/component/debugger.h b/src/mono/mono/component/debugger.h index 03e49e6ed59362..0eae7a4fa1e579 100644 --- a/src/mono/mono/component/debugger.h +++ b/src/mono/mono/component/debugger.h @@ -157,6 +157,30 @@ typedef struct { typedef int DbgEngineErrorCode; +typedef struct _InvokeData InvokeData; + +struct _InvokeData +{ + int id; + int flags; + guint8 *p; + guint8 *endp; + /* This is the context which needs to be restored after the invoke */ + MonoContext ctx; + gboolean has_ctx; + /* + * If this is set, invoke this method with the arguments given by ARGS. + */ + MonoMethod *method; + gpointer *args; + guint32 suspend_count; + int nmethods; + + InvokeData *last_invoke; +}; + +typedef struct _DebuggerTlsData DebuggerTlsData; + typedef struct MonoComponentDebugger { MonoComponent component; void (*init) (void); @@ -178,26 +202,39 @@ typedef struct MonoComponentDebugger { void (*register_transport) (DebuggerTransport* trans); //debugger-agent gboolean (*mono_debugger_agent_transport_handshake) (void); void (*mono_debugger_agent_parse_options) (char* options); - void (*mono_de_init) (DebuggerEngineCallbacks *cbs); //debugger-engine + + void (*mono_de_init) (DebuggerEngineCallbacks *cbs); void (*mono_debugger_free_objref) (gpointer value); //debugger-engine removeAfterMergeWasmPR - void (*mono_de_set_log_level) (int level, FILE* file); //debugger-engine removeAfterMergeWasmPR - void (*mono_de_add_pending_breakpoints) (MonoMethod* method, MonoJitInfo* ji); //debugger-engine removeAfterMergeWasmPR + void (*mono_de_set_log_level) (int level, FILE* file); + void (*mono_de_add_pending_breakpoints) (MonoMethod* method, MonoJitInfo* ji); void (*mono_de_clear_breakpoint) (MonoBreakpoint* bp); //debugger-engine removeAfterMergeWasmPR - void (*mono_de_process_single_step) (void* tls, gboolean from_signal); //debugger-engine removeAfterMergeWasmPR - void (*mono_de_process_breakpoint) (void* tls, gboolean from_signal); //debugger-engine removeAfterMergeWasmPR + void (*mono_de_process_single_step) (void* tls, gboolean from_signal); + void (*mono_de_process_breakpoint) (void* tls, gboolean from_signal); MonoBreakpoint* (*mono_de_set_breakpoint) (MonoMethod* method, long il_offset, EventRequest* req, MonoError* error); //debugger-engine removeAfterMergeWasmPR - void (*mono_de_cancel_all_ss) (void); //debugger-engine removeAfterMergeWasmPR + void (*mono_de_cancel_all_ss) (void); DbgEngineErrorCode (*mono_de_ss_create) (MonoInternalThread* thread, MdbgProtStepSize size, MdbgProtStepDepth depth, MdbgProtStepFilter filter, EventRequest* req); //debugger-engine removeAfterMergeWasmPR - void (*mono_de_domain_add) (MonoDomain* domain); //debugger-engine removeAfterMergeWasmPR + void (*mono_de_domain_add) (MonoDomain* domain); void (*mono_de_collect_breakpoints_by_sp) (SeqPoint* sp, MonoJitInfo* ji, GPtrArray* ss_reqs, GPtrArray* bp_reqs); //debugger-engine removeAfterMergeWasmPR MonoBreakpoint* (*mono_de_get_breakpoint_by_id) (int id); //debugger-engine removeAfterMergeWasmPR DbgEngineErrorCode (*mono_de_set_interp_var) (MonoType* t, gpointer addr, guint8* val_buf); //debugger-engine removeAfterMergeWasmPR - gboolean (*set_set_notification_for_wait_completion_flag) (DbgEngineStackFrame* frame); //debugger-engine removeAfterMergeWasmPR - MonoMethod* (*get_notify_debugger_of_wait_completion_method) (void); //debugger-engine removeAfterMergeWasmPR + gboolean (*set_set_notification_for_wait_completion_flag) (DbgEngineStackFrame* frame); + MonoMethod* (*get_notify_debugger_of_wait_completion_method) (void); MonoClass* (*get_class_to_get_builder_field) (DbgEngineStackFrame* frame); //debugger-engine removeAfterMergeWasmPR MonoMethod* (*get_object_id_for_debugger_method) (MonoClass* async_builder_class); //debugger-engine removeAfterMergeWasmPR - void (*mono_de_clear_all_breakpoints) (void); //debugger-engine removeAfterMergeWasmPR gpointer (*get_async_method_builder) (DbgEngineStackFrame *frame); //debugger-engine removeAfterMergeWasmPR + int (*mono_ss_create_init_args) (SingleStepReq *ss_req, SingleStepArgs *args); + void (*mono_ss_args_destroy) (SingleStepArgs *ss_args); + int (*mono_get_this_async_id) (DbgEngineStackFrame *frame); + + MdbgProtErrorCode (*mono_process_dbg_packet) (int id, MdbgProtCommandSet command_set, int command, gboolean *no_reply, guint8 *p, guint8 *end, MdbgProtBuffer *buf); + void (*mono_init_debugger_agent_for_wasm) (int log_level); + void* (*mono_dbg_create_breakpoint_events) (GPtrArray *ss_reqs, GPtrArray *bp_reqs, MonoJitInfo *ji, MdbgProtEventKind kind); + void (*mono_dbg_process_breakpoint_events) (void *_evts, MonoMethod *method, MonoContext *ctx, int il_offset); + void (*mono_wasm_save_thread_context) (void); + DebuggerTlsData* (*mono_wasm_get_tls) (void); + MdbgProtErrorCode (*mono_do_invoke_method) (DebuggerTlsData *tls, MdbgProtBuffer *buf, InvokeData *invoke, guint8 *p, guint8 **endp); + void (*mono_ss_discard_frame_context) (void *the_tls); + void (*mono_ss_calculate_framecount) (void *the_tls, MonoContext *ctx, gboolean force_use_ctx, DbgEngineStackFrame ***frames, int *nframes); } MonoComponentDebugger; @@ -216,7 +253,6 @@ void win32_debugger_log(FILE *stream, const gchar *format, ...); #define PRINT_MSG(...) g_print (__VA_ARGS__) #endif -typedef struct _DebuggerTlsData DebuggerTlsDataTHAYS; MONO_COMPONENT_EXPORT_ENTRYPOINT MonoComponentDebugger * diff --git a/src/mono/mono/mini/debugger-agent-external.c b/src/mono/mono/mini/debugger-agent-external.c index 1c64fb4da014d8..2cd559f1353b46 100644 --- a/src/mono/mono/mini/debugger-agent-external.c +++ b/src/mono/mono/mini/debugger-agent-external.c @@ -4,12 +4,10 @@ #include #include +#include "debugger-agent-external.h" #ifndef DISABLE_SDB -MONO_API void -mono_debugger_agent_register_transport (DebuggerTransport *trans); - void mono_debugger_agent_register_transport (DebuggerTransport *trans) { diff --git a/src/mono/mono/mini/debugger-agent-external.h b/src/mono/mono/mini/debugger-agent-external.h index 0066255521305d..f61cb66e683ca7 100644 --- a/src/mono/mono/mini/debugger-agent-external.h +++ b/src/mono/mono/mini/debugger-agent-external.h @@ -6,6 +6,7 @@ #define __MONO_DEBUGGER_AGENT_H__ #include "mini.h" +#include "mono/component/debugger.h" MONO_API void mono_debugger_agent_init (void); @@ -16,4 +17,7 @@ mono_debugger_agent_parse_options (char *options); MONO_API MONO_RT_EXTERNAL_ONLY gboolean mono_debugger_agent_transport_handshake (void); -#endif \ No newline at end of file +MONO_API void +mono_debugger_agent_register_transport (DebuggerTransport *trans); + +#endif diff --git a/src/mono/mono/mini/mini-wasm-debugger.c b/src/mono/mono/mini/mini-wasm-debugger.c index 999b4aa1694f5f..1c3c098b6bdbcb 100644 --- a/src/mono/mono/mini/mini-wasm-debugger.c +++ b/src/mono/mono/mini/mini-wasm-debugger.c @@ -41,7 +41,6 @@ extern void mono_wasm_asm_loaded (const char *asm_name, const char *assembly_dat G_END_DECLS -static void handle_exception (MonoException *exc, MonoContext *throw_ctx, MonoContext *catch_ctx, StackFrameInfo *catch_frame); static gboolean receive_debugger_agent_message (void *data, int len); static void assembly_loaded (MonoProfiler *prof, MonoAssembly *assembly); @@ -141,7 +140,7 @@ ensure_runtime_is_suspended (void) static int handle_multiple_ss_requests (void) { - mono_de_cancel_all_ss (); + mono_component_debugger ()->mono_de_cancel_all_ss (); return 1; } @@ -160,17 +159,16 @@ mono_wasm_debugger_init (void) .ss_calculate_framecount = ss_calculate_framecount, .ensure_jit = ensure_jit, .ensure_runtime_is_suspended = ensure_runtime_is_suspended, - .get_this_async_id = mono_get_this_async_id, - .set_set_notification_for_wait_completion_flag = set_set_notification_for_wait_completion_flag, - .get_notify_debugger_of_wait_completion_method = get_notify_debugger_of_wait_completion_method, - .create_breakpoint_events = mono_dbg_create_breakpoint_events, - .process_breakpoint_events = mono_dbg_process_breakpoint_events, - .ss_create_init_args = mono_ss_create_init_args, - .ss_args_destroy = mono_ss_args_destroy, + .get_this_async_id = mono_component_debugger ()->mono_get_this_async_id, + .set_set_notification_for_wait_completion_flag = mono_component_debugger ()->set_set_notification_for_wait_completion_flag, + .get_notify_debugger_of_wait_completion_method = mono_component_debugger ()->get_notify_debugger_of_wait_completion_method, + .create_breakpoint_events = mono_component_debugger ()->mono_dbg_create_breakpoint_events, + .process_breakpoint_events = mono_component_debugger ()->mono_dbg_process_breakpoint_events, + .ss_create_init_args = mono_component_debugger ()->mono_ss_create_init_args, + .ss_args_destroy = mono_component_debugger ()->mono_ss_args_destroy, .handle_multiple_ss_requests = handle_multiple_ss_requests, }; - - mono_component_debugger ()->mono_debug_init (MONO_DEBUG_FORMAT_MONO); + mono_debug_init (MONO_DEBUG_FORMAT_MONO); mono_component_debugger ()->mono_de_init (&cbs); mono_component_debugger ()->mono_de_set_log_level (log_level, stdout); @@ -185,9 +183,6 @@ mono_wasm_debugger_init (void) mono_profiler_set_domain_loaded_callback (prof, appdomain_load); mono_profiler_set_assembly_loaded_callback (prof, assembly_loaded); - mini_get_dbg_callbacks ()->handle_exception = mono_component_debugger ()->mono_debugger_agent_handle_exception; - mini_get_dbg_callbacks ()->user_break = mono_component_debugger ()->mono_dbg_debugger_agent_user_break; - //debugger-agent initialization DebuggerTransport trans; trans.name = "buffer-wasm-communication"; @@ -408,7 +403,7 @@ mono_wasm_send_dbg_command (int id, MdbgProtCommandSet command_set, int command, InvokeData invoke_data; memset (&invoke_data, 0, sizeof (InvokeData)); invoke_data.endp = data + size; - error = mono_do_invoke_method (tls, &buf, &invoke_data, data, &data); + error = mono_component_debugger ()->mono_do_invoke_method (tls, &buf, &invoke_data, data, &data); } else error = mono_component_debugger ()->mono_process_dbg_packet (id, command_set, command, &no_reply, data, data + size, &buf); diff --git a/src/mono/wasm/Makefile b/src/mono/wasm/Makefile index 86288cd674e703..64d7b9d658f94e 100644 --- a/src/mono/wasm/Makefile +++ b/src/mono/wasm/Makefile @@ -51,6 +51,7 @@ provision-wasm: .stamp-wasm-install-and-select-$(EMSCRIPTEN_VERSION) # FIXME: When https://github.com/dotnet/runtime/issues/54565 is fixed, and the WasmApp targets are updated to use mono runtime components, remove this MONO_COMPONENT_LIBS= \ $(MONO_BIN_DIR)/libmono-component-hot_reload-static.a \ + $(MONO_BIN_DIR)/libmono-component-debugger-static.a \ $(MONO_BIN_DIR)/libmono-component-diagnostics_tracing-stub-static.a MONO_OBJ_DIR=$(OBJDIR)/mono/Browser.wasm.$(CONFIG) diff --git a/src/mono/wasm/wasm.proj b/src/mono/wasm/wasm.proj index ffc2fb92825ba5..c8186ff30d3b6e 100644 --- a/src/mono/wasm/wasm.proj +++ b/src/mono/wasm/wasm.proj @@ -190,6 +190,7 @@ mono_de_init (&cbs); + mono_de_init (&cbs); transport_init (); @@ -1583,7 +1568,7 @@ static GHashTable *obj_to_objref; static MonoGHashTable *suspended_objs; #ifdef TARGET_WASM -static void +void mono_init_debugger_agent_for_wasm (int log_level_parm) { if (mono_atomic_cas_i32 (&agent_inited, 1, 0) == 1) @@ -2187,14 +2172,14 @@ save_thread_context (MonoContext *ctx) } #ifdef TARGET_WASM -static void +void mono_wasm_save_thread_context (void) { debugger_wasm_thread.really_suspended = TRUE; mono_thread_state_init_from_current (&debugger_wasm_thread.context); } -static DebuggerTlsData* +DebuggerTlsData* mono_wasm_get_tls (void) { return &debugger_wasm_thread; @@ -4069,7 +4054,7 @@ event_requests_cleanup (void) * * Ensure DebuggerTlsData fields are filled out. */ -static void +void mono_ss_calculate_framecount (void *the_tls, MonoContext *ctx, gboolean force_use_ctx, DbgEngineStackFrame ***frames, int *nframes) { DebuggerTlsData *tls = (DebuggerTlsData*)the_tls; @@ -4092,7 +4077,7 @@ mono_ss_calculate_framecount (void *the_tls, MonoContext *ctx, gboolean force_us * * Discard frame data and invalidate any context */ -static void +void mono_ss_discard_frame_context (void *the_tls) { DebuggerTlsData *tls = (DebuggerTlsData*)the_tls; @@ -4208,7 +4193,7 @@ typedef struct { int suspend_policy; } BreakPointEvents; -static void* +void* mono_dbg_create_breakpoint_events (GPtrArray *ss_reqs, GPtrArray *bp_reqs, MonoJitInfo *ji, EventKind kind) { int suspend_policy = 0; @@ -4225,7 +4210,7 @@ mono_dbg_create_breakpoint_events (GPtrArray *ss_reqs, GPtrArray *bp_reqs, MonoJ return evts; } -static void +void mono_dbg_process_breakpoint_events (void *_evts, MonoMethod *method, MonoContext *ctx, int il_offset) { BreakPointEvents *evts = (BreakPointEvents*)_evts; @@ -5955,7 +5940,7 @@ add_thread (gpointer key, gpointer value, gpointer user_data) } -static ErrorCode +ErrorCode mono_do_invoke_method (DebuggerTlsData *tls, Buffer *buf, InvokeData *invoke, guint8 *p, guint8 **endp) { ERROR_DECL (error); @@ -10016,7 +10001,7 @@ wait_for_attach (void) return TRUE; } -static ErrorCode +ErrorCode mono_process_dbg_packet (int id, CommandSet command_set, int command, gboolean *no_reply, guint8 *buf, guint8 *end, Buffer *ret_buf) { ErrorCode err; @@ -10251,17 +10236,7 @@ debugger_agent_add_function_pointers(MonoComponentDebugger* fn_table) fn_table->register_transport = register_transport; fn_table->mono_debugger_agent_parse_options = mono_debugger_agent_parse_options; - //used externally by wasm debugger fn_table->mono_debugger_agent_transport_handshake = mono_debugger_agent_transport_handshake; - fn_table->mono_process_dbg_packet = mono_process_dbg_packet; - fn_table->mono_init_debugger_agent_for_wasm = mono_init_debugger_agent_for_wasm; - fn_table->mono_dbg_create_breakpoint_events = mono_dbg_create_breakpoint_events; - fn_table->mono_dbg_process_breakpoint_events = mono_dbg_process_breakpoint_events; - fn_table->mono_wasm_save_thread_context = mono_wasm_save_thread_context; - fn_table->mono_wasm_get_tls = mono_wasm_get_tls; - fn_table->mono_do_invoke_method = mono_do_invoke_method; - fn_table->mono_ss_discard_frame_context = mono_ss_discard_frame_context; - fn_table->mono_ss_calculate_framecount = mono_ss_calculate_framecount; } diff --git a/src/mono/mono/component/debugger-agent.h b/src/mono/mono/component/debugger-agent.h index a39818014247d4..19c3cb7369819a 100644 --- a/src/mono/mono/component/debugger-agent.h +++ b/src/mono/mono/component/debugger-agent.h @@ -12,4 +12,36 @@ void debugger_agent_add_function_pointers (MonoComponentDebugger* fn_table); +void +mono_ss_calculate_framecount (void *the_tls, MonoContext *ctx, gboolean force_use_ctx, DbgEngineStackFrame ***frames, int *nframes); + +void +mono_ss_discard_frame_context (void *the_tls); + +#ifdef TARGET_WASM +DebuggerTlsData* +mono_wasm_get_tls (void); + +void +mono_init_debugger_agent_for_wasm (int log_level); + +void +mono_wasm_save_thread_context (void); + +#endif + +void +mini_wasm_debugger_add_function_pointers (MonoComponentDebugger* fn_table); + +MdbgProtErrorCode +mono_do_invoke_method (DebuggerTlsData *tls, MdbgProtBuffer *buf, InvokeData *invoke, guint8 *p, guint8 **endp); + +MdbgProtErrorCode +mono_process_dbg_packet (int id, MdbgProtCommandSet command_set, int command, gboolean *no_reply, guint8 *p, guint8 *end, MdbgProtBuffer *buf); + +void +mono_dbg_process_breakpoint_events (void *_evts, MonoMethod *method, MonoContext *ctx, int il_offset); + +void* +mono_dbg_create_breakpoint_events (GPtrArray *ss_reqs, GPtrArray *bp_reqs, MonoJitInfo *ji, MdbgProtEventKind kind); #endif diff --git a/src/mono/mono/component/debugger-engine.c b/src/mono/mono/component/debugger-engine.c index ae8a637be5f931..be8def19bb0e07 100644 --- a/src/mono/mono/component/debugger-engine.c +++ b/src/mono/mono/component/debugger-engine.c @@ -24,7 +24,6 @@ static void mono_de_ss_start (SingleStepReq *ss_req, SingleStepArgs *ss_args); static gboolean mono_de_ss_update (SingleStepReq *req, MonoJitInfo *ji, SeqPoint *sp, void *tls, MonoContext *ctx, MonoMethod* method); -static void mono_de_init(DebuggerEngineCallbacks* cbs); static gpointer get_this_addr(DbgEngineStackFrame* the_frame); static MonoMethod* get_set_notification_method(MonoClass* async_builder_class); @@ -884,13 +883,13 @@ mono_de_process_single_step (void *tls, gboolean from_signal) g_ptr_array_add (reqs, ss_req->req); void *bp_events; - bp_events = rt_callbacks.create_breakpoint_events (reqs, NULL, ji, EVENT_KIND_BREAKPOINT); + bp_events = mono_dbg_create_breakpoint_events (reqs, NULL, ji, EVENT_KIND_BREAKPOINT); g_ptr_array_free (reqs, TRUE); mono_loader_unlock (); - rt_callbacks.process_breakpoint_events (bp_events, method, ctx, il_offset); + mono_dbg_process_breakpoint_events (bp_events, method, ctx, il_offset); exit: mono_de_ss_req_release (ss_req); @@ -1115,7 +1114,7 @@ mono_de_process_breakpoint (void *void_tls, gboolean from_signal) mono_debug_free_method_async_debug_info (asyncMethod); //breakpoint was hit in parallelly executing async method, ignore it - if (ss_req->async_id != rt_callbacks.get_this_async_id (frames [0])) + if (ss_req->async_id != mono_get_this_async_id (frames [0])) continue; } @@ -1146,14 +1145,14 @@ mono_de_process_breakpoint (void *void_tls, gboolean from_signal) mono_de_ss_start (ss_req, &args); } - void *bp_events = rt_callbacks.create_breakpoint_events (ss_reqs, bp_reqs, ji, kind); + void *bp_events = mono_dbg_create_breakpoint_events (ss_reqs, bp_reqs, ji, kind); mono_loader_unlock (); g_ptr_array_free (bp_reqs, TRUE); g_ptr_array_free (ss_reqs, TRUE); - rt_callbacks.process_breakpoint_events (bp_events, method, ctx, sp.il_offset); + mono_dbg_process_breakpoint_events (bp_events, method, ctx, sp.il_offset); } /* @@ -1344,7 +1343,7 @@ mono_de_ss_start (SingleStepReq *ss_req, SingleStepArgs *ss_args) // of this await call and sets async_id so we can distinguish it from parallel executions for (i = 0; i < asyncMethod->num_awaits; i++) { if (sp->il_offset == asyncMethod->yield_offsets [i]) { - ss_req->async_id = rt_callbacks.get_this_async_id (frames [0]); + ss_req->async_id = mono_get_this_async_id (frames [0]); ss_bp_add_one (ss_req, &ss_req_bp_count, &ss_req_bp_cache, method, asyncMethod->resume_offsets [i]); g_hash_table_destroy (ss_req_bp_cache); mono_debug_free_method_async_debug_info (asyncMethod); @@ -1360,9 +1359,9 @@ mono_de_ss_start (SingleStepReq *ss_req, SingleStepArgs *ss_args) } if (ss_req->depth == STEP_DEPTH_OUT) { //If we are inside `async void` method, do normal step-out - if (rt_callbacks.set_set_notification_for_wait_completion_flag (frames [0])) { - ss_req->async_id = rt_callbacks.get_this_async_id (frames [0]); - ss_req->async_stepout_method = rt_callbacks.get_notify_debugger_of_wait_completion_method (); + if (set_set_notification_for_wait_completion_flag (frames [0])) { + ss_req->async_id = mono_get_this_async_id (frames [0]); + ss_req->async_stepout_method = get_notify_debugger_of_wait_completion_method (); ss_bp_add_one (ss_req, &ss_req_bp_count, &ss_req_bp_cache, ss_req->async_stepout_method, 0); g_hash_table_destroy (ss_req_bp_cache); mono_debug_free_method_async_debug_info (asyncMethod); @@ -1491,7 +1490,7 @@ mono_de_ss_start (SingleStepReq *ss_req, SingleStepArgs *ss_args) mono_loader_unlock (); cleanup: - rt_callbacks.ss_args_destroy (ss_args); + mono_ss_args_destroy (ss_args); } @@ -1534,7 +1533,7 @@ mono_de_ss_create (MonoInternalThread *thread, StepSize size, StepDepth depth, S } SingleStepArgs args; - err = rt_callbacks.ss_create_init_args (ss_req, &args); + err = mono_ss_create_init_args (ss_req, &args); if (err) return err; g_ptr_array_add (the_ss_reqs, ss_req); @@ -1561,7 +1560,7 @@ mono_de_set_log_level (int level, FILE *file) * * Inits the shared debugger engine. Not reentrant. */ -static void +void mono_de_init (DebuggerEngineCallbacks *cbs) { rt_callbacks = *cbs; @@ -1764,19 +1763,9 @@ mono_de_set_interp_var (MonoType *t, gpointer addr, guint8 *val_buf) void debugger_engine_add_function_pointers(MonoComponentDebugger* fn_table) { - fn_table->mono_de_init = mono_de_init; - fn_table->mono_de_set_log_level = mono_de_set_log_level; fn_table->mono_de_add_pending_breakpoints = mono_de_add_pending_breakpoints; - fn_table->mono_de_process_single_step = mono_de_process_single_step; - fn_table->mono_de_process_breakpoint = mono_de_process_breakpoint; fn_table->mono_de_cancel_all_ss = mono_de_cancel_all_ss; fn_table->mono_de_domain_add = mono_de_domain_add; - fn_table->set_set_notification_for_wait_completion_flag = set_set_notification_for_wait_completion_flag; - fn_table->get_notify_debugger_of_wait_completion_method = get_notify_debugger_of_wait_completion_method; - fn_table->get_async_method_builder = get_async_method_builder; - fn_table->mono_ss_create_init_args = mono_ss_create_init_args; - fn_table->mono_ss_args_destroy = mono_ss_args_destroy; - fn_table->mono_get_this_async_id = mono_get_this_async_id; } #endif diff --git a/src/mono/mono/component/debugger-engine.h b/src/mono/mono/component/debugger-engine.h index a7c55d1e1ea33e..38c588cb00c881 100644 --- a/src/mono/mono/component/debugger-engine.h +++ b/src/mono/mono/component/debugger-engine.h @@ -415,3 +415,6 @@ mono_ss_args_destroy (SingleStepArgs *ss_args); int mono_get_this_async_id (DbgEngineStackFrame *frame); + +void +mono_de_init(DebuggerEngineCallbacks* cbs); diff --git a/src/mono/mono/component/debugger-stub.c b/src/mono/mono/component/debugger-stub.c index 363943fea22dce..8a6cdc66183ad3 100644 --- a/src/mono/mono/component/debugger-stub.c +++ b/src/mono/mono/component/debugger-stub.c @@ -66,72 +66,23 @@ stub_mono_debugger_agent_transport_handshake (void); static void stub_mono_debugger_agent_parse_options (char *options); -static void -stub_mono_de_init (DebuggerEngineCallbacks *cbs); //debugger-engine - -static void -stub_mono_de_set_log_level (int level, FILE *file); //debugger-engine removeAfterMergeWasmPR - static void stub_mono_de_add_pending_breakpoints (MonoMethod *method, MonoJitInfo *ji); //debugger-engine removeAfterMergeWasmPR -static void -stub_mono_de_process_single_step (void *tls, gboolean from_signal); //debugger-engine removeAfterMergeWasmPR - -static void -stub_mono_de_process_breakpoint (void *tls, gboolean from_signal); //debugger-engine removeAfterMergeWasmPR - static void stub_mono_de_cancel_all_ss (void); //debugger-engine removeAfterMergeWasmPR static void stub_mono_de_domain_add (MonoDomain *domain); //debugger-engine removeAfterMergeWasmPR -static gboolean -stub_set_set_notification_for_wait_completion_flag (DbgEngineStackFrame *frame); //debugger-engine removeAfterMergeWasmPR - -static MonoMethod * -stub_get_notify_debugger_of_wait_completion_method (void); //debugger-engine removeAfterMergeWasmPR - -static gpointer -stub_get_async_method_builder (DbgEngineStackFrame *frame); //debugger-engine removeAfterMergeWasmPR - -static MdbgProtErrorCode -stub_mono_process_dbg_packet (int id, MdbgProtCommandSet command_set, int command, gboolean *no_reply, guint8 *p, guint8 *end, MdbgProtBuffer *buf); - -static void -stub_mono_init_debugger_agent_for_wasm (int log_level); - -static void* -stub_mono_dbg_create_breakpoint_events (GPtrArray *ss_reqs, GPtrArray *bp_reqs, MonoJitInfo *ji, MdbgProtEventKind kind); - -static void -stub_mono_dbg_process_breakpoint_events (void *_evts, MonoMethod *method, MonoContext *ctx, int il_offset); - -static void -stub_mono_wasm_save_thread_context (void); - -static DebuggerTlsData * -stub_mono_wasm_get_tls (void); - -static MdbgProtErrorCode -stub_mono_do_invoke_method (DebuggerTlsData *tls, MdbgProtBuffer *buf, InvokeData *invoke, guint8 *p, guint8 **endp); - -static void -stub_mono_ss_discard_frame_context (void *the_tls); - -static void -stub_mono_ss_calculate_framecount (void *the_tls, MonoContext *ctx, gboolean force_use_ctx, DbgEngineStackFrame ***frames, int *nframes); - -static int -stub_mono_ss_create_init_args (SingleStepReq *ss_req, SingleStepArgs *args); - static void -stub_mono_ss_args_destroy (SingleStepArgs *ss_args); +stub_mono_wasm_debugger_init (void); -static int -stub_mono_get_this_async_id (DbgEngineStackFrame *frame); +static void +stub_mono_wasm_breakpoint_hit (void); +static void +stub_mono_wasm_single_step_hit (void); static MonoComponentDebugger fn_table = { { MONO_COMPONENT_ITF_VERSION, &debugger_avaliable }, @@ -154,29 +105,14 @@ static MonoComponentDebugger fn_table = { &stub_mono_debugger_agent_transport_handshake, &stub_mono_debugger_agent_parse_options, - &stub_mono_de_init, - &stub_mono_de_set_log_level, &stub_mono_de_add_pending_breakpoints, - &stub_mono_de_process_single_step, - &stub_mono_de_process_breakpoint, &stub_mono_de_cancel_all_ss, &stub_mono_de_domain_add, - &stub_set_set_notification_for_wait_completion_flag, - &stub_get_notify_debugger_of_wait_completion_method, - &stub_get_async_method_builder, - &stub_mono_ss_create_init_args, - &stub_mono_ss_args_destroy, - &stub_mono_get_this_async_id, - &stub_mono_process_dbg_packet, - &stub_mono_init_debugger_agent_for_wasm, - &stub_mono_dbg_create_breakpoint_events, - &stub_mono_dbg_process_breakpoint_events, - &stub_mono_wasm_save_thread_context, - &stub_mono_wasm_get_tls, - &stub_mono_do_invoke_method, - &stub_mono_ss_discard_frame_context, - &stub_mono_ss_calculate_framecount + //wasm + &stub_mono_wasm_debugger_init, + &stub_mono_wasm_breakpoint_hit, + &stub_mono_wasm_single_step_hit }; static bool @@ -289,31 +225,11 @@ stub_mono_debugger_agent_parse_options (char *options) { } -static void -stub_mono_de_init (DebuggerEngineCallbacks *cbs) -{ -} - -static void -stub_mono_de_set_log_level (int level, FILE *file) -{ -} - static void stub_mono_de_add_pending_breakpoints (MonoMethod *method, MonoJitInfo *ji) { } -static void -stub_mono_de_process_single_step (void *tls, gboolean from_signal) -{ -} - -static void -stub_mono_de_process_breakpoint (void *tls, gboolean from_signal) -{ -} - static void stub_mono_de_cancel_all_ss (void) { @@ -324,85 +240,17 @@ stub_mono_de_domain_add (MonoDomain *domain) { } -static gboolean -stub_set_set_notification_for_wait_completion_flag (DbgEngineStackFrame *frame) -{ - g_assert_not_reached(); -} - -static MonoMethod * -stub_get_notify_debugger_of_wait_completion_method (void) -{ - g_assert_not_reached(); -} - -static gpointer stub_get_async_method_builder (DbgEngineStackFrame *frame) -{ - g_assert_not_reached(); -} - -static MdbgProtErrorCode -stub_mono_process_dbg_packet (int id, MdbgProtCommandSet command_set, int command, gboolean *no_reply, guint8 *p, guint8 *end, MdbgProtBuffer *buf) -{ - g_assert_not_reached(); -} - -static void -stub_mono_init_debugger_agent_for_wasm (int log_level) -{ -} - -static void* -stub_mono_dbg_create_breakpoint_events (GPtrArray *ss_reqs, GPtrArray *bp_reqs, MonoJitInfo *ji, MdbgProtEventKind kind) -{ - g_assert_not_reached(); -} - -static void -stub_mono_dbg_process_breakpoint_events (void *_evts, MonoMethod *method, MonoContext *ctx, int il_offset) -{ -} - -static void -stub_mono_wasm_save_thread_context (void) -{ -} - -static DebuggerTlsData * -stub_mono_wasm_get_tls (void) -{ - g_assert_not_reached(); -} - -static MdbgProtErrorCode -stub_mono_do_invoke_method (DebuggerTlsData *tls, MdbgProtBuffer *buf, InvokeData *invoke, guint8 *p, guint8 **endp) -{ - g_assert_not_reached(); -} - -static void -stub_mono_ss_discard_frame_context (void *the_tls) -{ -} - -static void -stub_mono_ss_calculate_framecount (void *the_tls, MonoContext *ctx, gboolean force_use_ctx, DbgEngineStackFrame ***frames, int *nframes) -{ -} - -static int -stub_mono_ss_create_init_args (SingleStepReq *ss_req, SingleStepArgs *args) +static void +stub_mono_wasm_debugger_init (void) { - g_assert_not_reached(); } static void -stub_mono_ss_args_destroy (SingleStepArgs *ss_args) +stub_mono_wasm_breakpoint_hit (void) { } -static int -stub_mono_get_this_async_id (DbgEngineStackFrame *frame) +static void +stub_mono_wasm_single_step_hit (void) { - g_assert_not_reached(); } diff --git a/src/mono/mono/component/debugger.c b/src/mono/mono/component/debugger.c index 149ff95c0bf0c2..26718b8990f046 100644 --- a/src/mono/mono/component/debugger.c +++ b/src/mono/mono/component/debugger.c @@ -37,6 +37,7 @@ mono_component_debugger_init (void) { debugger_agent_add_function_pointers (&fn_table); debugger_engine_add_function_pointers (&fn_table); + mini_wasm_debugger_add_function_pointers (&fn_table); return &fn_table; } diff --git a/src/mono/mono/component/debugger.h b/src/mono/mono/component/debugger.h index 6426347e838297..bfbadc2813b1e6 100644 --- a/src/mono/mono/component/debugger.h +++ b/src/mono/mono/component/debugger.h @@ -120,17 +120,6 @@ typedef struct { void (*ss_calculate_framecount) (void *tls, MonoContext *ctx, gboolean force_use_ctx, DbgEngineStackFrame ***frames, int *nframes); gboolean (*ensure_jit) (DbgEngineStackFrame *frame); int (*ensure_runtime_is_suspended) (void); - - int (*get_this_async_id) (DbgEngineStackFrame *frame); - - void* (*create_breakpoint_events) (GPtrArray *ss_reqs, GPtrArray *bp_reqs, MonoJitInfo *ji, MdbgProtEventKind kind); - void (*process_breakpoint_events) (void *_evts, MonoMethod *method, MonoContext *ctx, int il_offset); - - gboolean (*set_set_notification_for_wait_completion_flag) (DbgEngineStackFrame *f); - MonoMethod* (*get_notify_debugger_of_wait_completion_method)(void); - - int (*ss_create_init_args) (SingleStepReq *ss_req, SingleStepArgs *args); - void (*ss_args_destroy) (SingleStepArgs *ss_args); int (*handle_multiple_ss_requests)(void); } DebuggerEngineCallbacks; @@ -203,29 +192,14 @@ typedef struct MonoComponentDebugger { gboolean (*mono_debugger_agent_transport_handshake) (void); void (*mono_debugger_agent_parse_options) (char* options); - void (*mono_de_init) (DebuggerEngineCallbacks *cbs); - void (*mono_de_set_log_level) (int level, FILE* file); void (*mono_de_add_pending_breakpoints) (MonoMethod* method, MonoJitInfo* ji); - void (*mono_de_process_single_step) (void* tls, gboolean from_signal); - void (*mono_de_process_breakpoint) (void* tls, gboolean from_signal); void (*mono_de_cancel_all_ss) (void); void (*mono_de_domain_add) (MonoDomain* domain); - gboolean (*set_set_notification_for_wait_completion_flag) (DbgEngineStackFrame* frame); - MonoMethod* (*get_notify_debugger_of_wait_completion_method) (void); - gpointer (*get_async_method_builder) (DbgEngineStackFrame *frame); //debugger-engine removeAfterMergeWasmPR - int (*mono_ss_create_init_args) (SingleStepReq *ss_req, SingleStepArgs *args); - void (*mono_ss_args_destroy) (SingleStepArgs *ss_args); - int (*mono_get_this_async_id) (DbgEngineStackFrame *frame); - - MdbgProtErrorCode (*mono_process_dbg_packet) (int id, MdbgProtCommandSet command_set, int command, gboolean *no_reply, guint8 *p, guint8 *end, MdbgProtBuffer *buf); - void (*mono_init_debugger_agent_for_wasm) (int log_level); - void* (*mono_dbg_create_breakpoint_events) (GPtrArray *ss_reqs, GPtrArray *bp_reqs, MonoJitInfo *ji, MdbgProtEventKind kind); - void (*mono_dbg_process_breakpoint_events) (void *_evts, MonoMethod *method, MonoContext *ctx, int il_offset); - void (*mono_wasm_save_thread_context) (void); - DebuggerTlsData* (*mono_wasm_get_tls) (void); - MdbgProtErrorCode (*mono_do_invoke_method) (DebuggerTlsData *tls, MdbgProtBuffer *buf, InvokeData *invoke, guint8 *p, guint8 **endp); - void (*mono_ss_discard_frame_context) (void *the_tls); - void (*mono_ss_calculate_framecount) (void *the_tls, MonoContext *ctx, gboolean force_use_ctx, DbgEngineStackFrame ***frames, int *nframes); + + //wasm + void (*mono_wasm_debugger_init) (void); + void (*mono_wasm_breakpoint_hit) (void); + void (*mono_wasm_single_step_hit) (void); } MonoComponentDebugger; diff --git a/src/mono/mono/mini/mini-wasm-debugger.c b/src/mono/mono/component/mini-wasm-debugger.c similarity index 85% rename from src/mono/mono/mini/mini-wasm-debugger.c rename to src/mono/mono/component/mini-wasm-debugger.c index 1c3c098b6bdbcb..0dd4a4c757432d 100644 --- a/src/mono/mono/mini/mini-wasm-debugger.c +++ b/src/mono/mono/component/mini-wasm-debugger.c @@ -1,6 +1,6 @@ #include -#include "mini.h" -#include "mini-runtime.h" +#include +#include #include #include #include @@ -114,14 +114,14 @@ begin_single_step_processing (MonoContext *ctx, gboolean from_signal) static void ss_discard_frame_context (void *the_tls) { - mono_component_debugger ()->mono_ss_discard_frame_context (mono_component_debugger ()->mono_wasm_get_tls ()); + mono_ss_discard_frame_context (mono_wasm_get_tls ()); } static void ss_calculate_framecount (void *tls, MonoContext *ctx, gboolean force_use_ctx, DbgEngineStackFrame ***out_frames, int *nframes) { - mono_component_debugger ()->mono_wasm_save_thread_context (); - mono_component_debugger ()->mono_ss_calculate_framecount (mono_component_debugger ()->mono_wasm_get_tls (), NULL, force_use_ctx, out_frames, nframes); + mono_wasm_save_thread_context (); + mono_ss_calculate_framecount (mono_wasm_get_tls (), NULL, force_use_ctx, out_frames, nframes); } static gboolean @@ -159,18 +159,11 @@ mono_wasm_debugger_init (void) .ss_calculate_framecount = ss_calculate_framecount, .ensure_jit = ensure_jit, .ensure_runtime_is_suspended = ensure_runtime_is_suspended, - .get_this_async_id = mono_component_debugger ()->mono_get_this_async_id, - .set_set_notification_for_wait_completion_flag = mono_component_debugger ()->set_set_notification_for_wait_completion_flag, - .get_notify_debugger_of_wait_completion_method = mono_component_debugger ()->get_notify_debugger_of_wait_completion_method, - .create_breakpoint_events = mono_component_debugger ()->mono_dbg_create_breakpoint_events, - .process_breakpoint_events = mono_component_debugger ()->mono_dbg_process_breakpoint_events, - .ss_create_init_args = mono_component_debugger ()->mono_ss_create_init_args, - .ss_args_destroy = mono_component_debugger ()->mono_ss_args_destroy, .handle_multiple_ss_requests = handle_multiple_ss_requests, }; mono_debug_init (MONO_DEBUG_FORMAT_MONO); - mono_component_debugger ()->mono_de_init (&cbs); - mono_component_debugger ()->mono_de_set_log_level (log_level, stdout); + mono_de_init (&cbs); + mono_de_set_log_level (log_level, stdout); mini_debug_options.gen_sdb_seq_points = TRUE; mini_debug_options.mdb_optimizations = TRUE; @@ -189,7 +182,7 @@ mono_wasm_debugger_init (void) trans.send = receive_debugger_agent_message; mono_component_debugger ()->register_transport (&trans); - mono_component_debugger ()->mono_init_debugger_agent_for_wasm (log_level); + mono_init_debugger_agent_for_wasm (log_level); } MONO_API void @@ -233,13 +226,13 @@ assembly_loaded (MonoProfiler *prof, MonoAssembly *assembly) void mono_wasm_single_step_hit (void) { - mono_component_debugger ()->mono_de_process_single_step (mono_component_debugger ()->mono_wasm_get_tls (), FALSE); + mono_de_process_single_step (mono_wasm_get_tls (), FALSE); } void mono_wasm_breakpoint_hit (void) { - mono_component_debugger ()->mono_de_process_breakpoint (mono_component_debugger ()->mono_wasm_get_tls (), FALSE); + mono_de_process_breakpoint (mono_wasm_get_tls (), FALSE); } static gboolean @@ -399,14 +392,14 @@ mono_wasm_send_dbg_command (int id, MdbgProtCommandSet command_set, int command, MdbgProtErrorCode error = 0; if (command_set == MDBGPROT_CMD_SET_VM && command == MDBGPROT_CMD_VM_INVOKE_METHOD ) { - DebuggerTlsData* tls = mono_component_debugger ()->mono_wasm_get_tls (); + DebuggerTlsData* tls = mono_wasm_get_tls (); InvokeData invoke_data; memset (&invoke_data, 0, sizeof (InvokeData)); invoke_data.endp = data + size; - error = mono_component_debugger ()->mono_do_invoke_method (tls, &buf, &invoke_data, data, &data); + error = mono_do_invoke_method (tls, &buf, &invoke_data, data, &data); } else - error = mono_component_debugger ()->mono_process_dbg_packet (id, command_set, command, &no_reply, data, data + size, &buf); + error = mono_process_dbg_packet (id, command_set, command, &no_reply, data, data + size, &buf); EM_ASM ({ MONO.mono_wasm_add_dbg_command_received ($0, $1, $2, $3); }, error == MDBGPROT_ERR_NONE, id, buf.buf, buf.p-buf.buf); @@ -421,7 +414,7 @@ receive_debugger_agent_message (void *data, int len) EM_ASM ({ MONO.mono_wasm_add_dbg_command_received (1, -1, $0, $1); }, data, len); - mono_component_debugger ()->mono_wasm_save_thread_context(); + mono_wasm_save_thread_context(); mono_wasm_fire_debugger_agent_message (); return FALSE; } @@ -444,3 +437,11 @@ mono_wasm_debugger_init (void) } #endif // HOST_WASM + +void +mini_wasm_debugger_add_function_pointers (MonoComponentDebugger* fn_table) +{ + fn_table->mono_wasm_debugger_init = mono_wasm_debugger_init; + fn_table->mono_wasm_breakpoint_hit = mono_wasm_breakpoint_hit; + fn_table->mono_wasm_single_step_hit = mono_wasm_single_step_hit; +} diff --git a/src/mono/mono/mini/CMakeLists.txt b/src/mono/mono/mini/CMakeLists.txt index 6a8d50f7a5fcd8..f1eb7636263d61 100644 --- a/src/mono/mono/mini/CMakeLists.txt +++ b/src/mono/mono/mini/CMakeLists.txt @@ -224,7 +224,6 @@ set(wasm_sources tramp-wasm.c exceptions-wasm.c aot-runtime-wasm.c - mini-wasm-debugger.c wasm_m2n_invoke.g.h cpu-wasm.h) diff --git a/src/mono/mono/mini/mini-runtime.c b/src/mono/mono/mini/mini-runtime.c index e873006afd6ab4..7bb3507e6b23cd 100644 --- a/src/mono/mono/mini/mini-runtime.c +++ b/src/mono/mono/mini/mini-runtime.c @@ -4406,7 +4406,7 @@ mini_init (const char *filename, const char *runtime_version) mono_component_debugger ()->init (); #ifdef TARGET_WASM - mono_wasm_debugger_init (); + mono_component_debugger ()->mono_wasm_debugger_init (); #endif #ifdef MONO_ARCH_GSHARED_SUPPORTED diff --git a/src/mono/mono/mini/tramp-wasm.c b/src/mono/mono/mini/tramp-wasm.c index 4156cfccb2344c..8ba5f54b97855e 100644 --- a/src/mono/mono/mini/tramp-wasm.c +++ b/src/mono/mono/mini/tramp-wasm.c @@ -1,5 +1,6 @@ #include "mini.h" #include "interp/interp.h" +#include void mono_sdb_single_step_trampoline (void); @@ -76,10 +77,10 @@ mono_arch_create_sdb_trampoline (gboolean single_step, MonoTrampInfo **info, gbo guint8* code; if (single_step) { name = "sdb_single_step_trampoline"; - code = (guint8*)mono_wasm_single_step_hit; + code = (guint8*)mono_component_debugger ()->mono_wasm_single_step_hit; } else { name = "sdb_breakpoint_trampoline"; - code = (guint8*)mono_wasm_breakpoint_hit; + code = (guint8*)mono_component_debugger ()->mono_wasm_breakpoint_hit; } if (info) From 0d4dfa273a2e1cfd693c9fb7fb2f8da219c94eb4 Mon Sep 17 00:00:00 2001 From: Thays Date: Mon, 28 Jun 2021 22:19:20 -0300 Subject: [PATCH 14/35] Fixing wasm debugger. --- src/mono/mono/component/debugger-stub.c | 11 ++++++++++- src/mono/mono/component/debugger.h | 2 +- src/mono/mono/component/mini-wasm-debugger.c | 7 +++++-- src/mono/mono/mini/mini-runtime.c | 2 -- src/mono/mono/mini/mini-wasm.c | 7 +++++++ src/mono/mono/mini/monovm.c | 4 ++++ 6 files changed, 27 insertions(+), 6 deletions(-) diff --git a/src/mono/mono/component/debugger-stub.c b/src/mono/mono/component/debugger-stub.c index 8a6cdc66183ad3..2b4546ce0e2060 100644 --- a/src/mono/mono/component/debugger-stub.c +++ b/src/mono/mono/component/debugger-stub.c @@ -84,6 +84,9 @@ stub_mono_wasm_breakpoint_hit (void); static void stub_mono_wasm_single_step_hit (void); +static void +stub_mono_wasm_enable_debugging (int log_level); + static MonoComponentDebugger fn_table = { { MONO_COMPONENT_ITF_VERSION, &debugger_avaliable }, &stub_debugger_init, @@ -112,7 +115,8 @@ static MonoComponentDebugger fn_table = { //wasm &stub_mono_wasm_debugger_init, &stub_mono_wasm_breakpoint_hit, - &stub_mono_wasm_single_step_hit + &stub_mono_wasm_single_step_hit, + &stub_mono_wasm_enable_debugging, }; static bool @@ -254,3 +258,8 @@ static void stub_mono_wasm_single_step_hit (void) { } + +static void +stub_mono_wasm_enable_debugging (int log_level) +{ +} diff --git a/src/mono/mono/component/debugger.h b/src/mono/mono/component/debugger.h index bfbadc2813b1e6..b7c34864db1767 100644 --- a/src/mono/mono/component/debugger.h +++ b/src/mono/mono/component/debugger.h @@ -200,10 +200,10 @@ typedef struct MonoComponentDebugger { void (*mono_wasm_debugger_init) (void); void (*mono_wasm_breakpoint_hit) (void); void (*mono_wasm_single_step_hit) (void); + void (*mono_wasm_enable_debugging) (int log_level); } MonoComponentDebugger; -typedef int DbgEngineErrorCodeTHAYS; #define DE_ERR_NONE 0 // WARNING WARNING WARNING // Error codes MUST match those of sdb for now diff --git a/src/mono/mono/component/mini-wasm-debugger.c b/src/mono/mono/component/mini-wasm-debugger.c index 0dd4a4c757432d..3400880f6716a2 100644 --- a/src/mono/mono/component/mini-wasm-debugger.c +++ b/src/mono/mono/component/mini-wasm-debugger.c @@ -25,6 +25,8 @@ #include "mono/metadata/assembly-internals.h" #include "mono/metadata/debug-mono-ppdb.h" +static void +mono_wasm_enable_debugging_internal (int debug_level); static int log_level = 1; //functions exported to be used by JS @@ -185,8 +187,8 @@ mono_wasm_debugger_init (void) mono_init_debugger_agent_for_wasm (log_level); } -MONO_API void -mono_wasm_enable_debugging (int debug_level) +static void +mono_wasm_enable_debugging_internal (int debug_level) { PRINT_DEBUG_MSG (1, "DEBUGGING ENABLED\n"); debugger_enabled = TRUE; @@ -444,4 +446,5 @@ mini_wasm_debugger_add_function_pointers (MonoComponentDebugger* fn_table) fn_table->mono_wasm_debugger_init = mono_wasm_debugger_init; fn_table->mono_wasm_breakpoint_hit = mono_wasm_breakpoint_hit; fn_table->mono_wasm_single_step_hit = mono_wasm_single_step_hit; + fn_table->mono_wasm_enable_debugging = mono_wasm_enable_debugging_internal; } diff --git a/src/mono/mono/mini/mini-runtime.c b/src/mono/mono/mini/mini-runtime.c index 7bb3507e6b23cd..ddd3a299213a88 100644 --- a/src/mono/mono/mini/mini-runtime.c +++ b/src/mono/mono/mini/mini-runtime.c @@ -4265,8 +4265,6 @@ mini_init (const char *filename, const char *runtime_version) mono_ee_interp_init (mono_interp_opts_string); #endif - mono_components_init (); - if (sdb_options) mono_component_debugger ()->parse_options (sdb_options); diff --git a/src/mono/mono/mini/mini-wasm.c b/src/mono/mono/mini/mini-wasm.c index 673e575781d9a0..db864fd891c654 100644 --- a/src/mono/mono/mini/mini-wasm.c +++ b/src/mono/mono/mini/mini-wasm.c @@ -9,6 +9,7 @@ #include #include #include +#include //XXX This is dirty, extend ee.h to support extracting info from MonoInterpFrameHandle #include @@ -760,3 +761,9 @@ mono_arch_load_function (MonoJitICallId jit_icall_id) { return NULL; } + +MONO_API void +mono_wasm_enable_debugging (int log_level) +{ + mono_component_debugger ()->mono_wasm_enable_debugging (log_level); +} diff --git a/src/mono/mono/mini/monovm.c b/src/mono/mono/mini/monovm.c index a7a5f8ad653257..527c86be9fca19 100644 --- a/src/mono/mono/mini/monovm.c +++ b/src/mono/mono/mini/monovm.c @@ -11,6 +11,8 @@ #include #include +#include + static MonoCoreTrustedPlatformAssemblies *trusted_platform_assemblies; static MonoCoreLookupPaths *native_lib_paths; static MonoCoreLookupPaths *app_paths; @@ -208,6 +210,8 @@ monovm_initialize (int propertyCount, const char **propertyKeys, const char **pr return 0x80004005; /* E_FAIL */ finish_initialization (); + + mono_components_init (); return 0; } From 4206b4b98feabda5b57f1d2d2d4bafede725e36d Mon Sep 17 00:00:00 2001 From: Thays Date: Mon, 28 Jun 2021 22:51:49 -0300 Subject: [PATCH 15/35] Fix non wasm compilation --- src/mono/mono/component/mini-wasm-debugger.c | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/src/mono/mono/component/mini-wasm-debugger.c b/src/mono/mono/component/mini-wasm-debugger.c index 3400880f6716a2..7f6524cfac5123 100644 --- a/src/mono/mono/component/mini-wasm-debugger.c +++ b/src/mono/mono/component/mini-wasm-debugger.c @@ -25,8 +25,6 @@ #include "mono/metadata/assembly-internals.h" #include "mono/metadata/debug-mono-ppdb.h" -static void -mono_wasm_enable_debugging_internal (int debug_level); static int log_level = 1; //functions exported to be used by JS @@ -187,7 +185,7 @@ mono_wasm_debugger_init (void) mono_init_debugger_agent_for_wasm (log_level); } -static void +void mono_wasm_enable_debugging_internal (int debug_level) { PRINT_DEBUG_MSG (1, "DEBUGGING ENABLED\n"); @@ -438,6 +436,11 @@ mono_wasm_debugger_init (void) { } +void +mono_wasm_enable_debugging_internal (int debug_level) +{ +} + #endif // HOST_WASM void From 570998ea31a5615f9f93d35472ae01c6a210b8cb Mon Sep 17 00:00:00 2001 From: Thays Date: Mon, 28 Jun 2021 22:58:45 -0300 Subject: [PATCH 16/35] Fixing compilation on other platforms. --- src/mono/mono/component/mini-wasm-debugger.c | 2 +- src/mono/mono/mini/mini-runtime.c | 2 +- src/mono/mono/mini/tramp-arm.c | 7 ++++--- src/mono/mono/mini/tramp-arm64.c | 7 ++++--- src/mono/mono/mini/tramp-s390x.c | 7 ++++--- src/mono/mono/mini/tramp-x86.c | 9 +++++---- 6 files changed, 19 insertions(+), 15 deletions(-) diff --git a/src/mono/mono/component/mini-wasm-debugger.c b/src/mono/mono/component/mini-wasm-debugger.c index 7f6524cfac5123..b0556cbf5dfa0e 100644 --- a/src/mono/mono/component/mini-wasm-debugger.c +++ b/src/mono/mono/component/mini-wasm-debugger.c @@ -12,7 +12,7 @@ #include #include #include -#include +#include "debugger-agent.h" #include //XXX This is dirty, extend ee.h to support extracting info from MonoInterpFrameHandle diff --git a/src/mono/mono/mini/mini-runtime.c b/src/mono/mono/mini/mini-runtime.c index ddd3a299213a88..26eb21118ffc39 100644 --- a/src/mono/mono/mini/mini-runtime.c +++ b/src/mono/mono/mini/mini-runtime.c @@ -4558,7 +4558,7 @@ register_icalls (void) #if defined(HOST_ANDROID) || defined(TARGET_ANDROID) mono_add_internal_call_internal ("System.Diagnostics.Debugger::Mono_UnhandledException_internal", - mini_get_dbg_callbacks ()->unhandled_exception); + mono_component_debugger ()->unhandled_exception); #endif /* diff --git a/src/mono/mono/mini/tramp-arm.c b/src/mono/mono/mini/tramp-arm.c index 3a9f87e02ae3ca..0834f106505e3d 100644 --- a/src/mono/mono/mini/tramp-arm.c +++ b/src/mono/mono/mini/tramp-arm.c @@ -24,7 +24,6 @@ #include "mini.h" #include "mini-arm.h" #include "mini-runtime.h" -#include "debugger-agent.h" #include "jit-icalls.h" #ifndef DISABLE_INTERPRETER @@ -32,6 +31,8 @@ #endif #include "mono/utils/mono-tls-inline.h" +#include + void mono_arch_patch_callsite (guint8 *method_start, guint8 *code_ptr, guint8 *addr) { @@ -810,9 +811,9 @@ mono_arch_create_sdb_trampoline (gboolean single_step, MonoTrampInfo **info, gbo ARM_LDR_IMM (code, ARMREG_IP, ARMREG_PC, 0); ARM_B (code, 0); if (single_step) - *(gpointer*)code = (gpointer)mini_get_dbg_callbacks ()->single_step_from_context; + *(gpointer*)code = (gpointer)mono_component_debugger ()->single_step_from_context; else - *(gpointer*)code = (gpointer)mini_get_dbg_callbacks ()->breakpoint_from_context; + *(gpointer*)code = (gpointer)mono_component_debugger ()->breakpoint_from_context; code += 4; ARM_BLX_REG (code, ARMREG_IP); } diff --git a/src/mono/mono/mini/tramp-arm64.c b/src/mono/mono/mini/tramp-arm64.c index bffb46341a2112..e0ea4f11e787ee 100644 --- a/src/mono/mono/mini/tramp-arm64.c +++ b/src/mono/mono/mini/tramp-arm64.c @@ -17,7 +17,6 @@ #include "mini.h" #include "mini-runtime.h" -#include "debugger-agent.h" #include #include @@ -27,6 +26,8 @@ #endif #include "mono/utils/mono-tls-inline.h" +#include + void mono_arch_patch_callsite (guint8 *method_start, guint8 *code_ptr, guint8 *addr) { @@ -536,7 +537,7 @@ mono_arch_create_general_rgctx_lazy_fetch_trampoline (MonoTrampInfo **info, gboo * mono_arch_create_sdb_trampoline: * * Return a trampoline which captures the current context, passes it to - * mini_get_dbg_callbacks ()->single_step_from_context ()/mini_get_dbg_callbacks ()->breakpoint_from_context (), + * mono_component_debugger ()->single_step_from_context ()/mono_component_debugger ()->breakpoint_from_context (), * then restores the (potentially changed) context. */ guint8* @@ -604,7 +605,7 @@ mono_arch_create_sdb_trampoline (gboolean single_step, MonoTrampInfo **info, gbo else code = mono_arm_emit_aotconst (&ji, code, buf, ARMREG_IP0, MONO_PATCH_INFO_JIT_ICALL_ADDR, GUINT_TO_POINTER (MONO_JIT_ICALL_mono_debugger_agent_breakpoint_from_context)); } else { - void (*addr) (MonoContext *ctx) = single_step ? mini_get_dbg_callbacks ()->single_step_from_context : mini_get_dbg_callbacks ()->breakpoint_from_context; + void (*addr) (MonoContext *ctx) = single_step ? mono_component_debugger ()->single_step_from_context : mono_component_debugger ()->breakpoint_from_context; code = mono_arm_emit_imm64 (code, ARMREG_IP0, (guint64)addr); } diff --git a/src/mono/mono/mini/tramp-s390x.c b/src/mono/mono/mini/tramp-s390x.c index d035295e8721fc..d301a3777eacf0 100644 --- a/src/mono/mono/mini/tramp-s390x.c +++ b/src/mono/mono/mini/tramp-s390x.c @@ -51,9 +51,10 @@ #include "mini-s390x.h" #include "mini-runtime.h" #include "jit-icalls.h" -#include "debugger-agent.h" #include "mono/utils/mono-tls-inline.h" +#include + /*========================= End of Includes ========================*/ /*------------------------------------------------------------------*/ @@ -195,9 +196,9 @@ mono_arch_create_sdb_trampoline (gboolean single_step, MonoTrampInfo **info, gbo s390_la (code, s390_r2, 0, STK_BASE, ctx_offset); if (single_step) - ep = (mini_get_dbg_callbacks())->single_step_from_context; + ep = (mono_component_debugger ())->single_step_from_context; else - ep = (mini_get_dbg_callbacks())->breakpoint_from_context; + ep = (mono_component_debugger ())->breakpoint_from_context; S390_SET (code, s390_r1, ep); s390_basr (code, s390_r14, s390_r1); diff --git a/src/mono/mono/mini/tramp-x86.c b/src/mono/mono/mini/tramp-x86.c index 218e961dc16483..582628105b1d51 100644 --- a/src/mono/mono/mini/tramp-x86.c +++ b/src/mono/mono/mini/tramp-x86.c @@ -24,10 +24,11 @@ #include "mini.h" #include "mini-x86.h" #include "mini-runtime.h" -#include "debugger-agent.h" #include "jit-icalls.h" #include "mono/utils/mono-tls-inline.h" +#include + /* * mono_arch_get_unbox_trampoline: * @m: method pointer @@ -618,7 +619,7 @@ mono_arch_get_gsharedvt_arg_trampoline (gpointer arg, gpointer addr) * mono_arch_create_sdb_trampoline: * * Return a trampoline which captures the current context, passes it to - * mini_get_dbg_callbacks ()->single_step_from_context ()/mini_get_dbg_callbacks ()->breakpoint_from_context (), + * mono_component_debugger ()->single_step_from_context ()/mono_component_debugger ()->breakpoint_from_context (), * then restores the (potentially changed) context. */ guint8* @@ -682,9 +683,9 @@ mono_arch_create_sdb_trampoline (gboolean single_step, MonoTrampInfo **info, gbo x86_breakpoint (code); } else { if (single_step) - x86_call_code (code, mini_get_dbg_callbacks ()->single_step_from_context); + x86_call_code (code, mono_component_debugger ()->single_step_from_context); else - x86_call_code (code, mini_get_dbg_callbacks ()->breakpoint_from_context); + x86_call_code (code, mono_component_debugger ()->breakpoint_from_context); } /* Restore registers from ctx */ From 6a9dd8c1a912e681e31cf755cb953467555eb873 Mon Sep 17 00:00:00 2001 From: Thays Date: Mon, 28 Jun 2021 23:20:13 -0300 Subject: [PATCH 17/35] Removing more code from component callback. --- src/mono/mono/component/debugger-agent.h | 9 ++++++ src/mono/mono/component/debugger-engine.c | 9 ------ src/mono/mono/component/debugger-engine.h | 12 -------- src/mono/mono/component/debugger-stub.c | 30 +------------------- src/mono/mono/component/debugger.c | 1 - src/mono/mono/component/debugger.h | 4 --- src/mono/mono/component/mini-wasm-debugger.c | 6 ++-- 7 files changed, 13 insertions(+), 58 deletions(-) diff --git a/src/mono/mono/component/debugger-agent.h b/src/mono/mono/component/debugger-agent.h index 19c3cb7369819a..e899d950a59e41 100644 --- a/src/mono/mono/component/debugger-agent.h +++ b/src/mono/mono/component/debugger-agent.h @@ -44,4 +44,13 @@ mono_dbg_process_breakpoint_events (void *_evts, MonoMethod *method, MonoContext void* mono_dbg_create_breakpoint_events (GPtrArray *ss_reqs, GPtrArray *bp_reqs, MonoJitInfo *ji, MdbgProtEventKind kind); + +int +mono_ss_create_init_args (SingleStepReq *ss_req, SingleStepArgs *args); + +void +mono_ss_args_destroy (SingleStepArgs *ss_args); + +int +mono_get_this_async_id (DbgEngineStackFrame *frame); #endif diff --git a/src/mono/mono/component/debugger-engine.c b/src/mono/mono/component/debugger-engine.c index be8def19bb0e07..78d985aeb79bd0 100644 --- a/src/mono/mono/component/debugger-engine.c +++ b/src/mono/mono/component/debugger-engine.c @@ -1759,13 +1759,4 @@ mono_de_set_interp_var (MonoType *t, gpointer addr, guint8 *val_buf) return ERR_NONE; } - -void -debugger_engine_add_function_pointers(MonoComponentDebugger* fn_table) -{ - fn_table->mono_de_add_pending_breakpoints = mono_de_add_pending_breakpoints; - fn_table->mono_de_cancel_all_ss = mono_de_cancel_all_ss; - fn_table->mono_de_domain_add = mono_de_domain_add; -} - #endif diff --git a/src/mono/mono/component/debugger-engine.h b/src/mono/mono/component/debugger-engine.h index 38c588cb00c881..26e3cc02b0c0b3 100644 --- a/src/mono/mono/component/debugger-engine.h +++ b/src/mono/mono/component/debugger-engine.h @@ -319,9 +319,6 @@ typedef struct gboolean has_ctx; } StackFrame; -void -debugger_engine_add_function_pointers(MonoComponentDebugger* fn_table); - #define DE_ERR_NONE 0 // WARNING WARNING WARNING // Error codes MUST match those of sdb for now @@ -407,14 +404,5 @@ void win32_debugger_log(FILE *stream, const gchar *format, ...); #define PRINT_MSG(...) g_print (__VA_ARGS__) #endif -int -mono_ss_create_init_args (SingleStepReq *ss_req, SingleStepArgs *args); - -void -mono_ss_args_destroy (SingleStepArgs *ss_args); - -int -mono_get_this_async_id (DbgEngineStackFrame *frame); - void mono_de_init(DebuggerEngineCallbacks* cbs); diff --git a/src/mono/mono/component/debugger-stub.c b/src/mono/mono/component/debugger-stub.c index 2b4546ce0e2060..7ce0ce79d7f753 100644 --- a/src/mono/mono/component/debugger-stub.c +++ b/src/mono/mono/component/debugger-stub.c @@ -66,15 +66,6 @@ stub_mono_debugger_agent_transport_handshake (void); static void stub_mono_debugger_agent_parse_options (char *options); -static void -stub_mono_de_add_pending_breakpoints (MonoMethod *method, MonoJitInfo *ji); //debugger-engine removeAfterMergeWasmPR - -static void -stub_mono_de_cancel_all_ss (void); //debugger-engine removeAfterMergeWasmPR - -static void -stub_mono_de_domain_add (MonoDomain *domain); //debugger-engine removeAfterMergeWasmPR - static void stub_mono_wasm_debugger_init (void); @@ -107,11 +98,7 @@ static MonoComponentDebugger fn_table = { &stub_register_transport, &stub_mono_debugger_agent_transport_handshake, &stub_mono_debugger_agent_parse_options, - - &stub_mono_de_add_pending_breakpoints, - &stub_mono_de_cancel_all_ss, - &stub_mono_de_domain_add, - + //wasm &stub_mono_wasm_debugger_init, &stub_mono_wasm_breakpoint_hit, @@ -229,21 +216,6 @@ stub_mono_debugger_agent_parse_options (char *options) { } -static void -stub_mono_de_add_pending_breakpoints (MonoMethod *method, MonoJitInfo *ji) -{ -} - -static void -stub_mono_de_cancel_all_ss (void) -{ -} - -static void -stub_mono_de_domain_add (MonoDomain *domain) -{ -} - static void stub_mono_wasm_debugger_init (void) { diff --git a/src/mono/mono/component/debugger.c b/src/mono/mono/component/debugger.c index 26718b8990f046..3dcf2edf0f3b27 100644 --- a/src/mono/mono/component/debugger.c +++ b/src/mono/mono/component/debugger.c @@ -36,7 +36,6 @@ MonoComponentDebugger * mono_component_debugger_init (void) { debugger_agent_add_function_pointers (&fn_table); - debugger_engine_add_function_pointers (&fn_table); mini_wasm_debugger_add_function_pointers (&fn_table); return &fn_table; } diff --git a/src/mono/mono/component/debugger.h b/src/mono/mono/component/debugger.h index b7c34864db1767..b5fbf662d5c3bb 100644 --- a/src/mono/mono/component/debugger.h +++ b/src/mono/mono/component/debugger.h @@ -192,10 +192,6 @@ typedef struct MonoComponentDebugger { gboolean (*mono_debugger_agent_transport_handshake) (void); void (*mono_debugger_agent_parse_options) (char* options); - void (*mono_de_add_pending_breakpoints) (MonoMethod* method, MonoJitInfo* ji); - void (*mono_de_cancel_all_ss) (void); - void (*mono_de_domain_add) (MonoDomain* domain); - //wasm void (*mono_wasm_debugger_init) (void); void (*mono_wasm_breakpoint_hit) (void); diff --git a/src/mono/mono/component/mini-wasm-debugger.c b/src/mono/mono/component/mini-wasm-debugger.c index b0556cbf5dfa0e..ea59a0c7bcefad 100644 --- a/src/mono/mono/component/mini-wasm-debugger.c +++ b/src/mono/mono/component/mini-wasm-debugger.c @@ -79,13 +79,13 @@ void wasm_debugger_log (int level, const gchar *format, ...) static void jit_done (MonoProfiler *prof, MonoMethod *method, MonoJitInfo *jinfo) { - mono_component_debugger ()->mono_de_add_pending_breakpoints (method, jinfo); + mono_de_add_pending_breakpoints (method, jinfo); } static void appdomain_load (MonoProfiler *prof, MonoDomain *domain) { - mono_component_debugger ()->mono_de_domain_add (domain); + mono_de_domain_add (domain); } static MonoContext* @@ -140,7 +140,7 @@ ensure_runtime_is_suspended (void) static int handle_multiple_ss_requests (void) { - mono_component_debugger ()->mono_de_cancel_all_ss (); + mono_de_cancel_all_ss (); return 1; } From abaa9d5838208489250dc7103126c9c93bd0ae2a Mon Sep 17 00:00:00 2001 From: Thays Date: Mon, 28 Jun 2021 23:27:55 -0300 Subject: [PATCH 18/35] Transforming more functions into static. --- src/mono/mono/component/mini-wasm-debugger.c | 17 ++++++++--------- src/mono/mono/mini/mini-wasm.h | 7 ------- 2 files changed, 8 insertions(+), 16 deletions(-) diff --git a/src/mono/mono/component/mini-wasm-debugger.c b/src/mono/mono/component/mini-wasm-debugger.c index ea59a0c7bcefad..d3d69b0c364107 100644 --- a/src/mono/mono/component/mini-wasm-debugger.c +++ b/src/mono/mono/component/mini-wasm-debugger.c @@ -144,7 +144,7 @@ handle_multiple_ss_requests (void) { return 1; } -void +static void mono_wasm_debugger_init (void) { if (!debugger_enabled) @@ -185,7 +185,7 @@ mono_wasm_debugger_init (void) mono_init_debugger_agent_for_wasm (log_level); } -void +static void mono_wasm_enable_debugging_internal (int debug_level) { PRINT_DEBUG_MSG (1, "DEBUGGING ENABLED\n"); @@ -222,14 +222,13 @@ assembly_loaded (MonoProfiler *prof, MonoAssembly *assembly) } } - -void +static void mono_wasm_single_step_hit (void) { mono_de_process_single_step (mono_wasm_get_tls (), FALSE); } -void +static void mono_wasm_breakpoint_hit (void) { mono_de_process_breakpoint (mono_wasm_get_tls (), FALSE); @@ -421,22 +420,22 @@ receive_debugger_agent_message (void *data, int len) #else // HOST_WASM -void +static void mono_wasm_single_step_hit (void) { } -void +static void mono_wasm_breakpoint_hit (void) { } -void +static void mono_wasm_debugger_init (void) { } -void +static void mono_wasm_enable_debugging_internal (int debug_level) { } diff --git a/src/mono/mono/mini/mini-wasm.h b/src/mono/mono/mini/mini-wasm.h index 1c78fb835289c2..df0a852b1a5632 100644 --- a/src/mono/mono/mini/mini-wasm.h +++ b/src/mono/mono/mini/mini-wasm.h @@ -97,18 +97,11 @@ typedef struct { #define MONO_ARCH_LLVM_TARGET_LAYOUT "e-m:e-p:32:32-i64:64-n32:64-S128" #define MONO_ARCH_LLVM_TARGET_TRIPLE "wasm32-unknown-emscripten" -void mono_wasm_debugger_init (void); - // sdks/wasm/driver.c is C and uses this G_EXTERN_C void mono_wasm_enable_debugging (int log_level); -void mono_wasm_breakpoint_hit (void); void mono_wasm_set_timeout (int timeout, int id); -void mono_wasm_single_step_hit (void); -void mono_wasm_breakpoint_hit (void); -void mono_wasm_user_break (void); - int mono_wasm_assembly_already_added (const char *assembly_name); void mono_wasm_print_stack_trace (void); From 6cbce7c2b5f83492b01f31ae8ea5080ad304d7af Mon Sep 17 00:00:00 2001 From: Thays Date: Tue, 29 Jun 2021 10:35:32 -0300 Subject: [PATCH 19/35] Fix compilation. --- src/mono/mono/mini/mini-arm.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/mono/mono/mini/mini-arm.c b/src/mono/mono/mini/mini-arm.c index 4fc43ee3071660..58c0cef04842e9 100644 --- a/src/mono/mono/mini/mini-arm.c +++ b/src/mono/mono/mini/mini-arm.c @@ -29,7 +29,6 @@ #include "mini-arm.h" #include "cpu-arm.h" #include "ir-emit.h" -#include "debugger-agent.h" #include "mini-gc.h" #include "mini-runtime.h" #include "aot-runtime.h" From bef0f118211f3cd5d6f04775ae0ea4346873549f Mon Sep 17 00:00:00 2001 From: Thays Date: Tue, 29 Jun 2021 11:21:40 -0300 Subject: [PATCH 20/35] Moving more files to component folder. --- src/mono/dlls/mscordbi/CMakeLists.txt | 4 +- src/mono/dlls/mscordbi/cordb.h | 2 +- src/mono/mono/component/CMakeLists.txt | 2 + src/mono/mono/component/debugger-engine.h | 4 +- .../mono/component/debugger-mono-compat.h | 21 + src/mono/mono/component/debugger-protocol.c | 298 ++++++++++++++ src/mono/mono/component/debugger-protocol.h | 384 ++++++++++++++++++ src/mono/mono/component/debugger.h | 2 +- src/mono/mono/component/mini-wasm-debugger.c | 2 +- src/mono/mono/mini/CMakeLists.txt | 2 - src/mono/mono/mini/mini.h | 2 +- 11 files changed, 713 insertions(+), 10 deletions(-) create mode 100644 src/mono/mono/component/debugger-mono-compat.h create mode 100644 src/mono/mono/component/debugger-protocol.c create mode 100644 src/mono/mono/component/debugger-protocol.h diff --git a/src/mono/dlls/mscordbi/CMakeLists.txt b/src/mono/dlls/mscordbi/CMakeLists.txt index d060638b40d804..32e61b129f34ac 100644 --- a/src/mono/dlls/mscordbi/CMakeLists.txt +++ b/src/mono/dlls/mscordbi/CMakeLists.txt @@ -130,11 +130,11 @@ if (CLR_CMAKE_HOST_UNIX) append("-Wno-strict-prototypes -Wno-deprecated -Wno-pointer-arith" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) endif (CLR_CMAKE_HOST_UNIX) -add_library(mscordbi SHARED "${mscorbi_sources};${PROJECT_SOURCE_DIR}/../../mono/mini/debugger-protocol.c;${PROJECT_SOURCE_DIR}/../../../coreclr/pal/prebuilt/idl/xcordebug_i.cpp;${PROJECT_SOURCE_DIR}/../../../coreclr/pal/prebuilt/idl/cordebug_i.cpp") +add_library(mscordbi SHARED "${mscorbi_sources};${PROJECT_SOURCE_DIR}/../../mono/component/debugger-protocol.c;${PROJECT_SOURCE_DIR}/../../../coreclr/pal/prebuilt/idl/xcordebug_i.cpp;${PROJECT_SOURCE_DIR}/../../../coreclr/pal/prebuilt/idl/cordebug_i.cpp") #SET(CMAKE_C_COMPILER ${CMAKE_CXX_COMPILER}) -set_source_files_properties(${PROJECT_SOURCE_DIR}/../../mono/mini/debugger-protocol.c PROPERTIES LANGUAGE CXX) +set_source_files_properties(${PROJECT_SOURCE_DIR}/../../mono/component/debugger-protocol.c PROPERTIES LANGUAGE CXX) set(COREDBI_LIBRARIES utilcodestaticnohost diff --git a/src/mono/dlls/mscordbi/cordb.h b/src/mono/dlls/mscordbi/cordb.h index f96ef8fc03d172..d81915dc85af3f 100644 --- a/src/mono/dlls/mscordbi/cordb.h +++ b/src/mono/dlls/mscordbi/cordb.h @@ -12,7 +12,7 @@ #include "corhdr.h" #include "xcordebug.h" -#include +#include #include #include "arraylist.h" diff --git a/src/mono/mono/component/CMakeLists.txt b/src/mono/mono/component/CMakeLists.txt index 3c9bf75b5f0d6d..62ab5b34528328 100644 --- a/src/mono/mono/component/CMakeLists.txt +++ b/src/mono/mono/component/CMakeLists.txt @@ -29,6 +29,8 @@ set(${MONO_DEBUGGER_COMPONENT_NAME}-sources ${MONO_COMPONENT_PATH}/debugger-state-machine.h ${MONO_COMPONENT_PATH}/debugger-state-machine.c ${MONO_COMPONENT_PATH}/mini-wasm-debugger.c + ${MONO_COMPONENT_PATH}/debugger-protocol.h + ${MONO_COMPONENT_PATH}/debugger-protocol.c ) set(${MONO_DEBUGGER_COMPONENT_NAME}-stub-sources ${MONO_COMPONENT_PATH}/debugger-stub.c diff --git a/src/mono/mono/component/debugger-engine.h b/src/mono/mono/component/debugger-engine.h index 26e3cc02b0c0b3..b79f6f47136e05 100644 --- a/src/mono/mono/component/debugger-engine.h +++ b/src/mono/mono/component/debugger-engine.h @@ -7,10 +7,10 @@ #include #include -#include +#include "debugger-state-machine.h" #include #include -#include +#include "debugger-protocol.h" #define ModifierKind MdbgProtModifierKind #define StepDepth MdbgProtStepDepth diff --git a/src/mono/mono/component/debugger-mono-compat.h b/src/mono/mono/component/debugger-mono-compat.h new file mode 100644 index 00000000000000..0492a71f3468cf --- /dev/null +++ b/src/mono/mono/component/debugger-mono-compat.h @@ -0,0 +1,21 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// +// File: DEBUGGER-MONO-COMPAT.H +// + +#ifndef __DBG_MONO_MONO_COMPAT_H__ +#define __DBG_MONO_MONO_COMPAT_H__ + +#include +#include + +static +inline +int32_t +dbg_rt_atomic_inc_int32_t (volatile int32_t *value) +{ + return (int32_t)mono_atomic_inc_i32 ((volatile gint32 *)value); +} + +#endif \ No newline at end of file diff --git a/src/mono/mono/component/debugger-protocol.c b/src/mono/mono/component/debugger-protocol.c new file mode 100644 index 00000000000000..2fe3096608a511 --- /dev/null +++ b/src/mono/mono/component/debugger-protocol.c @@ -0,0 +1,298 @@ +#include "debugger-protocol.h" + +#ifdef DBI_COMPONENT_MONO +#include "debugger-coreclr-compat.h" +#else +#include "debugger-mono-compat.h" +#endif + +static int32_t packet_id = 0; + +/* + * Functions to decode protocol data + */ +int +m_dbgprot_buffer_add_command_header (MdbgProtBuffer *data, int command_set, int command, MdbgProtBuffer *out) +{ + int id = dbg_rt_atomic_inc_int32_t ((volatile int32_t *)&packet_id); + + uint32_t len = (uint32_t)(data->p - data->buf + HEADER_LENGTH); + m_dbgprot_buffer_init (out, len); + m_dbgprot_buffer_add_int (out, len); + m_dbgprot_buffer_add_int (out, id); + m_dbgprot_buffer_add_byte (out, 0); /* flags */ + m_dbgprot_buffer_add_byte (out, command_set); + m_dbgprot_buffer_add_byte (out, command); + m_dbgprot_buffer_add_data (out, data->buf, (uint32_t) (data->p - data->buf)); + return id; +} + +void +m_dbgprot_decode_command_header (MdbgProtBuffer *recvbuf, MdbgProtHeader *header) +{ + header->len = m_dbgprot_decode_int (recvbuf->p, &recvbuf->p, recvbuf->end); + header->id = m_dbgprot_decode_int (recvbuf->p, &recvbuf->p, recvbuf->end); + header->flags = m_dbgprot_decode_byte (recvbuf->p, &recvbuf->p, recvbuf->end); + if (header->flags == REPLY_PACKET) { + header->error = m_dbgprot_decode_byte (recvbuf->p, &recvbuf->p, recvbuf->end); + header->error_2 = m_dbgprot_decode_byte (recvbuf->p, &recvbuf->p, recvbuf->end); + } + else { + header->command_set = m_dbgprot_decode_byte (recvbuf->p, &recvbuf->p, recvbuf->end); + header->command = m_dbgprot_decode_byte (recvbuf->p, &recvbuf->p, recvbuf->end); + } +} + +int +m_dbgprot_decode_byte (uint8_t *buf, uint8_t **endbuf, uint8_t *limit) +{ + *endbuf = buf + 1; + g_assert (*endbuf <= limit); + return buf [0]; +} + +int +m_dbgprot_decode_int (uint8_t *buf, uint8_t **endbuf, uint8_t *limit) +{ + *endbuf = buf + 4; + g_assert (*endbuf <= limit); + return (((int)buf [0]) << 24) | (((int)buf [1]) << 16) | (((int)buf [2]) << 8) | (((int)buf [3]) << 0); +} + +int64_t +m_dbgprot_decode_long (uint8_t *buf, uint8_t **endbuf, uint8_t *limit) +{ + uint32_t high = m_dbgprot_decode_int (buf, &buf, limit); + uint32_t low = m_dbgprot_decode_int (buf, &buf, limit); + + *endbuf = buf; + + return ((((uint64_t)high) << 32) | ((uint64_t)low)); +} + +int +m_dbgprot_decode_id (uint8_t *buf, uint8_t **endbuf, uint8_t *limit) +{ + return m_dbgprot_decode_int (buf, endbuf, limit); +} + +char* +m_dbgprot_decode_string (uint8_t *buf, uint8_t **endbuf, uint8_t *limit) +{ + int len = m_dbgprot_decode_int (buf, &buf, limit); + char *s; + + if (len < 0) { + *endbuf = buf; + return NULL; + } + + s = (char *)g_malloc (len + 1); + g_assert (s); + + memcpy (s, buf, len); + s [len] = '\0'; + buf += len; + *endbuf = buf; + + return s; +} + +char* +m_dbgprot_decode_string_with_len(uint8_t* buf, uint8_t** endbuf, uint8_t* limit, int *len) +{ + *len = m_dbgprot_decode_int(buf, &buf, limit); + char* s; + + if (*len < 0) { + *endbuf = buf; + return NULL; + } + + s = (char*)g_malloc(*len + 1); + g_assert(s); + + memcpy(s, buf, *len); + s[*len] = '\0'; + buf += *len; + *endbuf = buf; + + return s; +} + +uint8_t* +m_dbgprot_decode_byte_array (uint8_t *buf, uint8_t **endbuf, uint8_t *limit, int32_t *len) +{ + *len = m_dbgprot_decode_int (buf, &buf, limit); + uint8_t* s; + + if (*len < 0) { + *endbuf = buf; + return NULL; + } + + s = (uint8_t*)g_malloc (*len); + g_assert (s); + + memcpy (s, buf, *len); + buf += *len; + *endbuf = buf; + + return s; +} + +/* + * Functions to encode protocol data + */ + +void +m_dbgprot_buffer_init (MdbgProtBuffer *buf, uint32_t size) +{ + buf->buf = (uint8_t *)g_malloc (size); + buf->p = buf->buf; + buf->end = buf->buf + size; +} + +uint32_t +m_dbgprot_buffer_len (MdbgProtBuffer *buf) +{ + return (uint32_t)(buf->p - buf->buf); +} + +void +m_dbgprot_buffer_make_room (MdbgProtBuffer *buf, uint32_t size) +{ + if (((uint32_t)(buf->end - buf->p)) < size) { + size_t new_size = buf->end - buf->buf + size + 32; + uint8_t *p = (uint8_t *)g_realloc (buf->buf, new_size); + size = (uint32_t) (buf->p - buf->buf); + buf->buf = p; + buf->p = p + size; + buf->end = buf->buf + new_size; + } +} + +void +m_dbgprot_buffer_add_byte (MdbgProtBuffer *buf, uint8_t val) +{ + m_dbgprot_buffer_make_room (buf, 1); + buf->p [0] = val; + buf->p++; +} + +void +m_dbgprot_buffer_add_short (MdbgProtBuffer *buf, uint32_t val) +{ + m_dbgprot_buffer_make_room (buf, 2); + buf->p [0] = (val >> 8) & 0xff; + buf->p [1] = (val >> 0) & 0xff; + buf->p += 2; +} + +void +m_dbgprot_buffer_add_int (MdbgProtBuffer *buf, uint32_t val) +{ + m_dbgprot_buffer_make_room (buf, 4); + buf->p [0] = (val >> 24) & 0xff; + buf->p [1] = (val >> 16) & 0xff; + buf->p [2] = (val >> 8) & 0xff; + buf->p [3] = (val >> 0) & 0xff; + buf->p += 4; +} + +void +m_dbgprot_buffer_add_long (MdbgProtBuffer *buf, uint64_t l) +{ + m_dbgprot_buffer_add_int (buf, (l >> 32) & 0xffffffff); + m_dbgprot_buffer_add_int (buf, (l >> 0) & 0xffffffff); +} + +void +m_dbgprot_buffer_add_id (MdbgProtBuffer *buf, uint32_t id) +{ + m_dbgprot_buffer_add_int (buf, id); +} + +void +m_dbgprot_buffer_add_data (MdbgProtBuffer *buf, uint8_t *data, uint32_t len) +{ + m_dbgprot_buffer_make_room (buf, len); + memcpy (buf->p, data, len); + buf->p += len; +} + +void +m_dbgprot_buffer_add_utf16 (MdbgProtBuffer *buf, uint8_t *data, uint32_t len) +{ +#if G_BYTE_ORDER == G_LITTLE_ENDIAN + m_dbgprot_buffer_make_room (buf, len); + memcpy (buf->p, data, len); +#else + for (int i=0; ip[i] = data[i+1]; + buf->p[i+1] = data[i]; + } +#endif + buf->p += len; +} + +void +m_dbgprot_buffer_add_string (MdbgProtBuffer *buf, const char *str) +{ + uint32_t len; + + if (str == NULL) { + m_dbgprot_buffer_add_int (buf, 0); + } else { + len = (uint32_t) strlen (str); + m_dbgprot_buffer_add_int (buf, len); + m_dbgprot_buffer_add_data (buf, (uint8_t*)str, len); + } +} + +void +m_dbgprot_buffer_add_byte_array (MdbgProtBuffer *buf, uint8_t *bytes, uint32_t arr_len) +{ + m_dbgprot_buffer_add_int (buf, arr_len); + m_dbgprot_buffer_add_data (buf, bytes, arr_len); +} + +void +m_dbgprot_buffer_add_buffer (MdbgProtBuffer *buf, MdbgProtBuffer *data) +{ + m_dbgprot_buffer_add_data (buf, data->buf, m_dbgprot_buffer_len (data)); +} + +void +m_dbgprot_buffer_free (MdbgProtBuffer *buf) +{ + g_free (buf->buf); +} + +const char* +m_dbgprot_event_to_string (MdbgProtEventKind event) +{ + switch (event) { + case MDBGPROT_EVENT_KIND_VM_START: return "VM_START"; + case MDBGPROT_EVENT_KIND_VM_DEATH: return "VM_DEATH"; + case MDBGPROT_EVENT_KIND_THREAD_START: return "THREAD_START"; + case MDBGPROT_EVENT_KIND_THREAD_DEATH: return "THREAD_DEATH"; + case MDBGPROT_EVENT_KIND_APPDOMAIN_CREATE: return "APPDOMAIN_CREATE"; + case MDBGPROT_EVENT_KIND_APPDOMAIN_UNLOAD: return "APPDOMAIN_UNLOAD"; + case MDBGPROT_EVENT_KIND_METHOD_ENTRY: return "METHOD_ENTRY"; + case MDBGPROT_EVENT_KIND_METHOD_EXIT: return "METHOD_EXIT"; + case MDBGPROT_EVENT_KIND_ASSEMBLY_LOAD: return "ASSEMBLY_LOAD"; + case MDBGPROT_EVENT_KIND_ASSEMBLY_UNLOAD: return "ASSEMBLY_UNLOAD"; + case MDBGPROT_EVENT_KIND_BREAKPOINT: return "BREAKPOINT"; + case MDBGPROT_EVENT_KIND_STEP: return "STEP"; + case MDBGPROT_EVENT_KIND_TYPE_LOAD: return "TYPE_LOAD"; + case MDBGPROT_EVENT_KIND_EXCEPTION: return "EXCEPTION"; + case MDBGPROT_EVENT_KIND_KEEPALIVE: return "KEEPALIVE"; + case MDBGPROT_EVENT_KIND_USER_BREAK: return "USER_BREAK"; + case MDBGPROT_EVENT_KIND_USER_LOG: return "USER_LOG"; + case MDBGPROT_EVENT_KIND_CRASH: return "CRASH"; + default: + g_assert ( 1 ); + return ""; + } +} diff --git a/src/mono/mono/component/debugger-protocol.h b/src/mono/mono/component/debugger-protocol.h new file mode 100644 index 00000000000000..24e8a2e42c27e6 --- /dev/null +++ b/src/mono/mono/component/debugger-protocol.h @@ -0,0 +1,384 @@ +#ifndef __MONO_DEBUGGER_PROTOCOL_H__ +#define __MONO_DEBUGGER_PROTOCOL_H__ + +#include + +#define HEADER_LENGTH 11 +#define REPLY_PACKET 0x80 + +/* + * Wire Protocol definitions + */ + +#define MAJOR_VERSION 2 +#define MINOR_VERSION 60 + +typedef enum { + MDBGPROT_CMD_COMPOSITE = 100 +} MdbgProtCmdComposite; + +typedef enum { + MDBGPROT_CMD_VM_VERSION = 1, + MDBGPROT_CMD_VM_ALL_THREADS = 2, + MDBGPROT_CMD_VM_SUSPEND = 3, + MDBGPROT_CMD_VM_RESUME = 4, + MDBGPROT_CMD_VM_EXIT = 5, + MDBGPROT_CMD_VM_DISPOSE = 6, + MDBGPROT_CMD_VM_INVOKE_METHOD = 7, + MDBGPROT_CMD_VM_SET_PROTOCOL_VERSION = 8, + MDBGPROT_CMD_VM_ABORT_INVOKE = 9, + MDBGPROT_CMD_VM_SET_KEEPALIVE = 10, + MDBGPROT_CMD_VM_GET_TYPES_FOR_SOURCE_FILE = 11, + MDBGPROT_CMD_VM_GET_TYPES = 12, + MDBGPROT_CMD_VM_INVOKE_METHODS = 13, + MDBGPROT_CMD_VM_START_BUFFERING = 14, + MDBGPROT_CMD_VM_STOP_BUFFERING = 15, + MDBGPROT_CMD_VM_READ_MEMORY = 16, + MDBGPROT_CMD_VM_WRITE_MEMORY = 17, + MDBGPROT_CMD_GET_ASSEMBLY_BY_NAME = 18 +} MdbgProtCmdVM; + +typedef enum { + MDBGPROT_CMD_SET_VM = 1, + MDBGPROT_CMD_SET_OBJECT_REF = 9, + MDBGPROT_CMD_SET_STRING_REF = 10, + MDBGPROT_CMD_SET_THREAD = 11, + MDBGPROT_CMD_SET_ARRAY_REF = 13, + MDBGPROT_CMD_SET_EVENT_REQUEST = 15, + MDBGPROT_CMD_SET_STACK_FRAME = 16, + MDBGPROT_CMD_SET_APPDOMAIN = 20, + MDBGPROT_CMD_SET_ASSEMBLY = 21, + MDBGPROT_CMD_SET_METHOD = 22, + MDBGPROT_CMD_SET_TYPE = 23, + MDBGPROT_CMD_SET_MODULE = 24, + MDBGPROT_CMD_SET_FIELD = 25, + MDBGPROT_CMD_SET_EVENT = 64, + MDBGPROT_CMD_SET_POINTER = 65 +} MdbgProtCommandSet; + +typedef enum { + MDBGPROT_ERR_NONE = 0, + MDBGPROT_ERR_INVALID_OBJECT = 20, + MDBGPROT_ERR_INVALID_FIELDID = 25, + MDBGPROT_ERR_INVALID_FRAMEID = 30, + MDBGPROT_ERR_NOT_IMPLEMENTED = 100, + MDBGPROT_ERR_NOT_SUSPENDED = 101, + MDBGPROT_ERR_INVALID_ARGUMENT = 102, + MDBGPROT_ERR_UNLOADED = 103, + MDBGPROT_ERR_NO_INVOCATION = 104, + MDBGPROT_ERR_ABSENT_INFORMATION = 105, + MDBGPROT_ERR_NO_SEQ_POINT_AT_IL_OFFSET = 106, + MDBGPROT_ERR_INVOKE_ABORTED = 107, + MDBGPROT_ERR_LOADER_ERROR = 200, /*XXX extend the protocol to pass this information down the pipe */ +} MdbgProtErrorCode; + +typedef enum { + MDBGPROT_TOKEN_TYPE_STRING = 0, + MDBGPROT_TOKEN_TYPE_TYPE = 1, + MDBGPROT_TOKEN_TYPE_FIELD = 2, + MDBGPROT_TOKEN_TYPE_METHOD = 3, + MDBGPROT_TOKEN_TYPE_UNKNOWN = 4 +} MdbgProtDebuggerTokenType; + +typedef enum { + MDBGPROT_VALUE_TYPE_ID_NULL = 0xf0, + MDBGPROT_VALUE_TYPE_ID_TYPE = 0xf1, + MDBGPROT_VALUE_TYPE_ID_PARENT_VTYPE = 0xf2, + MDBGPROT_VALUE_TYPE_ID_FIXED_ARRAY = 0xf3 +} MdbgProtValueTypeId; + +typedef enum { + MDBGPROT_FRAME_FLAG_DEBUGGER_INVOKE = 1, + MDBGPROT_FRAME_FLAG_NATIVE_TRANSITION = 2 +} MdbgProtStackFrameFlags; + +typedef enum { + MDBGPROT_INVOKE_FLAG_DISABLE_BREAKPOINTS = 1, + MDBGPROT_INVOKE_FLAG_SINGLE_THREADED = 2, + MDBGPROT_INVOKE_FLAG_RETURN_OUT_THIS = 4, + MDBGPROT_INVOKE_FLAG_RETURN_OUT_ARGS = 8, + MDBGPROT_INVOKE_FLAG_VIRTUAL = 16 +} MdbgProtInvokeFlags; + +typedef enum { + BINDING_FLAGS_IGNORE_CASE = 0x70000000, +} MdbgProtBindingFlagsExtensions; + +typedef enum { + MDBGPROT_CMD_THREAD_GET_FRAME_INFO = 1, + MDBGPROT_CMD_THREAD_GET_NAME = 2, + MDBGPROT_CMD_THREAD_GET_STATE = 3, + MDBGPROT_CMD_THREAD_GET_INFO = 4, + MDBGPROT_CMD_THREAD_GET_ID = 5, + MDBGPROT_CMD_THREAD_GET_TID = 6, + MDBGPROT_CMD_THREAD_SET_IP = 7, + MDBGPROT_CMD_THREAD_ELAPSED_TIME = 8, + MDBGPROT_CMD_THREAD_GET_APPDOMAIN = 9, + MDBGPROT_CMD_THREAD_GET_CONTEXT = 10, + MDBGPROT_CMD_THREAD_SET_CONTEXT = 11 +} MdbgProtCmdThread; + +typedef enum { + MDBGPROT_CMD_APPDOMAIN_GET_ROOT_DOMAIN = 1, + MDBGPROT_CMD_APPDOMAIN_GET_FRIENDLY_NAME = 2, + MDBGPROT_CMD_APPDOMAIN_GET_ASSEMBLIES = 3, + MDBGPROT_CMD_APPDOMAIN_GET_ENTRY_ASSEMBLY = 4, + MDBGPROT_CMD_APPDOMAIN_CREATE_STRING = 5, + MDBGPROT_CMD_APPDOMAIN_GET_CORLIB = 6, + MDBGPROT_CMD_APPDOMAIN_CREATE_BOXED_VALUE = 7, + MDBGPROT_CMD_APPDOMAIN_CREATE_BYTE_ARRAY = 8, +} MdbgProtCmdAppDomain; + +typedef enum { + MDBGPROT_CMD_ASSEMBLY_GET_LOCATION = 1, + MDBGPROT_CMD_ASSEMBLY_GET_ENTRY_POINT = 2, + MDBGPROT_CMD_ASSEMBLY_GET_MANIFEST_MODULE = 3, + MDBGPROT_CMD_ASSEMBLY_GET_OBJECT = 4, + MDBGPROT_CMD_ASSEMBLY_GET_TYPE = 5, + MDBGPROT_CMD_ASSEMBLY_GET_NAME = 6, + MDBGPROT_CMD_ASSEMBLY_GET_DOMAIN = 7, + MDBGPROT_CMD_ASSEMBLY_GET_METADATA_BLOB = 8, + MDBGPROT_CMD_ASSEMBLY_GET_IS_DYNAMIC = 9, + MDBGPROT_CMD_ASSEMBLY_GET_PDB_BLOB = 10, + MDBGPROT_CMD_ASSEMBLY_GET_TYPE_FROM_TOKEN = 11, + MDBGPROT_CMD_ASSEMBLY_GET_METHOD_FROM_TOKEN = 12, + MDBGPROT_CMD_ASSEMBLY_HAS_DEBUG_INFO = 13, + MDBGPROT_CMD_ASSEMBLY_GET_CATTRS = 14, + MDBGPROT_CMD_ASSEMBLY_GET_CUSTOM_ATTRIBUTES = 15, + MDBGPROT_CMD_ASSEMBLY_GET_PEIMAGE_ADDRESS = 16, +} MdbgProtCmdAssembly; + +typedef enum { + MDBGPROT_CMD_MODULE_GET_INFO = 1, + MDBGPROT_CMD_MODULE_APPLY_CHANGES = 2, +} MdbgProtCmdModule; + +typedef enum { + MDBGPROT_CMD_FIELD_GET_INFO = 1, +} MdbgProtCmdField; + +typedef enum { + MDBGPROT_CMD_PROPERTY_GET_INFO = 1, +} MdbgProtCmdProperty; + +typedef enum { + MDBGPROT_CMD_METHOD_GET_NAME = 1, + MDBGPROT_CMD_METHOD_GET_DECLARING_TYPE = 2, + MDBGPROT_CMD_METHOD_GET_DEBUG_INFO = 3, + MDBGPROT_CMD_METHOD_GET_PARAM_INFO = 4, + MDBGPROT_CMD_METHOD_GET_LOCALS_INFO = 5, + MDBGPROT_CMD_METHOD_GET_INFO = 6, + MDBGPROT_CMD_METHOD_GET_BODY = 7, + MDBGPROT_CMD_METHOD_RESOLVE_TOKEN = 8, + MDBGPROT_CMD_METHOD_GET_CATTRS = 9, + MDBGPROT_CMD_METHOD_MAKE_GENERIC_METHOD = 10, + MDBGPROT_CMD_METHOD_TOKEN = 11, + MDBGPROT_CMD_METHOD_ASSEMBLY = 12, + MDBGPROT_CMD_METHOD_GET_CLASS_TOKEN = 13, + MDBGPROT_CMD_METHOD_HAS_ASYNC_DEBUG_INFO = 14, + MDBGPROT_CMD_METHOD_GET_NAME_FULL = 15 +} MdbgProtCmdMethod; + +typedef enum { + MDBGPROT_CMD_TYPE_GET_INFO = 1, + MDBGPROT_CMD_TYPE_GET_METHODS = 2, + MDBGPROT_CMD_TYPE_GET_FIELDS = 3, + MDBGPROT_CMD_TYPE_GET_VALUES = 4, + MDBGPROT_CMD_TYPE_GET_OBJECT = 5, + MDBGPROT_CMD_TYPE_GET_SOURCE_FILES = 6, + MDBGPROT_CMD_TYPE_SET_VALUES = 7, + MDBGPROT_CMD_TYPE_IS_ASSIGNABLE_FROM = 8, + MDBGPROT_CMD_TYPE_GET_PROPERTIES = 9, + MDBGPROT_CMD_TYPE_GET_CATTRS = 10, + MDBGPROT_CMD_TYPE_GET_FIELD_CATTRS = 11, + MDBGPROT_CMD_TYPE_GET_PROPERTY_CATTRS = 12, + MDBGPROT_CMD_TYPE_GET_SOURCE_FILES_2 = 13, + MDBGPROT_CMD_TYPE_GET_VALUES_2 = 14, + MDBGPROT_CMD_TYPE_GET_METHODS_BY_NAME_FLAGS = 15, + MDBGPROT_CMD_TYPE_GET_INTERFACES = 16, + MDBGPROT_CMD_TYPE_GET_INTERFACE_MAP = 17, + MDBGPROT_CMD_TYPE_IS_INITIALIZED = 18, + MDBGPROT_CMD_TYPE_CREATE_INSTANCE = 19, + MDBGPROT_CMD_TYPE_GET_VALUE_SIZE = 20, + MDBGPROT_CMD_TYPE_GET_VALUES_ICORDBG = 21, + MDBGPROT_CMD_TYPE_GET_PARENTS = 22 +} MdbgProtCmdType; + +typedef enum { + MDBGPROT_CMD_STACK_FRAME_GET_VALUES = 1, + MDBGPROT_CMD_STACK_FRAME_GET_THIS = 2, + MDBGPROT_CMD_STACK_FRAME_SET_VALUES = 3, + MDBGPROT_CMD_STACK_FRAME_GET_DOMAIN = 4, + MDBGPROT_CMD_STACK_FRAME_SET_THIS = 5, + MDBGPROT_CMD_STACK_FRAME_GET_ARGUMENT = 6, + MDBGPROT_CMD_STACK_FRAME_GET_ARGUMENTS = 7 +} MdbgProtCmdStackFrame; + +typedef enum { + MDBGPROT_CMD_ARRAY_REF_GET_LENGTH = 1, + MDBGPROT_CMD_ARRAY_REF_GET_VALUES = 2, + MDBGPROT_CMD_ARRAY_REF_SET_VALUES = 3, + MDBGPROT_CMD_ARRAY_REF_GET_TYPE = 4 +} MdbgProtCmdArray; + +typedef enum { + MDBGPROT_CMD_STRING_REF_GET_VALUE = 1, + MDBGPROT_CMD_STRING_REF_GET_LENGTH = 2, + MDBGPROT_CMD_STRING_REF_GET_CHARS = 3 +} MdbgProtCmdString; + +typedef enum { + MDBGPROT_CMD_POINTER_GET_VALUE = 1 +} MdbgProtCmdPointer; + +typedef enum { + MDBGPROT_CMD_OBJECT_REF_GET_TYPE = 1, + MDBGPROT_CMD_OBJECT_REF_GET_VALUES = 2, + MDBGPROT_CMD_OBJECT_REF_IS_COLLECTED = 3, + MDBGPROT_CMD_OBJECT_REF_GET_ADDRESS = 4, + MDBGPROT_CMD_OBJECT_REF_GET_DOMAIN = 5, + MDBGPROT_CMD_OBJECT_REF_SET_VALUES = 6, + MDBGPROT_CMD_OBJECT_REF_GET_INFO = 7, + MDBGPROT_CMD_OBJECT_REF_GET_VALUES_ICORDBG = 8, + MDBGPROT_CMD_OBJECT_REF_DELEGATE_GET_METHOD = 9, + MDBGPROT_CMD_OBJECT_IS_DELEGATE = 10 +} MdbgProtCmdObject; + +typedef enum { + MDBGPROT_SUSPEND_POLICY_NONE = 0, + MDBGPROT_SUSPEND_POLICY_EVENT_THREAD = 1, + MDBGPROT_SUSPEND_POLICY_ALL = 2 +} MdbgProtSuspendPolicy; + +typedef enum { + MDBGPROT_CMD_EVENT_REQUEST_SET = 1, + MDBGPROT_CMD_EVENT_REQUEST_CLEAR = 2, + MDBGPROT_CMD_EVENT_REQUEST_CLEAR_ALL_BREAKPOINTS = 3 +} MdbgProtCmdEvent; + +typedef struct { + uint8_t *buf, *p, *end; +} MdbgProtBuffer; + +typedef struct { + int len; + int id; + int flags; + int command_set; + int command; + int error; + int error_2; +} MdbgProtHeader; + +typedef struct ReplyPacket { + int id; + int error; + MdbgProtBuffer *data; +} MdbgProtReplyPacket; + +typedef enum { + MDBGPROT_EVENT_KIND_VM_START = 0, + MDBGPROT_EVENT_KIND_VM_DEATH = 1, + MDBGPROT_EVENT_KIND_THREAD_START = 2, + MDBGPROT_EVENT_KIND_THREAD_DEATH = 3, + MDBGPROT_EVENT_KIND_APPDOMAIN_CREATE = 4, + MDBGPROT_EVENT_KIND_APPDOMAIN_UNLOAD = 5, + MDBGPROT_EVENT_KIND_METHOD_ENTRY = 6, + MDBGPROT_EVENT_KIND_METHOD_EXIT = 7, + MDBGPROT_EVENT_KIND_ASSEMBLY_LOAD = 8, + MDBGPROT_EVENT_KIND_ASSEMBLY_UNLOAD = 9, + MDBGPROT_EVENT_KIND_BREAKPOINT = 10, + MDBGPROT_EVENT_KIND_STEP = 11, + MDBGPROT_EVENT_KIND_TYPE_LOAD = 12, + MDBGPROT_EVENT_KIND_EXCEPTION = 13, + MDBGPROT_EVENT_KIND_KEEPALIVE = 14, + MDBGPROT_EVENT_KIND_USER_BREAK = 15, + MDBGPROT_EVENT_KIND_USER_LOG = 16, + MDBGPROT_EVENT_KIND_CRASH = 17 +} MdbgProtEventKind; + +typedef enum { + MDBGPROT_MOD_KIND_COUNT = 1, + MDBGPROT_MOD_KIND_THREAD_ONLY = 3, + MDBGPROT_MOD_KIND_LOCATION_ONLY = 7, + MDBGPROT_MOD_KIND_EXCEPTION_ONLY = 8, + MDBGPROT_MOD_KIND_STEP = 10, + MDBGPROT_MOD_KIND_ASSEMBLY_ONLY = 11, + MDBGPROT_MOD_KIND_SOURCE_FILE_ONLY = 12, + MDBGPROT_MOD_KIND_TYPE_NAME_ONLY = 13, + MDBGPROT_MOD_KIND_NONE = 14 +} MdbgProtModifierKind; + +typedef enum { + MDBGPROT_STEP_DEPTH_INTO = 0, + MDBGPROT_STEP_DEPTH_OVER = 1, + MDBGPROT_STEP_DEPTH_OUT = 2 +} MdbgProtStepDepth; + +typedef enum { + MDBGPROT_STEP_SIZE_MIN = 0, + MDBGPROT_STEP_SIZE_LINE = 1 +} MdbgProtStepSize; + +typedef enum { + MDBGPROT_STEP_FILTER_NONE = 0, + MDBGPROT_STEP_FILTER_STATIC_CTOR = 1, + MDBGPROT_STEP_FILTER_DEBUGGER_HIDDEN = 2, + MDBGPROT_STEP_FILTER_DEBUGGER_STEP_THROUGH = 4, + MDBGPROT_STEP_FILTER_DEBUGGER_NON_USER_CODE = 8 +} MdbgProtStepFilter; + +/* + * IDS + */ + +typedef enum { + ID_ASSEMBLY = 0, + ID_MODULE = 1, + ID_TYPE = 2, + ID_METHOD = 3, + ID_FIELD = 4, + ID_DOMAIN = 5, + ID_PROPERTY = 6, + ID_PARAMETER = 7, + ID_NUM +} IdType; + +int m_dbgprot_buffer_add_command_header (MdbgProtBuffer *recvbuf, int cmd_set, int cmd, MdbgProtBuffer *out); +void m_dbgprot_decode_command_header (MdbgProtBuffer *recvbuf, MdbgProtHeader *header); + +/* + * Functions to decode protocol data + */ + +int m_dbgprot_decode_byte (uint8_t *buf, uint8_t **endbuf, uint8_t *limit); +int m_dbgprot_decode_int (uint8_t *buf, uint8_t **endbuf, uint8_t *limit); +int64_t m_dbgprot_decode_long (uint8_t *buf, uint8_t **endbuf, uint8_t *limit); +int m_dbgprot_decode_id (uint8_t *buf, uint8_t **endbuf, uint8_t *limit); +char* m_dbgprot_decode_string (uint8_t *buf, uint8_t **endbuf, uint8_t *limit); +char* m_dbgprot_decode_string_with_len(uint8_t* buf, uint8_t** endbuf, uint8_t* limit, int *len); +uint8_t* m_dbgprot_decode_byte_array(uint8_t *buf, uint8_t **endbuf, uint8_t *limit, int32_t *len); + +/* + * Functions to encode protocol data + */ + +void m_dbgprot_buffer_init (MdbgProtBuffer *buf, uint32_t size); +uint32_t m_dbgprot_buffer_len (MdbgProtBuffer *buf); +void m_dbgprot_buffer_make_room (MdbgProtBuffer *buf, uint32_t size); +void m_dbgprot_buffer_add_byte (MdbgProtBuffer *buf, uint8_t val); +void m_dbgprot_buffer_add_short (MdbgProtBuffer *buf, uint32_t val); +void m_dbgprot_buffer_add_int (MdbgProtBuffer *buf, uint32_t val); +void m_dbgprot_buffer_add_long (MdbgProtBuffer *buf, uint64_t l); +void m_dbgprot_buffer_add_id (MdbgProtBuffer *buf, uint32_t id); +void m_dbgprot_buffer_add_data (MdbgProtBuffer *buf, uint8_t *data, uint32_t len); +void m_dbgprot_buffer_add_utf16 (MdbgProtBuffer *buf, uint8_t *data, uint32_t len); +void m_dbgprot_buffer_add_string (MdbgProtBuffer *buf, const char *str); +void m_dbgprot_buffer_add_byte_array (MdbgProtBuffer *buf, uint8_t *bytes, uint32_t arr_len); +void m_dbgprot_buffer_add_buffer (MdbgProtBuffer *buf, MdbgProtBuffer *data); +void m_dbgprot_buffer_free (MdbgProtBuffer *buf); + +const char* m_dbgprot_event_to_string (MdbgProtEventKind event); + +#endif + diff --git a/src/mono/mono/component/debugger.h b/src/mono/mono/component/debugger.h index b5fbf662d5c3bb..9d9f0317cbc41e 100644 --- a/src/mono/mono/component/debugger.h +++ b/src/mono/mono/component/debugger.h @@ -11,7 +11,7 @@ #include "mono/utils/mono-context.h" #include "mono/utils/mono-stack-unwinding.h" #include "mono/component/component.h" -#include "mono/mini/debugger-protocol.h" +#include "debugger-protocol.h" #include "mono/metadata/seq-points-data.h" typedef struct { diff --git a/src/mono/mono/component/mini-wasm-debugger.c b/src/mono/mono/component/mini-wasm-debugger.c index f40d5c7dcd919c..d0d43826b80896 100644 --- a/src/mono/mono/component/mini-wasm-debugger.c +++ b/src/mono/mono/component/mini-wasm-debugger.c @@ -11,7 +11,7 @@ #include #include #include -#include +#include "debugger-protocol.h" #include "debugger-agent.h" #include diff --git a/src/mono/mono/mini/CMakeLists.txt b/src/mono/mono/mini/CMakeLists.txt index f1eb7636263d61..c66362a55f395f 100644 --- a/src/mono/mono/mini/CMakeLists.txt +++ b/src/mono/mono/mini/CMakeLists.txt @@ -170,8 +170,6 @@ set(mini_common_sources set(debugger_sources debugger-agent-external.h debugger-agent-external.c - debugger-protocol.h - debugger-protocol.c ) set(amd64_sources diff --git a/src/mono/mono/mini/mini.h b/src/mono/mono/mini/mini.h index c865bf5b2934e4..8447b5394160eb 100644 --- a/src/mono/mono/mini/mini.h +++ b/src/mono/mono/mini/mini.h @@ -2552,7 +2552,7 @@ void mono_walk_stack (MonoJitStackWalk func, MonoUnwi gboolean mono_thread_state_init_from_sigctx (MonoThreadUnwindState *ctx, void *sigctx); void mono_thread_state_init (MonoThreadUnwindState *ctx); gboolean mono_thread_state_init_from_current (MonoThreadUnwindState *ctx); -gboolean mono_thread_state_init_from_monoctx (MonoThreadUnwindState *ctx, MonoContext *mctx); +MONO_COMPONENT_API gboolean mono_thread_state_init_from_monoctx (MonoThreadUnwindState *ctx, MonoContext *mctx); void mono_setup_altstack (MonoJitTlsData *tls); void mono_free_altstack (MonoJitTlsData *tls); From 6c8fea86b68b3ce19f8cb46bf79d3a1526da86eb Mon Sep 17 00:00:00 2001 From: Thays Date: Tue, 29 Jun 2021 11:22:49 -0300 Subject: [PATCH 21/35] moving files. --- src/mono/mono/mini/debugger-mono-compat.h | 21 -- src/mono/mono/mini/debugger-protocol.c | 298 ----------------- src/mono/mono/mini/debugger-protocol.h | 384 ---------------------- 3 files changed, 703 deletions(-) delete mode 100644 src/mono/mono/mini/debugger-mono-compat.h delete mode 100644 src/mono/mono/mini/debugger-protocol.c delete mode 100644 src/mono/mono/mini/debugger-protocol.h diff --git a/src/mono/mono/mini/debugger-mono-compat.h b/src/mono/mono/mini/debugger-mono-compat.h deleted file mode 100644 index 0492a71f3468cf..00000000000000 --- a/src/mono/mono/mini/debugger-mono-compat.h +++ /dev/null @@ -1,21 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. -// -// File: DEBUGGER-MONO-COMPAT.H -// - -#ifndef __DBG_MONO_MONO_COMPAT_H__ -#define __DBG_MONO_MONO_COMPAT_H__ - -#include -#include - -static -inline -int32_t -dbg_rt_atomic_inc_int32_t (volatile int32_t *value) -{ - return (int32_t)mono_atomic_inc_i32 ((volatile gint32 *)value); -} - -#endif \ No newline at end of file diff --git a/src/mono/mono/mini/debugger-protocol.c b/src/mono/mono/mini/debugger-protocol.c deleted file mode 100644 index 2fe3096608a511..00000000000000 --- a/src/mono/mono/mini/debugger-protocol.c +++ /dev/null @@ -1,298 +0,0 @@ -#include "debugger-protocol.h" - -#ifdef DBI_COMPONENT_MONO -#include "debugger-coreclr-compat.h" -#else -#include "debugger-mono-compat.h" -#endif - -static int32_t packet_id = 0; - -/* - * Functions to decode protocol data - */ -int -m_dbgprot_buffer_add_command_header (MdbgProtBuffer *data, int command_set, int command, MdbgProtBuffer *out) -{ - int id = dbg_rt_atomic_inc_int32_t ((volatile int32_t *)&packet_id); - - uint32_t len = (uint32_t)(data->p - data->buf + HEADER_LENGTH); - m_dbgprot_buffer_init (out, len); - m_dbgprot_buffer_add_int (out, len); - m_dbgprot_buffer_add_int (out, id); - m_dbgprot_buffer_add_byte (out, 0); /* flags */ - m_dbgprot_buffer_add_byte (out, command_set); - m_dbgprot_buffer_add_byte (out, command); - m_dbgprot_buffer_add_data (out, data->buf, (uint32_t) (data->p - data->buf)); - return id; -} - -void -m_dbgprot_decode_command_header (MdbgProtBuffer *recvbuf, MdbgProtHeader *header) -{ - header->len = m_dbgprot_decode_int (recvbuf->p, &recvbuf->p, recvbuf->end); - header->id = m_dbgprot_decode_int (recvbuf->p, &recvbuf->p, recvbuf->end); - header->flags = m_dbgprot_decode_byte (recvbuf->p, &recvbuf->p, recvbuf->end); - if (header->flags == REPLY_PACKET) { - header->error = m_dbgprot_decode_byte (recvbuf->p, &recvbuf->p, recvbuf->end); - header->error_2 = m_dbgprot_decode_byte (recvbuf->p, &recvbuf->p, recvbuf->end); - } - else { - header->command_set = m_dbgprot_decode_byte (recvbuf->p, &recvbuf->p, recvbuf->end); - header->command = m_dbgprot_decode_byte (recvbuf->p, &recvbuf->p, recvbuf->end); - } -} - -int -m_dbgprot_decode_byte (uint8_t *buf, uint8_t **endbuf, uint8_t *limit) -{ - *endbuf = buf + 1; - g_assert (*endbuf <= limit); - return buf [0]; -} - -int -m_dbgprot_decode_int (uint8_t *buf, uint8_t **endbuf, uint8_t *limit) -{ - *endbuf = buf + 4; - g_assert (*endbuf <= limit); - return (((int)buf [0]) << 24) | (((int)buf [1]) << 16) | (((int)buf [2]) << 8) | (((int)buf [3]) << 0); -} - -int64_t -m_dbgprot_decode_long (uint8_t *buf, uint8_t **endbuf, uint8_t *limit) -{ - uint32_t high = m_dbgprot_decode_int (buf, &buf, limit); - uint32_t low = m_dbgprot_decode_int (buf, &buf, limit); - - *endbuf = buf; - - return ((((uint64_t)high) << 32) | ((uint64_t)low)); -} - -int -m_dbgprot_decode_id (uint8_t *buf, uint8_t **endbuf, uint8_t *limit) -{ - return m_dbgprot_decode_int (buf, endbuf, limit); -} - -char* -m_dbgprot_decode_string (uint8_t *buf, uint8_t **endbuf, uint8_t *limit) -{ - int len = m_dbgprot_decode_int (buf, &buf, limit); - char *s; - - if (len < 0) { - *endbuf = buf; - return NULL; - } - - s = (char *)g_malloc (len + 1); - g_assert (s); - - memcpy (s, buf, len); - s [len] = '\0'; - buf += len; - *endbuf = buf; - - return s; -} - -char* -m_dbgprot_decode_string_with_len(uint8_t* buf, uint8_t** endbuf, uint8_t* limit, int *len) -{ - *len = m_dbgprot_decode_int(buf, &buf, limit); - char* s; - - if (*len < 0) { - *endbuf = buf; - return NULL; - } - - s = (char*)g_malloc(*len + 1); - g_assert(s); - - memcpy(s, buf, *len); - s[*len] = '\0'; - buf += *len; - *endbuf = buf; - - return s; -} - -uint8_t* -m_dbgprot_decode_byte_array (uint8_t *buf, uint8_t **endbuf, uint8_t *limit, int32_t *len) -{ - *len = m_dbgprot_decode_int (buf, &buf, limit); - uint8_t* s; - - if (*len < 0) { - *endbuf = buf; - return NULL; - } - - s = (uint8_t*)g_malloc (*len); - g_assert (s); - - memcpy (s, buf, *len); - buf += *len; - *endbuf = buf; - - return s; -} - -/* - * Functions to encode protocol data - */ - -void -m_dbgprot_buffer_init (MdbgProtBuffer *buf, uint32_t size) -{ - buf->buf = (uint8_t *)g_malloc (size); - buf->p = buf->buf; - buf->end = buf->buf + size; -} - -uint32_t -m_dbgprot_buffer_len (MdbgProtBuffer *buf) -{ - return (uint32_t)(buf->p - buf->buf); -} - -void -m_dbgprot_buffer_make_room (MdbgProtBuffer *buf, uint32_t size) -{ - if (((uint32_t)(buf->end - buf->p)) < size) { - size_t new_size = buf->end - buf->buf + size + 32; - uint8_t *p = (uint8_t *)g_realloc (buf->buf, new_size); - size = (uint32_t) (buf->p - buf->buf); - buf->buf = p; - buf->p = p + size; - buf->end = buf->buf + new_size; - } -} - -void -m_dbgprot_buffer_add_byte (MdbgProtBuffer *buf, uint8_t val) -{ - m_dbgprot_buffer_make_room (buf, 1); - buf->p [0] = val; - buf->p++; -} - -void -m_dbgprot_buffer_add_short (MdbgProtBuffer *buf, uint32_t val) -{ - m_dbgprot_buffer_make_room (buf, 2); - buf->p [0] = (val >> 8) & 0xff; - buf->p [1] = (val >> 0) & 0xff; - buf->p += 2; -} - -void -m_dbgprot_buffer_add_int (MdbgProtBuffer *buf, uint32_t val) -{ - m_dbgprot_buffer_make_room (buf, 4); - buf->p [0] = (val >> 24) & 0xff; - buf->p [1] = (val >> 16) & 0xff; - buf->p [2] = (val >> 8) & 0xff; - buf->p [3] = (val >> 0) & 0xff; - buf->p += 4; -} - -void -m_dbgprot_buffer_add_long (MdbgProtBuffer *buf, uint64_t l) -{ - m_dbgprot_buffer_add_int (buf, (l >> 32) & 0xffffffff); - m_dbgprot_buffer_add_int (buf, (l >> 0) & 0xffffffff); -} - -void -m_dbgprot_buffer_add_id (MdbgProtBuffer *buf, uint32_t id) -{ - m_dbgprot_buffer_add_int (buf, id); -} - -void -m_dbgprot_buffer_add_data (MdbgProtBuffer *buf, uint8_t *data, uint32_t len) -{ - m_dbgprot_buffer_make_room (buf, len); - memcpy (buf->p, data, len); - buf->p += len; -} - -void -m_dbgprot_buffer_add_utf16 (MdbgProtBuffer *buf, uint8_t *data, uint32_t len) -{ -#if G_BYTE_ORDER == G_LITTLE_ENDIAN - m_dbgprot_buffer_make_room (buf, len); - memcpy (buf->p, data, len); -#else - for (int i=0; ip[i] = data[i+1]; - buf->p[i+1] = data[i]; - } -#endif - buf->p += len; -} - -void -m_dbgprot_buffer_add_string (MdbgProtBuffer *buf, const char *str) -{ - uint32_t len; - - if (str == NULL) { - m_dbgprot_buffer_add_int (buf, 0); - } else { - len = (uint32_t) strlen (str); - m_dbgprot_buffer_add_int (buf, len); - m_dbgprot_buffer_add_data (buf, (uint8_t*)str, len); - } -} - -void -m_dbgprot_buffer_add_byte_array (MdbgProtBuffer *buf, uint8_t *bytes, uint32_t arr_len) -{ - m_dbgprot_buffer_add_int (buf, arr_len); - m_dbgprot_buffer_add_data (buf, bytes, arr_len); -} - -void -m_dbgprot_buffer_add_buffer (MdbgProtBuffer *buf, MdbgProtBuffer *data) -{ - m_dbgprot_buffer_add_data (buf, data->buf, m_dbgprot_buffer_len (data)); -} - -void -m_dbgprot_buffer_free (MdbgProtBuffer *buf) -{ - g_free (buf->buf); -} - -const char* -m_dbgprot_event_to_string (MdbgProtEventKind event) -{ - switch (event) { - case MDBGPROT_EVENT_KIND_VM_START: return "VM_START"; - case MDBGPROT_EVENT_KIND_VM_DEATH: return "VM_DEATH"; - case MDBGPROT_EVENT_KIND_THREAD_START: return "THREAD_START"; - case MDBGPROT_EVENT_KIND_THREAD_DEATH: return "THREAD_DEATH"; - case MDBGPROT_EVENT_KIND_APPDOMAIN_CREATE: return "APPDOMAIN_CREATE"; - case MDBGPROT_EVENT_KIND_APPDOMAIN_UNLOAD: return "APPDOMAIN_UNLOAD"; - case MDBGPROT_EVENT_KIND_METHOD_ENTRY: return "METHOD_ENTRY"; - case MDBGPROT_EVENT_KIND_METHOD_EXIT: return "METHOD_EXIT"; - case MDBGPROT_EVENT_KIND_ASSEMBLY_LOAD: return "ASSEMBLY_LOAD"; - case MDBGPROT_EVENT_KIND_ASSEMBLY_UNLOAD: return "ASSEMBLY_UNLOAD"; - case MDBGPROT_EVENT_KIND_BREAKPOINT: return "BREAKPOINT"; - case MDBGPROT_EVENT_KIND_STEP: return "STEP"; - case MDBGPROT_EVENT_KIND_TYPE_LOAD: return "TYPE_LOAD"; - case MDBGPROT_EVENT_KIND_EXCEPTION: return "EXCEPTION"; - case MDBGPROT_EVENT_KIND_KEEPALIVE: return "KEEPALIVE"; - case MDBGPROT_EVENT_KIND_USER_BREAK: return "USER_BREAK"; - case MDBGPROT_EVENT_KIND_USER_LOG: return "USER_LOG"; - case MDBGPROT_EVENT_KIND_CRASH: return "CRASH"; - default: - g_assert ( 1 ); - return ""; - } -} diff --git a/src/mono/mono/mini/debugger-protocol.h b/src/mono/mono/mini/debugger-protocol.h deleted file mode 100644 index 24e8a2e42c27e6..00000000000000 --- a/src/mono/mono/mini/debugger-protocol.h +++ /dev/null @@ -1,384 +0,0 @@ -#ifndef __MONO_DEBUGGER_PROTOCOL_H__ -#define __MONO_DEBUGGER_PROTOCOL_H__ - -#include - -#define HEADER_LENGTH 11 -#define REPLY_PACKET 0x80 - -/* - * Wire Protocol definitions - */ - -#define MAJOR_VERSION 2 -#define MINOR_VERSION 60 - -typedef enum { - MDBGPROT_CMD_COMPOSITE = 100 -} MdbgProtCmdComposite; - -typedef enum { - MDBGPROT_CMD_VM_VERSION = 1, - MDBGPROT_CMD_VM_ALL_THREADS = 2, - MDBGPROT_CMD_VM_SUSPEND = 3, - MDBGPROT_CMD_VM_RESUME = 4, - MDBGPROT_CMD_VM_EXIT = 5, - MDBGPROT_CMD_VM_DISPOSE = 6, - MDBGPROT_CMD_VM_INVOKE_METHOD = 7, - MDBGPROT_CMD_VM_SET_PROTOCOL_VERSION = 8, - MDBGPROT_CMD_VM_ABORT_INVOKE = 9, - MDBGPROT_CMD_VM_SET_KEEPALIVE = 10, - MDBGPROT_CMD_VM_GET_TYPES_FOR_SOURCE_FILE = 11, - MDBGPROT_CMD_VM_GET_TYPES = 12, - MDBGPROT_CMD_VM_INVOKE_METHODS = 13, - MDBGPROT_CMD_VM_START_BUFFERING = 14, - MDBGPROT_CMD_VM_STOP_BUFFERING = 15, - MDBGPROT_CMD_VM_READ_MEMORY = 16, - MDBGPROT_CMD_VM_WRITE_MEMORY = 17, - MDBGPROT_CMD_GET_ASSEMBLY_BY_NAME = 18 -} MdbgProtCmdVM; - -typedef enum { - MDBGPROT_CMD_SET_VM = 1, - MDBGPROT_CMD_SET_OBJECT_REF = 9, - MDBGPROT_CMD_SET_STRING_REF = 10, - MDBGPROT_CMD_SET_THREAD = 11, - MDBGPROT_CMD_SET_ARRAY_REF = 13, - MDBGPROT_CMD_SET_EVENT_REQUEST = 15, - MDBGPROT_CMD_SET_STACK_FRAME = 16, - MDBGPROT_CMD_SET_APPDOMAIN = 20, - MDBGPROT_CMD_SET_ASSEMBLY = 21, - MDBGPROT_CMD_SET_METHOD = 22, - MDBGPROT_CMD_SET_TYPE = 23, - MDBGPROT_CMD_SET_MODULE = 24, - MDBGPROT_CMD_SET_FIELD = 25, - MDBGPROT_CMD_SET_EVENT = 64, - MDBGPROT_CMD_SET_POINTER = 65 -} MdbgProtCommandSet; - -typedef enum { - MDBGPROT_ERR_NONE = 0, - MDBGPROT_ERR_INVALID_OBJECT = 20, - MDBGPROT_ERR_INVALID_FIELDID = 25, - MDBGPROT_ERR_INVALID_FRAMEID = 30, - MDBGPROT_ERR_NOT_IMPLEMENTED = 100, - MDBGPROT_ERR_NOT_SUSPENDED = 101, - MDBGPROT_ERR_INVALID_ARGUMENT = 102, - MDBGPROT_ERR_UNLOADED = 103, - MDBGPROT_ERR_NO_INVOCATION = 104, - MDBGPROT_ERR_ABSENT_INFORMATION = 105, - MDBGPROT_ERR_NO_SEQ_POINT_AT_IL_OFFSET = 106, - MDBGPROT_ERR_INVOKE_ABORTED = 107, - MDBGPROT_ERR_LOADER_ERROR = 200, /*XXX extend the protocol to pass this information down the pipe */ -} MdbgProtErrorCode; - -typedef enum { - MDBGPROT_TOKEN_TYPE_STRING = 0, - MDBGPROT_TOKEN_TYPE_TYPE = 1, - MDBGPROT_TOKEN_TYPE_FIELD = 2, - MDBGPROT_TOKEN_TYPE_METHOD = 3, - MDBGPROT_TOKEN_TYPE_UNKNOWN = 4 -} MdbgProtDebuggerTokenType; - -typedef enum { - MDBGPROT_VALUE_TYPE_ID_NULL = 0xf0, - MDBGPROT_VALUE_TYPE_ID_TYPE = 0xf1, - MDBGPROT_VALUE_TYPE_ID_PARENT_VTYPE = 0xf2, - MDBGPROT_VALUE_TYPE_ID_FIXED_ARRAY = 0xf3 -} MdbgProtValueTypeId; - -typedef enum { - MDBGPROT_FRAME_FLAG_DEBUGGER_INVOKE = 1, - MDBGPROT_FRAME_FLAG_NATIVE_TRANSITION = 2 -} MdbgProtStackFrameFlags; - -typedef enum { - MDBGPROT_INVOKE_FLAG_DISABLE_BREAKPOINTS = 1, - MDBGPROT_INVOKE_FLAG_SINGLE_THREADED = 2, - MDBGPROT_INVOKE_FLAG_RETURN_OUT_THIS = 4, - MDBGPROT_INVOKE_FLAG_RETURN_OUT_ARGS = 8, - MDBGPROT_INVOKE_FLAG_VIRTUAL = 16 -} MdbgProtInvokeFlags; - -typedef enum { - BINDING_FLAGS_IGNORE_CASE = 0x70000000, -} MdbgProtBindingFlagsExtensions; - -typedef enum { - MDBGPROT_CMD_THREAD_GET_FRAME_INFO = 1, - MDBGPROT_CMD_THREAD_GET_NAME = 2, - MDBGPROT_CMD_THREAD_GET_STATE = 3, - MDBGPROT_CMD_THREAD_GET_INFO = 4, - MDBGPROT_CMD_THREAD_GET_ID = 5, - MDBGPROT_CMD_THREAD_GET_TID = 6, - MDBGPROT_CMD_THREAD_SET_IP = 7, - MDBGPROT_CMD_THREAD_ELAPSED_TIME = 8, - MDBGPROT_CMD_THREAD_GET_APPDOMAIN = 9, - MDBGPROT_CMD_THREAD_GET_CONTEXT = 10, - MDBGPROT_CMD_THREAD_SET_CONTEXT = 11 -} MdbgProtCmdThread; - -typedef enum { - MDBGPROT_CMD_APPDOMAIN_GET_ROOT_DOMAIN = 1, - MDBGPROT_CMD_APPDOMAIN_GET_FRIENDLY_NAME = 2, - MDBGPROT_CMD_APPDOMAIN_GET_ASSEMBLIES = 3, - MDBGPROT_CMD_APPDOMAIN_GET_ENTRY_ASSEMBLY = 4, - MDBGPROT_CMD_APPDOMAIN_CREATE_STRING = 5, - MDBGPROT_CMD_APPDOMAIN_GET_CORLIB = 6, - MDBGPROT_CMD_APPDOMAIN_CREATE_BOXED_VALUE = 7, - MDBGPROT_CMD_APPDOMAIN_CREATE_BYTE_ARRAY = 8, -} MdbgProtCmdAppDomain; - -typedef enum { - MDBGPROT_CMD_ASSEMBLY_GET_LOCATION = 1, - MDBGPROT_CMD_ASSEMBLY_GET_ENTRY_POINT = 2, - MDBGPROT_CMD_ASSEMBLY_GET_MANIFEST_MODULE = 3, - MDBGPROT_CMD_ASSEMBLY_GET_OBJECT = 4, - MDBGPROT_CMD_ASSEMBLY_GET_TYPE = 5, - MDBGPROT_CMD_ASSEMBLY_GET_NAME = 6, - MDBGPROT_CMD_ASSEMBLY_GET_DOMAIN = 7, - MDBGPROT_CMD_ASSEMBLY_GET_METADATA_BLOB = 8, - MDBGPROT_CMD_ASSEMBLY_GET_IS_DYNAMIC = 9, - MDBGPROT_CMD_ASSEMBLY_GET_PDB_BLOB = 10, - MDBGPROT_CMD_ASSEMBLY_GET_TYPE_FROM_TOKEN = 11, - MDBGPROT_CMD_ASSEMBLY_GET_METHOD_FROM_TOKEN = 12, - MDBGPROT_CMD_ASSEMBLY_HAS_DEBUG_INFO = 13, - MDBGPROT_CMD_ASSEMBLY_GET_CATTRS = 14, - MDBGPROT_CMD_ASSEMBLY_GET_CUSTOM_ATTRIBUTES = 15, - MDBGPROT_CMD_ASSEMBLY_GET_PEIMAGE_ADDRESS = 16, -} MdbgProtCmdAssembly; - -typedef enum { - MDBGPROT_CMD_MODULE_GET_INFO = 1, - MDBGPROT_CMD_MODULE_APPLY_CHANGES = 2, -} MdbgProtCmdModule; - -typedef enum { - MDBGPROT_CMD_FIELD_GET_INFO = 1, -} MdbgProtCmdField; - -typedef enum { - MDBGPROT_CMD_PROPERTY_GET_INFO = 1, -} MdbgProtCmdProperty; - -typedef enum { - MDBGPROT_CMD_METHOD_GET_NAME = 1, - MDBGPROT_CMD_METHOD_GET_DECLARING_TYPE = 2, - MDBGPROT_CMD_METHOD_GET_DEBUG_INFO = 3, - MDBGPROT_CMD_METHOD_GET_PARAM_INFO = 4, - MDBGPROT_CMD_METHOD_GET_LOCALS_INFO = 5, - MDBGPROT_CMD_METHOD_GET_INFO = 6, - MDBGPROT_CMD_METHOD_GET_BODY = 7, - MDBGPROT_CMD_METHOD_RESOLVE_TOKEN = 8, - MDBGPROT_CMD_METHOD_GET_CATTRS = 9, - MDBGPROT_CMD_METHOD_MAKE_GENERIC_METHOD = 10, - MDBGPROT_CMD_METHOD_TOKEN = 11, - MDBGPROT_CMD_METHOD_ASSEMBLY = 12, - MDBGPROT_CMD_METHOD_GET_CLASS_TOKEN = 13, - MDBGPROT_CMD_METHOD_HAS_ASYNC_DEBUG_INFO = 14, - MDBGPROT_CMD_METHOD_GET_NAME_FULL = 15 -} MdbgProtCmdMethod; - -typedef enum { - MDBGPROT_CMD_TYPE_GET_INFO = 1, - MDBGPROT_CMD_TYPE_GET_METHODS = 2, - MDBGPROT_CMD_TYPE_GET_FIELDS = 3, - MDBGPROT_CMD_TYPE_GET_VALUES = 4, - MDBGPROT_CMD_TYPE_GET_OBJECT = 5, - MDBGPROT_CMD_TYPE_GET_SOURCE_FILES = 6, - MDBGPROT_CMD_TYPE_SET_VALUES = 7, - MDBGPROT_CMD_TYPE_IS_ASSIGNABLE_FROM = 8, - MDBGPROT_CMD_TYPE_GET_PROPERTIES = 9, - MDBGPROT_CMD_TYPE_GET_CATTRS = 10, - MDBGPROT_CMD_TYPE_GET_FIELD_CATTRS = 11, - MDBGPROT_CMD_TYPE_GET_PROPERTY_CATTRS = 12, - MDBGPROT_CMD_TYPE_GET_SOURCE_FILES_2 = 13, - MDBGPROT_CMD_TYPE_GET_VALUES_2 = 14, - MDBGPROT_CMD_TYPE_GET_METHODS_BY_NAME_FLAGS = 15, - MDBGPROT_CMD_TYPE_GET_INTERFACES = 16, - MDBGPROT_CMD_TYPE_GET_INTERFACE_MAP = 17, - MDBGPROT_CMD_TYPE_IS_INITIALIZED = 18, - MDBGPROT_CMD_TYPE_CREATE_INSTANCE = 19, - MDBGPROT_CMD_TYPE_GET_VALUE_SIZE = 20, - MDBGPROT_CMD_TYPE_GET_VALUES_ICORDBG = 21, - MDBGPROT_CMD_TYPE_GET_PARENTS = 22 -} MdbgProtCmdType; - -typedef enum { - MDBGPROT_CMD_STACK_FRAME_GET_VALUES = 1, - MDBGPROT_CMD_STACK_FRAME_GET_THIS = 2, - MDBGPROT_CMD_STACK_FRAME_SET_VALUES = 3, - MDBGPROT_CMD_STACK_FRAME_GET_DOMAIN = 4, - MDBGPROT_CMD_STACK_FRAME_SET_THIS = 5, - MDBGPROT_CMD_STACK_FRAME_GET_ARGUMENT = 6, - MDBGPROT_CMD_STACK_FRAME_GET_ARGUMENTS = 7 -} MdbgProtCmdStackFrame; - -typedef enum { - MDBGPROT_CMD_ARRAY_REF_GET_LENGTH = 1, - MDBGPROT_CMD_ARRAY_REF_GET_VALUES = 2, - MDBGPROT_CMD_ARRAY_REF_SET_VALUES = 3, - MDBGPROT_CMD_ARRAY_REF_GET_TYPE = 4 -} MdbgProtCmdArray; - -typedef enum { - MDBGPROT_CMD_STRING_REF_GET_VALUE = 1, - MDBGPROT_CMD_STRING_REF_GET_LENGTH = 2, - MDBGPROT_CMD_STRING_REF_GET_CHARS = 3 -} MdbgProtCmdString; - -typedef enum { - MDBGPROT_CMD_POINTER_GET_VALUE = 1 -} MdbgProtCmdPointer; - -typedef enum { - MDBGPROT_CMD_OBJECT_REF_GET_TYPE = 1, - MDBGPROT_CMD_OBJECT_REF_GET_VALUES = 2, - MDBGPROT_CMD_OBJECT_REF_IS_COLLECTED = 3, - MDBGPROT_CMD_OBJECT_REF_GET_ADDRESS = 4, - MDBGPROT_CMD_OBJECT_REF_GET_DOMAIN = 5, - MDBGPROT_CMD_OBJECT_REF_SET_VALUES = 6, - MDBGPROT_CMD_OBJECT_REF_GET_INFO = 7, - MDBGPROT_CMD_OBJECT_REF_GET_VALUES_ICORDBG = 8, - MDBGPROT_CMD_OBJECT_REF_DELEGATE_GET_METHOD = 9, - MDBGPROT_CMD_OBJECT_IS_DELEGATE = 10 -} MdbgProtCmdObject; - -typedef enum { - MDBGPROT_SUSPEND_POLICY_NONE = 0, - MDBGPROT_SUSPEND_POLICY_EVENT_THREAD = 1, - MDBGPROT_SUSPEND_POLICY_ALL = 2 -} MdbgProtSuspendPolicy; - -typedef enum { - MDBGPROT_CMD_EVENT_REQUEST_SET = 1, - MDBGPROT_CMD_EVENT_REQUEST_CLEAR = 2, - MDBGPROT_CMD_EVENT_REQUEST_CLEAR_ALL_BREAKPOINTS = 3 -} MdbgProtCmdEvent; - -typedef struct { - uint8_t *buf, *p, *end; -} MdbgProtBuffer; - -typedef struct { - int len; - int id; - int flags; - int command_set; - int command; - int error; - int error_2; -} MdbgProtHeader; - -typedef struct ReplyPacket { - int id; - int error; - MdbgProtBuffer *data; -} MdbgProtReplyPacket; - -typedef enum { - MDBGPROT_EVENT_KIND_VM_START = 0, - MDBGPROT_EVENT_KIND_VM_DEATH = 1, - MDBGPROT_EVENT_KIND_THREAD_START = 2, - MDBGPROT_EVENT_KIND_THREAD_DEATH = 3, - MDBGPROT_EVENT_KIND_APPDOMAIN_CREATE = 4, - MDBGPROT_EVENT_KIND_APPDOMAIN_UNLOAD = 5, - MDBGPROT_EVENT_KIND_METHOD_ENTRY = 6, - MDBGPROT_EVENT_KIND_METHOD_EXIT = 7, - MDBGPROT_EVENT_KIND_ASSEMBLY_LOAD = 8, - MDBGPROT_EVENT_KIND_ASSEMBLY_UNLOAD = 9, - MDBGPROT_EVENT_KIND_BREAKPOINT = 10, - MDBGPROT_EVENT_KIND_STEP = 11, - MDBGPROT_EVENT_KIND_TYPE_LOAD = 12, - MDBGPROT_EVENT_KIND_EXCEPTION = 13, - MDBGPROT_EVENT_KIND_KEEPALIVE = 14, - MDBGPROT_EVENT_KIND_USER_BREAK = 15, - MDBGPROT_EVENT_KIND_USER_LOG = 16, - MDBGPROT_EVENT_KIND_CRASH = 17 -} MdbgProtEventKind; - -typedef enum { - MDBGPROT_MOD_KIND_COUNT = 1, - MDBGPROT_MOD_KIND_THREAD_ONLY = 3, - MDBGPROT_MOD_KIND_LOCATION_ONLY = 7, - MDBGPROT_MOD_KIND_EXCEPTION_ONLY = 8, - MDBGPROT_MOD_KIND_STEP = 10, - MDBGPROT_MOD_KIND_ASSEMBLY_ONLY = 11, - MDBGPROT_MOD_KIND_SOURCE_FILE_ONLY = 12, - MDBGPROT_MOD_KIND_TYPE_NAME_ONLY = 13, - MDBGPROT_MOD_KIND_NONE = 14 -} MdbgProtModifierKind; - -typedef enum { - MDBGPROT_STEP_DEPTH_INTO = 0, - MDBGPROT_STEP_DEPTH_OVER = 1, - MDBGPROT_STEP_DEPTH_OUT = 2 -} MdbgProtStepDepth; - -typedef enum { - MDBGPROT_STEP_SIZE_MIN = 0, - MDBGPROT_STEP_SIZE_LINE = 1 -} MdbgProtStepSize; - -typedef enum { - MDBGPROT_STEP_FILTER_NONE = 0, - MDBGPROT_STEP_FILTER_STATIC_CTOR = 1, - MDBGPROT_STEP_FILTER_DEBUGGER_HIDDEN = 2, - MDBGPROT_STEP_FILTER_DEBUGGER_STEP_THROUGH = 4, - MDBGPROT_STEP_FILTER_DEBUGGER_NON_USER_CODE = 8 -} MdbgProtStepFilter; - -/* - * IDS - */ - -typedef enum { - ID_ASSEMBLY = 0, - ID_MODULE = 1, - ID_TYPE = 2, - ID_METHOD = 3, - ID_FIELD = 4, - ID_DOMAIN = 5, - ID_PROPERTY = 6, - ID_PARAMETER = 7, - ID_NUM -} IdType; - -int m_dbgprot_buffer_add_command_header (MdbgProtBuffer *recvbuf, int cmd_set, int cmd, MdbgProtBuffer *out); -void m_dbgprot_decode_command_header (MdbgProtBuffer *recvbuf, MdbgProtHeader *header); - -/* - * Functions to decode protocol data - */ - -int m_dbgprot_decode_byte (uint8_t *buf, uint8_t **endbuf, uint8_t *limit); -int m_dbgprot_decode_int (uint8_t *buf, uint8_t **endbuf, uint8_t *limit); -int64_t m_dbgprot_decode_long (uint8_t *buf, uint8_t **endbuf, uint8_t *limit); -int m_dbgprot_decode_id (uint8_t *buf, uint8_t **endbuf, uint8_t *limit); -char* m_dbgprot_decode_string (uint8_t *buf, uint8_t **endbuf, uint8_t *limit); -char* m_dbgprot_decode_string_with_len(uint8_t* buf, uint8_t** endbuf, uint8_t* limit, int *len); -uint8_t* m_dbgprot_decode_byte_array(uint8_t *buf, uint8_t **endbuf, uint8_t *limit, int32_t *len); - -/* - * Functions to encode protocol data - */ - -void m_dbgprot_buffer_init (MdbgProtBuffer *buf, uint32_t size); -uint32_t m_dbgprot_buffer_len (MdbgProtBuffer *buf); -void m_dbgprot_buffer_make_room (MdbgProtBuffer *buf, uint32_t size); -void m_dbgprot_buffer_add_byte (MdbgProtBuffer *buf, uint8_t val); -void m_dbgprot_buffer_add_short (MdbgProtBuffer *buf, uint32_t val); -void m_dbgprot_buffer_add_int (MdbgProtBuffer *buf, uint32_t val); -void m_dbgprot_buffer_add_long (MdbgProtBuffer *buf, uint64_t l); -void m_dbgprot_buffer_add_id (MdbgProtBuffer *buf, uint32_t id); -void m_dbgprot_buffer_add_data (MdbgProtBuffer *buf, uint8_t *data, uint32_t len); -void m_dbgprot_buffer_add_utf16 (MdbgProtBuffer *buf, uint8_t *data, uint32_t len); -void m_dbgprot_buffer_add_string (MdbgProtBuffer *buf, const char *str); -void m_dbgprot_buffer_add_byte_array (MdbgProtBuffer *buf, uint8_t *bytes, uint32_t arr_len); -void m_dbgprot_buffer_add_buffer (MdbgProtBuffer *buf, MdbgProtBuffer *data); -void m_dbgprot_buffer_free (MdbgProtBuffer *buf); - -const char* m_dbgprot_event_to_string (MdbgProtEventKind event); - -#endif - From 7691f3ee7dc59667aea5fad59c7cea067233843e Mon Sep 17 00:00:00 2001 From: Thays Date: Tue, 29 Jun 2021 17:52:22 -0300 Subject: [PATCH 22/35] Fix android compilation. --- src/mono/mono/metadata/assembly-internals.h | 6 +-- src/mono/mono/metadata/class-init.h | 8 +-- src/mono/mono/metadata/class-internals.h | 54 +++++++++---------- .../mono/metadata/custom-attrs-internals.h | 4 +- src/mono/mono/metadata/debug-internals.h | 8 +-- src/mono/mono/metadata/debug-mono-ppdb.h | 2 +- src/mono/mono/metadata/domain-internals.h | 4 +- src/mono/mono/metadata/gc-internals.h | 8 +-- src/mono/mono/metadata/handle.h | 6 +-- src/mono/mono/metadata/loader-internals.h | 4 +- src/mono/mono/metadata/marshal.h | 2 +- src/mono/mono/metadata/metadata-internals.h | 10 ++-- src/mono/mono/metadata/mono-debug.h | 2 +- src/mono/mono/metadata/mono-hash-internals.h | 5 +- src/mono/mono/metadata/object-internals.h | 40 +++++++------- src/mono/mono/metadata/reflection-internals.h | 18 +++---- src/mono/mono/metadata/runtime.h | 4 +- src/mono/mono/metadata/seq-points-data.h | 7 +-- src/mono/mono/metadata/threads-types.h | 10 ++-- src/mono/mono/metadata/verify-internals.h | 2 +- src/mono/mono/mini/mini-runtime.h | 14 ++--- src/mono/mono/mini/mini.h | 36 ++++++------- src/mono/mono/mini/seq-points.h | 8 +-- src/mono/mono/sgen/gc-internal-agnostic.h | 2 +- src/mono/mono/utils/json.h | 26 ++++----- src/mono/mono/utils/memfuncs.h | 3 +- src/mono/mono/utils/mono-context.h | 4 +- src/mono/mono/utils/mono-error-internals.h | 3 +- src/mono/mono/utils/mono-flight-recorder.h | 14 ++--- src/mono/mono/utils/mono-threads-api.h | 2 +- src/mono/mono/utils/mono-threads.h | 4 +- src/mono/mono/utils/mono-time.h | 2 +- src/mono/mono/utils/networking.h | 8 +-- 33 files changed, 168 insertions(+), 162 deletions(-) diff --git a/src/mono/mono/metadata/assembly-internals.h b/src/mono/mono/metadata/assembly-internals.h index 4548b7fd864519..28f3fdc502ffc0 100644 --- a/src/mono/mono/metadata/assembly-internals.h +++ b/src/mono/mono/metadata/assembly-internals.h @@ -31,7 +31,7 @@ typedef enum { G_ENUM_FUNCTIONS (MonoAssemblyNameEqFlags) -void +MONO_COMPONENT_API void mono_assembly_name_free_internal (MonoAssemblyName *aname); gboolean @@ -108,7 +108,7 @@ void mono_assembly_request_prepare_open (MonoAssemblyOpenReque MonoAssemblyContextKind asmctx, MonoAssemblyLoadContext *alc); -void mono_assembly_request_prepare_byname (MonoAssemblyByNameRequest *req, +MONO_COMPONENT_API void mono_assembly_request_prepare_byname (MonoAssemblyByNameRequest *req, MonoAssemblyContextKind asmctx, MonoAssemblyLoadContext *alc); @@ -120,7 +120,7 @@ MonoAssembly* mono_assembly_request_load_from (MonoImage *image, const const MonoAssemblyLoadRequest *req, MonoImageOpenStatus *status); -MonoAssembly* mono_assembly_request_byname (MonoAssemblyName *aname, +MONO_COMPONENT_API MonoAssembly* mono_assembly_request_byname (MonoAssemblyName *aname, const MonoAssemblyByNameRequest *req, MonoImageOpenStatus *status); diff --git a/src/mono/mono/metadata/class-init.h b/src/mono/mono/metadata/class-init.h index 5dbf66b6d1b40a..1ec64459376cde 100644 --- a/src/mono/mono/metadata/class-init.h +++ b/src/mono/mono/metadata/class-init.h @@ -25,10 +25,10 @@ mono_class_create_generic_inst (MonoGenericClass *gclass); MonoClass * mono_class_create_bounded_array (MonoClass *element_class, uint32_t rank, mono_bool bounded); -MonoClass * +MONO_COMPONENT_API MonoClass * mono_class_create_array (MonoClass *element_class, uint32_t rank); -MonoClass * +MONO_COMPONENT_API MonoClass * mono_class_create_generic_parameter (MonoGenericParam *param); MonoClass * @@ -49,7 +49,7 @@ mono_class_setup_basic_field_info (MonoClass *klass); void mono_class_setup_fields (MonoClass *klass); -void +MONO_COMPONENT_API void mono_class_setup_methods (MonoClass *klass); void @@ -64,7 +64,7 @@ mono_class_layout_fields (MonoClass *klass, int base_instance_size, int packing_ void mono_class_setup_interface_offsets (MonoClass *klass); -void +MONO_COMPONENT_API void mono_class_setup_vtable (MonoClass *klass); void diff --git a/src/mono/mono/metadata/class-internals.h b/src/mono/mono/metadata/class-internals.h index 37ce4ce6a14a5e..50fd29d8f9510e 100644 --- a/src/mono/mono/metadata/class-internals.h +++ b/src/mono/mono/metadata/class-internals.h @@ -317,7 +317,7 @@ int mono_class_interface_match (const uint8_t *bitmap, int id); MONO_API int mono_class_interface_offset (MonoClass *klass, MonoClass *itf); -int mono_class_interface_offset_with_variance (MonoClass *klass, MonoClass *itf, gboolean *non_exact_match); +MONO_COMPONENT_API int mono_class_interface_offset_with_variance (MonoClass *klass, MonoClass *itf, gboolean *non_exact_match); typedef gpointer MonoRuntimeGenericContext; @@ -578,7 +578,7 @@ typedef struct { MonoMethod *wrapper_method; } MonoJitICallInfo; -void +MONO_COMPONENT_API void mono_class_setup_supertypes (MonoClass *klass); /* WARNING @@ -773,7 +773,7 @@ mono_class_get_implemented_interfaces (MonoClass *klass, MonoError *error); int mono_class_get_vtable_size (MonoClass *klass); -gboolean +MONO_COMPONENT_API gboolean mono_class_is_open_constructed_type (MonoType *t); void @@ -788,10 +788,10 @@ mono_class_get_finalizer (MonoClass *klass); gboolean mono_class_needs_cctor_run (MonoClass *klass, MonoMethod *caller); -gboolean +MONO_COMPONENT_API gboolean mono_class_field_is_special_static (MonoClassField *field); -guint32 +MONO_COMPONENT_API guint32 mono_class_field_get_special_static_type (MonoClassField *field); gboolean @@ -800,7 +800,7 @@ mono_class_has_special_static_fields (MonoClass *klass); const char* mono_class_get_field_default_value (MonoClassField *field, MonoTypeEnum *def_type); -MonoProperty* +MONO_COMPONENT_API MonoProperty* mono_class_get_property_from_name_internal (MonoClass *klass, const char *name); const char* @@ -894,10 +894,10 @@ mono_method_get_is_covariant_override_impl (MonoMethod *method); void mono_method_set_is_covariant_override_impl (MonoMethod *methoddef); -MonoMethod* +MONO_COMPONENT_API MonoMethod* mono_class_inflate_generic_method_full_checked (MonoMethod *method, MonoClass *klass_hint, MonoGenericContext *context, MonoError *error); -MonoMethod * +MONO_COMPONENT_API MonoMethod * mono_class_inflate_generic_method_checked (MonoMethod *method, MonoGenericContext *context, MonoError *error); MonoMemoryManager * @@ -915,7 +915,7 @@ mono_metadata_get_inflated_signature (MonoMethodSignature *sig, MonoGenericConte MonoType* mono_class_inflate_generic_type_with_mempool (MonoImage *image, MonoType *type, MonoGenericContext *context, MonoError *error); -MonoType* +MONO_COMPONENT_API MonoType* mono_class_inflate_generic_type_checked (MonoType *type, MonoGenericContext *context, MonoError *error); MONO_API void @@ -1054,7 +1054,7 @@ GENERATE_GET_CLASS_WITH_CACHE_DECL (assembly_load_context) GENERATE_GET_CLASS_WITH_CACHE_DECL (native_library) /* If you need a MonoType, use one of the mono_get_*_type () functions in class-inlines.h */ -extern MonoDefaults mono_defaults; +MONO_COMPONENT_API extern MonoDefaults mono_defaults; void mono_loader_init (void); @@ -1062,16 +1062,16 @@ mono_loader_init (void); void mono_loader_cleanup (void); -void +MONO_COMPONENT_API void mono_loader_lock (void); -void +MONO_COMPONENT_API void mono_loader_unlock (void); -void +MONO_COMPONENT_API void mono_loader_lock_track_ownership (gboolean track); -gboolean +MONO_COMPONENT_API gboolean mono_loader_lock_is_owned_by_self (void); void @@ -1086,7 +1086,7 @@ mono_reflection_init (void); void mono_icall_init (void); -gpointer +MONO_COMPONENT_API gpointer mono_method_get_wrapper_data (MonoMethod *method, guint32 id); gboolean @@ -1209,7 +1209,7 @@ mono_method_search_in_array_class (MonoClass *klass, const char *name, MonoMetho void mono_class_setup_interface_id (MonoClass *klass); -MonoGenericContainer* +MONO_COMPONENT_API MonoGenericContainer* mono_class_get_generic_container (MonoClass *klass); gpointer @@ -1220,13 +1220,13 @@ mono_class_alloc0 (MonoClass *klass, int size); #define mono_class_alloc0(klass, size) (g_cast (mono_class_alloc0 ((klass), (size)))) -void +MONO_COMPONENT_API void mono_class_setup_interfaces (MonoClass *klass, MonoError *error); -MonoClassField* +MONO_COMPONENT_API MonoClassField* mono_class_get_field_from_name_full (MonoClass *klass, const char *name, MonoType *type); -MonoVTable* +MONO_COMPONENT_API MonoVTable* mono_class_vtable_checked (MonoClass *klass, MonoError *error); void @@ -1247,7 +1247,7 @@ mono_class_is_variant_compatible (MonoClass *klass, MonoClass *oklass, gboolean gboolean mono_class_is_subclass_of_internal (MonoClass *klass, MonoClass *klassc, gboolean check_interfaces); -mono_bool +MONO_COMPONENT_API mono_bool mono_class_is_assignable_from_internal (MonoClass *klass, MonoClass *oklass); gboolean @@ -1261,7 +1261,7 @@ mono_field_get_type_checked (MonoClassField *field, MonoError *error); MonoType* mono_field_get_type_internal (MonoClassField *field); -MonoClassField* +MONO_COMPONENT_API MonoClassField* mono_class_get_fields_internal (MonoClass* klass, gpointer *iter); MonoClassField* @@ -1276,7 +1276,7 @@ mono_class_has_finalizer (MonoClass *klass); void mono_unload_interface_id (MonoClass *klass); -GPtrArray* +MONO_COMPONENT_API GPtrArray* mono_class_get_methods_by_name (MonoClass *klass, const char *name, guint32 bflags, guint32 mlisttype, gboolean allow_ctors, MonoError *error); char* @@ -1300,10 +1300,10 @@ mono_class_from_name_case_checked (MonoImage *image, const char* name_space, con MONO_PROFILER_API MonoClass * mono_class_from_mono_type_internal (MonoType *type); -MonoClassField* +MONO_COMPONENT_API MonoClassField* mono_field_from_token_checked (MonoImage *image, uint32_t token, MonoClass **retklass, MonoGenericContext *context, MonoError *error); -gpointer +MONO_COMPONENT_API gpointer mono_ldtoken_checked (MonoImage *image, guint32 token, MonoClass **handle_class, MonoGenericContext *context, MonoError *error); MonoImage * @@ -1312,10 +1312,10 @@ mono_get_image_for_generic_param (MonoGenericParam *param); char * mono_make_generic_name_string (MonoImage *image, int num); -MonoClass * +MONO_COMPONENT_API MonoClass * mono_class_load_from_name (MonoImage *image, const char* name_space, const char *name); -MonoClass* +MONO_COMPONENT_API MonoClass* mono_class_try_load_from_name (MonoImage *image, const char* name_space, const char *name); void @@ -1325,7 +1325,7 @@ gboolean mono_class_has_failure (const MonoClass *klass); /* Kind specific accessors */ -MonoGenericClass* +MONO_COMPONENT_API MonoGenericClass* mono_class_get_generic_class (MonoClass *klass); MonoGenericClass* diff --git a/src/mono/mono/metadata/custom-attrs-internals.h b/src/mono/mono/metadata/custom-attrs-internals.h index 407268a22fad50..16a232a80db5f4 100644 --- a/src/mono/mono/metadata/custom-attrs-internals.h +++ b/src/mono/mono/metadata/custom-attrs-internals.h @@ -29,10 +29,10 @@ mono_assembly_is_weak_field (MonoImage *image, guint32 field_idx); void mono_assembly_init_weak_fields (MonoImage *image); -void +MONO_COMPONENT_API void mono_reflection_create_custom_attr_data_args (MonoImage *image, MonoMethod *method, const guchar *data, guint32 len, MonoArrayHandleOut typed_args_out, MonoArrayHandleOut named_args_out, CattrNamedArg **named_arg_info, MonoError *error); -void +MONO_COMPONENT_API void mono_reflection_create_custom_attr_data_args_noalloc (MonoImage *image, MonoMethod *method, const guchar *data, guint32 len, gpointer **typed_args_out, gpointer **named_args_out, int *num_named_args, CattrNamedArg **named_arg_info, MonoError *error); diff --git a/src/mono/mono/metadata/debug-internals.h b/src/mono/mono/metadata/debug-internals.h index 4fb12e39eca24c..e08b767b4c3748 100644 --- a/src/mono/mono/metadata/debug-internals.h +++ b/src/mono/mono/metadata/debug-internals.h @@ -92,7 +92,7 @@ typedef struct { void mono_debugger_lock (void); void mono_debugger_unlock (void); -void +MONO_COMPONENT_API void mono_debug_get_seq_points (MonoDebugMethodInfo *minfo, char **source_file, GPtrArray **source_file_list, int **source_files, MonoSymSeqPoint **seq_points, int *n_seq_points); @@ -100,16 +100,16 @@ mono_debug_get_seq_points (MonoDebugMethodInfo *minfo, char **source_file, MONO_API void mono_debug_free_locals (MonoDebugLocalsInfo *info); -void +MONO_COMPONENT_API void mono_debug_free_method_async_debug_info (MonoDebugMethodAsyncInfo *info); -gboolean +MONO_COMPONENT_API gboolean mono_debug_image_has_debug_info (MonoImage *image); MonoDebugSourceLocation * mono_debug_lookup_source_location_by_il (MonoMethod *method, guint32 il_offset, MonoDomain *domain); -char* +MONO_COMPONENT_API char* mono_debug_image_get_sourcelink (MonoImage *image); #endif /* __DEBUG_INTERNALS_H__ */ diff --git a/src/mono/mono/metadata/debug-mono-ppdb.h b/src/mono/mono/metadata/debug-mono-ppdb.h index f7148be9f06a9c..c27a97069c97e0 100644 --- a/src/mono/mono/metadata/debug-mono-ppdb.h +++ b/src/mono/mono/metadata/debug-mono-ppdb.h @@ -38,7 +38,7 @@ mono_ppdb_lookup_locals (MonoDebugMethodInfo *minfo); MonoDebugMethodAsyncInfo* mono_ppdb_lookup_method_async_debug_info (MonoDebugMethodInfo *minfo); -MonoImage * +MONO_COMPONENT_API MonoImage * mono_ppdb_get_image (MonoPPDBFile *ppdb); char * diff --git a/src/mono/mono/metadata/domain-internals.h b/src/mono/mono/metadata/domain-internals.h index 176b70d772faf8..398898c6e609a0 100644 --- a/src/mono/mono/metadata/domain-internals.h +++ b/src/mono/mono/metadata/domain-internals.h @@ -80,7 +80,7 @@ mono_install_runtime_load (MonoLoadFunc func); MonoDomain* mono_runtime_load (const char *filename, const char *runtime_version); -void +MONO_COMPONENT_API void mono_runtime_quit_internal (void); void @@ -136,7 +136,7 @@ mono_runtime_register_runtimeconfig_json_properties (MonovmRuntimeConfigArgument void mono_runtime_install_appctx_properties (void); -void +MONO_COMPONENT_API void mono_domain_set_fast (MonoDomain *domain); G_END_DECLS diff --git a/src/mono/mono/metadata/gc-internals.h b/src/mono/mono/metadata/gc-internals.h index d1bd5590b06bb1..60e2d79d0ff3c3 100644 --- a/src/mono/mono/metadata/gc-internals.h +++ b/src/mono/mono/metadata/gc-internals.h @@ -68,7 +68,7 @@ void mono_object_register_finalizer_handle (MonoObjectHandle obj); extern void mono_gc_init (void); -extern void mono_gc_base_init (void); +MONO_COMPONENT_API extern void mono_gc_base_init (void); extern void mono_gc_base_cleanup (void); extern void mono_gc_init_icalls (void); @@ -78,7 +78,7 @@ extern void mono_gc_init_icalls (void); */ extern gboolean mono_gc_is_gc_thread (void); -extern gboolean mono_gc_is_finalizer_internal_thread (MonoInternalThread *thread); +MONO_COMPONENT_API extern gboolean mono_gc_is_finalizer_internal_thread (MonoInternalThread *thread); extern void mono_gc_set_stack_end (void *stack_end); @@ -174,7 +174,7 @@ typedef void (*MonoFinalizationProc)(gpointer, gpointer); // same as SGenFinaliz void mono_gc_register_for_finalization (MonoObject *obj, MonoFinalizationProc user_data); void mono_gc_add_memory_pressure (gint64 value); MONO_API int mono_gc_register_root (char *start, size_t size, MonoGCDescriptor descr, MonoGCRootSource source, void *key, const char *msg); -void mono_gc_deregister_root (char* addr); +MONO_COMPONENT_API void mono_gc_deregister_root (char* addr); void mono_gc_finalize_domain (MonoDomain *domain); void mono_gc_run_finalize (void *obj, void *data); void mono_gc_clear_domain (MonoDomain * domain); @@ -310,7 +310,7 @@ void mono_gc_set_desktop_mode (void); /* * Return whenever this GC can move objects */ -gboolean mono_gc_is_moving (void); +MONO_COMPONENT_API gboolean mono_gc_is_moving (void); typedef void* (*MonoGCLockedCallbackFunc) (void *data); diff --git a/src/mono/mono/metadata/handle.h b/src/mono/mono/metadata/handle.h index 62bf12881940cc..657427420c8ef6 100644 --- a/src/mono/mono/metadata/handle.h +++ b/src/mono/mono/metadata/handle.h @@ -124,9 +124,9 @@ typedef void (*GcScanFunc) (gpointer*, gpointer); #endif #ifndef MONO_HANDLE_TRACK_OWNER -MonoRawHandle mono_handle_new (MonoObject *object, MonoThreadInfo *info); +MONO_COMPONENT_API MonoRawHandle mono_handle_new (MonoObject *object, MonoThreadInfo *info); #else -MonoRawHandle mono_handle_new (MonoObject *object, MonoThreadInfo *info, const char* owner); +MONO_COMPONENT_API MonoRawHandle mono_handle_new (MonoObject *object, MonoThreadInfo *info, const char* owner); #endif void mono_handle_stack_scan (HandleStack *stack, GcScanFunc func, gpointer gc_data, gboolean precise, gboolean check); @@ -171,7 +171,7 @@ mono_stack_mark_pop (MonoThreadInfo *info, HandleStackMark *stackmark) } // There are deliberately locals and a constant NULL global with this same name. -extern MonoThreadInfo * const mono_thread_info_current_var; +MONO_COMPONENT_API extern MonoThreadInfo * const mono_thread_info_current_var; /* Icall macros diff --git a/src/mono/mono/metadata/loader-internals.h b/src/mono/mono/metadata/loader-internals.h index a317db69785468..0e1934455d1dc5 100644 --- a/src/mono/mono/metadata/loader-internals.h +++ b/src/mono/mono/metadata/loader-internals.h @@ -296,10 +296,10 @@ mono_mem_manager_free (MonoMemoryManager *memory_manager, gboolean debug_unload) void mono_mem_manager_free_objects (MonoMemoryManager *memory_manager); -void +MONO_COMPONENT_API void mono_mem_manager_lock (MonoMemoryManager *memory_manager); -void +MONO_COMPONENT_API void mono_mem_manager_unlock (MonoMemoryManager *memory_manager); MONO_COMPONENT_API diff --git a/src/mono/mono/metadata/marshal.h b/src/mono/mono/metadata/marshal.h index 6ce138c1170264..08300a001efd59 100644 --- a/src/mono/mono/metadata/marshal.h +++ b/src/mono/mono/metadata/marshal.h @@ -403,7 +403,7 @@ mono_type_to_stind (MonoType *type); /* functions to create various architecture independent helper functions */ -MonoMethod * +MONO_COMPONENT_API MonoMethod * mono_marshal_method_from_wrapper (MonoMethod *wrapper); WrapperInfo* diff --git a/src/mono/mono/metadata/metadata-internals.h b/src/mono/mono/metadata/metadata-internals.h index a3f56cf1f84b1c..545693ef12a584 100644 --- a/src/mono/mono/metadata/metadata-internals.h +++ b/src/mono/mono/metadata/metadata-internals.h @@ -720,7 +720,7 @@ table_info_get_rows (const MonoTableInfo *table) } /* for use with allocated memory blocks (assumes alignment is to 8 bytes) */ -guint mono_aligned_addr_hash (gconstpointer ptr); +MONO_COMPONENT_API guint mono_aligned_addr_hash (gconstpointer ptr); void mono_image_check_for_module_cctor (MonoImage *image); @@ -818,7 +818,7 @@ mono_image_effective_table (const MonoTableInfo **t, int *idx) int mono_image_relative_delta_index (MonoImage *image_dmeta, int token); -void +MONO_COMPONENT_API void mono_image_load_enc_delta (MonoImage *base_image, gconstpointer dmeta, uint32_t dmeta_len, gconstpointer dil, uint32_t dil_len, MonoError *error); gboolean @@ -916,7 +916,7 @@ mono_metadata_parse_generic_inst (MonoImage *image, const char **rptr, MonoError *error); -MonoGenericInst * +MONO_COMPONENT_API MonoGenericInst * mono_metadata_get_generic_inst (int type_argc, MonoType **type_argv); @@ -1052,7 +1052,7 @@ mono_type_create_from_typespec_checked (MonoImage *image, guint32 type_spec, Mon MonoMethodSignature* mono_method_get_signature_checked (MonoMethod *method, MonoImage *image, guint32 token, MonoGenericContext *context, MonoError *error); -MonoMethod * +MONO_COMPONENT_API MonoMethod * mono_get_method_checked (MonoImage *image, guint32 token, MonoClass *klass, MonoGenericContext *context, MonoError *error); guint32 @@ -1085,7 +1085,7 @@ mono_loader_set_strict_assembly_name_check (gboolean enabled); gboolean mono_loader_get_strict_assembly_name_check (void); -gboolean +MONO_COMPONENT_API gboolean mono_type_in_image (MonoType *type, MonoImage *image); gboolean diff --git a/src/mono/mono/metadata/mono-debug.h b/src/mono/mono/metadata/mono-debug.h index 4af24ca3d1a173..2ddbce09947153 100644 --- a/src/mono/mono/metadata/mono-debug.h +++ b/src/mono/mono/metadata/mono-debug.h @@ -191,7 +191,7 @@ mono_debug_add_delegate_trampoline (void* code, int size); MONO_API MonoDebugLocalsInfo* mono_debug_lookup_locals (MonoMethod *method, mono_bool ignore_pdb); -MonoDebugMethodAsyncInfo* +MONO_API MonoDebugMethodAsyncInfo* mono_debug_lookup_method_async_debug_info (MonoMethod *method); MONO_API diff --git a/src/mono/mono/metadata/mono-hash-internals.h b/src/mono/mono/metadata/mono-hash-internals.h index 1ba508b2030fde..84b8894f9e00e7 100644 --- a/src/mono/mono/metadata/mono-hash-internals.h +++ b/src/mono/mono/metadata/mono-hash-internals.h @@ -7,11 +7,12 @@ #include "mono/metadata/mono-hash.h" #include "mono/metadata/mono-gc.h" +#include "mono/utils/mono-compiler.h" -MonoGHashTable * +MONO_COMPONENT_API MonoGHashTable * mono_g_hash_table_new_type_internal (GHashFunc hash_func, GEqualFunc key_equal_func, MonoGHashGCType type, MonoGCRootSource source, void *key, const char *msg); -void +MONO_COMPONENT_API void mono_g_hash_table_insert_internal (MonoGHashTable *h, gpointer k, gpointer v); #endif /* __MONO_G_HASH_INTERNALS_H__ */ diff --git a/src/mono/mono/metadata/object-internals.h b/src/mono/mono/metadata/object-internals.h index 0af9ed940682c5..bba7439ff88395 100644 --- a/src/mono/mono/metadata/object-internals.h +++ b/src/mono/mono/metadata/object-internals.h @@ -84,7 +84,7 @@ } \ } while (0) -MonoClass * +MONO_COMPONENT_API MonoClass * mono_class_create_array (MonoClass *element_class, uint32_t rank); MonoArrayHandle @@ -1486,7 +1486,7 @@ mono_array_calc_byte_len (MonoClass *klass, uintptr_t len, uintptr_t *res); MonoArray* mono_array_new_checked (MonoClass *eclass, uintptr_t n, MonoError *error); -MonoArray* +MONO_COMPONENT_API MonoArray* mono_array_new_full_checked (MonoClass *array_class, uintptr_t *lengths, intptr_t *lower_bounds, MonoError *error); ICALL_EXPORT @@ -1499,7 +1499,7 @@ mono_create_ftnptr (gpointer addr); gpointer mono_get_addr_from_ftnptr (gpointer descr); -void +MONO_COMPONENT_API void mono_nullable_init (guint8 *buf, MonoObject *value, MonoClass *klass); void @@ -1508,13 +1508,13 @@ mono_nullable_init_from_handle (guint8 *buf, MonoObjectHandle value, MonoClass * void mono_nullable_init_unboxed (guint8 *buf, gpointer value, MonoClass *klass); -MonoObject * +MONO_COMPONENT_API MonoObject * mono_value_box_checked (MonoClass *klass, void* val, MonoError *error); MonoObjectHandle mono_value_box_handle (MonoClass *klass, gpointer val, MonoError *error); -MonoObject* +MONO_COMPONENT_API MonoObject* mono_nullable_box (gpointer buf, MonoClass *klass, MonoError *error); MonoObjectHandle @@ -1642,10 +1642,10 @@ mono_object_new_alloc_specific_checked (MonoVTable *vtable, MonoError *error); void mono_field_get_value_internal (MonoObject *obj, MonoClassField *field, void *value); -void +MONO_COMPONENT_API void mono_field_static_get_value_checked (MonoVTable *vt, MonoClassField *field, void *value, MonoStringHandleOut string_handle, MonoError *error); -void +MONO_COMPONENT_API void mono_field_static_get_value_for_thread (MonoInternalThread *thread, MonoVTable *vt, MonoClassField *field, void *value, MonoStringHandleOut string_handle, MonoError *error); guint8* @@ -1664,7 +1664,7 @@ mono_field_get_value_object_checked (MonoClassField *field, MonoObject *obj, Mon MonoObjectHandle mono_static_field_get_value_handle (MonoClassField *field, MonoError *error); -gpointer +MONO_COMPONENT_API gpointer mono_special_static_field_get_offset (MonoClassField *field, MonoError *error); gboolean @@ -1728,7 +1728,7 @@ mono_error_set_pending_exception (MonoError *error) MonoArray * mono_glist_to_array (GList *list, MonoClass *eclass, MonoError *error); -MonoObject * +MONO_COMPONENT_API MonoObject * mono_object_new_checked (MonoClass *klass, MonoError *error); MonoObjectHandle @@ -1772,7 +1772,7 @@ mono_string_new_len_checked (const char *text, guint length, MonoError *error); MonoString * mono_string_new_size_checked (gint32 len, MonoError *error); -MonoString* +MONO_COMPONENT_API MonoString* mono_ldstr_checked (MonoImage *image, uint32_t str_index, MonoError *error); MonoStringHandle @@ -1822,7 +1822,7 @@ mono_runtime_try_invoke (MonoMethod *method, void *obj, void **params, MonoObjec MONO_COMPONENT_API MonoObjectHandle mono_runtime_try_invoke_handle (MonoMethod *method, MonoObjectHandle obj, void **params, MonoError* error); -MonoObject* +MONO_COMPONENT_API MonoObject* mono_runtime_invoke_checked (MonoMethod *method, void *obj, void **params, MonoError *error); MonoObjectHandle @@ -1896,7 +1896,7 @@ mono_object_get_data (MonoObject *o) #define mono_handle_get_data_unsafe(handle) ((gpointer)((guint8*)MONO_HANDLE_RAW (handle) + MONO_ABI_SIZEOF (MonoObject))) -gpointer +MONO_COMPONENT_API gpointer mono_vtype_get_field_addr (gpointer vtype, MonoClassField *field); #define MONO_OBJECT_SETREF_INTERNAL(obj,fieldname,value) do { \ @@ -1929,7 +1929,7 @@ mono_string_empty_internal (MonoDomain *domain); char * mono_string_to_utf8len (MonoStringHandle s, gsize *utf8len, MonoError *error); -char* +MONO_COMPONENT_API char* mono_string_to_utf8_checked_internal (MonoString *string_obj, MonoError *error); mono_bool @@ -1938,7 +1938,7 @@ mono_string_equal_internal (MonoString *s1, MonoString *s2); unsigned mono_string_hash_internal (MonoString *s); -int +MONO_COMPONENT_API int mono_object_hash_internal (MonoObject* obj); ICALL_EXTERN_C @@ -1971,7 +1971,7 @@ MONO_PROFILER_API MonoDomain* mono_vtable_domain_internal (MonoVTable *vtable); MONO_PROFILER_API MonoClass* mono_vtable_class_internal (MonoVTable *vtable); -MonoMethod* +MONO_COMPONENT_API MonoMethod* mono_object_get_virtual_method_internal (MonoObject *obj, MonoMethod *method); MonoMethod* @@ -1995,7 +1995,7 @@ mono_raise_exception_internal (MonoException *ex); void mono_field_set_value_internal (MonoObject *obj, MonoClassField *field, void *value); -void +MONO_COMPONENT_API void mono_field_static_set_value_internal (MonoVTable *vt, MonoClassField *field, void *value); void @@ -2023,14 +2023,14 @@ mono_runtime_get_aotid_arr (void); MonoGCHandle mono_gchandle_new_internal (MonoObject *obj, mono_bool pinned); -MonoGCHandle +MONO_COMPONENT_API MonoGCHandle mono_gchandle_new_weakref_internal (MonoObject *obj, mono_bool track_resurrection); -ICALL_EXTERN_C +MONO_COMPONENT_API ICALL_EXTERN_C MonoObject* mono_gchandle_get_target_internal (MonoGCHandle gchandle); -void mono_gchandle_free_internal (MonoGCHandle gchandle); +MONO_COMPONENT_API void mono_gchandle_free_internal (MonoGCHandle gchandle); /* Reference queue support * @@ -2062,7 +2062,7 @@ mono_gc_wbarrier_set_arrayref_internal (MonoArray *arr, void* slot_ptr, MonoObj void mono_gc_wbarrier_arrayref_copy_internal (void* dest_ptr, const void* src_ptr, int count); -void +MONO_COMPONENT_API void mono_gc_wbarrier_generic_store_internal (void volatile* ptr, MonoObject* value); void diff --git a/src/mono/mono/metadata/reflection-internals.h b/src/mono/mono/metadata/reflection-internals.h index 9ea2c1cdc98165..b1504e4cda9f1a 100644 --- a/src/mono/mono/metadata/reflection-internals.h +++ b/src/mono/mono/metadata/reflection-internals.h @@ -25,7 +25,7 @@ mono_domain_try_type_resolve_name (MonoAssembly *assembly, MonoStringHandle name MonoReflectionTypeBuilderHandle mono_class_get_ref_info (MonoClass *klass); -gboolean +MONO_COMPONENT_API gboolean mono_reflection_parse_type_checked (char *name, MonoTypeNameParse *info, MonoError *error); gboolean @@ -37,7 +37,7 @@ mono_reflection_type_resolve_user_types (MonoReflectionType *type, MonoError *er MonoType * mono_reflection_type_handle_mono_type (MonoReflectionTypeHandle ref_type, MonoError *error); -MonoType* +MONO_COMPONENT_API MonoType* mono_reflection_get_type_checked (MonoAssemblyLoadContext *alc, MonoImage *rootimage, MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase, gboolean search_mscorlib, gboolean *type_resolve, MonoError *error); MonoType* @@ -63,17 +63,17 @@ mono_reflection_get_custom_attrs_blob_checked (MonoReflectionAssembly *assembly, MonoCustomAttrInfo* mono_custom_attrs_from_index_checked (MonoImage *image, uint32_t idx, gboolean ignore_missing, MonoError *error); -MonoCustomAttrInfo* +MONO_COMPONENT_API MonoCustomAttrInfo* mono_custom_attrs_from_method_checked (MonoMethod *method, MonoError *error); -MonoCustomAttrInfo* +MONO_COMPONENT_API MonoCustomAttrInfo* mono_custom_attrs_from_class_checked (MonoClass *klass, MonoError *error); -MonoCustomAttrInfo* +MONO_COMPONENT_API MonoCustomAttrInfo* mono_custom_attrs_from_assembly_checked (MonoAssembly *assembly, gboolean ignore_missing, MonoError *error); -MonoCustomAttrInfo* +MONO_COMPONENT_API MonoCustomAttrInfo* mono_custom_attrs_from_property_checked (MonoClass *klass, MonoProperty *property, MonoError *error); MonoCustomAttrInfo* mono_custom_attrs_from_event_checked (MonoClass *klass, MonoEvent *event, MonoError *error); -MonoCustomAttrInfo* +MONO_COMPONENT_API MonoCustomAttrInfo* mono_custom_attrs_from_field_checked (MonoClass *klass, MonoClassField *field, MonoError *error); MonoCustomAttrInfo* mono_custom_attrs_from_param_checked (MonoMethod *method, uint32_t param, MonoError *error); @@ -85,10 +85,10 @@ mono_identifier_unescape_type_name_chars (char* identifier); MonoImage * mono_find_dynamic_image_owner (void *ptr); -MonoReflectionAssemblyHandle +MONO_COMPONENT_API MonoReflectionAssemblyHandle mono_assembly_get_object_handle (MonoAssembly *assembly, MonoError *error); -MonoReflectionType* +MONO_COMPONENT_API MonoReflectionType* mono_type_get_object_checked (MonoType *type, MonoError *error); MonoReflectionTypeHandle diff --git a/src/mono/mono/metadata/runtime.h b/src/mono/mono/metadata/runtime.h index 99a6b4d364143f..9ddcf7616e59f1 100644 --- a/src/mono/mono/metadata/runtime.h +++ b/src/mono/mono/metadata/runtime.h @@ -16,13 +16,13 @@ #include #include -gboolean mono_runtime_try_shutdown (void); +MONO_COMPONENT_API gboolean mono_runtime_try_shutdown (void); void mono_runtime_init_tls (void); MONO_PROFILER_API char* mono_runtime_get_aotid (void); -MonoAssembly* mono_runtime_get_entry_assembly (void); +MONO_COMPONENT_API MonoAssembly* mono_runtime_get_entry_assembly (void); void mono_runtime_ensure_entry_assembly (MonoAssembly *assembly); diff --git a/src/mono/mono/metadata/seq-points-data.h b/src/mono/mono/metadata/seq-points-data.h index 8d07f442203412..4b9c1d0d479f8b 100644 --- a/src/mono/mono/metadata/seq-points-data.h +++ b/src/mono/mono/metadata/seq-points-data.h @@ -8,6 +8,7 @@ #define __MONO_SEQ_POINTS_DATA_H__ #include +#include "mono/utils/mono-compiler.h" #define MONO_SEQ_POINT_FLAG_NONEMPTY_STACK 1 #define MONO_SEQ_POINT_FLAG_EXIT_IL 2 @@ -45,13 +46,13 @@ typedef struct { void mono_seq_point_info_free (gpointer info); -gboolean +MONO_COMPONENT_API gboolean mono_seq_point_iterator_next (SeqPointIterator* it); -void +MONO_COMPONENT_API void mono_seq_point_iterator_init (SeqPointIterator* it, MonoSeqPointInfo* info); -void +MONO_COMPONENT_API void mono_seq_point_init_next (MonoSeqPointInfo* info, SeqPoint sp, SeqPoint* next); int diff --git a/src/mono/mono/metadata/threads-types.h b/src/mono/mono/metadata/threads-types.h index 394a526c5524d1..b9fe7d3a14fc3c 100644 --- a/src/mono/mono/metadata/threads-types.h +++ b/src/mono/mono/metadata/threads-types.h @@ -80,7 +80,7 @@ typedef enum { MONO_THREAD_CREATE_FLAGS_SMALL_STACK = 0x08, } MonoThreadCreateFlags; -MonoInternalThread* +MONO_COMPONENT_API MonoInternalThread* mono_thread_create_internal (MonoThreadStart func, gpointer arg, MonoThreadCreateFlags flags, MonoError *error); MonoInternalThreadHandle @@ -197,11 +197,11 @@ MONO_PROFILER_API MonoInternalThread *mono_thread_internal_current (void); MonoInternalThreadHandle mono_thread_internal_current_handle (void); -gboolean +MONO_COMPONENT_API gboolean mono_thread_internal_abort (MonoInternalThread *thread); void mono_thread_internal_suspend_for_shutdown (MonoInternalThread *thread); -void mono_thread_internal_reset_abort (MonoInternalThread *thread); +MONO_COMPONENT_API void mono_thread_internal_reset_abort (MonoInternalThread *thread); void mono_thread_internal_unhandled_exception (MonoObject* exc); @@ -299,7 +299,7 @@ uint32_t mono_alloc_special_static_data (uint32_t static_type, uint32_t size, ui ICALL_EXTERN_C void* mono_get_special_static_data (uint32_t offset); -gpointer mono_get_special_static_data_for_thread (MonoInternalThread *thread, guint32 offset); +MONO_COMPONENT_API gpointer mono_get_special_static_data_for_thread (MonoInternalThread *thread, guint32 offset); void mono_thread_resume_interruption (gboolean exec); @@ -344,7 +344,7 @@ mono_thread_internal_current_is_attached (void); void mono_thread_internal_describe (MonoInternalThread *internal, GString *str); -gboolean +MONO_COMPONENT_API gboolean mono_thread_internal_is_current (MonoInternalThread *internal); gboolean diff --git a/src/mono/mono/metadata/verify-internals.h b/src/mono/mono/metadata/verify-internals.h index 4609a05bc2dab3..ac4beff1450d96 100644 --- a/src/mono/mono/metadata/verify-internals.h +++ b/src/mono/mono/metadata/verify-internals.h @@ -11,7 +11,7 @@ #include gboolean mono_verifier_class_is_valid_generic_instantiation (MonoClass *klass); -gboolean mono_verifier_is_method_valid_generic_instantiation (MonoMethod *method); +MONO_COMPONENT_API gboolean mono_verifier_is_method_valid_generic_instantiation (MonoMethod *method); /*Token validation macros and functions */ #define IS_MEMBER_REF(token) (mono_metadata_token_table (token) == MONO_TABLE_MEMBERREF) diff --git a/src/mono/mono/mini/mini-runtime.h b/src/mono/mono/mini/mini-runtime.h index 0cf831ab62d3d6..6c12a63f0a2916 100644 --- a/src/mono/mono/mini/mini-runtime.h +++ b/src/mono/mono/mini/mini-runtime.h @@ -450,9 +450,9 @@ extern MonoMethod *mono_current_single_method; extern GSList *mono_single_method_list; extern GHashTable *mono_single_method_hash; extern GList* mono_aot_paths; -extern MonoDebugOptions mini_debug_options; +MONO_COMPONENT_API extern MonoDebugOptions mini_debug_options; extern GSList *mono_interp_only_classes; -extern char *sdb_options; +MONO_COMPONENT_API extern char *sdb_options; extern MonoMethodDesc *mono_stats_method_desc; /* @@ -505,7 +505,7 @@ void mono_runtime_print_stats (void); void mono_interp_stub_init (void); void mini_install_interp_callbacks (const MonoEECallbacks *cbs); -extern const +MONO_COMPONENT_API extern const MonoEECallbacks* mono_interp_callbacks_pointer; #define mini_get_interp_callbacks() (mono_interp_callbacks_pointer) @@ -525,10 +525,10 @@ void mono_precompile_assemblies (void); MONO_API int mono_parse_default_optimizations (const char* p); gboolean mono_running_on_valgrind (void); -MonoLMF * mono_get_lmf (void); +MONO_COMPONENT_API MonoLMF * mono_get_lmf (void); void mono_set_lmf (MonoLMF *lmf); -void mono_push_lmf (MonoLMFExt *ext); -void mono_pop_lmf (MonoLMF *lmf); +MONO_COMPONENT_API void mono_push_lmf (MonoLMFExt *ext); +MONO_COMPONENT_API void mono_pop_lmf (MonoLMF *lmf); MONO_API MONO_RT_EXTERNAL_ONLY void mono_jit_set_domain (MonoDomain *domain); @@ -550,7 +550,7 @@ gpointer mono_resolve_patch_target_ext (MonoMemoryManager *mem_manager, Mon void mini_register_jump_site (MonoMethod *method, gpointer ip); void mini_patch_jump_sites (MonoMethod *method, gpointer addr); void mini_patch_llvm_jit_callees (MonoMethod *method, gpointer addr); -gpointer mono_jit_search_all_backends_for_jit_info (MonoMethod *method, MonoJitInfo **ji); +MONO_COMPONENT_API gpointer mono_jit_search_all_backends_for_jit_info (MonoMethod *method, MonoJitInfo **ji); gpointer mono_jit_find_compiled_method_with_jit_info (MonoMethod *method, MonoJitInfo **ji); gpointer mono_jit_find_compiled_method (MonoMethod *method); gpointer mono_jit_compile_method (MonoMethod *method, MonoError *error); diff --git a/src/mono/mono/mini/mini.h b/src/mono/mono/mini/mini.h index 8447b5394160eb..d36f8e37f4fd8b 100644 --- a/src/mono/mono/mini/mini.h +++ b/src/mono/mono/mini/mini.h @@ -2431,7 +2431,7 @@ gboolean mono_arch_opcode_needs_emulation (MonoCompile *cfg, int opcode); gboolean mono_arch_tailcall_supported (MonoCompile *cfg, MonoMethodSignature *caller_sig, MonoMethodSignature *callee_sig, gboolean virtual_); int mono_arch_translate_tls_offset (int offset); gboolean mono_arch_opcode_supported (int opcode); -void mono_arch_setup_resume_sighandler_ctx (MonoContext *ctx, gpointer func); +MONO_COMPONENT_API void mono_arch_setup_resume_sighandler_ctx (MonoContext *ctx, gpointer func); gboolean mono_arch_have_fast_tls (void); #ifdef MONO_ARCH_HAS_REGISTER_ICALL @@ -2450,14 +2450,14 @@ mono_arch_is_soft_float (void) /* Soft Debug support */ #ifdef MONO_ARCH_SOFT_DEBUG_SUPPORTED -void mono_arch_set_breakpoint (MonoJitInfo *ji, guint8 *ip); -void mono_arch_clear_breakpoint (MonoJitInfo *ji, guint8 *ip); -void mono_arch_start_single_stepping (void); -void mono_arch_stop_single_stepping (void); +MONO_COMPONENT_API void mono_arch_set_breakpoint (MonoJitInfo *ji, guint8 *ip); +MONO_COMPONENT_API void mono_arch_clear_breakpoint (MonoJitInfo *ji, guint8 *ip); +MONO_COMPONENT_API void mono_arch_start_single_stepping (void); +MONO_COMPONENT_API void mono_arch_stop_single_stepping (void); gboolean mono_arch_is_single_step_event (void *info, void *sigctx); gboolean mono_arch_is_breakpoint_event (void *info, void *sigctx); -void mono_arch_skip_breakpoint (MonoContext *ctx, MonoJitInfo *ji); -void mono_arch_skip_single_step (MonoContext *ctx); +MONO_COMPONENT_API void mono_arch_skip_breakpoint (MonoContext *ctx, MonoJitInfo *ji); +MONO_COMPONENT_API void mono_arch_skip_single_step (MonoContext *ctx); SeqPointInfo *mono_arch_get_seq_point_info (guint8 *code); #endif @@ -2482,9 +2482,9 @@ void mono_handle_hard_stack_ovf (MonoJitTlsData *jit_tls, MonoJi void mono_arch_undo_ip_adjustment (MonoContext *ctx); void mono_arch_do_ip_adjustment (MonoContext *ctx); gpointer mono_arch_ip_from_context (void *sigctx); -host_mgreg_t mono_arch_context_get_int_reg (MonoContext *ctx, int reg); -host_mgreg_t*mono_arch_context_get_int_reg_address (MonoContext *ctx, int reg); -void mono_arch_context_set_int_reg (MonoContext *ctx, int reg, host_mgreg_t val); +MONO_COMPONENT_API host_mgreg_t mono_arch_context_get_int_reg (MonoContext *ctx, int reg); +MONO_COMPONENT_API host_mgreg_t*mono_arch_context_get_int_reg_address (MonoContext *ctx, int reg); +MONO_COMPONENT_API void mono_arch_context_set_int_reg (MonoContext *ctx, int reg, host_mgreg_t val); void mono_arch_flush_register_windows (void); gboolean mono_arch_is_inst_imm (int opcode, int imm_opcode, gint64 imm); gboolean mono_arch_is_int_overflow (void *sigctx, void *info); @@ -2546,18 +2546,18 @@ gboolean mono_handle_exception (MonoContext *ctx, gpointer obj) void mono_handle_native_crash (const char *signal, MonoContext *mctx, MONO_SIG_HANDLER_INFO_TYPE *siginfo); MONO_API void mono_print_thread_dump (void *sigctx); MONO_API void mono_print_thread_dump_from_ctx (MonoContext *ctx); -void mono_walk_stack_with_ctx (MonoJitStackWalk func, MonoContext *start_ctx, MonoUnwindOptions unwind_options, void *user_data); -void mono_walk_stack_with_state (MonoJitStackWalk func, MonoThreadUnwindState *state, MonoUnwindOptions unwind_options, void *user_data); +MONO_COMPONENT_API void mono_walk_stack_with_ctx (MonoJitStackWalk func, MonoContext *start_ctx, MonoUnwindOptions unwind_options, void *user_data); +MONO_COMPONENT_API void mono_walk_stack_with_state (MonoJitStackWalk func, MonoThreadUnwindState *state, MonoUnwindOptions unwind_options, void *user_data); void mono_walk_stack (MonoJitStackWalk func, MonoUnwindOptions options, void *user_data); gboolean mono_thread_state_init_from_sigctx (MonoThreadUnwindState *ctx, void *sigctx); void mono_thread_state_init (MonoThreadUnwindState *ctx); -gboolean mono_thread_state_init_from_current (MonoThreadUnwindState *ctx); +MONO_COMPONENT_API gboolean mono_thread_state_init_from_current (MonoThreadUnwindState *ctx); MONO_COMPONENT_API gboolean mono_thread_state_init_from_monoctx (MonoThreadUnwindState *ctx, MonoContext *mctx); void mono_setup_altstack (MonoJitTlsData *tls); void mono_free_altstack (MonoJitTlsData *tls); gpointer mono_altstack_restore_prot (host_mgreg_t *regs, guint8 *code, gpointer *tramp_data, guint8* tramp); -MonoJitInfo* mini_jit_info_table_find (gpointer addr); +MONO_COMPONENT_API MonoJitInfo* mini_jit_info_table_find (gpointer addr); MonoJitInfo* mini_jit_info_table_find_ext (gpointer addr, gboolean allow_trampolines); G_EXTERN_C void mono_resume_unwind (MonoContext *ctx); @@ -2565,7 +2565,7 @@ MonoJitInfo * mono_find_jit_info (MonoJitTlsData *jit_tls, MonoJi typedef gboolean (*MonoExceptionFrameWalk) (MonoMethod *method, gpointer ip, size_t native_offset, gboolean managed, gpointer user_data); MONO_API gboolean mono_exception_walk_trace (MonoException *ex, MonoExceptionFrameWalk func, gpointer user_data); -void mono_restore_context (MonoContext *ctx); +MONO_COMPONENT_API void mono_restore_context (MonoContext *ctx); guint8* mono_jinfo_get_unwind_info (MonoJitInfo *ji, guint32 *unwind_info_len); int mono_jinfo_get_epilog_size (MonoJitInfo *ji); G_EXTERN_C void mono_llvm_rethrow_exception (MonoObject *ex); @@ -2702,7 +2702,7 @@ mono_class_rgctx_get_array_size (int n, gboolean mrgctx); MonoGenericContext mono_method_construct_object_context (MonoMethod *method); -MonoMethod* +MONO_COMPONENT_API MonoMethod* mono_method_get_declaring_generic_method (MonoMethod *method); int @@ -2948,10 +2948,10 @@ mini_safepoints_enabled (void) gpointer mono_arch_load_function (MonoJitICallId jit_icall_id); -MonoGenericContext +MONO_COMPONENT_API MonoGenericContext mono_get_generic_context_from_stack_frame (MonoJitInfo *ji, gpointer generic_info); -gpointer +MONO_COMPONENT_API gpointer mono_get_generic_info_from_stack_frame (MonoJitInfo *ji, MonoContext *ctx); MonoMemoryManager* mini_get_default_mem_manager (void); diff --git a/src/mono/mono/mini/seq-points.h b/src/mono/mono/mini/seq-points.h index 17cba827789d50..a35584971c6c43 100644 --- a/src/mono/mono/mini/seq-points.h +++ b/src/mono/mono/mini/seq-points.h @@ -12,16 +12,16 @@ void mono_save_seq_point_info (MonoCompile *cfg, MonoJitInfo *jinfo); -MonoSeqPointInfo* +MONO_COMPONENT_API MonoSeqPointInfo* mono_get_seq_points (MonoMethod *method); -gboolean +MONO_COMPONENT_API gboolean mono_find_next_seq_point_for_native_offset (MonoMethod *method, gint32 native_offset, MonoSeqPointInfo **info, SeqPoint* seq_point); -gboolean +MONO_COMPONENT_API gboolean mono_find_prev_seq_point_for_native_offset (MonoMethod *method, gint32 native_offset, MonoSeqPointInfo **info, SeqPoint* seq_point); -gboolean +MONO_COMPONENT_API gboolean mono_find_seq_point (MonoMethod *method, gint32 il_offset, MonoSeqPointInfo **info, SeqPoint *seq_point); void diff --git a/src/mono/mono/sgen/gc-internal-agnostic.h b/src/mono/mono/sgen/gc-internal-agnostic.h index b14713fb62c677..73d431d54d8c7c 100644 --- a/src/mono/mono/sgen/gc-internal-agnostic.h +++ b/src/mono/mono/sgen/gc-internal-agnostic.h @@ -98,7 +98,7 @@ MonoGCDescriptor mono_gc_make_descr_from_bitmap (gsize *bitmap, int numbits) MonoGCDescriptor mono_gc_make_vector_descr (void); /* Return a root descriptor for a root with all refs */ -MonoGCDescriptor mono_gc_make_root_descr_all_refs (int numbits) +MONO_COMPONENT_API MonoGCDescriptor mono_gc_make_root_descr_all_refs (int numbits) MONO_PERMIT (need (sgen_lock_gc)); /* Return the bitmap encoded by a descriptor */ diff --git a/src/mono/mono/utils/json.h b/src/mono/mono/utils/json.h index 03e6503fc9816d..7b7d8e82b46895 100644 --- a/src/mono/mono/utils/json.h +++ b/src/mono/mono/utils/json.h @@ -12,7 +12,9 @@ #ifndef __MONO_UTILS_JSON_H__ #define __MONO_UTILS_JSON_H__ - #include +#include +#include "mono-compiler.h" + #define JSON_INDENT_VALUE 2 @@ -21,17 +23,17 @@ typedef struct JsonWriter { int indent; } JsonWriter; -void mono_json_writer_init (JsonWriter* writer); -void mono_json_writer_destroy (JsonWriter* writer); -void mono_json_writer_indent(JsonWriter* writer); -void mono_json_writer_indent_push(JsonWriter* writer); -void mono_json_writer_indent_pop(JsonWriter* writer); +MONO_COMPONENT_API void mono_json_writer_init (JsonWriter* writer); +MONO_COMPONENT_API void mono_json_writer_destroy (JsonWriter* writer); +MONO_COMPONENT_API void mono_json_writer_indent(JsonWriter* writer); +MONO_COMPONENT_API void mono_json_writer_indent_push(JsonWriter* writer); +MONO_COMPONENT_API void mono_json_writer_indent_pop(JsonWriter* writer); void mono_json_writer_vprintf(JsonWriter* writer, const gchar *format, va_list args); -void mono_json_writer_printf(JsonWriter* writer, const gchar *format, ...); -void mono_json_writer_array_begin(JsonWriter* writer); -void mono_json_writer_array_end(JsonWriter* writer); -void mono_json_writer_object_begin(JsonWriter* writer); -void mono_json_writer_object_end(JsonWriter* writer); -void mono_json_writer_object_key(JsonWriter* writer, const gchar* format, ...); +MONO_COMPONENT_API void mono_json_writer_printf(JsonWriter* writer, const gchar *format, ...); +MONO_COMPONENT_API void mono_json_writer_array_begin(JsonWriter* writer); +MONO_COMPONENT_API void mono_json_writer_array_end(JsonWriter* writer); +MONO_COMPONENT_API void mono_json_writer_object_begin(JsonWriter* writer); +MONO_COMPONENT_API void mono_json_writer_object_end(JsonWriter* writer); +MONO_COMPONENT_API void mono_json_writer_object_key(JsonWriter* writer, const gchar* format, ...); #endif diff --git a/src/mono/mono/utils/memfuncs.h b/src/mono/mono/utils/memfuncs.h index bc8c578bcb23aa..904b28c96562c4 100644 --- a/src/mono/mono/utils/memfuncs.h +++ b/src/mono/mono/utils/memfuncs.h @@ -12,6 +12,7 @@ #include #include +#include "mono-compiler.h" /* These functions must be used when it's possible that either destination is not @@ -19,7 +20,7 @@ word aligned or size is not a multiple of word size. */ void mono_gc_bzero_atomic (void *dest, size_t size); void mono_gc_bzero_aligned (void *dest, size_t size); -void mono_gc_memmove_atomic (void *dest, const void *src, size_t size); +MONO_COMPONENT_API void mono_gc_memmove_atomic (void *dest, const void *src, size_t size); void mono_gc_memmove_aligned (void *dest, const void *src, size_t size); guint64 mono_determine_physical_ram_size (void); guint64 mono_determine_physical_ram_available_size (void); diff --git a/src/mono/mono/utils/mono-context.h b/src/mono/mono/utils/mono-context.h index b305b9ba705893..bd1a3cd0104c2a 100644 --- a/src/mono/mono/utils/mono-context.h +++ b/src/mono/mono/utils/mono-context.h @@ -1076,7 +1076,7 @@ typedef struct { * The naming is misleading, the SIGCTX argument should be the platform's context * structure (ucontext_c on posix, CONTEXT on windows). */ -void mono_sigctx_to_monoctx (void *sigctx, MonoContext *mctx); +MONO_COMPONENT_API void mono_sigctx_to_monoctx (void *sigctx, MonoContext *mctx); /* * This will not completely initialize SIGCTX since MonoContext contains less @@ -1084,6 +1084,6 @@ void mono_sigctx_to_monoctx (void *sigctx, MonoContext *mctx); * the system, and use this function to override the parts of it which are * also in MonoContext. */ -void mono_monoctx_to_sigctx (MonoContext *mctx, void *sigctx); +MONO_COMPONENT_API void mono_monoctx_to_sigctx (MonoContext *mctx, void *sigctx); #endif /* __MONO_MONO_CONTEXT_H__ */ diff --git a/src/mono/mono/utils/mono-error-internals.h b/src/mono/mono/utils/mono-error-internals.h index 76b3e33ee9c2fb..2256c6b5adb6ff 100644 --- a/src/mono/mono/utils/mono-error-internals.h +++ b/src/mono/mono/utils/mono-error-internals.h @@ -164,6 +164,7 @@ void mono_error_dup_strings (MonoError *error, gboolean dup_strings); /* This function is not very useful as you can't provide any details beyond the message.*/ +MONO_COMPONENT_API void mono_error_set_error (MonoError *error, int error_code, const char *msg_format, ...) MONO_ATTR_FORMAT_PRINTF(3,4); @@ -283,7 +284,7 @@ mono_error_set_platform_not_supported (MonoError *error, const char *message) MonoException* mono_error_prepare_exception (MonoError *error, MonoError *error_out); -MonoException* +MONO_COMPONENT_API MonoException* mono_error_convert_to_exception (MonoError *error); void diff --git a/src/mono/mono/utils/mono-flight-recorder.h b/src/mono/mono/utils/mono-flight-recorder.h index 092c8be2221b59..6a56f02e42436d 100644 --- a/src/mono/mono/utils/mono-flight-recorder.h +++ b/src/mono/mono/utils/mono-flight-recorder.h @@ -31,16 +31,16 @@ typedef struct { MonoFlightRecorderItem *items [MONO_ZERO_LEN_ARRAY]; // The data of the history } MonoFlightRecorder; -MonoCoopMutex * +MONO_COMPONENT_API MonoCoopMutex * mono_flight_recorder_mutex (MonoFlightRecorder *recorder); -MonoFlightRecorder * +MONO_COMPONENT_API MonoFlightRecorder * mono_flight_recorder_init (size_t max_size, size_t payload_size); -void +MONO_COMPONENT_API void mono_flight_recorder_free (MonoFlightRecorder *recorder); -void +MONO_COMPONENT_API void mono_flight_recorder_append (MonoFlightRecorder *recorder, gpointer payload); // Used to traverse the ring buffer in order of oldest to newest message @@ -52,15 +52,15 @@ typedef struct { } MonoFlightRecorderIter; // Mutex has to be held when called -void +MONO_COMPONENT_API void mono_flight_recorder_iter_init (MonoFlightRecorder *recorder, MonoFlightRecorderIter *iter); // Mutex has to be held when called -void +MONO_COMPONENT_API void mono_flight_recorder_iter_destroy (MonoFlightRecorderIter *iter); // Mutex has to be held when called -gboolean +MONO_COMPONENT_API gboolean mono_flight_recorder_iter_next (MonoFlightRecorderIter *iter, MonoFlightRecorderHeader *header, gpointer *payload); #endif diff --git a/src/mono/mono/utils/mono-threads-api.h b/src/mono/mono/utils/mono-threads-api.h index a2c84d29e72438..0dee0c176f0fa7 100644 --- a/src/mono/mono/utils/mono-threads-api.h +++ b/src/mono/mono/utils/mono-threads-api.h @@ -48,7 +48,7 @@ mono_stackdata_get_stackpointer (const MonoStackData *stackdata) MONO_API MONO_RT_EXTERNAL_ONLY gpointer mono_threads_enter_gc_unsafe_region (gpointer* stackdata); -gpointer +MONO_COMPONENT_API gpointer mono_threads_enter_gc_unsafe_region_internal (MonoStackData *stackdata); MONO_API MONO_RT_EXTERNAL_ONLY void diff --git a/src/mono/mono/utils/mono-threads.h b/src/mono/mono/utils/mono-threads.h index adb65611f4c716..4a29ab561e7f6e 100644 --- a/src/mono/mono/utils/mono-threads.h +++ b/src/mono/mono/utils/mono-threads.h @@ -479,7 +479,7 @@ mono_thread_info_lookup (MonoNativeThreadId id); gboolean mono_thread_info_resume (MonoNativeThreadId tid); -void +MONO_COMPONENT_API void mono_thread_info_safe_suspend_and_run (MonoNativeThreadId id, gboolean interrupt_kernel, MonoSuspendThreadCallback callback, gpointer user_data); void @@ -552,7 +552,7 @@ mono_thread_info_is_live (THREAD_INFO_TYPE *info); int mono_thread_info_get_system_max_stack_size (void); -MonoThreadHandle* +MONO_COMPONENT_API MonoThreadHandle* mono_threads_open_thread_handle (MonoThreadHandle *handle); void diff --git a/src/mono/mono/utils/mono-time.h b/src/mono/mono/utils/mono-time.h index 874a4677c693ac..685f2bc76e31ef 100644 --- a/src/mono/mono/utils/mono-time.h +++ b/src/mono/mono/utils/mono-time.h @@ -17,7 +17,7 @@ gint64 mono_msec_boottime (void); /* Returns the number of milliseconds ticks from unspecified time: this should be monotonic */ -gint64 mono_msec_ticks (void); +MONO_COMPONENT_API gint64 mono_msec_ticks (void); /* Returns the number of 100ns ticks from unspecified time: this should be monotonic */ MONO_COMPONENT_API gint64 mono_100ns_ticks (void); diff --git a/src/mono/mono/utils/networking.h b/src/mono/mono/utils/networking.h index 4f6a0f5d733749..67a96391c6aed1 100644 --- a/src/mono/mono/utils/networking.h +++ b/src/mono/mono/utils/networking.h @@ -87,11 +87,11 @@ typedef struct { } MonoAddress; /* This only supports IPV4 / IPV6 and tcp */ -int mono_get_address_info (const char *hostname, int port, int flags, MonoAddressInfo **res); +MONO_COMPONENT_API int mono_get_address_info (const char *hostname, int port, int flags, MonoAddressInfo **res); -void mono_free_address_info (MonoAddressInfo *ai); +MONO_COMPONENT_API void mono_free_address_info (MonoAddressInfo *ai); -void mono_socket_address_init (MonoSocketAddress *sa, socklen_t *len, int family, const void *address, int port); +MONO_COMPONENT_API void mono_socket_address_init (MonoSocketAddress *sa, socklen_t *len, int family, const void *address, int port); void *mono_get_local_interfaces (int family, int *interface_count); @@ -107,7 +107,7 @@ int mono_networking_get_tcp_protocol (void); int mono_networking_get_ip_protocol (void); int mono_networking_get_ipv6_protocol (void); -void mono_networking_init (void); +MONO_COMPONENT_API void mono_networking_init (void); void mono_networking_shutdown (void); From 4131d9a222aa20276ba1ac0c85f68584361421c2 Mon Sep 17 00:00:00 2001 From: Thays Date: Tue, 29 Jun 2021 21:12:29 -0300 Subject: [PATCH 23/35] Fix wasm compilation. --- src/mono/mono/metadata/class-internals.h | 2 +- src/mono/mono/metadata/handle.c | 4 ++-- src/mono/mono/metadata/handle.h | 2 +- src/mono/mono/metadata/loader.c | 2 +- src/mono/mono/mini/mini-runtime.c | 6 +++--- src/mono/mono/mini/mini-runtime.h | 6 +++--- 6 files changed, 11 insertions(+), 11 deletions(-) diff --git a/src/mono/mono/metadata/class-internals.h b/src/mono/mono/metadata/class-internals.h index 50fd29d8f9510e..3759bb4de274f3 100644 --- a/src/mono/mono/metadata/class-internals.h +++ b/src/mono/mono/metadata/class-internals.h @@ -1054,7 +1054,7 @@ GENERATE_GET_CLASS_WITH_CACHE_DECL (assembly_load_context) GENERATE_GET_CLASS_WITH_CACHE_DECL (native_library) /* If you need a MonoType, use one of the mono_get_*_type () functions in class-inlines.h */ -MONO_COMPONENT_API extern MonoDefaults mono_defaults; +extern MonoDefaults mono_defaults; void mono_loader_init (void); diff --git a/src/mono/mono/metadata/handle.c b/src/mono/mono/metadata/handle.c index 50fb6f5612a3d6..c50d47e138340f 100644 --- a/src/mono/mono/metadata/handle.c +++ b/src/mono/mono/metadata/handle.c @@ -149,9 +149,9 @@ mono_handle_chunk_leak_check (HandleStack *handles) { // There are deliberately locals and a constant NULL global with this same name. #ifdef __cplusplus -extern MonoThreadInfo * const mono_thread_info_current_var = NULL; +MONO_COMPONENT_API MonoThreadInfo * const mono_thread_info_current_var = NULL; #else -MonoThreadInfo * const mono_thread_info_current_var = NULL; +MONO_COMPONENT_API MonoThreadInfo * const mono_thread_info_current_var = NULL; #endif /* Actual handles implementation */ diff --git a/src/mono/mono/metadata/handle.h b/src/mono/mono/metadata/handle.h index 657427420c8ef6..3cf1f3afe2f5ba 100644 --- a/src/mono/mono/metadata/handle.h +++ b/src/mono/mono/metadata/handle.h @@ -171,7 +171,7 @@ mono_stack_mark_pop (MonoThreadInfo *info, HandleStackMark *stackmark) } // There are deliberately locals and a constant NULL global with this same name. -MONO_COMPONENT_API extern MonoThreadInfo * const mono_thread_info_current_var; +extern MonoThreadInfo * const mono_thread_info_current_var; /* Icall macros diff --git a/src/mono/mono/metadata/loader.c b/src/mono/mono/metadata/loader.c index f16c8c36f81471..ab0d46399fe052 100644 --- a/src/mono/mono/metadata/loader.c +++ b/src/mono/mono/metadata/loader.c @@ -70,7 +70,7 @@ static gboolean loader_lock_track_ownership; */ static MonoNativeTlsKey loader_lock_nest_id; -MonoDefaults mono_defaults; +MONO_COMPONENT_API MonoDefaults mono_defaults; /* Statistics */ static gint32 inflated_signatures_size; diff --git a/src/mono/mono/mini/mini-runtime.c b/src/mono/mono/mini/mini-runtime.c index fe42680c600aa2..c5b25609cb96ed 100644 --- a/src/mono/mono/mini/mini-runtime.c +++ b/src/mono/mono/mini/mini-runtime.c @@ -143,8 +143,8 @@ static mono_mutex_t jit_mutex; static MonoCodeManager *global_codeman; -MonoDebugOptions mini_debug_options; -char *sdb_options; +MONO_COMPONENT_API MonoDebugOptions mini_debug_options; +MONO_COMPONENT_API char *sdb_options; #ifdef VALGRIND_JIT_REGISTER_MAP int valgrind_register; @@ -4205,7 +4205,7 @@ mini_add_profiler_argument (const char *desc) } -const MonoEECallbacks *mono_interp_callbacks_pointer; +MONO_COMPONENT_API const MonoEECallbacks *mono_interp_callbacks_pointer; void mini_install_interp_callbacks (const MonoEECallbacks *cbs) diff --git a/src/mono/mono/mini/mini-runtime.h b/src/mono/mono/mini/mini-runtime.h index 6c12a63f0a2916..a1f2e301c010c1 100644 --- a/src/mono/mono/mini/mini-runtime.h +++ b/src/mono/mono/mini/mini-runtime.h @@ -450,9 +450,9 @@ extern MonoMethod *mono_current_single_method; extern GSList *mono_single_method_list; extern GHashTable *mono_single_method_hash; extern GList* mono_aot_paths; -MONO_COMPONENT_API extern MonoDebugOptions mini_debug_options; +extern MonoDebugOptions mini_debug_options; extern GSList *mono_interp_only_classes; -MONO_COMPONENT_API extern char *sdb_options; +extern char *sdb_options; extern MonoMethodDesc *mono_stats_method_desc; /* @@ -505,7 +505,7 @@ void mono_runtime_print_stats (void); void mono_interp_stub_init (void); void mini_install_interp_callbacks (const MonoEECallbacks *cbs); -MONO_COMPONENT_API extern const +extern const MonoEECallbacks* mono_interp_callbacks_pointer; #define mini_get_interp_callbacks() (mono_interp_callbacks_pointer) From aff7dba6a0cc237adda26fb68775c52f8917db69 Mon Sep 17 00:00:00 2001 From: Thays Date: Wed, 30 Jun 2021 01:08:43 -0300 Subject: [PATCH 24/35] Try to fix windows compilation. --- src/mono/mono/component/debugger-agent.c | 117 +++++++++++++------ src/mono/mono/component/debugger-engine.c | 18 +-- src/mono/mono/component/debugger-stub.c | 4 +- src/mono/mono/component/debugger.h | 2 +- src/mono/mono/component/mini-wasm-debugger.c | 6 +- src/mono/mono/metadata/class-internals.h | 3 + src/mono/mono/metadata/handle.c | 10 +- src/mono/mono/metadata/handle.h | 2 + src/mono/mono/metadata/loader.c | 8 +- src/mono/mono/mini/debugger-agent-stubs.c | 2 +- src/mono/mono/mini/driver.c | 12 +- src/mono/mono/mini/mini-runtime.c | 14 ++- src/mono/mono/mini/mini-runtime.h | 5 +- 13 files changed, 139 insertions(+), 64 deletions(-) diff --git a/src/mono/mono/component/debugger-agent.c b/src/mono/mono/component/debugger-agent.c index 969aba60811acf..46e99e0c323a54 100644 --- a/src/mono/mono/component/debugger-agent.c +++ b/src/mono/mono/component/debugger-agent.c @@ -127,6 +127,47 @@ #pragma warning(disable:4312) // FIXME pointer cast to different size #endif +#define GENERATE_TRY_GET_CLASS_WITH_CACHE_DBG(shortname,name_space,name) \ +MonoClass* \ +mono_class_try_get_##shortname##_class (void) \ +{ \ + static volatile MonoClass *tmp_class; \ + static volatile gboolean inited; \ + MonoClass *klass = (MonoClass *)tmp_class; \ + mono_memory_barrier (); \ + if (!inited) { \ + klass = mono_class_try_load_from_name (get_mono_defaults ()->corlib, name_space, name); \ + tmp_class = klass; \ + mono_memory_barrier (); \ + inited = TRUE; \ + } \ + return klass; \ +} + +#ifndef MONO_HANDLE_TRACK_OWNER + +#define MONO_HANDLE_NEW_DBG(type, object) \ + (MONO_HANDLE_CAST_FOR (type) (mono_handle_new (MONO_HANDLE_TYPECHECK_FOR (type) (object), get_mono_thread_info_current_var ()))) + +#else + +#define MONO_HANDLE_NEW_DBG(type, object) \ + (MONO_HANDLE_CAST_FOR (type) (mono_handle_new (MONO_HANDLE_TYPECHECK_FOR (type) (object), get_mono_thread_info_current_var (), HANDLE_OWNER))) + +#endif + +static inline MonoType* +mono_get_object_type_dbg (void) +{ + return m_class_get_byval_arg (get_mono_defaults ()->object_class); +} + +static inline MonoType* +mono_get_void_type_dbg (void) +{ + return m_class_get_byval_arg (get_mono_defaults ()->void_class); +} + typedef struct { gboolean enabled; char *transport; @@ -481,8 +522,9 @@ static int handle_multiple_ss_requests (void); static void mono_dbg_debugger_agent_user_break (void); -static GENERATE_TRY_GET_CLASS_WITH_CACHE (fixed_buffer, "System.Runtime.CompilerServices", "FixedBufferAttribute") +static GENERATE_TRY_GET_CLASS_WITH_CACHE_DBG (fixed_buffer, "System.Runtime.CompilerServices", "FixedBufferAttribute") +static char *sdb_options; #ifndef DISABLE_SOCKET_TRANSPORT static void @@ -554,8 +596,9 @@ parse_flag (const char *option, char *flag) } static void -debugger_agent_parse_options (char *options) +debugger_agent_parse_options (void) { + char *options = sdb_options; char **args, **ptr; char *host; int port; @@ -2142,11 +2185,11 @@ get_top_method_ji (gpointer ip, MonoDomain **domain, gpointer *out_ip) g_assert (ext->kind == MONO_LMFEXT_INTERP_EXIT || ext->kind == MONO_LMFEXT_INTERP_EXIT_WITH_CTX); frame = (MonoInterpFrameHandle*)ext->interp_exit_data; - ji = mini_get_interp_callbacks ()->frame_get_jit_info (frame); + ji = mini_get_interp_callbacks_api ()->frame_get_jit_info (frame); if (domain) *domain = mono_domain_get (); if (out_ip) - *out_ip = mini_get_interp_callbacks ()->frame_get_ip (frame); + *out_ip = mini_get_interp_callbacks_api ()->frame_get_ip (frame); } return ji; } @@ -2448,7 +2491,7 @@ process_suspend (DebuggerTlsData *tls, MonoContext *ctx) g_assert (ji); /* Can't suspend in these methods */ method = jinfo_get_method (ji); - if (method->klass == mono_defaults.string_class && (!strcmp (method->name, "memset") || strstr (method->name, "memcpy"))) + if (method->klass == get_mono_defaults ()->string_class && (!strcmp (method->name, "memset") || strstr (method->name, "memcpy"))) return; save_thread_context (ctx); @@ -2905,7 +2948,7 @@ static gint32 isFixedSizeArray (MonoClassField *f) CattrNamedArg *arginfo; int num_named_args; - mono_reflection_create_custom_attr_data_args_noalloc (mono_defaults.corlib, attr->ctor, attr->data, attr->data_size, + mono_reflection_create_custom_attr_data_args_noalloc (get_mono_defaults ()->corlib, attr->ctor, attr->data, attr->data_size, &typed_args, &named_args, &num_named_args, &arginfo, error); if (!is_ok (error)) { ret = 0; @@ -3066,7 +3109,7 @@ compute_frame_info (MonoInternalThread *thread, DebuggerTlsData *tls, gboolean f gboolean has_interp_resume_state = FALSE; MonoInterpFrameHandle interp_resume_frame = NULL; gpointer interp_resume_ip = 0; - mini_get_interp_callbacks ()->get_resume_state (jit_data, &has_interp_resume_state, &interp_resume_frame, &interp_resume_ip); + mini_get_interp_callbacks_api ()->get_resume_state (jit_data, &has_interp_resume_state, &interp_resume_frame, &interp_resume_ip); if (has_interp_resume_state && tls->frame_count > 0) { StackFrame *top_frame = tls->frames [0]; if (interp_resume_frame == top_frame->interp_frame) { @@ -3200,9 +3243,9 @@ dbg_path_get_basename (const char *filename) return g_strdup (&r[1]); } -static GENERATE_TRY_GET_CLASS_WITH_CACHE(hidden_klass, "System.Diagnostics", "DebuggerHiddenAttribute") -static GENERATE_TRY_GET_CLASS_WITH_CACHE(step_through_klass, "System.Diagnostics", "DebuggerStepThroughAttribute") -static GENERATE_TRY_GET_CLASS_WITH_CACHE(non_user_klass, "System.Diagnostics", "DebuggerNonUserCodeAttribute") +static GENERATE_TRY_GET_CLASS_WITH_CACHE_DBG (hidden_klass, "System.Diagnostics", "DebuggerHiddenAttribute") +static GENERATE_TRY_GET_CLASS_WITH_CACHE_DBG (step_through_klass, "System.Diagnostics", "DebuggerStepThroughAttribute") +static GENERATE_TRY_GET_CLASS_WITH_CACHE_DBG (non_user_klass, "System.Diagnostics", "DebuggerNonUserCodeAttribute") static void init_jit_info_dbg_attrs (MonoJitInfo *ji) @@ -3715,7 +3758,7 @@ runtime_initialized (MonoProfiler *prof) { process_profiler_event (EVENT_KIND_VM_START, mono_thread_current ()); if (CHECK_PROTOCOL_VERSION (2, 59)) - process_profiler_event (EVENT_KIND_ASSEMBLY_LOAD, (mono_defaults.corlib->assembly)); + process_profiler_event (EVENT_KIND_ASSEMBLY_LOAD, (get_mono_defaults ()->corlib->assembly)); if (agent_config.defer) { ERROR_DECL (error); start_debugger_thread (error); @@ -4342,7 +4385,7 @@ mono_dbg_debugger_agent_user_break (void) mono_loader_unlock (); process_event (EVENT_KIND_USER_BREAK, NULL, 0, &ctx, events, suspend_policy); - } else if (mini_debug_options.native_debugger_break) { + } else if (get_mini_debug_options ()->native_debugger_break) { G_BREAKPOINT (); } } @@ -4757,7 +4800,7 @@ static void debugger_agent_handle_exception (MonoException *exc, MonoContext *throw_ctx, MonoContext *catch_ctx, StackFrameInfo *catch_frame) { - if (catch_ctx == NULL && catch_frame == NULL && mini_debug_options.suspend_on_unhandled && mono_object_class (exc) != mono_defaults.threadabortexception_class) { + if (catch_ctx == NULL && catch_frame == NULL && get_mini_debug_options ()->suspend_on_unhandled && mono_object_class (exc) != get_mono_defaults ()->threadabortexception_class) { mono_runtime_printf_err ("Unhandled exception, suspending..."); while (1) ; @@ -6136,7 +6179,7 @@ mono_do_invoke_method (DebuggerTlsData *tls, Buffer *buf, InvokeData *invoke, gu PRINT_DEBUG_MSG (1, "[%p] Invoke result: %p, exc: %s, time: %ld ms.\n", (gpointer) (gsize) mono_native_thread_id_get (), res, exc ? m_class_get_name (exc->vtable->klass) : NULL, (long)mono_stopwatch_elapsed_ms (&watch)); if (exc) { buffer_add_byte (buf, 0); - buffer_add_value (buf, mono_get_object_type (), &exc, domain); + buffer_add_value (buf, mono_get_object_type_dbg (), &exc, domain); } else { gboolean out_this = FALSE; gboolean out_args = FALSE; @@ -6151,11 +6194,11 @@ mono_do_invoke_method (DebuggerTlsData *tls, Buffer *buf, InvokeData *invoke, gu } else if (sig->ret->type == MONO_TYPE_VOID && !m->string_ctor) { if (!strcmp (m->name, ".ctor")) { if (!m_class_is_valuetype (m->klass)) - buffer_add_value (buf, mono_get_object_type (), &this_arg, domain); + buffer_add_value (buf, mono_get_object_type_dbg (), &this_arg, domain); else buffer_add_value (buf, m_class_get_byval_arg (m->klass), this_buf, domain); } else { - buffer_add_value (buf, mono_get_void_type (), NULL, domain); + buffer_add_value (buf, mono_get_void_type_dbg (), NULL, domain); } } else if (MONO_TYPE_IS_REFERENCE (sig->ret)) { if (sig->ret->byref) { @@ -6497,7 +6540,7 @@ module_apply_changes (MonoImage *image, MonoArray *dmeta, MonoArray *dil, MonoAr static void buffer_add_cattr_arg (Buffer *buf, MonoType *t, MonoDomain *domain, MonoObject *val) { - if (val && val->vtable->klass == mono_defaults.runtimetype_class) { + if (val && val->vtable->klass == get_mono_defaults ()->runtimetype_class) { /* Special case these so the client doesn't have to handle Type objects */ buffer_add_byte (buf, VALUE_TYPE_ID_TYPE); @@ -6538,9 +6581,9 @@ buffer_add_cattrs (Buffer *buf, MonoDomain *domain, MonoImage *image, MonoClass ERROR_DECL (error); SETUP_ICALL_FRAME; - typed_args_h = MONO_HANDLE_NEW (MonoArray, NULL); - named_args_h = MONO_HANDLE_NEW (MonoArray, NULL); - val_h = MONO_HANDLE_NEW (MonoObject, NULL); + typed_args_h = MONO_HANDLE_NEW_DBG (MonoArray, NULL); + named_args_h = MONO_HANDLE_NEW_DBG (MonoArray, NULL); + val_h = MONO_HANDLE_NEW_DBG (MonoObject, NULL); mono_reflection_create_custom_attr_data_args (image, attr->ctor, attr->data, attr->data_size, typed_args_h, named_args_h, &arginfo, error); if (!is_ok (error)) { @@ -6702,7 +6745,7 @@ vm_commands (int command, int id, guint8 *p, guint8 *end, Buffer *buf) wait_for_suspend (); #ifdef TRY_MANAGED_SYSTEM_ENVIRONMENT_EXIT - env_class = mono_class_try_load_from_name (mono_defaults.corlib, "System", "Environment"); + env_class = mono_class_try_load_from_name (get_mono_defaults ()->corlib, "System", "Environment"); if (env_class) { ERROR_DECL (error); exit_method = mono_class_get_method_from_name_checked (env_class, "Exit", 1, 0, error); @@ -7083,7 +7126,7 @@ event_commands (int command, guint8 *p, guint8 *end, Buffer *buf) if (exc_class) { req->modifiers [i].data.exc_class = exc_class; - if (!mono_class_is_assignable_from_internal (mono_defaults.exception_class, exc_class)) { + if (!mono_class_is_assignable_from_internal (get_mono_defaults ()->exception_class, exc_class)) { g_free (req); return ERR_INVALID_ARGUMENT; } @@ -7744,7 +7787,7 @@ collect_interfaces (MonoClass *klass, GHashTable *ifaces, MonoError *error) static int get_static_field_value(MonoClassField* f, MonoClass* klass, MonoDomain* domain, MonoInternalThread* thread, Buffer* buf) { - MonoStringHandle string_handle = MONO_HANDLE_NEW(MonoString, NULL); // FIXME? Not always needed. + MonoStringHandle string_handle = MONO_HANDLE_NEW_DBG (MonoString, NULL); // FIXME? Not always needed. ERROR_DECL(error); guint8* val; MonoVTable* vtable; @@ -8686,19 +8729,19 @@ method_commands_internal (int command, MonoMethod *method, MonoDomain *domain, g g_error ("Could not load token due to %s", mono_error_get_message (error)); } - if (handle_class == mono_defaults.typehandle_class) { + if (handle_class == get_mono_defaults ()->typehandle_class) { buffer_add_byte (buf, TOKEN_TYPE_TYPE); if (method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD) buffer_add_typeid (buf, domain, (MonoClass *) val); else buffer_add_typeid (buf, domain, mono_class_from_mono_type_internal ((MonoType*)val)); - } else if (handle_class == mono_defaults.fieldhandle_class) { + } else if (handle_class == get_mono_defaults ()->fieldhandle_class) { buffer_add_byte (buf, TOKEN_TYPE_FIELD); buffer_add_fieldid (buf, domain, (MonoClassField *)val); - } else if (handle_class == mono_defaults.methodhandle_class) { + } else if (handle_class == get_mono_defaults ()->methodhandle_class) { buffer_add_byte (buf, TOKEN_TYPE_METHOD); buffer_add_methodid (buf, domain, (MonoMethod *)val); - } else if (handle_class == mono_defaults.string_class) { + } else if (handle_class == get_mono_defaults ()->string_class) { char *s; s = mono_string_to_utf8_checked_internal ((MonoString *)val, error); @@ -8997,7 +9040,7 @@ thread_commands (int command, guint8 *p, guint8 *end, Buffer *buf) if (tls->frames [0]->de.ji->is_interp) { MonoJitTlsData *jit_data = thread->thread_info->jit_data; - mini_get_interp_callbacks ()->set_resume_state (jit_data, NULL, NULL, tls->frames [0]->interp_frame, (guint8*)tls->frames [0]->de.ji->code_start + sp.native_offset); + mini_get_interp_callbacks_api ()->set_resume_state (jit_data, NULL, NULL, tls->frames [0]->interp_frame, (guint8*)tls->frames [0]->de.ji->code_start + sp.native_offset); } else { MONO_CONTEXT_SET_IP (&tls->restore_state.ctx, (guint8*)tls->frames [0]->de.ji->code_start + sp.native_offset); } @@ -9039,12 +9082,12 @@ cmd_stack_frame_get_this (StackFrame *frame, MonoMethodSignature *sig, Buffer *b if (m_class_is_valuetype (frame->api_method->klass)) { if (!sig->hasthis) { MonoObject *p = NULL; - buffer_add_value (buf, mono_get_object_type (), &p, frame->de.domain); + buffer_add_value (buf, mono_get_object_type_dbg (), &p, frame->de.domain); } else { if (frame->de.ji->is_interp) { guint8 *addr; - addr = (guint8*)mini_get_interp_callbacks ()->frame_get_this (frame->interp_frame); + addr = (guint8*)mini_get_interp_callbacks_api ()->frame_get_this (frame->interp_frame); buffer_add_value_full (buf, m_class_get_this_arg (frame->actual_method->klass), addr, frame->de.domain, FALSE, NULL, 1); } else { @@ -9059,7 +9102,7 @@ cmd_stack_frame_get_this (StackFrame *frame, MonoMethodSignature *sig, Buffer *b if (frame->de.ji->is_interp) { guint8 *addr; - addr = (guint8*)mini_get_interp_callbacks ()->frame_get_this (frame->interp_frame); + addr = (guint8*)mini_get_interp_callbacks_api ()->frame_get_this (frame->interp_frame); buffer_add_value_full (buf, m_class_get_byval_arg (frame->api_method->klass), addr, frame->de.domain, FALSE, NULL, 1); } else { @@ -9076,7 +9119,7 @@ cmd_stack_frame_get_parameter (StackFrame *frame, MonoMethodSignature *sig, int if (frame->de.ji->is_interp) { guint8 *addr; - addr = (guint8*)mini_get_interp_callbacks ()->frame_get_arg (frame->interp_frame, pos); + addr = (guint8*)mini_get_interp_callbacks_api ()->frame_get_arg (frame->interp_frame, pos); buffer_add_value_full (buf, sig->params [pos], addr, frame->de.domain, FALSE, NULL, 1); } else { @@ -9199,7 +9242,7 @@ frame_commands (int command, guint8 *p, guint8 *end, Buffer *buf) if (frame->de.ji->is_interp) { guint8 *addr; - addr = (guint8*)mini_get_interp_callbacks ()->frame_get_local (frame->interp_frame, pos); + addr = (guint8*)mini_get_interp_callbacks_api ()->frame_get_local (frame->interp_frame, pos); buffer_add_value_full (buf, header->locals [pos], addr, frame->de.domain, FALSE, NULL, 1); } else { @@ -9265,9 +9308,9 @@ frame_commands (int command, guint8 *p, guint8 *end, Buffer *buf) guint8 *addr; if (is_arg) - addr = (guint8*)mini_get_interp_callbacks ()->frame_get_arg (frame->interp_frame, pos); + addr = (guint8*)mini_get_interp_callbacks_api ()->frame_get_arg (frame->interp_frame, pos); else - addr = (guint8*)mini_get_interp_callbacks ()->frame_get_local (frame->interp_frame, pos); + addr = (guint8*)mini_get_interp_callbacks_api ()->frame_get_local (frame->interp_frame, pos); err = mono_de_set_interp_var (t, addr, val_buf); if (err != ERR_NONE) return err; @@ -9300,7 +9343,7 @@ frame_commands (int command, guint8 *p, guint8 *end, Buffer *buf) if (frame->de.ji->is_interp) { guint8 *addr; - addr = (guint8*)mini_get_interp_callbacks ()->frame_get_this (frame->interp_frame); + addr = (guint8*)mini_get_interp_callbacks_api ()->frame_get_this (frame->interp_frame); err = mono_de_set_interp_var (m_class_get_this_arg (frame->actual_method->klass), addr, val_buf); if (err != ERR_NONE) return err; @@ -9542,7 +9585,7 @@ object_commands (int command, guint8 *p, guint8 *end, Buffer *buf) MonoClassField *f = NULL; MonoClass *k; gboolean found; - MonoStringHandle string_handle = MONO_HANDLE_NEW (MonoString, NULL); // FIXME? Not always needed. + MonoStringHandle string_handle = MONO_HANDLE_NEW_DBG (MonoString, NULL); // FIXME? Not always needed. if (command == CMD_OBJECT_REF_IS_COLLECTED) { objid = decode_objid (p, &p, end); diff --git a/src/mono/mono/component/debugger-engine.c b/src/mono/mono/component/debugger-engine.c index 78d985aeb79bd0..d23f0ab9c51431 100644 --- a/src/mono/mono/component/debugger-engine.c +++ b/src/mono/mono/component/debugger-engine.c @@ -212,7 +212,7 @@ insert_breakpoint (MonoSeqPointInfo *seq_points, MonoDomain *domain, MonoJitInfo PRINT_DEBUG_MSG (1, "[dbg] Attempting to insert seq point at dead IL offset %d, ignoring.\n", (int)bp->il_offset); } else if (count == 0) { if (ji->is_interp) { - mini_get_interp_callbacks ()->set_breakpoint (ji, inst->ip); + mini_get_interp_callbacks_api ()->set_breakpoint (ji, inst->ip); } else { #ifdef MONO_ARCH_SOFT_DEBUG_SUPPORTED mono_arch_set_breakpoint (ji, inst->ip); @@ -241,7 +241,7 @@ remove_breakpoint (BreakpointInstance *inst) if (count == 1 && inst->native_offset != SEQ_POINT_NATIVE_OFFSET_DEAD_CODE) { if (ji->is_interp) { - mini_get_interp_callbacks ()->clear_breakpoint (ji, ip); + mini_get_interp_callbacks_api ()->clear_breakpoint (ji, ip); } else { #ifdef MONO_ARCH_SOFT_DEBUG_SUPPORTED mono_arch_clear_breakpoint (ji, ip); @@ -608,7 +608,7 @@ mono_de_start_single_stepping (void) #ifdef MONO_ARCH_SOFT_DEBUG_SUPPORTED mono_arch_start_single_stepping (); #endif - mini_get_interp_callbacks ()->start_single_stepping (); + mini_get_interp_callbacks_api ()->start_single_stepping (); } } @@ -621,7 +621,7 @@ mono_de_stop_single_stepping (void) #ifdef MONO_ARCH_SOFT_DEBUG_SUPPORTED mono_arch_stop_single_stepping (); #endif - mini_get_interp_callbacks ()->stop_single_stepping (); + mini_get_interp_callbacks_api ()->stop_single_stepping (); } } @@ -647,11 +647,11 @@ get_top_method_ji (gpointer ip, MonoDomain **domain, gpointer *out_ip) g_assert (ext->kind == MONO_LMFEXT_INTERP_EXIT || ext->kind == MONO_LMFEXT_INTERP_EXIT_WITH_CTX); frame = (MonoInterpFrameHandle*)ext->interp_exit_data; - ji = mini_get_interp_callbacks ()->frame_get_jit_info (frame); + ji = mini_get_interp_callbacks_api ()->frame_get_jit_info (frame); if (domain) *domain = mono_domain_get (); if (out_ip) - *out_ip = mini_get_interp_callbacks ()->frame_get_ip (frame); + *out_ip = mini_get_interp_callbacks_api ()->frame_get_ip (frame); } return ji; } @@ -823,7 +823,7 @@ mono_de_process_single_step (void *tls, gboolean from_signal) * Stopping in memset makes half-initialized vtypes visible. * Stopping in memcpy makes half-copied vtypes visible. */ - if (method->klass == mono_defaults.string_class && (!strcmp (method->name, "memset") || strstr (method->name, "memcpy"))) + if (method->klass == get_mono_defaults ()->string_class && (!strcmp (method->name, "memset") || strstr (method->name, "memcpy"))) goto exit; /* @@ -1667,7 +1667,7 @@ get_this_addr (DbgEngineStackFrame *the_frame) { StackFrame *frame = (StackFrame *)the_frame; if (frame->de.ji->is_interp) - return mini_get_interp_callbacks ()->frame_get_this (frame->interp_frame); + return mini_get_interp_callbacks_api ()->frame_get_this (frame->interp_frame); MonoDebugVarInfo *var = frame->jit->this_var; if ((var->index & MONO_DEBUG_VAR_ADDRESS_MODE_FLAGS) != MONO_DEBUG_VAR_ADDRESS_MODE_REGOFFSET) @@ -1730,7 +1730,7 @@ get_notify_debugger_of_wait_completion_method (void) if (notify_debugger_of_wait_completion_method_cache != NULL) return notify_debugger_of_wait_completion_method_cache; ERROR_DECL (error); - MonoClass* task_class = mono_class_load_from_name (mono_defaults.corlib, "System.Threading.Tasks", "Task"); + MonoClass* task_class = mono_class_load_from_name (get_mono_defaults ()->corlib, "System.Threading.Tasks", "Task"); GPtrArray* array = mono_class_get_methods_by_name (task_class, "NotifyDebuggerOfWaitCompletion", 0x24, 1, FALSE, error); mono_error_assert_ok (error); g_assert (array->len == 1); diff --git a/src/mono/mono/component/debugger-stub.c b/src/mono/mono/component/debugger-stub.c index 7ce0ce79d7f753..e094274288a142 100644 --- a/src/mono/mono/component/debugger-stub.c +++ b/src/mono/mono/component/debugger-stub.c @@ -13,7 +13,7 @@ static bool debugger_avaliable (void); static void -stub_debugger_parse_options (char *options); +stub_debugger_parse_options (void); static void stub_debugger_init (void); @@ -119,7 +119,7 @@ mono_component_debugger_init (void) } static void -stub_debugger_parse_options (char *options) +stub_debugger_parse_options (void) { g_error ("This runtime is configured with the debugger agent disabled."); } diff --git a/src/mono/mono/component/debugger.h b/src/mono/mono/component/debugger.h index 9d9f0317cbc41e..3e2d4a25a25fe5 100644 --- a/src/mono/mono/component/debugger.h +++ b/src/mono/mono/component/debugger.h @@ -174,7 +174,7 @@ typedef struct MonoComponentDebugger { MonoComponent component; void (*init) (void); void (*user_break) (void); - void (*parse_options) (char *options); + void (*parse_options) (void); void (*breakpoint_hit) (void *sigctx); void (*single_step_event) (void *sigctx); void (*single_step_from_context) (MonoContext *ctx); diff --git a/src/mono/mono/component/mini-wasm-debugger.c b/src/mono/mono/component/mini-wasm-debugger.c index d0d43826b80896..dddcd845b5c4f5 100644 --- a/src/mono/mono/component/mini-wasm-debugger.c +++ b/src/mono/mono/component/mini-wasm-debugger.c @@ -165,10 +165,10 @@ mono_wasm_debugger_init (void) mono_de_init (&cbs); mono_de_set_log_level (log_level, stdout); - mini_debug_options.gen_sdb_seq_points = TRUE; - mini_debug_options.mdb_optimizations = TRUE; + get_mini_debug_options ()->gen_sdb_seq_points = TRUE; + get_mini_debug_options ()->mdb_optimizations = TRUE; mono_disable_optimizations (MONO_OPT_LINEARS); - mini_debug_options.load_aot_jit_info_eagerly = TRUE; + get_mini_debug_options ()->load_aot_jit_info_eagerly = TRUE; MonoProfilerHandle prof = mono_profiler_create (NULL); mono_profiler_set_jit_done_callback (prof, jit_done); diff --git a/src/mono/mono/metadata/class-internals.h b/src/mono/mono/metadata/class-internals.h index 3759bb4de274f3..f29e828a35b618 100644 --- a/src/mono/mono/metadata/class-internals.h +++ b/src/mono/mono/metadata/class-internals.h @@ -1056,6 +1056,9 @@ GENERATE_GET_CLASS_WITH_CACHE_DECL (native_library) /* If you need a MonoType, use one of the mono_get_*_type () functions in class-inlines.h */ extern MonoDefaults mono_defaults; +MONO_COMPONENT_API MonoDefaults * +get_mono_defaults (void); + void mono_loader_init (void); diff --git a/src/mono/mono/metadata/handle.c b/src/mono/mono/metadata/handle.c index c50d47e138340f..ab84a3ed8c9b66 100644 --- a/src/mono/mono/metadata/handle.c +++ b/src/mono/mono/metadata/handle.c @@ -149,9 +149,9 @@ mono_handle_chunk_leak_check (HandleStack *handles) { // There are deliberately locals and a constant NULL global with this same name. #ifdef __cplusplus -MONO_COMPONENT_API MonoThreadInfo * const mono_thread_info_current_var = NULL; +MonoThreadInfo * const mono_thread_info_current_var = NULL; #else -MONO_COMPONENT_API MonoThreadInfo * const mono_thread_info_current_var = NULL; +MonoThreadInfo * const mono_thread_info_current_var = NULL; #endif /* Actual handles implementation */ @@ -517,3 +517,9 @@ mono_handle_array_getref (MonoObjectHandleOut dest, MonoArrayHandle array, uintp MONO_HANDLE_SUPPRESS (g_assert (dest.__raw)); MONO_HANDLE_SUPPRESS (*dest.__raw = (MonoObject*)mono_array_get_internal (MONO_HANDLE_RAW (array), gpointer, index)); } + +MonoThreadInfo * const +get_mono_thread_info_current_var (void) +{ + return mono_thread_info_current_var; +} diff --git a/src/mono/mono/metadata/handle.h b/src/mono/mono/metadata/handle.h index 3cf1f3afe2f5ba..227827666b73a9 100644 --- a/src/mono/mono/metadata/handle.h +++ b/src/mono/mono/metadata/handle.h @@ -173,6 +173,8 @@ mono_stack_mark_pop (MonoThreadInfo *info, HandleStackMark *stackmark) // There are deliberately locals and a constant NULL global with this same name. extern MonoThreadInfo * const mono_thread_info_current_var; +MONO_COMPONENT_API MonoThreadInfo * const get_mono_thread_info_current_var (void); + /* Icall macros */ diff --git a/src/mono/mono/metadata/loader.c b/src/mono/mono/metadata/loader.c index ab0d46399fe052..17d5995fa71360 100644 --- a/src/mono/mono/metadata/loader.c +++ b/src/mono/mono/metadata/loader.c @@ -70,7 +70,7 @@ static gboolean loader_lock_track_ownership; */ static MonoNativeTlsKey loader_lock_nest_id; -MONO_COMPONENT_API MonoDefaults mono_defaults; +MonoDefaults mono_defaults; /* Statistics */ static gint32 inflated_signatures_size; @@ -2123,3 +2123,9 @@ mono_method_get_index (MonoMethod *method) } return 0; } + +MonoDefaults * +get_mono_defaults (void) +{ + return &mono_defaults; +} diff --git a/src/mono/mono/mini/debugger-agent-stubs.c b/src/mono/mono/mini/debugger-agent-stubs.c index 7746e3ae8c8049..a1bc833b4c8e50 100644 --- a/src/mono/mono/mini/debugger-agent-stubs.c +++ b/src/mono/mono/mini/debugger-agent-stubs.c @@ -15,7 +15,7 @@ #include "debugger-agent.h" static void -stub_debugger_agent_parse_options (char *options) +stub_debugger_agent_parse_options (void) { g_error ("This runtime is configured with the debugger agent disabled."); } diff --git a/src/mono/mono/mini/driver.c b/src/mono/mono/mini/driver.c index 5ecb4ee07d2bab..7c37d2bddf8726 100644 --- a/src/mono/mono/mini/driver.c +++ b/src/mono/mono/mini/driver.c @@ -56,6 +56,8 @@ #include "mono/metadata/custom-attrs-internals.h" #include +#include + #include "mini.h" #include "jit.h" #include "aot-compiler.h" @@ -1806,7 +1808,7 @@ mono_jit_parse_options (int argc, char * argv[]) if (strncmp (argv [i], "--debugger-agent=", 17) == 0) { MonoDebugOptions *opt = mini_get_debug_options (); - sdb_options = g_strdup (argv [i] + 17); + mono_component_debugger ()->mono_debugger_agent_parse_options (g_strdup (argv [i] + 17)); opt->mdb_optimizations = TRUE; enable_debugging = TRUE; } else if (!strcmp (argv [i], "--soft-breakpoints")) { @@ -2381,7 +2383,7 @@ mono_main (int argc, char* argv[]) } else if (strncmp (argv [i], "--debugger-agent=", 17) == 0) { MonoDebugOptions *opt = mini_get_debug_options (); - sdb_options = g_strdup (argv [i] + 17); + mono_component_debugger ()->mono_debugger_agent_parse_options (g_strdup (argv [i] + 17)); opt->mdb_optimizations = TRUE; enable_debugging = TRUE; } else if (strcmp (argv [i], "--security") == 0) { @@ -3259,3 +3261,9 @@ mono_parse_env_options (int *ref_argc, char **ref_argv []) fprintf (stderr, "%s", ret); exit (1); } + +MonoDebugOptions * +get_mini_debug_options (void) +{ + return &mini_debug_options; +} diff --git a/src/mono/mono/mini/mini-runtime.c b/src/mono/mono/mini/mini-runtime.c index c5b25609cb96ed..cc982007e7907d 100644 --- a/src/mono/mono/mini/mini-runtime.c +++ b/src/mono/mono/mini/mini-runtime.c @@ -143,8 +143,7 @@ static mono_mutex_t jit_mutex; static MonoCodeManager *global_codeman; -MONO_COMPONENT_API MonoDebugOptions mini_debug_options; -MONO_COMPONENT_API char *sdb_options; +MonoDebugOptions mini_debug_options; #ifdef VALGRIND_JIT_REGISTER_MAP int valgrind_register; @@ -4205,7 +4204,7 @@ mini_add_profiler_argument (const char *desc) } -MONO_COMPONENT_API const MonoEECallbacks *mono_interp_callbacks_pointer; +const MonoEECallbacks *mono_interp_callbacks_pointer; void mini_install_interp_callbacks (const MonoEECallbacks *cbs) @@ -4271,8 +4270,7 @@ mini_init (const char *filename, const char *runtime_version) mono_ee_interp_init (mono_interp_opts_string); #endif - if (sdb_options) - mono_component_debugger ()->parse_options (sdb_options); + mono_component_debugger ()->parse_options (); mono_os_mutex_init_recursive (&jit_mutex); @@ -5159,3 +5157,9 @@ mini_get_stack_overflow_ex (void) { return mono_get_root_domain ()->stack_overflow_ex; } + +const MonoEECallbacks* +mini_get_interp_callbacks_api (void) +{ + return mono_interp_callbacks_pointer; +} diff --git a/src/mono/mono/mini/mini-runtime.h b/src/mono/mono/mini/mini-runtime.h index a1f2e301c010c1..57fb1b2982466a 100644 --- a/src/mono/mono/mini/mini-runtime.h +++ b/src/mono/mono/mini/mini-runtime.h @@ -452,9 +452,10 @@ extern GHashTable *mono_single_method_hash; extern GList* mono_aot_paths; extern MonoDebugOptions mini_debug_options; extern GSList *mono_interp_only_classes; -extern char *sdb_options; extern MonoMethodDesc *mono_stats_method_desc; +MONO_COMPONENT_API MonoDebugOptions *get_mini_debug_options (void); + /* This struct describes what execution engine feature to use. This subsume, and will eventually sunset, mono_aot_only / mono_llvm_only and friends. @@ -510,6 +511,8 @@ MonoEECallbacks* mono_interp_callbacks_pointer; #define mini_get_interp_callbacks() (mono_interp_callbacks_pointer) +MONO_COMPONENT_API const MonoEECallbacks* mini_get_interp_callbacks_api (void); + MonoDomain* mini_init (const char *filename, const char *runtime_version); void mini_cleanup (MonoDomain *domain); MONO_API MonoDebugOptions *mini_get_debug_options (void); From e4303f5e513fe185b06008e8d59d34a320fca5f6 Mon Sep 17 00:00:00 2001 From: Thays Date: Wed, 30 Jun 2021 02:36:52 -0300 Subject: [PATCH 25/35] Changing what @lambdageek suggested. --- src/mono/mono/component/debugger-agent.c | 4 ++-- src/mono/mono/metadata/handle.c | 6 ------ src/mono/mono/metadata/handle.h | 2 -- 3 files changed, 2 insertions(+), 10 deletions(-) diff --git a/src/mono/mono/component/debugger-agent.c b/src/mono/mono/component/debugger-agent.c index 46e99e0c323a54..2e9abeefafa2f2 100644 --- a/src/mono/mono/component/debugger-agent.c +++ b/src/mono/mono/component/debugger-agent.c @@ -147,12 +147,12 @@ mono_class_try_get_##shortname##_class (void) \ #ifndef MONO_HANDLE_TRACK_OWNER #define MONO_HANDLE_NEW_DBG(type, object) \ - (MONO_HANDLE_CAST_FOR (type) (mono_handle_new (MONO_HANDLE_TYPECHECK_FOR (type) (object), get_mono_thread_info_current_var ()))) + (MONO_HANDLE_CAST_FOR (type) (mono_handle_new (MONO_HANDLE_TYPECHECK_FOR (type) (object), mono_thread_info_current ()))) #else #define MONO_HANDLE_NEW_DBG(type, object) \ - (MONO_HANDLE_CAST_FOR (type) (mono_handle_new (MONO_HANDLE_TYPECHECK_FOR (type) (object), get_mono_thread_info_current_var (), HANDLE_OWNER))) + (MONO_HANDLE_CAST_FOR (type) (mono_handle_new (MONO_HANDLE_TYPECHECK_FOR (type) (object), mono_thread_info_current (), HANDLE_OWNER))) #endif diff --git a/src/mono/mono/metadata/handle.c b/src/mono/mono/metadata/handle.c index ab84a3ed8c9b66..d6af32f73b291c 100644 --- a/src/mono/mono/metadata/handle.c +++ b/src/mono/mono/metadata/handle.c @@ -517,9 +517,3 @@ mono_handle_array_getref (MonoObjectHandleOut dest, MonoArrayHandle array, uintp MONO_HANDLE_SUPPRESS (g_assert (dest.__raw)); MONO_HANDLE_SUPPRESS (*dest.__raw = (MonoObject*)mono_array_get_internal (MONO_HANDLE_RAW (array), gpointer, index)); } - -MonoThreadInfo * const -get_mono_thread_info_current_var (void) -{ - return mono_thread_info_current_var; -} diff --git a/src/mono/mono/metadata/handle.h b/src/mono/mono/metadata/handle.h index 227827666b73a9..3cf1f3afe2f5ba 100644 --- a/src/mono/mono/metadata/handle.h +++ b/src/mono/mono/metadata/handle.h @@ -173,8 +173,6 @@ mono_stack_mark_pop (MonoThreadInfo *info, HandleStackMark *stackmark) // There are deliberately locals and a constant NULL global with this same name. extern MonoThreadInfo * const mono_thread_info_current_var; -MONO_COMPONENT_API MonoThreadInfo * const get_mono_thread_info_current_var (void); - /* Icall macros */ From ca2b371c1444fb937d2d14c7a51e4d78f5964dd8 Mon Sep 17 00:00:00 2001 From: Thays Date: Wed, 30 Jun 2021 03:08:08 -0300 Subject: [PATCH 26/35] Changing what @lamdbageek suggested. --- src/mono/mono/component/debugger-agent.c | 41 +++++++++++--------- src/mono/mono/component/debugger-engine.c | 4 +- src/mono/mono/component/debugger-stub.c | 4 +- src/mono/mono/component/debugger.h | 6 ++- src/mono/mono/metadata/class-internals.h | 3 -- src/mono/mono/metadata/loader.c | 6 --- src/mono/mono/mini/debugger-agent-external.c | 4 +- src/mono/mono/mini/debugger-agent-external.h | 2 +- src/mono/mono/mini/driver.c | 4 +- src/mono/mono/mini/mini-runtime.c | 2 +- 10 files changed, 37 insertions(+), 39 deletions(-) diff --git a/src/mono/mono/component/debugger-agent.c b/src/mono/mono/component/debugger-agent.c index 2e9abeefafa2f2..628e3e9a1b66d0 100644 --- a/src/mono/mono/component/debugger-agent.c +++ b/src/mono/mono/component/debugger-agent.c @@ -136,7 +136,7 @@ mono_class_try_get_##shortname##_class (void) \ MonoClass *klass = (MonoClass *)tmp_class; \ mono_memory_barrier (); \ if (!inited) { \ - klass = mono_class_try_load_from_name (get_mono_defaults ()->corlib, name_space, name); \ + klass = mono_class_try_load_from_name (mdbg_mono_defaults->corlib, name_space, name); \ tmp_class = klass; \ mono_memory_barrier (); \ inited = TRUE; \ @@ -159,13 +159,13 @@ mono_class_try_get_##shortname##_class (void) \ static inline MonoType* mono_get_object_type_dbg (void) { - return m_class_get_byval_arg (get_mono_defaults ()->object_class); + return m_class_get_byval_arg (mdbg_mono_defaults->object_class); } static inline MonoType* mono_get_void_type_dbg (void) { - return m_class_get_byval_arg (get_mono_defaults ()->void_class); + return m_class_get_byval_arg (mdbg_mono_defaults->void_class); } typedef struct { @@ -410,6 +410,7 @@ static gint32 suspend_count; /* Whenever to buffer reply messages and send them together */ static gboolean buffer_replies; +MonoDefaults *mdbg_mono_defaults; #ifndef TARGET_WASM #define GET_TLS_DATA_FROM_THREAD(thread) \ @@ -524,7 +525,7 @@ static void mono_dbg_debugger_agent_user_break (void); static GENERATE_TRY_GET_CLASS_WITH_CACHE_DBG (fixed_buffer, "System.Runtime.CompilerServices", "FixedBufferAttribute") -static char *sdb_options; +static char *sdb_options = NULL; #ifndef DISABLE_SOCKET_TRANSPORT static void @@ -598,6 +599,8 @@ parse_flag (const char *option, char *flag) static void debugger_agent_parse_options (void) { + if (!sdb_options) + return; char *options = sdb_options; char **args, **ptr; char *host; @@ -735,8 +738,10 @@ mono_debugger_is_disconnected (void) } static void -debugger_agent_init (void) +debugger_agent_init (MonoDefaults *mono_defaults) { + mdbg_mono_defaults = mono_defaults; + if (!agent_config.enabled) return; @@ -2491,7 +2496,7 @@ process_suspend (DebuggerTlsData *tls, MonoContext *ctx) g_assert (ji); /* Can't suspend in these methods */ method = jinfo_get_method (ji); - if (method->klass == get_mono_defaults ()->string_class && (!strcmp (method->name, "memset") || strstr (method->name, "memcpy"))) + if (method->klass == mdbg_mono_defaults->string_class && (!strcmp (method->name, "memset") || strstr (method->name, "memcpy"))) return; save_thread_context (ctx); @@ -2948,7 +2953,7 @@ static gint32 isFixedSizeArray (MonoClassField *f) CattrNamedArg *arginfo; int num_named_args; - mono_reflection_create_custom_attr_data_args_noalloc (get_mono_defaults ()->corlib, attr->ctor, attr->data, attr->data_size, + mono_reflection_create_custom_attr_data_args_noalloc (mdbg_mono_defaults->corlib, attr->ctor, attr->data, attr->data_size, &typed_args, &named_args, &num_named_args, &arginfo, error); if (!is_ok (error)) { ret = 0; @@ -3758,7 +3763,7 @@ runtime_initialized (MonoProfiler *prof) { process_profiler_event (EVENT_KIND_VM_START, mono_thread_current ()); if (CHECK_PROTOCOL_VERSION (2, 59)) - process_profiler_event (EVENT_KIND_ASSEMBLY_LOAD, (get_mono_defaults ()->corlib->assembly)); + process_profiler_event (EVENT_KIND_ASSEMBLY_LOAD, (mdbg_mono_defaults->corlib->assembly)); if (agent_config.defer) { ERROR_DECL (error); start_debugger_thread (error); @@ -4800,7 +4805,7 @@ static void debugger_agent_handle_exception (MonoException *exc, MonoContext *throw_ctx, MonoContext *catch_ctx, StackFrameInfo *catch_frame) { - if (catch_ctx == NULL && catch_frame == NULL && get_mini_debug_options ()->suspend_on_unhandled && mono_object_class (exc) != get_mono_defaults ()->threadabortexception_class) { + if (catch_ctx == NULL && catch_frame == NULL && get_mini_debug_options ()->suspend_on_unhandled && mono_object_class (exc) != mdbg_mono_defaults->threadabortexception_class) { mono_runtime_printf_err ("Unhandled exception, suspending..."); while (1) ; @@ -6540,7 +6545,7 @@ module_apply_changes (MonoImage *image, MonoArray *dmeta, MonoArray *dil, MonoAr static void buffer_add_cattr_arg (Buffer *buf, MonoType *t, MonoDomain *domain, MonoObject *val) { - if (val && val->vtable->klass == get_mono_defaults ()->runtimetype_class) { + if (val && val->vtable->klass == mdbg_mono_defaults->runtimetype_class) { /* Special case these so the client doesn't have to handle Type objects */ buffer_add_byte (buf, VALUE_TYPE_ID_TYPE); @@ -6745,7 +6750,7 @@ vm_commands (int command, int id, guint8 *p, guint8 *end, Buffer *buf) wait_for_suspend (); #ifdef TRY_MANAGED_SYSTEM_ENVIRONMENT_EXIT - env_class = mono_class_try_load_from_name (get_mono_defaults ()->corlib, "System", "Environment"); + env_class = mono_class_try_load_from_name (mdbg_mono_defaults->corlib, "System", "Environment"); if (env_class) { ERROR_DECL (error); exit_method = mono_class_get_method_from_name_checked (env_class, "Exit", 1, 0, error); @@ -7126,7 +7131,7 @@ event_commands (int command, guint8 *p, guint8 *end, Buffer *buf) if (exc_class) { req->modifiers [i].data.exc_class = exc_class; - if (!mono_class_is_assignable_from_internal (get_mono_defaults ()->exception_class, exc_class)) { + if (!mono_class_is_assignable_from_internal (mdbg_mono_defaults->exception_class, exc_class)) { g_free (req); return ERR_INVALID_ARGUMENT; } @@ -8729,19 +8734,19 @@ method_commands_internal (int command, MonoMethod *method, MonoDomain *domain, g g_error ("Could not load token due to %s", mono_error_get_message (error)); } - if (handle_class == get_mono_defaults ()->typehandle_class) { + if (handle_class == mdbg_mono_defaults->typehandle_class) { buffer_add_byte (buf, TOKEN_TYPE_TYPE); if (method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD) buffer_add_typeid (buf, domain, (MonoClass *) val); else buffer_add_typeid (buf, domain, mono_class_from_mono_type_internal ((MonoType*)val)); - } else if (handle_class == get_mono_defaults ()->fieldhandle_class) { + } else if (handle_class == mdbg_mono_defaults->fieldhandle_class) { buffer_add_byte (buf, TOKEN_TYPE_FIELD); buffer_add_fieldid (buf, domain, (MonoClassField *)val); - } else if (handle_class == get_mono_defaults ()->methodhandle_class) { + } else if (handle_class == mdbg_mono_defaults->methodhandle_class) { buffer_add_byte (buf, TOKEN_TYPE_METHOD); buffer_add_methodid (buf, domain, (MonoMethod *)val); - } else if (handle_class == get_mono_defaults ()->string_class) { + } else if (handle_class == mdbg_mono_defaults->string_class) { char *s; s = mono_string_to_utf8_checked_internal ((MonoString *)val, error); @@ -10264,7 +10269,7 @@ debugger_thread (void *arg) } static void -mono_debugger_agent_parse_options (char *options) +set_sdb_options (char *options) { sdb_options = options; } @@ -10289,7 +10294,7 @@ debugger_agent_add_function_pointers(MonoComponentDebugger* fn_table) fn_table->send_crash = mono_debugger_agent_send_crash; fn_table->register_transport = register_transport; - fn_table->mono_debugger_agent_parse_options = mono_debugger_agent_parse_options; + fn_table->set_sdb_options = set_sdb_options; fn_table->mono_debugger_agent_transport_handshake = mono_debugger_agent_transport_handshake; } diff --git a/src/mono/mono/component/debugger-engine.c b/src/mono/mono/component/debugger-engine.c index d23f0ab9c51431..063e5f547992c1 100644 --- a/src/mono/mono/component/debugger-engine.c +++ b/src/mono/mono/component/debugger-engine.c @@ -823,7 +823,7 @@ mono_de_process_single_step (void *tls, gboolean from_signal) * Stopping in memset makes half-initialized vtypes visible. * Stopping in memcpy makes half-copied vtypes visible. */ - if (method->klass == get_mono_defaults ()->string_class && (!strcmp (method->name, "memset") || strstr (method->name, "memcpy"))) + if (method->klass == mdbg_mono_defaults->string_class && (!strcmp (method->name, "memset") || strstr (method->name, "memcpy"))) goto exit; /* @@ -1730,7 +1730,7 @@ get_notify_debugger_of_wait_completion_method (void) if (notify_debugger_of_wait_completion_method_cache != NULL) return notify_debugger_of_wait_completion_method_cache; ERROR_DECL (error); - MonoClass* task_class = mono_class_load_from_name (get_mono_defaults ()->corlib, "System.Threading.Tasks", "Task"); + MonoClass* task_class = mono_class_load_from_name (mdbg_mono_defaults->corlib, "System.Threading.Tasks", "Task"); GPtrArray* array = mono_class_get_methods_by_name (task_class, "NotifyDebuggerOfWaitCompletion", 0x24, 1, FALSE, error); mono_error_assert_ok (error); g_assert (array->len == 1); diff --git a/src/mono/mono/component/debugger-stub.c b/src/mono/mono/component/debugger-stub.c index e094274288a142..7cda35c0b399f4 100644 --- a/src/mono/mono/component/debugger-stub.c +++ b/src/mono/mono/component/debugger-stub.c @@ -16,7 +16,7 @@ static void stub_debugger_parse_options (void); static void -stub_debugger_init (void); +stub_debugger_init (MonoDefaults *mono_defaults); static void stub_debugger_breakpoint_hit (void *sigctx); @@ -125,7 +125,7 @@ stub_debugger_parse_options (void) } static void -stub_debugger_init (void) +stub_debugger_init (MonoDefaults *mono_defaults) { } diff --git a/src/mono/mono/component/debugger.h b/src/mono/mono/component/debugger.h index 3e2d4a25a25fe5..3c3f868bd63806 100644 --- a/src/mono/mono/component/debugger.h +++ b/src/mono/mono/component/debugger.h @@ -172,7 +172,7 @@ typedef struct _DebuggerTlsData DebuggerTlsData; typedef struct MonoComponentDebugger { MonoComponent component; - void (*init) (void); + void (*init) (MonoDefaults *mono_defaults); void (*user_break) (void); void (*parse_options) (void); void (*breakpoint_hit) (void *sigctx); @@ -190,7 +190,7 @@ typedef struct MonoComponentDebugger { void (*send_crash) (char *json_dump, MonoStackHash *hashes, int pause); void (*register_transport) (DebuggerTransport* trans); //debugger-agent gboolean (*mono_debugger_agent_transport_handshake) (void); - void (*mono_debugger_agent_parse_options) (char* options); + void (*set_sdb_options) (char* options); //wasm void (*mono_wasm_debugger_init) (void); @@ -200,6 +200,8 @@ typedef struct MonoComponentDebugger { } MonoComponentDebugger; +extern MonoDefaults *mdbg_mono_defaults; + #define DE_ERR_NONE 0 // WARNING WARNING WARNING // Error codes MUST match those of sdb for now diff --git a/src/mono/mono/metadata/class-internals.h b/src/mono/mono/metadata/class-internals.h index f29e828a35b618..3759bb4de274f3 100644 --- a/src/mono/mono/metadata/class-internals.h +++ b/src/mono/mono/metadata/class-internals.h @@ -1056,9 +1056,6 @@ GENERATE_GET_CLASS_WITH_CACHE_DECL (native_library) /* If you need a MonoType, use one of the mono_get_*_type () functions in class-inlines.h */ extern MonoDefaults mono_defaults; -MONO_COMPONENT_API MonoDefaults * -get_mono_defaults (void); - void mono_loader_init (void); diff --git a/src/mono/mono/metadata/loader.c b/src/mono/mono/metadata/loader.c index 17d5995fa71360..f16c8c36f81471 100644 --- a/src/mono/mono/metadata/loader.c +++ b/src/mono/mono/metadata/loader.c @@ -2123,9 +2123,3 @@ mono_method_get_index (MonoMethod *method) } return 0; } - -MonoDefaults * -get_mono_defaults (void) -{ - return &mono_defaults; -} diff --git a/src/mono/mono/mini/debugger-agent-external.c b/src/mono/mono/mini/debugger-agent-external.c index 2cd559f1353b46..0d52901c3debd9 100644 --- a/src/mono/mono/mini/debugger-agent-external.c +++ b/src/mono/mono/mini/debugger-agent-external.c @@ -27,9 +27,9 @@ mono_debugger_agent_init (void) } void -mono_debugger_agent_parse_options (char *options) +set_sdb_options (char *options) { - mono_component_debugger ()->mono_debugger_agent_parse_options (options); + mono_component_debugger ()->set_sdb_options (options); } #endif /* DISABLE_SDB */ diff --git a/src/mono/mono/mini/debugger-agent-external.h b/src/mono/mono/mini/debugger-agent-external.h index f61cb66e683ca7..636af4e82f6b2c 100644 --- a/src/mono/mono/mini/debugger-agent-external.h +++ b/src/mono/mono/mini/debugger-agent-external.h @@ -12,7 +12,7 @@ MONO_API void mono_debugger_agent_init (void); MONO_API void -mono_debugger_agent_parse_options (char *options); +set_sdb_options (char *options); MONO_API MONO_RT_EXTERNAL_ONLY gboolean mono_debugger_agent_transport_handshake (void); diff --git a/src/mono/mono/mini/driver.c b/src/mono/mono/mini/driver.c index 7c37d2bddf8726..2de3e2047c5a0c 100644 --- a/src/mono/mono/mini/driver.c +++ b/src/mono/mono/mini/driver.c @@ -1808,7 +1808,7 @@ mono_jit_parse_options (int argc, char * argv[]) if (strncmp (argv [i], "--debugger-agent=", 17) == 0) { MonoDebugOptions *opt = mini_get_debug_options (); - mono_component_debugger ()->mono_debugger_agent_parse_options (g_strdup (argv [i] + 17)); + mono_component_debugger ()->set_sdb_options (g_strdup (argv [i] + 17)); opt->mdb_optimizations = TRUE; enable_debugging = TRUE; } else if (!strcmp (argv [i], "--soft-breakpoints")) { @@ -2383,7 +2383,7 @@ mono_main (int argc, char* argv[]) } else if (strncmp (argv [i], "--debugger-agent=", 17) == 0) { MonoDebugOptions *opt = mini_get_debug_options (); - mono_component_debugger ()->mono_debugger_agent_parse_options (g_strdup (argv [i] + 17)); + mono_component_debugger ()->set_sdb_options (g_strdup (argv [i] + 17)); opt->mdb_optimizations = TRUE; enable_debugging = TRUE; } else if (strcmp (argv [i], "--security") == 0) { diff --git a/src/mono/mono/mini/mini-runtime.c b/src/mono/mono/mini/mini-runtime.c index cc982007e7907d..dc7de35a6dc70f 100644 --- a/src/mono/mono/mini/mini-runtime.c +++ b/src/mono/mono/mini/mini-runtime.c @@ -4405,7 +4405,7 @@ mini_init (const char *filename, const char *runtime_version) if (default_opt & MONO_OPT_AOT) mono_aot_init (); - mono_component_debugger ()->init (); + mono_component_debugger ()->init (&mono_defaults); #ifdef TARGET_WASM mono_component_debugger ()->mono_wasm_debugger_init (); From 5cbd9efb9206b8b41a5c712467044236bb120889 Mon Sep 17 00:00:00 2001 From: Thays Date: Wed, 30 Jun 2021 03:13:05 -0300 Subject: [PATCH 27/35] Not used anymore. --- src/mono/mono/mini/debugger-agent-stubs.c | 122 ---------------------- 1 file changed, 122 deletions(-) delete mode 100644 src/mono/mono/mini/debugger-agent-stubs.c diff --git a/src/mono/mono/mini/debugger-agent-stubs.c b/src/mono/mono/mini/debugger-agent-stubs.c deleted file mode 100644 index a1bc833b4c8e50..00000000000000 --- a/src/mono/mono/mini/debugger-agent-stubs.c +++ /dev/null @@ -1,122 +0,0 @@ -/* \file - * Soft Debugger stubs - * - * Author: - * Zoltan Varga (vargaz@gmail.com) - * - * Copyright 2009-2010 Novell, Inc. - * Copyright 2011 Xamarin Inc. - * Licensed under the MIT license. See LICENSE file in the project root for full license information. - */ - -#include - -#include "mini-runtime.h" -#include "debugger-agent.h" - -static void -stub_debugger_agent_parse_options (void) -{ - g_error ("This runtime is configured with the debugger agent disabled."); -} - -static void -stub_debugger_agent_init (void) -{ -} - -static void -stub_debugger_agent_breakpoint_hit (void *sigctx) -{ -} - -static void -stub_debugger_agent_single_step_event (void *sigctx) -{ -} - -static void -stub_debugger_agent_free_mem_manager (gpointer mem_manager) -{ -} - -static void -stub_debugger_agent_handle_exception (MonoException *exc, MonoContext *throw_ctx, - MonoContext *catch_ctx, StackFrameInfo *catch_frame) -{ -} - -static void -stub_debugger_agent_begin_exception_filter (MonoException *exc, MonoContext *ctx, MonoContext *orig_ctx) -{ -} - -static void -stub_debugger_agent_end_exception_filter (MonoException *exc, MonoContext *ctx, MonoContext *orig_ctx) -{ -} - -static void -stub_debugger_agent_user_break (void) -{ - G_BREAKPOINT (); -} - -static void -stub_debugger_agent_debug_log (int level, MonoString *category, MonoString *message) -{ -} - -static gboolean -stub_debugger_agent_debug_log_is_enabled (void) -{ - return FALSE; -} - -static void -stub_debugger_agent_unhandled_exception (MonoException *exc) -{ - g_assert_not_reached (); -} - -static void -stub_debugger_agent_single_step_from_context (MonoContext *ctx) -{ - g_assert_not_reached (); -} - -static void -stub_debugger_agent_breakpoint_from_context (MonoContext *ctx) -{ - g_assert_not_reached (); -} - -static void -stub_debugger_agent_send_crash (char *json_dump, MonoStackHash *hashes, int pause) -{ -} - -void -mono_debugger_agent_stub_init (void) -{ - MonoDebuggerCallbacks cbs; - - memset (&cbs, 0, sizeof (MonoDebuggerCallbacks)); - cbs.version = MONO_DBG_CALLBACKS_VERSION; - cbs.parse_options = stub_debugger_agent_parse_options; - cbs.init = stub_debugger_agent_init; - cbs.breakpoint_hit = stub_debugger_agent_breakpoint_hit; - cbs.single_step_event = stub_debugger_agent_single_step_event; - cbs.single_step_from_context = stub_debugger_agent_single_step_from_context; - cbs.breakpoint_from_context = stub_debugger_agent_breakpoint_from_context; - cbs.unhandled_exception = stub_debugger_agent_unhandled_exception; - cbs.handle_exception = stub_debugger_agent_handle_exception; - cbs.begin_exception_filter = stub_debugger_agent_begin_exception_filter; - cbs.end_exception_filter = stub_debugger_agent_end_exception_filter; - cbs.user_break = stub_debugger_agent_user_break; - cbs.debug_log = stub_debugger_agent_debug_log; - cbs.debug_log_is_enabled = stub_debugger_agent_debug_log_is_enabled; - cbs.send_crash = stub_debugger_agent_send_crash; - - mini_install_dbg_callbacks (&cbs); -} From e011e5b1331e149b64541a9f4446432f0db4d23b Mon Sep 17 00:00:00 2001 From: Thays Date: Wed, 30 Jun 2021 11:23:38 -0300 Subject: [PATCH 28/35] Using the same function to initialize wasm and non-wasm debugger. --- src/mono/mono/component/debugger-agent.c | 4 ++-- src/mono/mono/component/debugger-stub.c | 9 -------- src/mono/mono/component/debugger.c | 22 +------------------- src/mono/mono/component/debugger.h | 1 - src/mono/mono/component/mini-wasm-debugger.c | 8 ++++--- src/mono/mono/mini/mini-runtime.c | 4 ---- 6 files changed, 8 insertions(+), 40 deletions(-) diff --git a/src/mono/mono/component/debugger-agent.c b/src/mono/mono/component/debugger-agent.c index 628e3e9a1b66d0..74b9c67ffd6498 100644 --- a/src/mono/mono/component/debugger-agent.c +++ b/src/mono/mono/component/debugger-agent.c @@ -740,11 +740,11 @@ mono_debugger_is_disconnected (void) static void debugger_agent_init (MonoDefaults *mono_defaults) { - mdbg_mono_defaults = mono_defaults; - if (!agent_config.enabled) return; + mdbg_mono_defaults = mono_defaults; + DebuggerEngineCallbacks cbs; memset (&cbs, 0, sizeof (cbs)); cbs.tls_get_restore_state = tls_get_restore_state; diff --git a/src/mono/mono/component/debugger-stub.c b/src/mono/mono/component/debugger-stub.c index 7cda35c0b399f4..4e8dbcd070a0bb 100644 --- a/src/mono/mono/component/debugger-stub.c +++ b/src/mono/mono/component/debugger-stub.c @@ -66,9 +66,6 @@ stub_mono_debugger_agent_transport_handshake (void); static void stub_mono_debugger_agent_parse_options (char *options); -static void -stub_mono_wasm_debugger_init (void); - static void stub_mono_wasm_breakpoint_hit (void); @@ -100,7 +97,6 @@ static MonoComponentDebugger fn_table = { &stub_mono_debugger_agent_parse_options, //wasm - &stub_mono_wasm_debugger_init, &stub_mono_wasm_breakpoint_hit, &stub_mono_wasm_single_step_hit, &stub_mono_wasm_enable_debugging, @@ -216,11 +212,6 @@ stub_mono_debugger_agent_parse_options (char *options) { } -static void -stub_mono_wasm_debugger_init (void) -{ -} - static void stub_mono_wasm_breakpoint_hit (void) { diff --git a/src/mono/mono/component/debugger.c b/src/mono/mono/component/debugger.c index 3dcf2edf0f3b27..74c9f15eded36f 100644 --- a/src/mono/mono/component/debugger.c +++ b/src/mono/mono/component/debugger.c @@ -13,16 +13,8 @@ static bool debugger_avaliable (void); -static void -debugger_init (void); - -static void -debugger_user_break (void); - static MonoComponentDebugger fn_table = { - { MONO_COMPONENT_ITF_VERSION, &debugger_avaliable }, - &debugger_init, - &debugger_user_break, + { MONO_COMPONENT_ITF_VERSION, &debugger_avaliable } }; static bool @@ -39,15 +31,3 @@ mono_component_debugger_init (void) mini_wasm_debugger_add_function_pointers (&fn_table); return &fn_table; } - -static void -debugger_init (void) -{ - -} - -static void -debugger_user_break (void) -{ - -} diff --git a/src/mono/mono/component/debugger.h b/src/mono/mono/component/debugger.h index 3c3f868bd63806..6cb478e28f69d5 100644 --- a/src/mono/mono/component/debugger.h +++ b/src/mono/mono/component/debugger.h @@ -193,7 +193,6 @@ typedef struct MonoComponentDebugger { void (*set_sdb_options) (char* options); //wasm - void (*mono_wasm_debugger_init) (void); void (*mono_wasm_breakpoint_hit) (void); void (*mono_wasm_single_step_hit) (void); void (*mono_wasm_enable_debugging) (int log_level); diff --git a/src/mono/mono/component/mini-wasm-debugger.c b/src/mono/mono/component/mini-wasm-debugger.c index dddcd845b5c4f5..fc18c2faa67e0a 100644 --- a/src/mono/mono/component/mini-wasm-debugger.c +++ b/src/mono/mono/component/mini-wasm-debugger.c @@ -145,11 +145,13 @@ handle_multiple_ss_requests (void) { } static void -mono_wasm_debugger_init (void) +mono_wasm_debugger_init (MonoDefaults *mono_defaults) { if (!debugger_enabled) return; + mdbg_mono_defaults = mono_defaults; + DebuggerEngineCallbacks cbs = { .tls_get_restore_state = tls_get_restore_state, .try_process_suspend = try_process_suspend, @@ -432,7 +434,7 @@ mono_wasm_breakpoint_hit (void) } static void -mono_wasm_debugger_init (void) +mono_wasm_debugger_init (MonoDefaults *mono_defaults) { } @@ -446,7 +448,7 @@ mono_wasm_enable_debugging_internal (int debug_level) void mini_wasm_debugger_add_function_pointers (MonoComponentDebugger* fn_table) { - fn_table->mono_wasm_debugger_init = mono_wasm_debugger_init; + fn_table->init = mono_wasm_debugger_init; fn_table->mono_wasm_breakpoint_hit = mono_wasm_breakpoint_hit; fn_table->mono_wasm_single_step_hit = mono_wasm_single_step_hit; fn_table->mono_wasm_enable_debugging = mono_wasm_enable_debugging_internal; diff --git a/src/mono/mono/mini/mini-runtime.c b/src/mono/mono/mini/mini-runtime.c index dc7de35a6dc70f..23cf953c0958a7 100644 --- a/src/mono/mono/mini/mini-runtime.c +++ b/src/mono/mono/mini/mini-runtime.c @@ -4407,10 +4407,6 @@ mini_init (const char *filename, const char *runtime_version) mono_component_debugger ()->init (&mono_defaults); -#ifdef TARGET_WASM - mono_component_debugger ()->mono_wasm_debugger_init (); -#endif - #ifdef MONO_ARCH_GSHARED_SUPPORTED mono_set_generic_sharing_supported (TRUE); #endif From 94041190736d7885e5bdeeb8edc59ef63e5b35cc Mon Sep 17 00:00:00 2001 From: Thays Date: Wed, 30 Jun 2021 11:47:57 -0300 Subject: [PATCH 29/35] Rollback exported function name. --- src/mono/mono/mini/debugger-agent-external.c | 2 +- src/mono/mono/mini/debugger-agent-external.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/mono/mono/mini/debugger-agent-external.c b/src/mono/mono/mini/debugger-agent-external.c index 0d52901c3debd9..7fdd77dabbc0f6 100644 --- a/src/mono/mono/mini/debugger-agent-external.c +++ b/src/mono/mono/mini/debugger-agent-external.c @@ -27,7 +27,7 @@ mono_debugger_agent_init (void) } void -set_sdb_options (char *options) +mono_debugger_agent_parse_options (char *options) { mono_component_debugger ()->set_sdb_options (options); } diff --git a/src/mono/mono/mini/debugger-agent-external.h b/src/mono/mono/mini/debugger-agent-external.h index 636af4e82f6b2c..f61cb66e683ca7 100644 --- a/src/mono/mono/mini/debugger-agent-external.h +++ b/src/mono/mono/mini/debugger-agent-external.h @@ -12,7 +12,7 @@ MONO_API void mono_debugger_agent_init (void); MONO_API void -set_sdb_options (char *options); +mono_debugger_agent_parse_options (char *options); MONO_API MONO_RT_EXTERNAL_ONLY gboolean mono_debugger_agent_transport_handshake (void); From 2775fd0db828dfb8e5c0551e179ecc14fbd15e02 Mon Sep 17 00:00:00 2001 From: Thays Date: Wed, 30 Jun 2021 15:54:53 -0300 Subject: [PATCH 30/35] Changing where components are initialized. Saving debugger transport information outside the component. --- src/mono/mono/component/debugger-agent.c | 32 ++++++++------------ src/mono/mono/component/debugger-stub.c | 20 +----------- src/mono/mono/component/debugger.h | 3 +- src/mono/mono/component/mini-wasm-debugger.c | 28 ++++++++--------- src/mono/mono/mini/debugger-agent-external.c | 21 ++++++++++++- src/mono/mono/mini/debugger-agent-external.h | 3 ++ src/mono/mono/mini/mini-runtime.c | 3 +- src/mono/mono/mini/mini-wasm.c | 9 +++++- src/mono/mono/mini/mini.h | 3 ++ src/mono/mono/mini/monovm.c | 2 -- 10 files changed, 64 insertions(+), 60 deletions(-) diff --git a/src/mono/mono/component/debugger-agent.c b/src/mono/mono/component/debugger-agent.c index 74b9c67ffd6498..1a790b15259656 100644 --- a/src/mono/mono/component/debugger-agent.c +++ b/src/mono/mono/component/debugger-agent.c @@ -90,6 +90,7 @@ #include #include #include +#include #ifdef HAVE_UCONTEXT_H #include @@ -439,7 +440,6 @@ MonoDefaults *mdbg_mono_defaults; static void transport_init (void); static void transport_connect (const char *address); static gboolean transport_handshake (void); -static void register_transport (DebuggerTransport *trans); static gsize WINAPI debugger_thread (void *arg); @@ -1264,7 +1264,7 @@ register_socket_transport (void) trans.send = socket_transport_send; trans.recv = socket_transport_recv; - register_transport (&trans); + mono_debugger_agent_register_transport (&trans); } /* @@ -1305,7 +1305,7 @@ register_socket_fd_transport (void) trans.send = socket_transport_send; trans.recv = socket_transport_recv; - register_transport (&trans); + mono_debugger_agent_register_transport (&trans); } #endif /* DISABLE_SOCKET_TRANSPORT */ @@ -1314,21 +1314,9 @@ register_socket_fd_transport (void) * TRANSPORT CODE */ -#define MAX_TRANSPORTS 16 -static DebuggerTransport *transport; - -static DebuggerTransport transports [MAX_TRANSPORTS]; -static int ntransports = 0; - -static void -register_transport (DebuggerTransport *trans) -{ - g_assert (ntransports < MAX_TRANSPORTS); - memcpy (&transports [ntransports], trans, sizeof (DebuggerTransport)); - ntransports ++; -} +static DebuggerTransport *transport; static void transport_init (void) @@ -1339,6 +1327,8 @@ transport_init (void) register_socket_transport (); register_socket_fd_transport (); #endif + int ntransports = 0; + DebuggerTransport *transports = mono_debugger_agent_get_transports (&ntransports); for (i = 0; i < ntransports; ++i) { if (!strcmp (agent_config.transport, transports [i].name)) @@ -1399,7 +1389,7 @@ transport_recv (void *buf, int len) } static gboolean -mono_debugger_agent_transport_handshake (void) +debugger_agent_transport_handshake (void) { gboolean result; MONO_ENTER_GC_UNSAFE; @@ -1622,11 +1612,14 @@ mono_init_debugger_agent_for_wasm (int log_level_parm) if (mono_atomic_cas_i32 (&agent_inited, 1, 0) == 1) return; + int ntransports = 0; + DebuggerTransport *transports = mono_debugger_agent_get_transports (&ntransports); + ids_init(); objrefs = g_hash_table_new_full (NULL, NULL, NULL, mono_debugger_free_objref); obj_to_objref = g_hash_table_new (NULL, NULL); - log_level = log_level; + log_level = log_level_parm; event_requests = g_ptr_array_new (); vm_start_event_sent = TRUE; transport = &transports [0]; @@ -10293,10 +10286,9 @@ debugger_agent_add_function_pointers(MonoComponentDebugger* fn_table) fn_table->debug_log_is_enabled = debugger_agent_debug_log_is_enabled; fn_table->send_crash = mono_debugger_agent_send_crash; - fn_table->register_transport = register_transport; fn_table->set_sdb_options = set_sdb_options; - fn_table->mono_debugger_agent_transport_handshake = mono_debugger_agent_transport_handshake; + fn_table->mono_debugger_agent_transport_handshake = debugger_agent_transport_handshake; } diff --git a/src/mono/mono/component/debugger-stub.c b/src/mono/mono/component/debugger-stub.c index 4e8dbcd070a0bb..83c2b2aa38d0fe 100644 --- a/src/mono/mono/component/debugger-stub.c +++ b/src/mono/mono/component/debugger-stub.c @@ -57,9 +57,6 @@ stub_debugger_breakpoint_from_context (MonoContext *ctx); static void stub_debugger_send_crash (char *json_dump, MonoStackHash *hashes, int pause); -static void -stub_register_transport (DebuggerTransport *trans); //debugger-agent - static gboolean stub_mono_debugger_agent_transport_handshake (void); @@ -72,9 +69,6 @@ stub_mono_wasm_breakpoint_hit (void); static void stub_mono_wasm_single_step_hit (void); -static void -stub_mono_wasm_enable_debugging (int log_level); - static MonoComponentDebugger fn_table = { { MONO_COMPONENT_ITF_VERSION, &debugger_avaliable }, &stub_debugger_init, @@ -92,14 +86,12 @@ static MonoComponentDebugger fn_table = { &stub_debugger_debug_log, &stub_debugger_debug_log_is_enabled, &stub_debugger_send_crash, - &stub_register_transport, &stub_mono_debugger_agent_transport_handshake, &stub_mono_debugger_agent_parse_options, //wasm &stub_mono_wasm_breakpoint_hit, - &stub_mono_wasm_single_step_hit, - &stub_mono_wasm_enable_debugging, + &stub_mono_wasm_single_step_hit }; static bool @@ -196,11 +188,6 @@ stub_debugger_send_crash (char *json_dump, MonoStackHash *hashes, int pause) { } -static void -stub_register_transport(DebuggerTransport *trans) //debugger-agent -{ -} - static gboolean stub_mono_debugger_agent_transport_handshake(void) { @@ -221,8 +208,3 @@ static void stub_mono_wasm_single_step_hit (void) { } - -static void -stub_mono_wasm_enable_debugging (int log_level) -{ -} diff --git a/src/mono/mono/component/debugger.h b/src/mono/mono/component/debugger.h index 6cb478e28f69d5..b243e903591ddf 100644 --- a/src/mono/mono/component/debugger.h +++ b/src/mono/mono/component/debugger.h @@ -188,14 +188,13 @@ typedef struct MonoComponentDebugger { void (*debug_log) (int level, MonoString *category, MonoString *message); gboolean (*debug_log_is_enabled) (void); void (*send_crash) (char *json_dump, MonoStackHash *hashes, int pause); - void (*register_transport) (DebuggerTransport* trans); //debugger-agent gboolean (*mono_debugger_agent_transport_handshake) (void); void (*set_sdb_options) (char* options); //wasm void (*mono_wasm_breakpoint_hit) (void); void (*mono_wasm_single_step_hit) (void); - void (*mono_wasm_enable_debugging) (int log_level); + } MonoComponentDebugger; diff --git a/src/mono/mono/component/mini-wasm-debugger.c b/src/mono/mono/component/mini-wasm-debugger.c index fc18c2faa67e0a..4df2172841efe8 100644 --- a/src/mono/mono/component/mini-wasm-debugger.c +++ b/src/mono/mono/component/mini-wasm-debugger.c @@ -25,6 +25,8 @@ #include "mono/metadata/assembly-internals.h" #include "mono/metadata/debug-mono-ppdb.h" +#include + static int log_level = 1; //functions exported to be used by JS @@ -144,9 +146,20 @@ handle_multiple_ss_requests (void) { return 1; } +static void +mono_wasm_enable_debugging_internal (int debug_level) +{ + PRINT_DEBUG_MSG (1, "DEBUGGING ENABLED\n"); + debugger_enabled = TRUE; + log_level = debug_level; +} + static void mono_wasm_debugger_init (MonoDefaults *mono_defaults) { + int debug_level = mono_wasm_get_debug_level(); + mono_wasm_enable_debugging_internal (debug_level); + if (!debugger_enabled) return; @@ -183,18 +196,10 @@ mono_wasm_debugger_init (MonoDefaults *mono_defaults) trans.name = "buffer-wasm-communication"; trans.send = receive_debugger_agent_message; - mono_component_debugger ()->register_transport (&trans); + mono_debugger_agent_register_transport (&trans); mono_init_debugger_agent_for_wasm (log_level); } -static void -mono_wasm_enable_debugging_internal (int debug_level) -{ - PRINT_DEBUG_MSG (1, "DEBUGGING ENABLED\n"); - debugger_enabled = TRUE; - log_level = debug_level; -} - static void assembly_loaded (MonoProfiler *prof, MonoAssembly *assembly) { @@ -438,10 +443,6 @@ mono_wasm_debugger_init (MonoDefaults *mono_defaults) { } -static void -mono_wasm_enable_debugging_internal (int debug_level) -{ -} #endif // HOST_WASM @@ -451,5 +452,4 @@ mini_wasm_debugger_add_function_pointers (MonoComponentDebugger* fn_table) fn_table->init = mono_wasm_debugger_init; fn_table->mono_wasm_breakpoint_hit = mono_wasm_breakpoint_hit; fn_table->mono_wasm_single_step_hit = mono_wasm_single_step_hit; - fn_table->mono_wasm_enable_debugging = mono_wasm_enable_debugging_internal; } diff --git a/src/mono/mono/mini/debugger-agent-external.c b/src/mono/mono/mini/debugger-agent-external.c index 7fdd77dabbc0f6..64421c3339d2b1 100644 --- a/src/mono/mono/mini/debugger-agent-external.c +++ b/src/mono/mono/mini/debugger-agent-external.c @@ -8,10 +8,24 @@ #ifndef DISABLE_SDB +#define MAX_TRANSPORTS 16 +static DebuggerTransport transports [MAX_TRANSPORTS]; +static int ntransports = 0; + +static void +register_transport (DebuggerTransport *trans) +{ + g_assert (ntransports < MAX_TRANSPORTS); + + memcpy (&transports [ntransports], trans, sizeof (DebuggerTransport)); + ntransports ++; +} + void + mono_debugger_agent_register_transport (DebuggerTransport *trans) { - mono_component_debugger ()->register_transport (trans); + register_transport (trans); } gboolean @@ -32,4 +46,9 @@ mono_debugger_agent_parse_options (char *options) mono_component_debugger ()->set_sdb_options (options); } +DebuggerTransport *mono_debugger_agent_get_transports (int *ntrans) +{ + *ntrans = ntransports; + return transports; +} #endif /* DISABLE_SDB */ diff --git a/src/mono/mono/mini/debugger-agent-external.h b/src/mono/mono/mini/debugger-agent-external.h index f61cb66e683ca7..af9f7c0898b1a6 100644 --- a/src/mono/mono/mini/debugger-agent-external.h +++ b/src/mono/mono/mini/debugger-agent-external.h @@ -20,4 +20,7 @@ mono_debugger_agent_transport_handshake (void); MONO_API void mono_debugger_agent_register_transport (DebuggerTransport *trans); +MONO_COMPONENT_API DebuggerTransport * +mono_debugger_agent_get_transports (int *ntrans); + #endif diff --git a/src/mono/mono/mini/mini-runtime.c b/src/mono/mono/mini/mini-runtime.c index 23cf953c0958a7..c48664f3883598 100644 --- a/src/mono/mono/mini/mini-runtime.c +++ b/src/mono/mono/mini/mini-runtime.c @@ -4269,7 +4269,8 @@ mini_init (const char *filename, const char *runtime_version) if (mono_use_interpreter) mono_ee_interp_init (mono_interp_opts_string); #endif - + mono_components_init (); + mono_component_debugger ()->parse_options (); mono_os_mutex_init_recursive (&jit_mutex); diff --git a/src/mono/mono/mini/mini-wasm.c b/src/mono/mono/mini/mini-wasm.c index db864fd891c654..56d58e1c6a0d28 100644 --- a/src/mono/mono/mini/mini-wasm.c +++ b/src/mono/mono/mini/mini-wasm.c @@ -14,6 +14,7 @@ //XXX This is dirty, extend ee.h to support extracting info from MonoInterpFrameHandle #include +static int mono_wasm_debug_level = 0; #ifndef DISABLE_JIT #include "ir-emit.h" @@ -765,5 +766,11 @@ mono_arch_load_function (MonoJitICallId jit_icall_id) MONO_API void mono_wasm_enable_debugging (int log_level) { - mono_component_debugger ()->mono_wasm_enable_debugging (log_level); + mono_wasm_debug_level = log_level; +} + +int +mono_wasm_get_debug_level (void) +{ + return mono_wasm_debug_level; } diff --git a/src/mono/mono/mini/mini.h b/src/mono/mono/mini/mini.h index d36f8e37f4fd8b..a95cbabcb51746 100644 --- a/src/mono/mono/mini/mini.h +++ b/src/mono/mono/mini/mini.h @@ -2956,4 +2956,7 @@ mono_get_generic_info_from_stack_frame (MonoJitInfo *ji, MonoContext *ctx); MonoMemoryManager* mini_get_default_mem_manager (void); +MONO_COMPONENT_API int +mono_wasm_get_debug_level (void); + #endif /* __MONO_MINI_H__ */ diff --git a/src/mono/mono/mini/monovm.c b/src/mono/mono/mini/monovm.c index 527c86be9fca19..d3f1cdb93c6787 100644 --- a/src/mono/mono/mini/monovm.c +++ b/src/mono/mono/mini/monovm.c @@ -210,8 +210,6 @@ monovm_initialize (int propertyCount, const char **propertyKeys, const char **pr return 0x80004005; /* E_FAIL */ finish_initialization (); - - mono_components_init (); return 0; } From 0ead04dbfc701c23f6406b66f4543a9784ad2c74 Mon Sep 17 00:00:00 2001 From: Thays Date: Wed, 30 Jun 2021 16:12:30 -0300 Subject: [PATCH 31/35] set sdb options before component startup. --- src/mono/mono/component/debugger-agent.c | 14 ++------------ src/mono/mono/component/debugger-stub.c | 9 --------- src/mono/mono/component/debugger.h | 1 - src/mono/mono/mini/debugger-agent-external.c | 14 +++++++++++--- src/mono/mono/mini/debugger-agent-external.h | 3 +++ src/mono/mono/mini/driver.c | 5 +++-- 6 files changed, 19 insertions(+), 27 deletions(-) diff --git a/src/mono/mono/component/debugger-agent.c b/src/mono/mono/component/debugger-agent.c index 1a790b15259656..177e994e12a954 100644 --- a/src/mono/mono/component/debugger-agent.c +++ b/src/mono/mono/component/debugger-agent.c @@ -525,8 +525,6 @@ static void mono_dbg_debugger_agent_user_break (void); static GENERATE_TRY_GET_CLASS_WITH_CACHE_DBG (fixed_buffer, "System.Runtime.CompilerServices", "FixedBufferAttribute") -static char *sdb_options = NULL; - #ifndef DISABLE_SOCKET_TRANSPORT static void register_socket_transport (void); @@ -599,9 +597,9 @@ parse_flag (const char *option, char *flag) static void debugger_agent_parse_options (void) { - if (!sdb_options) + char *options = mono_debugger_agent_get_sdb_options (); + if (!options) return; - char *options = sdb_options; char **args, **ptr; char *host; int port; @@ -10261,11 +10259,6 @@ debugger_thread (void *arg) return 0; } -static void -set_sdb_options (char *options) -{ - sdb_options = options; -} void debugger_agent_add_function_pointers(MonoComponentDebugger* fn_table) @@ -10285,9 +10278,6 @@ debugger_agent_add_function_pointers(MonoComponentDebugger* fn_table) fn_table->debug_log = debugger_agent_debug_log; fn_table->debug_log_is_enabled = debugger_agent_debug_log_is_enabled; fn_table->send_crash = mono_debugger_agent_send_crash; - - fn_table->set_sdb_options = set_sdb_options; - fn_table->mono_debugger_agent_transport_handshake = debugger_agent_transport_handshake; } diff --git a/src/mono/mono/component/debugger-stub.c b/src/mono/mono/component/debugger-stub.c index 83c2b2aa38d0fe..b2f100ae22b28b 100644 --- a/src/mono/mono/component/debugger-stub.c +++ b/src/mono/mono/component/debugger-stub.c @@ -60,9 +60,6 @@ stub_debugger_send_crash (char *json_dump, MonoStackHash *hashes, int pause); static gboolean stub_mono_debugger_agent_transport_handshake (void); -static void -stub_mono_debugger_agent_parse_options (char *options); - static void stub_mono_wasm_breakpoint_hit (void); @@ -87,7 +84,6 @@ static MonoComponentDebugger fn_table = { &stub_debugger_debug_log_is_enabled, &stub_debugger_send_crash, &stub_mono_debugger_agent_transport_handshake, - &stub_mono_debugger_agent_parse_options, //wasm &stub_mono_wasm_breakpoint_hit, @@ -194,11 +190,6 @@ stub_mono_debugger_agent_transport_handshake(void) g_assert_not_reached(); } -static void -stub_mono_debugger_agent_parse_options (char *options) -{ -} - static void stub_mono_wasm_breakpoint_hit (void) { diff --git a/src/mono/mono/component/debugger.h b/src/mono/mono/component/debugger.h index b243e903591ddf..74d3bded527e32 100644 --- a/src/mono/mono/component/debugger.h +++ b/src/mono/mono/component/debugger.h @@ -189,7 +189,6 @@ typedef struct MonoComponentDebugger { gboolean (*debug_log_is_enabled) (void); void (*send_crash) (char *json_dump, MonoStackHash *hashes, int pause); gboolean (*mono_debugger_agent_transport_handshake) (void); - void (*set_sdb_options) (char* options); //wasm void (*mono_wasm_breakpoint_hit) (void); diff --git a/src/mono/mono/mini/debugger-agent-external.c b/src/mono/mono/mini/debugger-agent-external.c index 64421c3339d2b1..1ca38ea310e868 100644 --- a/src/mono/mono/mini/debugger-agent-external.c +++ b/src/mono/mono/mini/debugger-agent-external.c @@ -8,6 +8,8 @@ #ifndef DISABLE_SDB +static char *sdb_options = NULL; + #define MAX_TRANSPORTS 16 static DebuggerTransport transports [MAX_TRANSPORTS]; static int ntransports = 0; @@ -22,7 +24,6 @@ register_transport (DebuggerTransport *trans) } void - mono_debugger_agent_register_transport (DebuggerTransport *trans) { register_transport (trans); @@ -43,12 +44,19 @@ mono_debugger_agent_init (void) void mono_debugger_agent_parse_options (char *options) { - mono_component_debugger ()->set_sdb_options (options); + sdb_options = options; } -DebuggerTransport *mono_debugger_agent_get_transports (int *ntrans) +DebuggerTransport * +mono_debugger_agent_get_transports (int *ntrans) { *ntrans = ntransports; return transports; } + +char * +mono_debugger_agent_get_sdb_options (void) +{ + return sdb_options; +} #endif /* DISABLE_SDB */ diff --git a/src/mono/mono/mini/debugger-agent-external.h b/src/mono/mono/mini/debugger-agent-external.h index af9f7c0898b1a6..b37cd6b5e046ef 100644 --- a/src/mono/mono/mini/debugger-agent-external.h +++ b/src/mono/mono/mini/debugger-agent-external.h @@ -23,4 +23,7 @@ mono_debugger_agent_register_transport (DebuggerTransport *trans); MONO_COMPONENT_API DebuggerTransport * mono_debugger_agent_get_transports (int *ntrans); +MONO_COMPONENT_API char * +mono_debugger_agent_get_sdb_options (void); + #endif diff --git a/src/mono/mono/mini/driver.c b/src/mono/mono/mini/driver.c index 2de3e2047c5a0c..f2792e4e6a4e41 100644 --- a/src/mono/mono/mini/driver.c +++ b/src/mono/mono/mini/driver.c @@ -57,6 +57,7 @@ #include #include +#include #include "mini.h" #include "jit.h" @@ -1808,7 +1809,7 @@ mono_jit_parse_options (int argc, char * argv[]) if (strncmp (argv [i], "--debugger-agent=", 17) == 0) { MonoDebugOptions *opt = mini_get_debug_options (); - mono_component_debugger ()->set_sdb_options (g_strdup (argv [i] + 17)); + mono_debugger_agent_parse_options (g_strdup (argv [i] + 17)); opt->mdb_optimizations = TRUE; enable_debugging = TRUE; } else if (!strcmp (argv [i], "--soft-breakpoints")) { @@ -2383,7 +2384,7 @@ mono_main (int argc, char* argv[]) } else if (strncmp (argv [i], "--debugger-agent=", 17) == 0) { MonoDebugOptions *opt = mini_get_debug_options (); - mono_component_debugger ()->set_sdb_options (g_strdup (argv [i] + 17)); + mono_debugger_agent_parse_options (g_strdup (argv [i] + 17)); opt->mdb_optimizations = TRUE; enable_debugging = TRUE; } else if (strcmp (argv [i], "--security") == 0) { From 5e5fe29fe5d2efba76cbc904f945aba4dd725e34 Mon Sep 17 00:00:00 2001 From: Thays Date: Wed, 30 Jun 2021 16:49:53 -0300 Subject: [PATCH 32/35] Fixing console debug. --- src/mono/mono/component/debugger.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/mono/mono/component/debugger.c b/src/mono/mono/component/debugger.c index 74c9f15eded36f..2ebb4f46aae91a 100644 --- a/src/mono/mono/component/debugger.c +++ b/src/mono/mono/component/debugger.c @@ -28,6 +28,8 @@ MonoComponentDebugger * mono_component_debugger_init (void) { debugger_agent_add_function_pointers (&fn_table); +#ifdef TARGET_WASM mini_wasm_debugger_add_function_pointers (&fn_table); +#endif return &fn_table; } From 74213251cf6890ff4961d8ce18be34eb747346ec Mon Sep 17 00:00:00 2001 From: Thays Date: Wed, 30 Jun 2021 18:21:08 -0300 Subject: [PATCH 33/35] Fix ios compilation. --- src/mono/mono/metadata/handle.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/mono/mono/metadata/handle.h b/src/mono/mono/metadata/handle.h index 3cf1f3afe2f5ba..0e43247971a061 100644 --- a/src/mono/mono/metadata/handle.h +++ b/src/mono/mono/metadata/handle.h @@ -134,7 +134,7 @@ gboolean mono_handle_stack_is_empty (HandleStack *stack); HandleStack* mono_handle_stack_alloc (void); void mono_handle_stack_free (HandleStack *handlestack); MonoRawHandle mono_stack_mark_pop_value (MonoThreadInfo *info, HandleStackMark *stackmark, MonoRawHandle value); -MonoThreadInfo* mono_stack_mark_record_size (MonoThreadInfo *info, HandleStackMark *stackmark, const char *func_name); +MONO_COMPONENT_API MonoThreadInfo* mono_stack_mark_record_size (MonoThreadInfo *info, HandleStackMark *stackmark, const char *func_name); void mono_handle_stack_free_domain (HandleStack *stack, MonoDomain *domain); #ifdef MONO_HANDLE_TRACK_SP From a2e9249185add58a683eb58af1537a402e41af2c Mon Sep 17 00:00:00 2001 From: Thays Date: Thu, 1 Jul 2021 10:55:59 -0300 Subject: [PATCH 34/35] Fix calling parse_options without parameters. --- src/mono/mono/component/debugger-agent.c | 5 ++--- src/mono/mono/component/debugger-stub.c | 12 +++++++----- src/mono/mono/component/debugger.h | 4 ++-- src/mono/mono/mini/debugger-agent-external.c | 2 +- src/mono/mono/mini/mini-runtime.c | 3 ++- 5 files changed, 14 insertions(+), 12 deletions(-) diff --git a/src/mono/mono/component/debugger-agent.c b/src/mono/mono/component/debugger-agent.c index 177e994e12a954..74240419d2ff3d 100644 --- a/src/mono/mono/component/debugger-agent.c +++ b/src/mono/mono/component/debugger-agent.c @@ -595,9 +595,8 @@ parse_flag (const char *option, char *flag) } static void -debugger_agent_parse_options (void) +debugger_agent_parse_options (char *options) { - char *options = mono_debugger_agent_get_sdb_options (); if (!options) return; char **args, **ptr; @@ -10278,7 +10277,7 @@ debugger_agent_add_function_pointers(MonoComponentDebugger* fn_table) fn_table->debug_log = debugger_agent_debug_log; fn_table->debug_log_is_enabled = debugger_agent_debug_log_is_enabled; fn_table->send_crash = mono_debugger_agent_send_crash; - fn_table->mono_debugger_agent_transport_handshake = debugger_agent_transport_handshake; + fn_table->transport_handshake = debugger_agent_transport_handshake; } diff --git a/src/mono/mono/component/debugger-stub.c b/src/mono/mono/component/debugger-stub.c index b2f100ae22b28b..1c5467adadddd6 100644 --- a/src/mono/mono/component/debugger-stub.c +++ b/src/mono/mono/component/debugger-stub.c @@ -13,7 +13,7 @@ static bool debugger_avaliable (void); static void -stub_debugger_parse_options (void); +stub_debugger_parse_options (char *options); static void stub_debugger_init (MonoDefaults *mono_defaults); @@ -58,7 +58,7 @@ static void stub_debugger_send_crash (char *json_dump, MonoStackHash *hashes, int pause); static gboolean -stub_mono_debugger_agent_transport_handshake (void); +stub_debugger_transport_handshake (void); static void stub_mono_wasm_breakpoint_hit (void); @@ -83,7 +83,7 @@ static MonoComponentDebugger fn_table = { &stub_debugger_debug_log, &stub_debugger_debug_log_is_enabled, &stub_debugger_send_crash, - &stub_mono_debugger_agent_transport_handshake, + &stub_debugger_transport_handshake, //wasm &stub_mono_wasm_breakpoint_hit, @@ -103,8 +103,10 @@ mono_component_debugger_init (void) } static void -stub_debugger_parse_options (void) +stub_debugger_parse_options (char *options) { + if (!options) + return; g_error ("This runtime is configured with the debugger agent disabled."); } @@ -185,7 +187,7 @@ stub_debugger_send_crash (char *json_dump, MonoStackHash *hashes, int pause) } static gboolean -stub_mono_debugger_agent_transport_handshake(void) +stub_debugger_transport_handshake (void) { g_assert_not_reached(); } diff --git a/src/mono/mono/component/debugger.h b/src/mono/mono/component/debugger.h index 74d3bded527e32..de50c5641137ae 100644 --- a/src/mono/mono/component/debugger.h +++ b/src/mono/mono/component/debugger.h @@ -174,7 +174,7 @@ typedef struct MonoComponentDebugger { MonoComponent component; void (*init) (MonoDefaults *mono_defaults); void (*user_break) (void); - void (*parse_options) (void); + void (*parse_options) (char *options); void (*breakpoint_hit) (void *sigctx); void (*single_step_event) (void *sigctx); void (*single_step_from_context) (MonoContext *ctx); @@ -188,7 +188,7 @@ typedef struct MonoComponentDebugger { void (*debug_log) (int level, MonoString *category, MonoString *message); gboolean (*debug_log_is_enabled) (void); void (*send_crash) (char *json_dump, MonoStackHash *hashes, int pause); - gboolean (*mono_debugger_agent_transport_handshake) (void); + gboolean (*transport_handshake) (void); //wasm void (*mono_wasm_breakpoint_hit) (void); diff --git a/src/mono/mono/mini/debugger-agent-external.c b/src/mono/mono/mini/debugger-agent-external.c index 1ca38ea310e868..af2d1057359ad0 100644 --- a/src/mono/mono/mini/debugger-agent-external.c +++ b/src/mono/mono/mini/debugger-agent-external.c @@ -32,7 +32,7 @@ mono_debugger_agent_register_transport (DebuggerTransport *trans) gboolean mono_debugger_agent_transport_handshake (void) { - return mono_component_debugger ()->mono_debugger_agent_transport_handshake (); + return mono_component_debugger ()->transport_handshake (); } void diff --git a/src/mono/mono/mini/mini-runtime.c b/src/mono/mono/mini/mini-runtime.c index c48664f3883598..45367721b8b86f 100644 --- a/src/mono/mono/mini/mini-runtime.c +++ b/src/mono/mono/mini/mini-runtime.c @@ -72,6 +72,7 @@ #include #include #include +#include #include "mini.h" #include "seq-points.h" @@ -4271,7 +4272,7 @@ mini_init (const char *filename, const char *runtime_version) #endif mono_components_init (); - mono_component_debugger ()->parse_options (); + mono_component_debugger ()->parse_options (mono_debugger_agent_get_sdb_options ()); mono_os_mutex_init_recursive (&jit_mutex); From be85f16afed4a8b6c0cbbaf1e68a1fcc0302a774 Mon Sep 17 00:00:00 2001 From: Thays Date: Thu, 1 Jul 2021 13:39:26 -0300 Subject: [PATCH 35/35] Last @lambdageek suggestions. --- src/mono/mono/component/debugger-agent.c | 2 +- src/mono/mono/component/debugger-agent.h | 2 +- src/mono/mono/component/debugger-engine.c | 17 +++-------------- src/mono/mono/component/debugger-engine.h | 1 - 4 files changed, 5 insertions(+), 17 deletions(-) diff --git a/src/mono/mono/component/debugger-agent.c b/src/mono/mono/component/debugger-agent.c index 74240419d2ff3d..f72c95392e9744 100644 --- a/src/mono/mono/component/debugger-agent.c +++ b/src/mono/mono/component/debugger-agent.c @@ -4162,7 +4162,7 @@ breakpoint_matches_assembly (MonoBreakpoint *bp, MonoAssembly *assembly) //This ID is used to figure out if breakpoint hit on resumeOffset belongs to us or not //since thread probably changed... int -mono_get_this_async_id (DbgEngineStackFrame *frame) +mono_de_frame_async_id (DbgEngineStackFrame *frame) { MonoClassField *builder_field; gpointer builder; diff --git a/src/mono/mono/component/debugger-agent.h b/src/mono/mono/component/debugger-agent.h index e899d950a59e41..60f42448202471 100644 --- a/src/mono/mono/component/debugger-agent.h +++ b/src/mono/mono/component/debugger-agent.h @@ -52,5 +52,5 @@ void mono_ss_args_destroy (SingleStepArgs *ss_args); int -mono_get_this_async_id (DbgEngineStackFrame *frame); +mono_de_frame_async_id (DbgEngineStackFrame *frame); #endif diff --git a/src/mono/mono/component/debugger-engine.c b/src/mono/mono/component/debugger-engine.c index 063e5f547992c1..7310283357178f 100644 --- a/src/mono/mono/component/debugger-engine.c +++ b/src/mono/mono/component/debugger-engine.c @@ -91,17 +91,6 @@ mono_de_foreach_domain (GHFunc func, gpointer user_data) g_hash_table_foreach (domains, func, user_data); } -/* - * LOCKING: Takes the loader lock - */ -void -mono_de_domain_remove (MonoDomain *domain) -{ - mono_loader_lock (); - g_hash_table_remove (domains, domain); - mono_loader_unlock (); -} - /* * LOCKING: Takes the loader lock */ @@ -1114,7 +1103,7 @@ mono_de_process_breakpoint (void *void_tls, gboolean from_signal) mono_debug_free_method_async_debug_info (asyncMethod); //breakpoint was hit in parallelly executing async method, ignore it - if (ss_req->async_id != mono_get_this_async_id (frames [0])) + if (ss_req->async_id != mono_de_frame_async_id (frames [0])) continue; } @@ -1343,7 +1332,7 @@ mono_de_ss_start (SingleStepReq *ss_req, SingleStepArgs *ss_args) // of this await call and sets async_id so we can distinguish it from parallel executions for (i = 0; i < asyncMethod->num_awaits; i++) { if (sp->il_offset == asyncMethod->yield_offsets [i]) { - ss_req->async_id = mono_get_this_async_id (frames [0]); + ss_req->async_id = mono_de_frame_async_id (frames [0]); ss_bp_add_one (ss_req, &ss_req_bp_count, &ss_req_bp_cache, method, asyncMethod->resume_offsets [i]); g_hash_table_destroy (ss_req_bp_cache); mono_debug_free_method_async_debug_info (asyncMethod); @@ -1360,7 +1349,7 @@ mono_de_ss_start (SingleStepReq *ss_req, SingleStepArgs *ss_args) if (ss_req->depth == STEP_DEPTH_OUT) { //If we are inside `async void` method, do normal step-out if (set_set_notification_for_wait_completion_flag (frames [0])) { - ss_req->async_id = mono_get_this_async_id (frames [0]); + ss_req->async_id = mono_de_frame_async_id (frames [0]); ss_req->async_stepout_method = get_notify_debugger_of_wait_completion_method (); ss_bp_add_one (ss_req, &ss_req_bp_count, &ss_req_bp_cache, ss_req->async_stepout_method, 0); g_hash_table_destroy (ss_req_bp_cache); diff --git a/src/mono/mono/component/debugger-engine.h b/src/mono/mono/component/debugger-engine.h index b79f6f47136e05..a3c30d6d995cc3 100644 --- a/src/mono/mono/component/debugger-engine.h +++ b/src/mono/mono/component/debugger-engine.h @@ -349,7 +349,6 @@ void mono_de_unlock (void); // domain handling void mono_de_foreach_domain (GHFunc func, gpointer user_data); void mono_de_domain_add (MonoDomain *domain); -void mono_de_domain_remove (MonoDomain *domain); //never called, can remove? //breakpoints void mono_de_clear_breakpoint (MonoBreakpoint *bp);